Fixed-Function Terrain Multi-Texturing Effect

 
///////////////////////////////////////////////////////////
//	FFP  Terrain MultiTexturing Effect
//
//	Blending (2) Textures
//
//	By:  Eric A. Hendrickson-Lambert (Steempipe)
//
//
//	1/6/05: Update original code for MK_1
//	        to build with A6.31.4 & DX9.00c
//	
//////////////////////////////////////////////////////////


//*****************************************************
//**  I had strange results with putting the alphamaps
//**  in to the HMP as entSkins.  
//**  Just load them as mtlSkins.
//*****************************************************

// RGB Channels are blank
// The A channel has the blending weight (pattern)
bmap blendmap = <blendmap.tga>;		// Blender for Pass p1


//*****************************************************
//**  entSkins 1-4 are tilable textures 
//**  Be sure to add mipmaps to them in MED
//*****************************************************


var Detail_Size = 0;


function mtl_terraintex_init()
{

bmap_to_mipmap(mtl.skin1);


//
// Adjust the texture transform to do some tiling of the textures
//

mtl.matrix11 = float(28);	// default u scale 
mtl.matrix22 = float(28);	// default v scale

}

///////////////////////////////////////////////////////////////////////
//The Material
///////////////////////////////////////////////////////////////////////

material mat_terraintex
{

skin1 = blendmap; 
   


// define a material effect string
     
event = mtl_terraintex_init;
  	
	effect = 
	"
    	matrix matMtl;
               	
       	texture mtlSkin1;	// Blending map for Pass P1
	
	texture entSkin1;	// Tileable Tex
	texture entSkin2;	// Tileable Tex
	
       
	
   
///////////////////////////////////////////////////////////////////////
//The Technique
///////////////////////////////////////////////////////////////////////

technique ffp_terrain_tex
       	{
         	pass P0
		//////////////////////////////////////////////////////
		//// Lets lay the first texture down.  no alpha work
		//////////////////////////////////////////////////////
         	{
        		
            		AlphaBlendEnable=False;
			AlphaTestEnable=False;
				
			Lighting = True;

			zEnable=True;
			zWriteEnable=True;
			
			////////////////////////////////////////
			// Stage 0
			///////////////////////////////////////

        		Texture[0] = <entSkin1>;	

            		magFilter[0]=linear;
			minFilter[0]=linear;
			mipFilter[0]=linear;
			
       			TextureTransformFlags[0] = Count2;
       			TextureTransform[0] = <matMtl>;
			texcoordindex[0]=1;

           		ColorArg1[0] = Texture; 
           		ColorOp[0] = Modulate;
            		ColorArg2[0] = Diffuse;
		       	AlphaOp[0]=Disable;
			
			//////////////////////////////////////
			//stage 1
			//////////////////////////////////////

			ColorOp[1]=Disable;
			AlphaOp[1]=Disable;
           
        	}

		pass P1
		//////////////////////////////////////////////////////
		//// Now we blend another texture using an alphamap
		//////////////////////////////////////////////////////
         	{
        					
			//////////////////////////////////////
			// Stage 0
			//////////////////////////////////////            		

			// We need to enable alphablending 
			
			AlphaBlendEnable=True;
			SrcBlend=SrcAlpha;
			DestBlend=InvSrcAlpha;
			
			zEnable=False;
			zWriteEnable=False;

			Texture[0] = <mtlSkin1>;

            		magFilter[0]=Linear;
			minFilter[0]=Linear;
			mipFilter[0]=Linear;
			
			//
			// We don't want the alphamap to tile
			//
       			TextureTransformFlags[0] = disable;
       			
			TexCoordIndex[0]=0;	
		
           		ColorArg1[0] = Current; 
           		ColorOp[0] = SelectArg1;
            		AlphaArg1[0] = Texture;
                	AlphaOp[0]=SelectArg1;

			//////////////////////////////////////////////
			// Stage 1
			//////////////////////////////////////////////

			Texture[1] = <entSkin2>;
			
			zEnable=True;
			zWriteEnable=True;

           		magFilter[1]=Linear;
			minFilter[1]=Linear;
			mipFilter[1]=Linear;
			
	
	       		TextureTransformFlags[1] = Count2;
       			TextureTransform[1] = <matMtl>;
			TexCoordIndex[1]=1;

	           	ColorArg1[1] = Texture; 
        	   	ColorOp[1] = Modulate;
            		AlphaArg1[1] = Current;
                	AlphaOp[1]=Disable;
		
			///////////////////////////////////////////////
			// Stage 2
			///////////////////////////////////////////////
			ColorOp[2]=Disable;
			AlphaOp[2]=Disable;
			
           
        	}

         	

     	 } // End of Technique

   "; // end of the effect string

} // End of Material 


