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);
}
}
|
