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

	// 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.5f)*sunStrength)+0.7;
		
		// Add 8 dynamic lights (maximum for vs 1.1)
		for (int i=0; i<6; i++)
		Out.tColor += DoPointLight(P,N,i);
		
		// 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*150;	// tiling texture red
		Out.Tex6  = inTexCoord0.xy*210;	// tiling texture green
		Out.Tex7  = inTexCoord0.xy*70;	// tiling texture blue
		Out.Tex8  = inTexCoord0.xy*180;	// 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);
		
		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*(ShadowMap*1.5)*(BaseCaustics);
		
		FinalColor = (FinalColor)*(mtlSkill1);
		
		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{}}
	
	";
}

function generate_grass()
{
	while(player==null){wait(1);}
	var player_position1;
	var player_position2;
	while (1)
	{
		vec_set (temp.x, camera.x);
		temp.x += 2200 - random(3500);
		vec_set (temp.y, camera.y);
		temp.y += 2200 - random(3500);
		temp.z = camera.z + 200;
		if (zendan_var==0 && anbari_var==0 && bighome_var==0 && ghar_var==0 && stabl_var==0)//dar dakhele sakhtemanha alaf dar nayad
		{	
			// not too close to the player and the player has moved recently?
			if ((abs(temp.x - camera.x) > 800) || (abs(temp.y - camera.y) > 800) && temp.z>water_level && beach_level_var==0 )
			{
				// increase the nexus if you want to have more than 2000 bushes at once
				if (((player_position1.x != player_position2.x) && (number_of_bushes <2000) ) || (total_frames < 300) )//temp.y baraye inke too sahel dar nayad
				{
					if (random(1) > 0.1 )
					{
						ent_create (grass1_mdl, temp.x, place_grass);
					}
					else
					{
						ent_create (grass2_mdl, temp.x, place_grass2);
					}
				}
				vec_set (player_position1.x, camera.x);
				wait (1);
				vec_set (player_position2.x, camera.x);
			}
		}
		wait(0);
	}
}

ent_seed (char* name, ENTITY* terrain, BMAP* mask, COLOR* color, var dist, var mode, EVENT act) 
Creates a number of model or sprite entities on terrain, using a seed mask.