///////////////////////////////////////////////////////////////////////
//The Action we assign in WED
///////////////////////////////////////////////////////////////////////

action ffp_TerrainTex
{
	my.transparent=off;
	my.material = mat_terraintex;
	

}

material mat_ffp_multitex
{	
	event = mtl_terraintex_init;
	skin1 = blendmap1; //Blendmap for  texture 2
	skin2 = blendmap2; //Blendmap for  texture 3
	effect
	"
	TEXTURE entSkin1;
	TEXTURE entSkin2;
	TEXTURE entSkin3;

	TEXTURE mtlSkin1;
	TEXTURE mtlSkin2;


	matrix matMtl;

	technique ffp_terrain_tex
	{
		pass P0
		//////////////////////////////////////////////////////
		//// Lets lay the first TEXTURE down.  no alpha work
		//// This will tile across the entire HMP
		//////////////////////////////////////////////////////
		{
			
			alphablendenable=false;
			alphatestenable=false;
			
			zenable=true;
			zwriteenable=true;
			
			////////////////////////////////////////
			// Stage 0
			///////////////////////////////////////

			TEXTURE[0] = <entSkin1>;	

			magFilter[0]=linear;
			minFilter[0]=linear;
			mipFilter[0]=linear;
			
			TEXTURETransformFlags[0] = Count2;
			TEXTURETransform[0] = <matMtl>;
			texcoordindex[0]=0;

			ColorArg1[0] = TEXTURE; 
			ColorOp[0] = SELECTARG1;
			
			alphaop[0]=disable;
			
			//////////////////////////////////////
			//stage 1
			//////////////////////////////////////

			colorop[1]=disable;
			alphaop[1]=disable;
			
		}

		pass P1
		//////////////////////////////////////////////////////
		//// Now we blend another TEXTURE using an alphamap
		//// This TEXTURE will be blended
		//////////////////////////////////////////////////////
		{
			
			//////////////////////////////////////
			// Stage 0 - Setup the alphamap
			//////////////////////////////////////            		

			// We need to enable alphablending 
			
			alphablendenable=true;
			srcblend=srcalpha;
			destblend=invsrcalpha;
			
			// AlphaTestEnable uses the AlphaRef and AlphaFunc to 
			// determine which pixels get drawn.
			// In this case, anything greater that 0 will be drawn.
			alphatestenable=true;
			alpharef=0x00000000;      	//Reference Value
			alphafunc=Greater;  	  	//Comparison Function
				
			TEXTURE[0] = <mtlSkin1>;

			magFilter[0]=linear;
			minFilter[0]=linear;
			mipFilter[0]=linear;
			
			//
			// We don't want the alphamap to tile
			//
			TEXTURETransformFlags[0] = disable;
			
			texcoordindex[0]=0;	
			
			COLORARG1[0] = CURRENT; 
			ColorOp[0] = SELECTARG1;
			ALPHAARG1[0] = TEXTURE | ALPHAREPLICATE;
			alphaop[0]=selectarg1;

			//////////////////////////////////////////////
			// Stage 1 -- This is the TEXTURE to splat
			//////////////////////////////////////////////

			TEXTURE[1] = <entSkin2>;
			

			// Zenable is supposed to default to true.  
			// This enables depth testing to determine what pixels 
			// are visible to the viewer
			
			zenable=true;
			zwriteenable=true;

			magFilter[1]=linear;
			minFilter[1]=linear;
			mipFilter[1]=linear;
			
			
			TEXTURETransformFlags[1] = Count2;
			TEXTURETransform[1] = <matMtl>;
			texcoordindex[1]=1;

			COLORARG1[1] = TEXTURE; 
			ColorOp[1] = modulate;
			ALPHAARG1[1] = CURRENT | ALPHAREPLICATE;
			alphaop[1]=disable;
			
			///////////////////////////////////////////////
			// Stage 2
			///////////////////////////////////////////////
			colorop[2]=disable;
			alphaop[2]=disable;
			
			
		}

		pass P2
		{
			
			////////////////////////////////////////
			// Stage 0
			////////////////////////////////////////

			alphablendenable=true;
			srcblend=srcalpha;
			destblend=invsrcalpha;
			
			alphatestenable=true;
			alpharef=0x00000000;      
			alphafunc=Greater;  	 
			
			TEXTURE[0] = <mtlSkin2>;
			
			magFilter[0]=linear;
			minFilter[0]=linear;
			mipFilter[0]=linear;
			
			
			TEXTURETransformFlags[0] = disable;
			
			texcoordindex[0]=1;
			
			COLORARG1[0] = CURRENT; 
			ColorOp[0] = selectarg1;
			ALPHAARG1[0] = TEXTURE | ALPHAREPLICATE;
			alphaop[0]=selectarg1;

			/////////////////////////////////////////
			// Stage 1
			/////////////////////////////////////////
			TEXTURE[1] = <entSkin3>;

			zenable=true;
			zwriteenable=true;
			
			magFilter[1]=linear;
			minFilter[1]=linear;
			mipFilter[1]=linear;
			
			
			TEXTURETransformFlags[1] = Count2;
			TEXTURETransform[1] = <matMtl>;
			texcoordindex[1]=0;

			COLORARG1[1] = TEXTURE; 
			ColorOp[1] = modulate;
			ALPHAARG1[1] = CURRENT | ALPHAREPLICATE;
			alphaop[1]=disable;
			
			////////////////////////////////////////
			// Stage 2
			////////////////////////////////////////
			colorop[2]=disable;
			alphaop[2]=disable;

		} // End of Pass P2

	} // End of Technique
	";
}

 ///////////////////////////////////////////////////////////

