Sorry your browser is not supported!

tcolor += tex2D( BlurSampler2, texCoord0 ) * 0.75;
tcolor += tex2D( BlurSampler3, texCoord0 ) * 0.5;
tcolor += tex2D( BlurSampler4, texCoord0 ) * 0.25;

//////////////////////////////////////////////
// Simple Blur Shader with four textures
//////////////////////////////////////////////

float4x4 matWorldViewProjection : WorldViewProjection;
float4 mtrlAmbient;
float4 mtrlDiffuse;
float4 lightPos;

float pSize; //size of the displacement 
float factor_s; // factor for color addition
float cloudcover; //omfg im writting in hlsl!
float a;

//VS output / PS input:
struct Blur_OUTPUT
{
    float4 vPos : POSITION;
    float4 vColor: COLOR0;
    float4 texCoord0 : TEXCOORD0;
    
    //ONLY TEXTCOORD0
    //float4 texCoord1 : TEXCOORD1;
    //float4 texCoord2 : TEXCOORD2;
    //float4 texCoord3 : TEXCOORD3;
    //float4 texCoord4 : TEXCOORD4;
    //float4 texCoord5 : TEXCOORD5;
    //float4 texCoord6 : TEXCOORD6;
    //float4 texCoord7 : TEXCOORD7;
};


//////////////////////////
//  Vertex Shader:
//////////////////////////
// This blur the texture in the specific direction - up, down, left, and right.
//////////////////////////
Blur_OUTPUT BlurVS1(float4 vPos : POSITION, float4 vNorm: NORMAL, float4 texCoord0 : TEXCOORD0)
{
	Blur_OUTPUT OUT;
	
	float4 vLightDir;

	OUT.vPos = mul(vPos, matWorldViewProjection);

	// Compute diffuse lighting
	vLightDir = normalize(lightPos - vPos);

	vNorm = normalize(vNorm);

	OUT.vColor = dot(vNorm, vLightDir) * mtrlDiffuse + mtrlAmbient;

	//pick coordinates around the vertex
	//left-top
	//OUT.texCoord1 = texCoord0 + float4(-pSize, pSize, 0.0f, 0.0f); 
	//top
	//OUT.texCoord2 = texCoord0 + float4(0.0f, pSize, 0.0f, 0.0f); 
	//right-top
	//OUT.texCoord3 = texCoord0 + float4(pSize, pSize, 0.0f, 0.0f); 
	//right
	//OUT.texCoord4 = texCoord0 + float4(pSize, 0.0f, 0.0f, 0.0f); 
	//left
	//OUT.texCoord5 = texCoord0 + float4(-pSize, 0.0f, 0.0f, 0.0f); 
	//left-down
	//OUT.texCoord6 = texCoord0 + float4(-pSize, -pSize, 0.0f, 0.0f); 
	//down
	//OUT.texCoord7 = texCoord0 + float4(0.0f, -pSize, 0.0f, 0.0f);  
	//right-down
	//OUT.texCoord0 = texCoord0 + float4(pSize, -pSize, 0.0f, 0.0f); 

	//ONLY TEXTCOORD0
	OUT.texCoord0 = texCoord0 ;

	
	return OUT;
}


//////////////////////////
//  Pixel Shader:
//////////////////////////


texture BlurTexture
<
	string name = "tex1.jpg";
>;

sampler BlurSampler = sampler_state
{
    Texture   = (BlurTexture);
};

texture BlurTexture2
<
	string name = "tex2.jpg";
>;

sampler BlurSampler2 = sampler_state
{
    Texture   = (BlurTexture2);
};

texture BlurTexture3
<
	string name = "tex3.jpg";
>;


sampler BlurSampler3 = sampler_state
{
    Texture   = (BlurTexture3);
};

texture BlurTexture4
<
	string name = "tex4.jpg";
>;


sampler BlurSampler4 = sampler_state
{
    Texture   = (BlurTexture4);
};



//float4 BlurPS1(float4 vColor: COLOR0, float4 texCoord0 : TEXCOORD0, float4 texCoord1 :TEXCOORD1, float4 texCoord2 : TEXCOORD2, 
//float4 texCoord3 : TEXCOORD3, float4 texCoord4 : TEXCOORD4, 
//float4 texCoord5 : TEXCOORD5, float4 texCoord6 : TEXCOORD6, 
//float4 texCoord7 : TEXCOORD7
//) : COLOR0

