1 registered members (AbrahamR),
717
guests, and 4
spiders. |
Key:
Admin,
Global Mod,
Mod
|
|
|
Re: Multitex Terrain Normalmapping
[Re: sivan]
#432753
11/13/13 21:27
11/13/13 21:27
|
Joined: Nov 2007
Posts: 318 Brasil, Paraná
NeoNeper
Senior Member
|
Senior Member
Joined: Nov 2007
Posts: 318
Brasil, Paraná
|
and the mystyMood? I tested to verify operation. This working fine in version A8. Tests with multiple lights in the scene, and as far as I've seen, seems to work correctly. Only Shadows are in trouble. They are static and do not movimental with sunlight.
MystyMood could be an option? Or this very old and should no longer be used?
Last edited by NeoNeper; 11/13/13 21:29.
Please! Use easy words to be translated. because my English is not very good! Grateful. _______________________________________________________
|
|
|
Re: Multitex Terrain Normalmapping
[Re: NeoNeper]
#432761
11/14/13 09:51
11/14/13 09:51
|
Joined: Mar 2011
Posts: 3,150 Budapest
sivan
Expert
|
Expert
Joined: Mar 2011
Posts: 3,150
Budapest
|
I think Mystimoods is limited in tile texture quantity.
------------------------------------------------------- My terrain shaders use: a base colormap (24bit) max. 7 tiled textures (32b, blending on alpha) a static lightmap.
the base colormap is used by water mirror view, and to decrease repetitivness of tiled textures, and its blending strength can be adjusted. if no lightmap, no problem, there are 2 pixel shaders to handle it automatically. if less tiled textures are set, no problem too, it works fine.
Last edited by sivan; 11/14/13 09:55.
|
|
|
Re: Multitex Terrain Normalmapping
[Re: Dooley]
#457933
02/08/16 08:00
02/08/16 08:00
|
Joined: Mar 2011
Posts: 3,150 Budapest
sivan
Expert
|
Expert
Joined: Mar 2011
Posts: 3,150
Budapest
|
yeah, it is still on my C:\, I can upload the full package, but here is the terrain related stuff. moreover I can make easily a new MapBuilder update with a terrain multitexturing shader with normal and specular map support, if there is a request from the crowd of this community... terrain_materials.c
///////////////////////////////////////////////////////////////////////////////////////////////////
////MystyMood terrain materias. Just to keep the terrain_template more tidy!
////
////Jun 07 by www.loopix-project.com
////Nov 07 Lite-C conversion by Alexis Rozhkov aka Shadow
///////////////////////////////////////////////////////////////////////////////////////////////////
////bitmaps for terrain 1
BMAP* terr_blendtex_red_1 = "terr_red_1.bmp";
BMAP* terr_blendtex_green_1 = "terr_green_1.bmp";
BMAP* terr_blendtex_blue_1 = "terr_blue_1.bmp";
BMAP* terr_blendtex_black_1 = "terr_black_1.bmp";
BMAP* terr_colormap_1 = "terr_colormap_1.bmp";
BMAP* terr_detailmap_1 = "terr_detailmap_1.bmp";
BMAP* terr_shadowmap_1 = "terr_shadowmap_1.tga";
////bitmaps for terrain 2
//bmap terr_blendtex_red_2 = "terr_red_2.bmp";
//bmap terr_blendtex_green_2 = "terr_green_2.bmp";
//bmap terr_blendtex_blue_2 = "terr_blue_2.bmp";
//bmap terr_blendtex_black_2 = "terr_black_2.bmp";
//bmap terr_colormap_2 = "terr_colormap_2.bmp";
//bmap terr_detailmap_2 = "terr_detailmap_2.bmp";
//bmap terr_shadowmap_2 = "terr_shadowmap_2.tga";
////bitmaps for terrain 3
//bmap terr_blendtex_red_3 = "terr_red_3.bmp";
//bmap terr_blendtex_green_3 = "terr_green_3.bmp";
//bmap terr_blendtex_blue_3 = "terr_blue_3.bmp";
//bmap terr_blendtex_black_3 = "terr_black_3.bmp";
//bmap terr_colormap_3 = "terr_colormap_3.bmp";
//bmap terr_detailmap_3 = "terr_detailmap_3.bmp";
//bmap terr_shadowmap_3 = "terr_shadowmap_3.tga";
////bitmaps for terrain 4
//bmap terr_blendtex_red_4 = "terr_red_4.bmp";
//bmap terr_blendtex_green_4 = "terr_green_4.bmp";
//bmap terr_blendtex_blue_4 = "terr_blue_4.bmp";
//bmap terr_blendtex_black_4 = "terr_black_4.bmp";
//bmap terr_colormap_4 = "terr_colormap_4.bmp";
//bmap terr_detailmap_4 = "terr_detailmap_4.bmp";
//bmap terr_shadowmap_4 = "terr_shadowmap_4.tga";
//add more bitmap-sets for more terrains...
//prototype functions
function mat_terr_hlsl_refl_event();
//function mat_terr_hlsl_no_caust_refl_event();
function init_mat_terr_hlsl();
function init_mat_terr_ffe();
//HLSL MATERIALS FOR TERRAINS
MATERIAL* mat_terr_hlsl_1 =
{
flags = tangent;
skin1 = terr_blendtex_red_1;
skin2 = terr_blendtex_green_1;
skin3 = terr_blendtex_blue_1;
skin4 = terr_blendtex_black_1;
event=init_mat_terr_hlsl;
effect
"
/////////////////////////////////////////////////////////////////////////////////////////////
// Define your needed values
float4x4 matWorldViewProj;
float4x4 matWorld;
float4x4 matWorldInv;
float4x4 matWorldView;
float4 mtlSkill1;
float4 mtlSkill2;
float4 vecSkill41;
float4 vecSunDir;
float4 vecFog;
float4 vecLight;
float4 vecLightPos[8]; // preset this with light positions (xyz) and ranges (w)
float4 vecLightColor[8]; // preset this with light colors
float3 vecFalloff = float3(0.f, 0.f, 1.5f);
float4 vecSunDiffuse = {1.0f, 1.0f, 0.8f, 1.0f};
float sunStrength = 0.3f;
float dynalightStrength = 10;
// Define your textures
texture mtlSkin1;
texture mtlSkin2;
texture mtlSkin3;
texture mtlSkin4;
texture entSkin1;
texture entSkin2;
texture entSkin3;
texture entSkin4;
/////////////////////////////////////////////////////////////////////////////////////////////
// Texture settings
sampler sTex1 = sampler_state
{
Texture = <entSkin1>; // rgb-blendmap
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
};
sampler sTex2 = sampler_state
{
Texture = <entSkin2>; // shadowmap
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
};
sampler sTex3 = sampler_state
{
Texture = <entSkin3>; // causticsA
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
};
sampler sTex4= sampler_state
{
Texture = <entSkin4>; // causticsB
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
};
sampler sTex5 = sampler_state
{
Texture = <mtlSkin1>; // red
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
};
sampler sTex6 = sampler_state
{
Texture = <mtlSkin2>; // green
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
};
sampler sTex7 = sampler_state
{
Texture = <mtlSkin3>; // blue
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
};
sampler sTex8 = sampler_state
{
Texture = <mtlSkin4>; // black
MipFilter = Linear;
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Wrap;
};
//////////////////////////////////////////////////////////////////////
// return the sun light on the surface
float4 DoSunLight(float3 N)
{
// modulate the sunlight by the surface angle
return vecSunDiffuse * dot(N,-vecSunDir);
}
// return the dynamic light on the surface
float4 DoPointLight(float3 P, float3 N, int i)
{
// calculate the light ray pointing from the light to the surface
float3 D = vecLightPos[i].xyz - P;
// calculate the angle between surface and light ray
float NdotL = dot(N, normalize(D));
// modulate the light by the surface angle
float4 Color = vecLightColor[i] * NdotL;
// calculate the light attenuation factor, DX uses a really strange formula here
float fac = 0.f;
if (NdotL >= 0.f && vecLightPos[i].w > 0.f)
{
// get the distance factor
float LD = length(D)/vecLightPos[i].w;
#ifdef DXLIGHTING
if (LD < 1.3f)
fac = 1.f/(vecFalloff.x + vecFalloff.y*LD + vecFalloff.z*LD*LD);
#else // linear Lighting
if (LD < 1.f)
fac = 1.f - LD;
#endif
}
return Color * fac;
}
float DoFog(float4 Pos)
{
// convert the vector position to view space to get it's depth (.z)
float3 P = mul(Pos,matWorldView);
// apply the linear fog formula
return saturate((vecFog.y-P.z) * vecFog.z);
}
struct TMULTI_VS_OUT // Output to the pixelshader fragment
{
float4 Pos : POSITION;
float Fog : FOG;
float4 tColor : COLOR0;
float2 Tex1 : TEXCOORD0;
float2 Tex2 : TEXCOORD1;
float2 Tex3 : TEXCOORD2;
float2 Tex4 : TEXCOORD3;
float2 Tex5 : TEXCOORD4;
float2 Tex6 : TEXCOORD5;
float2 Tex7 : TEXCOORD6;
float2 Tex8 : TEXCOORD7;
};
TMULTI_VS_OUT TMulti_VS(
float4 inPos : POSITION,
float3 inNormal : NORMAL,
float2 inTexCoord0 : TEXCOORD0)
{
TMULTI_VS_OUT Out;
// transform the vector position to screen coordinates
Out.Pos = mul(inPos, matWorldViewProj);
float3 N = normalize(mul(inNormal, matWorldInv));
float3 P = mul(inPos, matWorld);
// Add ambient and sun light
Out.tColor = ((DoSunLight(N) - 0.2f)*sunStrength)+0.6;
// Add 8 dynamic lights (maximum for vs 1.1)
for (int i=0; i<6; i++)
Out.tColor += DoPointLight(P,N,i)*dynalightStrength;
// Add fog
Out.Fog = DoFog(inPos);
// scale the texture coordinates for the masked textures
Out.Tex1 = inTexCoord0.xy; // rgb-blendmap (not tiled)
Out.Tex2 = inTexCoord0.xy; // shadowmap (not tiled)
Out.Tex3 = (inTexCoord0.xy*vecSkill41.w+vecSkill41.w/50)+0.1* vecSkill41.xy;//sin(vecSkill41);//moving the caustics texture
Out.Tex4 = (inTexCoord0.xy*vecSkill41.w)-0.1* vecSkill41.y;//moving the caustics texture
Out.Tex5 = inTexCoord0.xy*40; // tiling texture red
Out.Tex6 = inTexCoord0.xy*60; // tiling texture green
Out.Tex7 = inTexCoord0.xy*20; // tiling texture blue
Out.Tex8 = inTexCoord0.xy*40; // tiling texture black
return Out;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// pixelshader
float4 ps( TMULTI_VS_OUT In ) : COLOR
{
float4 BlendColor = tex2D(sTex1,In.Tex1);
float4 ShadowMap = (tex2D(sTex2,In.Tex2)*1.5);
float4 causticsA = tex2D(sTex3,In.Tex3);
float4 causticsB = tex2D(sTex4,In.Tex4);
float4 RedColor = tex2D(sTex5,In.Tex5);
float4 GreenColor = tex2D(sTex6,In.Tex6);
float4 BlueColor = tex2D(sTex7,In.Tex7);
float4 BlackColor = tex2D(sTex8,In.Tex8);
float4 BaseRed = lerp(BlackColor,RedColor,BlendColor.r);
float4 BaseGreen = lerp(BaseRed,GreenColor,BlendColor.g);
float4 FinalColor = lerp(BaseGreen,BlueColor,BlendColor.b);
float4 BaseCaustics = lerp(FinalColor,(FinalColor*(causticsA+causticsB)),(ShadowMap.a*mtlSkill2));
//////////////////////////////////////////////////////////////////////////////////////////////
FinalColor = In.tColor*(BaseCaustics*(ShadowMap));
FinalColor = (FinalColor*mtlSkill1)*(ShadowMap);
FinalColor.a = 1.0f; // prevent transparency
return FinalColor;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
//
technique mytechnique
{
// Define your passes
pass p0
{
VertexShader = compile vs_2_0 TMulti_VS();
PixelShader = compile ps_2_0 ps();
}
}
technique fallback{pass p0{}}
";
}
//MATERIAL* mat_terr_hlsl_2 =
//{
//
// flags = tangent;
//
// skin1 = terr_blendtex_red_2;
// skin2 = terr_blendtex_green_2;
// skin3 = terr_blendtex_blue_2;
// skin4 = terr_blendtex_black_2;
//
// event=init_mat_terr_hlsl;
//
// effect
// "
// /////////////////////////////////////////////////////////////////////////////////////////////
// // Define your needed values
// float4x4 matWorldViewProj;
// float4x4 matWorld;
// float4x4 matWorldInv;
// float4x4 matWorldView;
//
// float4 mtlSkill1;
// float4 mtlSkill2;
//
// float4 vecSkill41;
//
//
// float4 vecSunDir;
// float4 vecFog;
// float4 vecLight;
//
// float4 vecLightPos[8]; // preset this with light positions (xyz) and ranges (w)
// float4 vecLightColor[8]; // preset this with light colors
// float3 vecFalloff = float3(0.f, 0.f, 1.5f);
// float4 vecSunDiffuse = {1.0f, 1.0f, 0.8f, 1.0f};
//
// float sunStrength = 0.3f;
// float dynalightStrength = 10;
//
// // Define your textures
// texture mtlSkin1;
// texture mtlSkin2;
// texture mtlSkin3;
// texture mtlSkin4;
//
// texture entSkin1;
// texture entSkin2;
// texture entSkin3;
// texture entSkin4;
//
// /////////////////////////////////////////////////////////////////////////////////////////////
// // Texture settings
//
//
// sampler sTex1 = sampler_state
// {
// Texture = <entSkin1>; // rgb-blendmap
// MipFilter = Linear;
// MinFilter = Linear;
// MagFilter = Linear;
// AddressU = Wrap;
// AddressV = Wrap;
// };
// sampler sTex2 = sampler_state
// {
// Texture = <entSkin2>; // shadowmap
// MipFilter = Linear;
// MinFilter = Linear;
// MagFilter = Linear;
// AddressU = Wrap;
// AddressV = Wrap;
// };
// sampler sTex3 = sampler_state
// {
// Texture = <entSkin3>; // causticsA
// MipFilter = Linear;
// MinFilter = Linear;
// MagFilter = Linear;
// AddressU = Wrap;
// AddressV = Wrap;
// };
// sampler sTex4= sampler_state
// {
// Texture = <entSkin4>; // causticsB
// MipFilter = Linear;
// MinFilter = Linear;
// MagFilter = Linear;
// AddressU = Wrap;
// AddressV = Wrap;
// };
//
//
// sampler sTex5 = sampler_state
// {
// Texture = <mtlSkin1>; // red
// MipFilter = Linear;
// MinFilter = Linear;
// MagFilter = Linear;
// AddressU = Wrap;
// AddressV = Wrap;
// };
// sampler sTex6 = sampler_state
// {
// Texture = <mtlSkin2>; // green
// MipFilter = Linear;
// MinFilter = Linear;
// MagFilter = Linear;
// AddressU = Wrap;
// AddressV = Wrap;
// };
// sampler sTex7 = sampler_state
// {
// Texture = <mtlSkin3>; // blue
// MipFilter = Linear;
// MinFilter = Linear;
// MagFilter = Linear;
// AddressU = Wrap;
// AddressV = Wrap;
// };
// sampler sTex8 = sampler_state
// {
// Texture = <mtlSkin4>; // black
// MipFilter = Linear;
// MinFilter = Linear;
// MagFilter = Linear;
// AddressU = Wrap;
// AddressV = Wrap;
// };
//
// //////////////////////////////////////////////////////////////////////
// // return the sun light on the surface
// float4 DoSunLight(float3 N)
// {
// // modulate the sunlight by the surface angle
// return vecSunDiffuse * dot(N,-vecSunDir);
// }
//
// // return the dynamic light on the surface
// float4 DoPointLight(float3 P, float3 N, int i)
// {
// // calculate the light ray pointing from the light to the surface
// float3 D = vecLightPos[i].xyz - P;
// // calculate the angle between surface and light ray
// float NdotL = dot(N, normalize(D));
// // modulate the light by the surface angle
// float4 Color = vecLightColor[i] * NdotL;
//
// // calculate the light attenuation factor, DX uses a really strange formula here
// float fac = 0.f;
// if (NdotL >= 0.f && vecLightPos[i].w > 0.f)
// {
// // get the distance factor
// float LD = length(D)/vecLightPos[i].w;
// #ifdef DXLIGHTING
// if (LD < 1.3f)
// fac = 1.f/(vecFalloff.x + vecFalloff.y*LD + vecFalloff.z*LD*LD);
// #else // linear Lighting
// if (LD < 1.f)
// fac = 1.f - LD;
// #endif
// }
// return Color * fac;
// }
//
//
// float DoFog(float4 Pos)
// {
// // convert the vector position to view space to get it's depth (.z)
// float3 P = mul(Pos,matWorldView);
// // apply the linear fog formula
// return saturate((vecFog.y-P.z) * vecFog.z);
// }
//
//
// struct TMULTI_VS_OUT // Output to the pixelshader fragment
// {
// float4 Pos : POSITION;
// float Fog : FOG;
//
// float4 tColor : COLOR0;
//
// float2 Tex1 : TEXCOORD0;
// float2 Tex2 : TEXCOORD1;
//
// float2 Tex3 : TEXCOORD2;
// float2 Tex4 : TEXCOORD3;
//
// float2 Tex5 : TEXCOORD4;
// float2 Tex6 : TEXCOORD5;
// float2 Tex7 : TEXCOORD6;
// float2 Tex8 : TEXCOORD7;
// };
//
// TMULTI_VS_OUT TMulti_VS(
// float4 inPos : POSITION,
// float3 inNormal : NORMAL,
// float2 inTexCoord0 : TEXCOORD0)
// {
//
// TMULTI_VS_OUT Out;
//
// // transform the vector position to screen coordinates
// Out.Pos = mul(inPos, matWorldViewProj);
// float3 N = normalize(mul(inNormal, matWorldInv));
// float3 P = mul(inPos, matWorld);
//
// // Add ambient and sun light
// Out.tColor = ((DoSunLight(N) - 0.2f)*sunStrength)+0.6;
//
// // Add 8 dynamic lights (maximum for vs 1.1)
// for (int i=0; i<6; i++)
// Out.tColor += DoPointLight(P,N,i)*dynalightStrength;
//
// // Add fog
// Out.Fog = DoFog(inPos);
//
// // scale the texture coordinates for the masked textures
// Out.Tex1 = inTexCoord0.xy; // rgb-blendmap (not tiled)
// Out.Tex2 = inTexCoord0.xy; // shadowmap (not tiled)
//
// Out.Tex3 = (inTexCoord0.xy*vecSkill41.w+vecSkill41.w/50)+0.1* vecSkill41.xy;//sin(vecSkill41);//moving the caustics texture
// Out.Tex4 = (inTexCoord0.xy*vecSkill41.w)-0.1* vecSkill41.y;//moving the caustics texture
//
// Out.Tex5 = inTexCoord0.xy*40; // tiling texture red
// Out.Tex6 = inTexCoord0.xy*60; // tiling texture green
// Out.Tex7 = inTexCoord0.xy*20; // tiling texture blue
// Out.Tex8 = inTexCoord0.xy*40; // tiling texture black
//
//
//
// return Out;
// }
//
//
// //////////////////////////////////////////////////////////////////////////////////////////////////////
// // pixelshader
// float4 ps( TMULTI_VS_OUT In ) : COLOR
// {
// float4 BlendColor = tex2D(sTex1,In.Tex1);
// float4 ShadowMap = (tex2D(sTex2,In.Tex2)*1.5);
//
// float4 causticsA = tex2D(sTex3,In.Tex3);
// float4 causticsB = tex2D(sTex4,In.Tex4);
//
// float4 RedColor = tex2D(sTex5,In.Tex5);
// float4 GreenColor = tex2D(sTex6,In.Tex6);
// float4 BlueColor = tex2D(sTex7,In.Tex7);
// float4 BlackColor = tex2D(sTex8,In.Tex8);
//
//
// float4 BaseRed = lerp(BlackColor,RedColor,BlendColor.r);
// float4 BaseGreen = lerp(BaseRed,GreenColor,BlendColor.g);
//
//
// float4 FinalColor = lerp(BaseGreen,BlueColor,BlendColor.b);
//
//
// float4 BaseCaustics = lerp(FinalColor,(FinalColor*(causticsA+causticsB)),(ShadowMap.a*mtlSkill2));
//
// //////////////////////////////////////////////////////////////////////////////////////////////
//
//
// FinalColor = In.tColor*(BaseCaustics*(ShadowMap));
//
// FinalColor = (FinalColor*mtlSkill1)*(ShadowMap);
//
// FinalColor.a = 1.0f; // prevent transparency
//
// return FinalColor;
// }
// //////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// technique mytechnique
// {
// // Define your passes
// pass p0
// {
// VertexShader = compile vs_2_0 TMulti_VS();
// PixelShader = compile ps_2_0 ps();
// }
// }
//
//technique fallback{pass p0{}}
//
// ";
//}
//FFE FALLBACK MATERIALS FOR TERRAINS
MATERIAL* mat_terr_ffe_1 =
{
skin1 = terr_colormap_1;
skin2 = terr_detailmap_1;
skin3 = terr_shadowmap_1;
event = init_mat_terr_ffe;
effect = "
float4 mtlSkill1;
Texture mtlSkin1;
Texture mtlSkin2;
Texture mtlSkin3;
texture mtlSkin4;
technique technique_two
{
pass p0
{
Texture[0] = <mtlSkin1>;
Texture[1] = <mtlSkin2>;
Texture[2]=<mtlSkin3>;
ColorArg1[0] = Texture;
ColorOp[0] = modulate2x;
ColorArg2[0] = current;
ColorArg1[1] = Texture;
ColorOp[1] = addsigned;
TextureTransformFlags[0] = Disable;
TexCoordIndex[0] = 0;
TextureTransformFlags[1] = Count2;
TexCoordIndex[1] = 1;
TextureTransform[1]= {
8.0, 0.0, 0.0 ,0.0,//u-scale detailmap CHANGE THIS TO YOUR NEEDS!
0.0, 8.0, 0.0, 0.0,//v-scale detailmap CHANGE THIS TO YOUR NEEDS!
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0
};
ColorArg1[2]=Texture;
ColorOp[2]=Modulate;
ColorArg2[2]=Current;
TexCoordIndex[2]=0;
TextureTransformFlags[2]=Count2;
TextureTransform[2]={1.0,0.0,0.0,0.0,
0.0,1.0,0.0,0.0,
0.0,0.0,0.0,0.0,
0.0,0.0,0.0,0.0};
Texture[4] = <mtlSkin4>;//alpha in this texture makes entSkin1-texture transparent
TexCoordIndex[4] = 0;
ColorArg1[4] = <mtlSkill1>;//Current;// Get current texture (0)
ColorOp[4] = Modulate2x;//ModulateAlpha_AddColor;//and add alpha to indicate transparency
ColorArg2[4] = Current;
}
}
";
}
//MATERIAL* mat_terr_ffe_2 =
//{
//
// skin1 = terr_colormap_2;
// skin2 = terr_detailmap_2;
//
// skin3 = terr_shadowmap_2;
//
// event = init_mat_terr_ffe;
//
// effect = "
//
// float4 mtlSkill1;
//
// Texture mtlSkin1;
// Texture mtlSkin2;
//
// Texture mtlSkin3;
//
// texture mtlSkin4;
//
// technique technique_two
// {
// pass p0
// {
// Texture[0] = <mtlSkin1>;
// Texture[1] = <mtlSkin2>;
//
// Texture[2]=<mtlSkin3>;
//
//
// ColorArg1[0] = Texture;
// ColorOp[0] = modulate2x;
// ColorArg2[0] = current;
//
// ColorArg1[1] = Texture;
// ColorOp[1] = addsigned;
//
// TextureTransformFlags[0] = Disable;
// TexCoordIndex[0] = 0;
//
// TextureTransformFlags[1] = Count2;
// TexCoordIndex[1] = 1;
// TextureTransform[1]= {
// 15.0, 0.0, 0.0 ,0.0,//u-scale detailmap CHANGE THIS TO YOUR NEEDS!
// 0.0, 15.0, 0.0, 0.0,//v-scale detailmap CHANGE THIS TO YOUR NEEDS!
// 0.0, 0.0, 0.0, 0.0,
// 0.0, 0.0, 0.0, 0.0
// };
//
//
// ColorArg1[2]=Texture;
// ColorOp[2]=Modulate;
// ColorArg2[2]=Current;
// TexCoordIndex[2]=0;
// TextureTransformFlags[2]=Count2;
// TextureTransform[2]={1.0,0.0,0.0,0.0,
// 0.0,1.0,0.0,0.0,
// 0.0,0.0,0.0,0.0,
// 0.0,0.0,0.0,0.0};
//
//
// Texture[4] = <mtlSkin4>;//alpha in this texture makes entSkin1-texture transparent
//
// TexCoordIndex[4] = 0;
//
// ColorArg1[4] = <mtlSkill1>;//Current;// Get current texture (0)
// ColorOp[4] = Modulate2x;//ModulateAlpha_AddColor;//and add alpha to indicate transparency
// ColorArg2[4] = Current;
// }
// }
// ";
//}
function mat_terr_hlsl_refl_event()
{
if(render_view != view_rr)//displays shader terrain above watersurface...the real terrain
{
if(my.terr_id_number == 1){
mtl = mat_terr_hlsl_1;
}
// if(my.terr_id_number == 2){
// mtl = mat_terr_hlsl_2;
// }
// if(my.terr_id_number == 3){
// mtl = mat_terr_hlsl_3;
// }
// if(my.terr_id_number == 4){
// mtl = mat_terr_hlsl_4;
// }
////add more terrain materials the same way...
mtl.skill1 = pixel_for_vec (vector(clamp((d3d_fogcolor1.blue*my.terr_fogcol_fac)+(my.terr_add_blue*clamp(sun_angle.tilt/30,0.4,1))+(lightning),0,255),clamp((d3d_fogcolor1.green*my.terr_fogcol_fac)+(my.terr_add_green*clamp(sun_angle.tilt/30,0.4,1))+(lightning),0,255),clamp((d3d_fogcolor1.red*my.terr_fogcol_fac)+(my.terr_add_red*clamp(sun_angle.tilt/30,0.4,1))+(lightning),0,255)),100,8888);
if(is(my,terr_no_caustics)){
mtl.skill2 = pixel_for_vec(vector(0,0,0),100,8888);
}
else{
mtl.skill2 = pixel_for_vec(vector(my.terr_caust_strenght,my.terr_caust_strenght,my.terr_caust_strenght),100,8888);
}
}
else//displays ffe terrain on reflecting watersurface...because shader terrain doesen't display correctly in a render to texture view
{
if(my.terr_id_number == 1){
mtl = mat_terr_ffe_1;
}
// if(my.terr_id_number == 2){
// mtl = mat_terr_ffe_2;
// }
// if(my.terr_id_number == 3){
// mtl = mat_terr_ffe_3;
// }
// if(my.terr_id_number == 4){
// mtl = mat_terr_ffe_4;
// }
////add more terrain materials the same way...
vec_set(mtl.ambient_blue,vector(clamp((d3d_fogcolor1.blue*my.terr_fogcol_fac)+(my.terr_add_blue*clamp(sun_angle.tilt/30,0.2,1))+(lightning),0,255),clamp((d3d_fogcolor1.green*my.terr_fogcol_fac)+(my.terr_add_green*clamp(sun_angle.tilt/30,0.2,1))+(lightning),0,255),clamp((d3d_fogcolor1.red*my.terr_fogcol_fac)+(my.terr_add_red*clamp(sun_angle.tilt/30,0.2,1))+(lightning),0,255)));
}
}
function init_mat_terr_hlsl()
{
bmap_to_mipmap(mtl.skin1);
bmap_to_mipmap(mtl.skin2);
bmap_to_mipmap(mtl.skin3);
bmap_to_mipmap(mtl.skin4);
if(is(view_rr,VISIBLE))
{
mtl.event = mat_terr_hlsl_refl_event;
}
else{
mtl.skill1 = pixel_for_vec(vector(clamp((d3d_fogcolor1.blue*my.terr_fogcol_fac)+(my.terr_add_blue*clamp(sun_angle.tilt/30,0.4,1))+(lightning),0,255),clamp((d3d_fogcolor1.green*my.terr_fogcol_fac)+(my.terr_add_green*clamp(sun_angle.tilt/30,0.4,1))+(lightning),0,255),clamp((d3d_fogcolor1.red*my.terr_fogcol_fac)+(my.terr_add_red*clamp(sun_angle.tilt/30,0.4,1))+(lightning),0,255)),100,8888);
if(is(my,terr_no_caustics)){
mtl.skill2 = pixel_for_vec(vector(0,0,0),100,8888);
}
else{
mtl.skill2 = pixel_for_vec(vector(my.terr_caust_strenght,my.terr_caust_strenght,my.terr_caust_strenght),100,8888);
}
}
set(mtl,ENABLE_RENDER);
}
function init_mat_terr_ffe()
{
bmap_to_mipmap(mtl.skin1);
bmap_to_mipmap(mtl.skin2);
vec_set(mtl.ambient_blue,vector(clamp((d3d_fogcolor1.blue*my.terr_fogcol_fac)+(my.terr_add_blue*clamp(sun_angle.tilt/30,0.2,1))+(lightning),0,255),clamp((d3d_fogcolor1.green*my.terr_fogcol_fac)+(my.terr_add_green*clamp(sun_angle.tilt/30,0.2,1))+(lightning),0,255),clamp((d3d_fogcolor1.red*my.terr_fogcol_fac)+(my.terr_add_red*clamp(sun_angle.tilt/30,0.2,1))+(lightning),0,255)));
set(mtl,ENABLE_RENDER);
}
terrain_templte.c
///////////////////////////////////////////////////////////////////////////////////////////////////
////MystyMood multitexture-terrainshader that makes it easy to implement terrains made
////with EarthSculptor (http://www.earthsculptor.com/) into 3dgs. It's able to blend 4 textures and
////I also included an underwater multicaustics wave sun reflectionand and easy shadowmap generation.
////Contains ffe fallbacks, supports dynamic lights and sunlight and A6 stencil shadows
////
////NEEDS: terrain_materials.wdl
////
////Jun 07 by www.loopix-project.com
////Nov 07 Lite-C conversion by Alexis Rozhkov aka Shadow
///////////////////////////////////////////////////////////////////////////////////////////////////
#define terr_add_red skill1 //add a color tint
#define terr_add_green skill2
#define terr_add_blue skill3
#define terr_fogcol_fac skill4//factor of focgcolor1 influence
#define terr_caust_speed skill5//speed of the underwater caustics (sun-wave reflection)
#define terr_caust_scale skill6//scale of the underwater caustics
#define terr_caust_strenght skill7
#define terr_id_number skill8//scale of the underwater caustics
#define terr_ffe_only FLAG1//check this flag if you don't want shader terrain (looks not so good)
#define terr_shad_gen FLAG3//check this flag for generating the shadowmap (static-shadowmap...uncheck for normal terrain use)
#define terr_no_caustics FLAG4//flag to disable underwater caustics
////this loads the terrain_material.wdl wich is needed
#include "terrain_materials.c"
//string terr_shadowmap_string = "terr_shadowmap_1.tga";
STRING* terr_shadowmap_str = "terr_shadowmap_";
STRING* terr_shadowmap_tempstr1 = "";
STRING* terr_shadowmap_tempstr2 = "";
STRING* terr_shadowmap_filetype = ".tga";//for terr_shadowmap: terr_shadowmap.tga...
////SHADOWMAP GENERATION ADJUSTMENTS TO BE MADE HERE!
var shadow_brightness=120;//brightness of shadows...(0=black, 255=white)
var shadow_pixel_z_adjust = -1;//play with this within a range of -5 to 5! This affects the shadow offset from the object
var blur_passes = 1;//the higher the softer the borders of the shadows
BMAP* canvas_shadowmap;
VECTOR canvas_shadowmap_size;
FONT* fnt_arial = "arial#25";
STRING* strg_wait_shadow_gen = "Please wait...shadowmap-generation is progressing...\n This can take some time...";
STRING* strg_shadow_finished = "Shadowmap is now generated and saved to your project folder!";
STRING* strg_press_shadow_gen = "Press 'G' to generate shadowmap!";
TEXT* txt_wait_shadow_gen =
{
font = fnt_arial;
layer = 10;
flags = center_x,center_y,outline;
string = strg_wait_shadow_gen;
red = 255;
green = 0;
blue = 0;
}
TEXT* txt_shadow_finished =
{
font = fnt_arial;
layer = 10;
flags = center_x,center_y,outline;
string = strg_shadow_finished;
red = 0;
green = 255;
blue = 0;
}
TEXT* txt_press_shadow_gen =
{
font = fnt_arial;
layer = 10;
flags = center_x,center_y,outline;
string = strg_press_shadow_gen;
red = 0;
green = 0;
blue = 255;
}
var shadow_fhandle_n;
//---------------------------------------------------------write tga
function shadow_write8(var shadow_byte) // write char
{
file_asc_write(shadow_fhandle_n,shadow_byte);
}
function shadow_write16(var shadow_short) // write unsigned shadow_short
{
file_asc_write(shadow_fhandle_n,shadow_short&255);
file_asc_write(shadow_fhandle_n,(shadow_short>>8)&255);
}
function write_shadowmap_tga(shadowmap_file_name)
{
var i;
var format;
var pixel;
var pixelalpha;
VECTOR canvas_shadowmap_size;
VECTOR temp;
canvas_shadowmap_size.x=bmap_width(canvas_shadowmap);
canvas_shadowmap_size.y=bmap_height(canvas_shadowmap);
format=bmap_lock(canvas_shadowmap,0);
shadow_fhandle_n=file_open_write(shadowmap_file_name);
//------------------------------------write header
shadow_write8(0);
shadow_write8(0);
shadow_write8(2); // image type // 10 = RLE compressed tga, 2 = uncompressed tga
shadow_write16(0);
shadow_write16(0);
shadow_write8(0);
shadow_write16(0);
shadow_write16(0);
shadow_write16(canvas_shadowmap_size.x); // width
shadow_write16(canvas_shadowmap_size.y); // height
shadow_write8(24);//or 32 for alphachanel
shadow_write8(0);
//------------------------------------write image data
i=0;
while(i<canvas_shadowmap_size.x*canvas_shadowmap_size.y)
{
pixel = pixel_for_bmap(canvas_shadowmap,i%canvas_shadowmap_size.x,(canvas_shadowmap_size.y-1)-integer(i/canvas_shadowmap_size.x));
pixel_to_vec(temp,pixelalpha,format,pixel);
shadow_write8(temp.x); // b
shadow_write8(temp.y); // g
shadow_write8(temp.z); // r
i+=1;
if(i%max_loops == 0){wait(1);}
}
wait(1);
file_close(shadow_fhandle_n);
bmap_unlock(canvas_shadowmap);
reset(txt_wait_shadow_gen,VISIBLE);
txt_shadow_finished.pos_x = screen_size.x/2;
txt_shadow_finished.pos_y = screen_size.y/2;
set(txt_shadow_finished,VISIBLE);
wait(-4);
reset(txt_shadow_finished,VISIBLE);
}
function shadow_get_xyz(shadow_px,shadow_py)
{
VECTOR pixel_size;
VECTOR temp;
pixel_size.x=(my.max_x-my.min_x)/canvas_shadowmap_size.x;
pixel_size.y=(my.max_y-my.min_y)/canvas_shadowmap_size.y;
temp.x=((my.x-my.min_x)-(pixel_size.x*shadow_px))-pixel_size.x/2;
temp.y=((my.y-my.min_y)-(pixel_size.y*shadow_py))-pixel_size.y/2;
c_trace(vector(temp.x,temp.y,my.z+50000),vector(temp.x,temp.y,my.z-50000),IGNORE_MODELS+IGNORE_SPRITES+IGNORE_MAPS);
temp.z=target.z;
}
////blur
function blur(var passes)
{
var i;
var px;
var py;
var format;
var pixel;
VECTOR pixelcolor;
var pixelalpha;
VECTOR sample1;
VECTOR sample2;
VECTOR sample3;
VECTOR sample4;
VECTOR sample5;
VECTOR sample6;
VECTOR sample7;
VECTOR sample8;
VECTOR sample9;
VECTOR temp;
i=0;
while(i<passes)
{
py=0;
while(py<canvas_shadowmap_size.y)
{
px=0;
while(px<canvas_shadowmap_size.x)
{
format=bmap_lock(canvas_shadowmap,0);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px,0,canvas_shadowmap_size.x-1),clamp(py,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample1,pixelalpha,format,pixel);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px-1,0,canvas_shadowmap_size.x-1),clamp(py,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample2,pixelalpha,format,pixel);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px-1,0,canvas_shadowmap_size.x-1),clamp(py+1,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample3,pixelalpha,format,pixel);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px,0,canvas_shadowmap_size.x-1),clamp(py+1,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample4,pixelalpha,format,pixel);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px+1,0,canvas_shadowmap_size.x-1),clamp(py+1,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample5,pixelalpha,format,pixel);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px+1,0,canvas_shadowmap_size.x-1),clamp(py,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample6,pixelalpha,format,pixel);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px+1,0,canvas_shadowmap_size.x-1),clamp(py-1,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample7,pixelalpha,format,pixel);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px,0,canvas_shadowmap_size.x-1),clamp(py-1,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample8,pixelalpha,format,pixel);
pixel=pixel_for_bmap(canvas_shadowmap,clamp((canvas_shadowmap_size.x-1)-px-1,0,canvas_shadowmap_size.x-1),clamp(py-1,0,canvas_shadowmap_size.x-1));
pixel_to_vec(sample9,pixelalpha,format,pixel);
pixelcolor.x=integer((sample1.x*7+sample2.x*2+sample3.x+sample4.x*2+sample5.x+sample6.x*2+sample7.x+sample8.x*2+sample9.x)/19);
pixelcolor.y=integer((sample1.y*7+sample2.y*2+sample3.y+sample4.y*2+sample5.y+sample6.y*2+sample7.y+sample8.y*2+sample9.y)/19);
pixelcolor.z=integer((sample1.z*7+sample2.z*2+sample3.z+sample4.z*2+sample5.z+sample6.z*2+sample7.z+sample8.z*2+sample9.z)/19);
pixel=pixel_for_vec(pixelcolor,100,format);
pixel_to_bmap(canvas_shadowmap,(canvas_shadowmap_size.x-1)-px,py,pixel);
bmap_unlock(canvas_shadowmap);
px+=1;
}
py+=1;
wait(1); // without a wait after each line the loop could get too big if the shadow map is huge
}
i+=1;
}
write_shadowmap_tga(terr_shadowmap_tempstr1);
}
function shadowmap_gen()
{
//NOTE: YOUR TERRAIN ACTION MUST INCLUDE "C_SETMINMAX(ME); MY.POLYGON=ON;" AT THE VERY BEGINING!!!
reset(txt_press_shadow_gen,VISIBLE);
var shadow_px;
var shadow_py;
var format;
var pixel;
var dist;
VECTOR temp;
canvas_shadowmap=bmap_for_entity(my,2); // the second texture of the terrain is the shadowmap
canvas_shadowmap_size.x=bmap_width(canvas_shadowmap);
canvas_shadowmap_size.y=bmap_height(canvas_shadowmap);
you = my;//need this pointer to avoid terrain self-shadows
shadow_py=0;
while(shadow_py<canvas_shadowmap_size.y)
{
shadow_px=0;
while(shadow_px<canvas_shadowmap_size.x)
{
shadow_get_xyz(shadow_px,shadow_py); // get the world coordinates of the pixel
c_trace(sun_pos.x,vector(temp.x,temp.y,temp.z+(shadow_pixel_z_adjust)),IGNORE_PASSENTS); // trace from the sun to the pixel
if(trace_hit && you != my) // draw shadow pixel if there is no obstacle. Only draws shadows if the you entity is not the ent_terrain
{
format=bmap_lock(canvas_shadowmap,0);
pixel=pixel_for_vec(vector(shadow_brightness,shadow_brightness,shadow_brightness),100,format);
pixel_to_bmap(canvas_shadowmap,(canvas_shadowmap_size.x-1)-shadow_px,shadow_py,pixel);
bmap_unlock(canvas_shadowmap);
}
shadow_px+=1;
}
shadow_py+=1;
txt_wait_shadow_gen.pos_x = screen_size.x/2;
txt_wait_shadow_gen.pos_y = screen_size.y/2;
set(txt_wait_shadow_gen,VISIBLE);
wait(1); // without a wait after each line the loop could get too big if the shadow map is huge
}
blur(blur_passes); // do blur pass
}
MATERIAL* mat_terr_shadowmap =
{
effect=
"
texture mtlSkin1;
texture entSkin2;
technique one_pass_shadow
{
pass p0
{
Texture[0]=<mtlSkin1>;
Texture[1]=<entSkin2>;
ColorArg1[0]=Texture;
ColorOp[0]=Modulate2x;
ColorArg2[0]=Diffuse;
TexCoordIndex[0]=0;
TextureTransformFlags[0]=Count2;
TextureTransform[0]={1.0,0.0,0.0,0.0, // color map u scale
0.0,1.0,0.0,0.0, // color map v scale
0.0,0.0,0.0,0.0,
0.0,0.0,0.0,0.0};
ColorArg1[1]=Texture;
ColorOp[1]=Modulate;
ColorArg2[1]=Current;
TexCoordIndex[1]=0;
TextureTransformFlags[1]=Count2;
TextureTransform[1]={1.0,0.0,0.0,0.0,
0.0,1.0,0.0,0.0,
0.0,0.0,0.0,0.0,
0.0,0.0,0.0,0.0};
}
}
";
}
//title:MystyMood Terrain Template
//image:loopix_logo.pcx
//action:act_terrain
//skill1:terr_add_red 150
//help: terrain tint red 0-255
//skill2:terr_add_green 150
//help: terrain tint green 0-255
//skill3:terr_add_blue 150
//help: terrain tint blue 0-255
// section:
//skill4:terr_fogcol_fac 0.500
//help: influence of fogcolor1 on terrain 0...1
// section:
//skill5:terr_caust_speed 0.050
//help: underwater caustics speed
//skill6:terr_caust_scale 40.000
//help: underwater caustics scale
//section:
//skill7:terr_caust_strenght 150
//help: defines the visibility strenght of underwater caustics
//section:
//skill8:terr_id_number 1
//help: defines the terrain wich is needed to choose the corresponding material
// section:
//text: flag for non shader terrain only
//flag1:terr_ffe_only 0
// section:
//text: flag for shadow generation mode (pressing "g")...uncheck when done
//flag3:terr_shad_gen 0
// section:
//text: flag for disableing underwater caustics
//flag4:terr_no_caustics 0
//uses:terr_add_red,terr_add_green,terr_add_blue,terr_fogcol_fac,terr_ffe_only,terr_spec_pow_ffe,terr_shad_gen,terr_caust_speed,terr_caust_scale,terr_no_caustics,terr_caust_strenght,terr_id_number
action act_terrain() {
ent_terrain = me;
// my.x = 0;
// my.y = 0;
// my.z = 0;
c_setminmax(me);
wait(1);
set(my,POLYGON);
//if youn want to implement a SEED_IT (www.gameus.de) object seed-action, do it right here!
//set defaults
if(!my.terr_fogcol_fac){my.terr_fogcol_fac = 0.2;}
if(!my.terr_add_blue){my.terr_add_blue = 150;}
if(!my.terr_add_green){my.terr_add_green = 150;}
if(!my.terr_add_red){my.terr_add_red = 150;}
if(!my.terr_caust_speed){my.terr_caust_speed = 0.05;}
if(!my.terr_caust_scale){my.terr_caust_scale = 40;}
if(!my.terr_caust_strenght){my.terr_caust_strenght = 150;}
if(!my.terr_id_number){my.terr_id_number = 1;}
////this is to find the according shadowmap
str_cpy(terr_shadowmap_tempstr1,terr_shadowmap_str);
str_for_num(terr_shadowmap_tempstr2,ent_terrain.terr_id_number);
str_cat(terr_shadowmap_tempstr1,terr_shadowmap_tempstr2);
str_cat(terr_shadowmap_tempstr1,terr_shadowmap_filetype);
wait(1);
var count;
var a ;
if(!is(my,terr_shad_gen)){
if(d3d_shaderversion >= 2020 && !is(my,terr_ffe_only)){
if(my.terr_id_number == 1){
my.material = mat_terr_hlsl_1;
}
// if(my.terr_id_number == 2){
// my.material = mat_terr_hlsl_2;
// }
// if(my.terr_id_number == 3){
// my.material = mat_terr_hlsl_3;
// }
// if(my.terr_id_number == 4){
// my.material = mat_terr_hlsl_4;
// }
////add more terrain materials the same way...
my.skill44 = floatv(my.terr_caust_scale);
while(1){
my.skill41 = floatv(count);
my.skill42 = floatv(-count);
a += my.terr_caust_speed*time_step;
count = a;
wait(1);
}
}
else{
if(my.terr_id_number == 1){
my.material = mat_terr_ffe_1;
}
// if(my.terr_id_number == 2){
// my.material = mat_terr_ffe_2;
// }
// if(my.terr_id_number == 3){
// my.material = mat_terr_ffe_3;
// }
// if(my.terr_id_number == 4){
// my.material = mat_terr_ffe_4;
// }
////add more terrain materials the same way...
}
}
else{//when in shadowmap generation mode...
dynamic_day_night = 0;
// sun_angle.pan = sun_azimuth;
// sun_angle.tilt = sun_elevation;
my.material = mat_terr_shadowmap;
txt_press_shadow_gen.pos_x = screen_size.x/2;
txt_press_shadow_gen.pos_y = screen_size.y/2;
set(txt_press_shadow_gen,VISIBLE);
while(key_g == 0){wait(1);}
shadowmap_gen();
reset(txt_press_shadow_gen,VISIBLE);
}
}
|
|
|
|