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

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