//ONLY NEED TEXTCOORD0 AS INPUT
float4 BlurPS1(float4 vColor: COLOR0, float4 texCoord0 : TEXCOORD0 ) : COLOR0
{

        
	// Sample the Texture
	float4 tcolor = tex2D( BlurSampler, texCoord0 );
	
	// Add the texture values at each of the supplied texCoords
	//USING TEXTCOORD0
	tcolor += tex2D( BlurSampler2, texCoord0 ) * 0.75;
	tcolor += tex2D( BlurSampler3, texCoord0 ) * 0.5;
	tcolor += tex2D( BlurSampler4, texCoord0 ) * 0.25;

        tcolor /= 4.0;

        a = tcolor.r - cloudcover;

        //if (a < 0.0) { a = 0.0; }
        
        a = (pow(0.01, a) * 1.0);


        tcolor.r = a;
        tcolor.g = a;
        tcolor.b = a;
        tcolor.a = 1.0-a;

	return tcolor;

        
}


//////////////////////////
//  Techniques:
//////////////////////////

technique T0
{
	pass P0 
	{
                //SET THE RENDER STATES FOR ALPHA TRANSPARENCY

		AlphaBlendEnable = true;
		SrcBlend = SrcAlpha;

		DestBlend = ONE;
		BlendOp = Add;
		ZEnable = true;

		CullMode = CCW;

		MipFilter[0] = LINEAR;
		MinFilter[0] = LINEAR;
		MagFilter[0] = LINEAR;

		vertexshader = compile vs_1_1 BlurVS1();
		pixelshader  = compile ps_2_0 BlurPS1();

	}
	
	
		
}

                //SET THE RENDER STATES FOR ALPHA TRANSPARENCY

		AlphaBlendEnable = true;
		SrcBlend = SrcAlpha;

		DestBlend = ONE;
		BlendOp = Add;
		ZEnable = true;

	//watch out for incorrect values of "a"	
        tcolor.a = 1.0-a;

		//vertexshader = compile vs_1_1 BlurVS1();

// Add the texture values at each of the supplied texCoords
	tcolor += tex2D( BlurSampler2, texCoord1 ) * 0.75;
	tcolor += tex2D( BlurSampler3, texCoord1 ) * 0.5;
	tcolor += tex2D( BlurSampler4, texCoord1 ) * 0.25;

//pick coordinates around the vertex
	//left-top
	OUT.texCoord1 = texCoord0 + float4(-pSize, pSize, 0.0f, 0.0f); 

tcolor.a = 1.0-a;

a = tcolor.r - cloudcover;

tcolor.r = a;
tcolor.g = a;
tcolor.b = a;

float4 vPos : POSITION;

if ( vPos.y < 0.0 )
{
OUT.vColor.a = 1.0;
}

//////////////////////////////////////////////
// Cloud Shader
//////////////////////////////////////////////
// Written by - Jeff Wieland
// 12.29.05
//////////////////////////////////////////////


////////////////
// UN-TWEAKS
////////////////

matrix WorldViewProj:WorldViewProjection;


/////////////
// TWEAKS
/////////////

float cloudcover; //0.0 - 1.0 (full clouds - no clouds)
float a; //buffer


///////////////////
// TEXTURES
///////////////////

// four textures for each of 4 texture stages (0-3)

texture tex0 <string name = ""; >;
sampler tex0samp = sampler_state
{ texture   = (tex0); };

texture tex1 <string name = ""; >;
sampler tex1samp = sampler_state
{ texture   = (tex1); };

texture tex2 <string name = ""; >;
sampler tex2samp = sampler_state
{ texture   = (tex2); };

texture tex3 <string name = ""; >;
sampler tex3samp = sampler_state
{ texture   = (tex3); };


//////////////////////////
//  PIXEL SHADER
//////////////////////////

float4 PS(float4 texCoord0 : TEXCOORD0 ) : COLOR 
{

// grab the color of the pixel at texture stage 0
float4 color = tex2D( tex0samp, texCoord0 );
	
// combine with the color of the pixels at stage 1-3
color += tex2D( tex1samp, texCoord0 ) * 0.75;
color += tex2D( tex2samp, texCoord0 ) * 0.5;
color += tex2D( tex3samp, texCoord0 ) * 0.25;

color /= 4.0;

// factor cloudcover
a = color.r - cloudcover;

// curve the clouds    
a = (pow(0.01, a) * 1.0);

color.r = a;
color.g = a;
color.b = a;
color.a = 1.0-a;

return color;

}