//	FFP  Terrain MultiTexturing Effect

//

//	By:  Eric A. Hendrickson-Lambert (Steempipe)

//

//	Rev. 04.05.04.1  

//

//	Description:

//	Using 2 tileable textures and an alphamap for blending.  

//	This code uses (2) passes because more than 2 stages would be needed

//	for 1 pass.  The First Fallback Technique is just a 2 stage 1 pass but

//	has the transformation.  The second fallback has no transformation.

//

//////////////////////////////////////////////////////////





// A tileable texture

//bmap grass = <tilegrass.bmp>;





//RGB Channels are blank

//The A channel has the blending weight (pattern)

bmap blendmap = <blendme.tga>;



// A tileable texture		

//bmap sand = <tilesand.bmp>;

   



function mtl_terraintex_init()

{





//bmap_to_mipmap(mtl.skin1);

bmap_to_mipmap(mtl.skin2);

//bmap_to_mipmap(mtl.skin3);



//

// Adjust the texture transform to do some tiling of the textures

//

mtl.matrix11 = float(18);	// default u scale 

mtl.matrix22 = float(18);	// default v scale



}







material mat_terraintex

{

//skin1 = grass; 

Skin2 = blendmap;     

//skin3 = sand;



// define a material effect string

     

event = mtl_terraintex_init;

  	

	effect = 

	"

    

	matrix matMtl;

       

	

       	texture entSkin1; 	// Grass

       	texture mtlSkin2; 	// Alpha Blending Map

	texture entSkin2;	// sand

	texture entSkin3;	// detailmap

        texture entSkin4;       // Basic Skin



	   



// default technique





technique ffp_terrain_tex

       		{

         		pass P0

         		{

        	

            		alphablendenable=false;



			//

			// Stage 0

			//

        		Texture[0] = <entSkin1>;	



            		magFilter[0]=linear;

			minFilter[0]=linear;

			mipFilter[0]=linear;

			





       			TextureTransformFlags[0] = Count2;

       			TextureTransform[0] = <matMtl>;

			texcoordindex[0]=0;



           		ColorArg1[0] = Texture; 

           		ColorOp[0] = selectarg1;

            		

		       	alphaop[0]=disable;

			

			//

			//stage 1

			//

			colorop[1]=disable;

			alphaop[1]=disable;

           

        		}



			pass P1

         		{

        	

            		// We need to enable alphablending 

			

			alphablendenable=true;

			srcblend=srcalpha;

			destblend=invsrcalpha;



			//

			// Stage 0

			//

        		Texture[0] = <mtlSkin2>;



            		magFilter[0]=linear;

			minFilter[0]=linear;

			mipFilter[0]=linear;

			

			//

			// We don't want the alphamap to tile

			//

       			TextureTransformFlags[0] = disable;

       			

			texcoordindex[0]=1;

		

           		ColorArg1[0] = current; 

           		ColorOp[0] = selectarg1;

            		alphaarg1[0] = texture | alphareplicate;

                	alphaop[0]=selectarg1;



			//

			// Stage 1

			//

			Texture[1] = <entSkin2>;//sand



           		magFilter[1]=linear;

			minFilter[1]=linear;

			mipFilter[1]=linear;

			

	

	       		TextureTransformFlags[1] = Count2;

       			TextureTransform[1] = <matMtl>;

			texcoordindex[1]=0;



	           	ColorArg1[1] = texture; 

        	   	ColorOp[1] = modulate;

            		alphaarg1[1] = current | alphareplicate;

                	alphaop[1]=disable;

		

			//

			// Stage 2

			//

			colorop[2]=disable;

			alphaop[2]=disable;

			

           

        		}



           



     	 	}



   		

 technique firstfallback

      {

        pass P0

        {

         //

			// Stage 0

			//

        		Texture[0] = <entSkin4>;	



            		magFilter[0]=linear;

			minFilter[0]=linear;

			mipFilter[0]=linear;

			       			

       			texcoordindex[1]=0;



           		ColorArg1[0] = Texture; 

			ColorArg2[0] = Diffuse;

           		ColorOp[0] = Modulate;

            		//

			// Stage 1

			//

			Texture[1] = <entSkin3>;



           		magFilter[1]=linear;

			minFilter[1]=linear;

			mipFilter[1]=linear;

			

	

	       		TextureTransformFlags[1] = Count2;

       			TextureTransform[1] = <matMtl>;

			texcoordindex[1]=1;



	           	ColorArg1[1] = texture;

			ColorArg2[1] = Current; 

        	   	ColorOp[1] = addsigned;

            		

	

        }

	} 







technique secondfallback

      {

        pass P0

        {

         //

			// Stage 0

			//

        		Texture[0] = <entSkin4>;	



           		ColorArg1[0] = Texture; 

			//ColorArg2[0] = Diffuse;

           		ColorOp[0] = selectarg1;



            		//

			// Stage 1

			//

			Texture[1] = <entSkin4>;



	           	ColorArg1[1] = texture;

			ColorArg2[1] = Current; 

        	   	ColorOp[1] = modulate;

         

        }

	} 

	

     

   	"; // end of the effect string



}







action ffp_TerrainTex

{

my.material = mat_terraintex;

}