//////////////////////////
//  TECHNIQUE
//////////////////////////
technique T
{
 pass p0
 {		
  PixelShader = compile ps_2_0 PS(); 		
 }
}

//////////////////////////////////////////////
// Cloud Shader
//////////////////////////////////////////////
// Written by - Jeff Wieland
// 12.29.05
//////////////////////////////////////////////


////////////////
// UN-TWEAKS
////////////////

matrix WorldViewProj:WorldViewProjection;


/////////////
// TWEAKS
/////////////

float cloudcover; //0.0 - 1.0 (full clouds - no clouds)
float a; //buffer

/////////////////////////
//  DATA STRUCTS
/////////////////////////


struct input
{
   float4 pos:		POSITION;
   float2 uv:		TEXCOORD;
};
 
struct output
{
    float4 pos:		POSITION;
    float2 uv:		TEXCOORD;
    float4 color:	COLOR;
};

///////////////////
// VERTEX SHADER
///////////////////


output VS(input IN)
{
	output OUT;

	OUT.pos = mul(IN.pos,WorldViewProj);
	OUT.uv = IN.uv;

	OUT.color.r = 1.0;
	OUT.color.g = 1.0;
	OUT.color.b = 1.0;
        //WHY IS IT NOT MAKING THE VERT INVISIBLE?
	OUT.color.a = 0.0;

	return OUT;
}

///////////////////
// TEXTURES
///////////////////

// four textures for each of 4 texture stages (0-3)

texture tex0 <string name = ""; >;
sampler tex0samp = sampler_state
{ texture   = (tex0); };

texture tex1 <string name = ""; >;
sampler tex1samp = sampler_state
{ texture   = (tex1); };

texture tex2 <string name = ""; >;
sampler tex2samp = sampler_state
{ texture   = (tex2); };

texture tex3 <string name = ""; >;
sampler tex3samp = sampler_state
{ texture   = (tex3); };


//////////////////////////
//  PIXEL SHADER
//////////////////////////

float4 PS(float4 texcoord : TEXCOORD ) : COLOR 
{

// grab the color of the pixel at texture stage 0
float4 color = tex2D( tex0samp, texcoord );
	
// combine with the color of the pixels at stage 1-3
color += tex2D( tex1samp, texcoord ) * 0.75;
color += tex2D( tex2samp, texcoord ) * 0.5;
color += tex2D( tex3samp, texcoord ) * 0.25;

color /= 4.0;

// factor cloudcover
a = color.r - cloudcover;

// curve the clouds    
a = (pow(0.01, a) * 1.0);

color.r = a;
color.g = a;
color.b = a;
color.a = 1.0-a;

return color;

}


//////////////////////////
//  TECHNIQUE
//////////////////////////
technique T
{
 pass p0
 {		
  VertexShader = compile vs_2_0 VS(); 
  PixelShader = compile ps_2_0 PS(); 		
 }
}

//SET THE RENDER STATES FOR ALPHA TRANSPARENCY

		AlphaBlendEnable = true;
		SrcBlend = SrcAlpha;

		DestBlend = ONE;
		BlendOp = Add;
		ZEnable = true;

//-----------------
// un-tweaks
//-----------------

 matrix WorldVP:WorldViewProjection; 
 matrix World:World;    

//-----------------
// tweaks
//-----------------

 float4 Light_Position = {150.0f, 150.0f, 0.0f, 1.0f};    
 float4 Light_Colour   = {1.0f, 0.0f, 0.0f, 1.0f};    
 float  Light_Range    = 150.0f;    
	
//-----------------
// Texture
//-----------------

 texture Base 
    <
	string Name="";
    >;	
 sampler2D Base_Sample = sampler_state 
    {
 	texture = <Base>;
    };


//-----------------
// structs 
//-----------------

 struct input
     {
 	float4 pos : POSITION ; 
 	float2 UV : TEXCOORD ; 

     };
 struct output
     {
	float4 opos : POSITION  ; 
 	float2 Uv : TEXCOORD0 ; 
	float3 Attenuation : TEXCOORD2;
     };

//-----------------
// vertex shader
//-----------------

 output vertex_shader(input IN) 
     {
 	output OUT;

	OUT.opos = mul( IN.pos , WorldVP ); 
 	OUT.Uv = IN.UV;

	float3 WorldPos = mul( IN.pos , World ); 

	float3 LightPos =  WorldPos - Light_Position; 
	OUT.Attenuation = LightPos / Light_Range; 

	return OUT;
    }

//-----------------
// pixel shader
//-----------------

  float4 pixel_shader(output IN)  : COLOR
     {

	float4 Texture=tex2D(Base_Sample,IN.Uv); 

	float4 DiffuseLight = 1 -  dot( IN.Attenuation , IN.Attenuation );
	float4 Light = DiffuseLight * Light_Colour;

	return Texture * Light ;
     }

//-----------------
// techniques   
//-----------------

 technique light
      {
 	pass p1
      {		
 	vertexShader = compile vs_1_1 vertex_shader(); 
 	pixelShader  = compile ps_1_4 pixel_shader(); 	
      }
      }

/
-----------------
// un-tweaks
//-----------------

 matrix WorldVP:WorldViewProjection; 
 matrix World:World;

//-----------------
// tweaks
//-----------------

  float4 Light_Position; 

//-----------------
// Textures
//-----------------

 texture Base 
    <
	string Name="";
    >;	
 sampler2D Base_Sample = sampler_state 
    {
 	texture = <Base>;
    };

//-----------------
// structs
//-----------------
 struct input
     {
    	float4 pos : POSITION ; 
    	float2 UV : TEXCOORD ; 
	float3 Normal : NORMAL ;
     };
 struct output
     {
    	float4 opos : POSITION  ; 
    	float2 Uv : TEXCOORD0 ;
     	float4 outcol : color0    ; 
     };

//-----------------
// vertex shader
//-----------------

 output vertex_Shader(input IN)
     {
    	output OUT;
   	OUT.opos=mul(IN.pos,WorldVP);
  	OUT.Uv=IN.UV;
	float4 WorldPos=mul(IN.pos,World); 
	float3 Wnormal=mul(IN.Normal,World);  
        float3 LightVec = WorldPos.xyz-Light_Position.xyz;
 	Wnormal=normalize(Wnormal);	
	float alpha=1;	
    	if(dot(Wnormal,-LightVec)<0.0f) alpha = 0; 
  	OUT.outcol=float4(1,1,1,alpha); 
   	return OUT;
    }

//-----------------
// techniques
//-----------------

  technique test
      {
     	pass p1
      {
     	vertexShader = compile vs_1_0 vertex_Shader();
        Sampler[0] = <Base_Sample>;
  	ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
      }
      }

sync on
sync rate 50
`-------

make object sphere 1,100,50,50
load image "Fieldstone.tga",1
texture object 1,0,1
load effect "test.fx",1,0
set object effect 1,1
`-------

make object sphere 2,10
vec=make vector4(1)
`-------

position camera 0,0,-150
point camera 0,0,0
`-------

do
`-------

ang#=wrapvalue(ang#+0.5)
position object 2,-sin(ang#)*70,-cos(ang#)*70,-cos(ang#)*70
set vector4 1,object position x(2),object position y(2),object position z(2),0
set effect constant vector 1,"Light_Position",1
`-------

sync
loop
`-------

//
// FX Effect file - Cartoon
//

// Constants
matrix wvp : WorldViewProjection;
matrix world : World;
matrix worldIT : WorldIT;
float4 eyePos : EyePosition;
float4 lhtDir < string UIDirectional = "Light Direction"; >;

// Model and Texture Names
string XFile = "default.x";
texture toonshade < string name = "shade.bmp"; >;
texture toonedge < string name = "edge.bmp"; >;
texture basetex < string name = "base.bmp"; >;

technique ToonWithTex
{
	pass p0
	{
		VertexShaderConstant[0] = <wvp>;
		VertexShaderConstant[4] = <worldIT>;
		VertexShaderConstant[8] = <world>;
		VertexShaderConstant[12] = <eyePos>;
		VertexShaderConstant[13] = <lhtDir>;

		VertexShader = 
		asm
		{

			// v0  -- position
			// v3  -- normal

			vs.1.1

			dcl_position      v0
			dcl_normal        v3
			dcl_texcoord0	  v6		
	
			// transform position
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

			// transform normal
			dp3 r0.x, v3, c8
			dp3 r0.y, v3, c9
			dp3 r0.z, v3, c10

			// normalize normal
			dp3 r0.w, r0, r0
			rsq r0.w, r0.w
			mul r0, r0, r0.w

			// compute world space position
			dp4 r1.x, v0, c8
			dp4 r1.y, v0, c9
			dp4 r1.z, v0, c10
			dp4 r1.w, v0, c11

			// vector from point to eye
			add r2, c12, -r1

			// normalize e
			dp3 r2.w, r2, r2
			rsq r2.w, r2.w
			mul r2, r2, r2.w

			// e dot n
			dp3 oT1.x, r0, r2

			// l dot n
			dp3 oT2.x, r0, -c13
		
			//Dump our basetex's coords into oT0.
			mov oT0, v6
		};

		Texture[2] = <toonshade>;
		Texture[1] = <toonedge>;
		Texture[0] = <basetex>;

		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;
		MinFilter[2] = Linear;
		MagFilter[2] = Linear;
		MipFilter[2] = Linear;		

		AddressU[2] = Clamp;
		AddressV[2] = Clamp;
		AddressU[1] = Clamp;
		AddressV[1] = Clamp;
		AddressU[0] = Wrap;
		AddressV[0] = Wrap;
		
		ColorOp[0] = SelectArg1;
		ColorArg1[0] = Texture;

		ColorOp[1] = Modulate;
		ColorArg1[1] = Texture;
		ColorArg2[1] = Current;
		
		ColorOp[2] = Lerp;
		ColorArg1[2]= Texture;
		ColorArg2[2] = Current;

	}
}

//**************************************************************//
//  Effect File exported by RenderMonkey 1.6
//
//  - Although many improvements were made to RenderMonkey FX  
//    file export, there are still situations that may cause   
//    compilation problems once the file is exported, such as  
//    occasional naming conflicts for methods, since FX format 
//    does not support any notions of name spaces. You need to 
//    try to create workspaces in such a way as to minimize    
//    potential naming conflicts on export.                    
//    
//  - Note that to minimize resulting name collisions in the FX 
//    file, RenderMonkey will mangle names for passes, shaders  
//    and function names as necessary to reduce name conflicts. 
//**************************************************************//

//--------------------------------------------------------------//
// Atmospheric Effects
//--------------------------------------------------------------//
//--------------------------------------------------------------//
// CloudsEffect_ASM
//--------------------------------------------------------------//
//--------------------------------------------------------------//
// Single Pass
//--------------------------------------------------------------//
string Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Screen_Aligned_Quad : ModelData = "../../../Program Files/ATI Research Inc/RenderMonkey 1.6/Examples/Media/Models/ScreenAlignedQuad.3ds";

//--------------------------------------------------------------//
// Vertex Shader
//--------------------------------------------------------------//
VertexShader Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Vertex_Shader_ = asm
{
   vs.1.1
   
   dcl_position   v0
   dcl_normal     v1
   dcl_texcoord   v2
   
   mov  r0, v0        // align the quad with the screen
   mov  r0.w, c0.z
   mov  r0.z, c0.x
   mov  oPos, r0
   
   mov  r4, v2      // output base tex coord
   mov  oT4, r4  
   
   mov  r0, c1.xxxx  // (time*cloud0vel)
   mul  r1, c9.xyxy, r0
   
   mul  r2, c9.zwzw, r0  // (time*cloud0disvel) 
   
   mad  oT0, r4.yx, c10.xyxy, r1.xy
   mad  oT1, r4.yx, c10.zwzw, r2.xy
   
   mul  r1, c11.xyxy, r0  // (time*cloud1vel)
   
   mul  r2, c11.zwzw, r0  // (time*cloud1disvel)
   
   mad  oT2, r4.yx, c12.xyxy, r1.xy
   mad  oT3, r4.yx, c12.zwzw, r2.xy
   
   
   
   
   
   

};

//--------------------------------------------------------------//
// Pixel Shader
//--------------------------------------------------------------//
PixelShader Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Pixel_Shader_ = asm
{
   ps.1.4
   
   texld  r0, t1
   texld  r1, t3
   texcrd r2.rgb, t0
   texcrd r3.rgb, t2
   
      mad r0.rgb, c1, r0_bx2, r2 ; perturb base map coords by cloud coords
      mad r1.rgb, c3, r1_bx2, r3 ; perturb base map coords by cloud coords
   
   phase
   
   texld r0, r0
   texld r1, r1
   texld r2, t4
   
      mov_x2 r3.rgb, r2.a              ; alpha of horizon (glow map)
      +mul_sat r3.a, 1-r0.a, 1-r1.a    ; mask edges for cloud glow
    
      mad_sat r0.rgb, 1-r0.a, c2, c2.a ; scale and bias inverted clouds layer 0
      +mov_x2_sat r0.a, r0.a           ; boost cloud alpha 0
   
      mad_sat r1.rgb, 1-r1.a, c4, c4.a ; scale and bias inverted clouds layer 1
      +mov_x2_sat r1.a, r1.a           ; boost cloud alpha 1
   
      lrp r0.rgb, r1.a, r1, r0         ; combine cloud layers
      +mov r4.a, c5.a                  ; ...
   
      mul_x2 r3, r3.a, r3              ; multiply glow by edges of clouds
      mad_x2 r3, r3, c5, r4.a          ; scale and bias glowing sections of clouds
   
      mul r0.rgb, r3, r0               ; multiply glow by combination of cloud layers
      +add_d2_sat r0.a, r0.a, r1.a     ; add alphas of cloud layers
   
      lrp_sat r0, r0.a, r0, r2         ; lerp between clouds and horizon
   
   

};

//--------------------------------------------------------------//
// Technique Section for Atmospheric Effects
//--------------------------------------------------------------//
technique CloudsEffect_ASM
{
   pass Single_Pass
   {
      ZENABLE = TRUE;
      FILLMODE = SOLID;
      SHADEMODE = GOURAUD;
      ZWRITEENABLE = TRUE;
      ALPHATESTENABLE = FALSE;
      LASTPIXEL = TRUE;
      SRCBLEND = ONE;
      DESTBLEND = ZERO;
      CULLMODE = NONE;
      ALPHAREF = 0x0;
      ALPHAFUNC = LESS;
      DITHERENABLE = FALSE;
      ALPHABLENDENABLE = FALSE;
      FOGENABLE = FALSE;
      SPECULARENABLE = FALSE;
      FOGCOLOR = 0xFFFFFFFF;
      FOGTABLEMODE = NONE;
      FOGSTART = 0.000000;
      FOGEND = 0.000000;
      FOGDENSITY = 0.000000;
      STENCILENABLE = FALSE;
      STENCILFAIL = KEEP;
      STENCILZFAIL = KEEP;
      STENCILPASS = KEEP;
      STENCILFUNC = ALWAYS;
      STENCILREF = 0x0;
      STENCILMASK = 0xffffffff;
      STENCILWRITEMASK = 0xffffffff;
      TEXTUREFACTOR = 0x0;
      WRAP0 = 0;
      WRAP1 = 0;
      WRAP2 = 0;
      WRAP3 = 0;
      WRAP4 = 0;
      WRAP5 = 0;
      WRAP6 = 0;
      WRAP7 = 0;
      CLIPPING = FALSE;
      LIGHTING = FALSE;
      AMBIENT = 0x11111111;
      FOGVERTEXMODE = NONE;
      COLORVERTEX = TRUE;
      LOCALVIEWER = TRUE;
      NORMALIZENORMALS = FALSE;
      DIFFUSEMATERIALSOURCE = COLOR1;
      SPECULARMATERIALSOURCE = COLOR2;
      AMBIENTMATERIALSOURCE = COLOR2;
      EMISSIVEMATERIALSOURCE = COLOR2;
      VERTEXBLEND = DISABLE;
      CLIPPLANEENABLE = 0;
      POINTSIZE = 0.000000;
      POINTSIZE_MIN = 0.000000;
      POINTSPRITEENABLE = FALSE;
      POINTSCALEENABLE = FALSE;
      POINTSCALE_A = 0.000000;
      POINTSCALE_B = 0.000000;
      POINTSCALE_C = 0.000000;
      MULTISAMPLEANTIALIAS = TRUE;
      MULTISAMPLEMASK = 0xffffffff;
      COLORWRITEENABLE = RED | GREEN | BLUE | ALPHA;
      TWEENFACTOR = 0.000000;
      BLENDOP = ADD;
      POSITIONDEGREE = CUBIC;
      NORMALDEGREE = LINEAR;
      ZFUNC = ALWAYS;

      VertexShader = (Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Vertex_Shader_);
      PixelShader = (Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Pixel_Shader_);
   }

}