We have upgraded to the latest version of MediaWiki and now support TLS1.2 and transcoding!
Please contact us via Discord or Twitter if you experience any problems.

Bully: Scholarship Edition (Windows)/Unused Text

From The Cutting Room Floor
Jump to navigation Jump to search

This is a sub-page of Bully: Scholarship Edition (Windows).

Subpages

BullySE Windows gm english.png
Development Text
Author: Bill Henderson Created 10/12/1999
BullySE Windows gm english.png
Testing Stuff

Effects2.bft

Effect
	BEGIN
		EffectName "DoNothing"
		UpdateWhenFaded TRUE
		KillWhenFaded TRUE
		EffectImportance 1
		HightDetailDistance 1.000000
		LowDetailDistance 5.000000
		MaxRadius 1.000000
		FadeDistance 9.000000
		LIST_COUNT 1
		DefinitionTypeName "HeatHazePrimitive"
		Definition
			BEGIN
				StartTime 0.000000
				Duration 0.010000
				PrimitiveDescription "Heat Haze does nothing now and dies right away"
				Definition
					BEGIN
						UsingInterpolator FALSE
						IndexValues 0
						FloatValue 0.000000
					END
				FloatValue 1.000000
				FloatValue 1.000000
				Bool FALSE
			END
	END

Uncompiled Shader Code

There's a few good spots of raw shader code still within the game's executable.

0x54D798

// Input data (needs to match, or be a subset of the vertex shader output)			
struct PsInput																		
{																					
	float4 diffuse: COLOR0;															
};																					
																					
//------------------------------------------------------------------------------	
// This is the main pixel shader.													
//------------------------------------------------------------------------------	
float4 main(PsInput i) : COLOR														
{ 																					
	// Output final color															
	float4 o;																		
	o.rgb = i.diffuse.rgb;															
	o.a = i.diffuse.a;																
	return o;																		
}//main																			
  ps_2_0      // Input data (needs to match, or be a subset of the vertex shader output)			
struct PsInput																		
{																					
	float2 texCoord:  TEXCOORD0;													
	float4 diffuse:   COLOR0;														
};																					
																					
sampler2D baseTex : register(s0);       											
																					
//------------------------------------------------------------------------------	
// This is the main pixel shader.													
//------------------------------------------------------------------------------	
float4 main(PsInput i) : COLOR														
{ 																					
	// Get base color																
	float4 cBase = tex2D(baseTex, i.texCoord);										
																					
	// Output final color															
	float4 o;																		
	o.rgb = cBase.rgb * i.diffuse.rgb;												
	o.a = cBase.a * i.diffuse.a;													
	return o;																		
}//main																			
 float4x4 mViewProjection : register(c0);											
																					
// Our input structure																
struct VsInput																		
{																					
	float3 pos:       POSITION0;													
	float4 color:     COLOR0;														
};																					
																					
// Our output structure, this needs to match what lives in the pixel shader		
// or at least not be any less than what's used in the pixel shader.				
struct VsOutput																	
{																					
	float4 pos:       POSITION0;													
	float4 diffuse:   COLOR0;														
};																					
																					
//-----------------------------------------------------------------------------	
// The main vertex shader function (entry point into shader)						
//-----------------------------------------------------------------------------	
VsOutput main(VsInput i)															
{																					
	// Output structure																
	VsOutput o;																		
																					
	// Convert our position to view space.											
	float4 pos = float4(i.pos, 1.0f);												
	o.pos = mul(pos, mViewProjection);												
																					
	// Pass along vertex color														
	o.diffuse = i.color.bgra / 255.0f;												
																					
	// All done																		
	return o;																		
}//mainVS																			
     float4x4 mProjection : register(c0);												
																					
// Our input structure																
struct VsInput																		
{																					
	float3 pos:       POSITION0;													
	float2 texCoord:  TEXCOORD0;													
	float4 color:     COLOR0;														
};																					
																					
// Our output structure, this needs to match what lives in the pixel shader		
// or at least not be any less than what's used in the pixel shader.				
struct VsOutput																	
{																					
	float4 pos:       POSITION0;													
	float2 texCoord:  TEXCOORD0;													
	float4 diffuse:   COLOR0;														
};																					
																					
//-----------------------------------------------------------------------------	
// The main vertex shader function (entry point into shader)						
//-----------------------------------------------------------------------------	
VsOutput main(VsInput i)															
{																					
	// Output structure																
	VsOutput o;																		
																					
	// Convert our position to view space.											
	float4 pos = float4(i.pos, 1.0f);												
	o.pos = pos;																	
	o.pos.y = 1.0f - i.pos.y;														
	o.pos.xy = (o.pos.xy * 2.0f) - 1.0f;											
	o.pos.zw = mul(pos, mProjection).zw;											
	o.pos.z = o.pos.z / o.pos.w;													
	o.pos.w = 1.0f;																	
																					
	// Pass along texture coordinate												
	o.texCoord.xy = i.texCoord.xy;													
																					
	// Pass along vertex color														
	o.diffuse = i.color.bgra / 255.0f;												
																					
	// All done																		
	return o;																		
}//mainVS																			
  vs_2_0  float4x4 mViewProjection : register(c0);											
																					
// Our input structure																
struct VsInput																		
{																					
	float3 pos:       POSITION0;													
	float2 texCoord:  TEXCOORD0;													
	float4 color:     COLOR0;														
};																					
																					
// Our output structure, this needs to match what lives in the pixel shader		
// or at least not be any less than what's used in the pixel shader.				
struct VsOutput																	
{																					
	float4 pos:       POSITION0;													
	float2 texCoord:  TEXCOORD0;													
	float4 diffuse:   COLOR0;														
};																					
																					
//-----------------------------------------------------------------------------	
// The main vertex shader function (entry point into shader)						
//-----------------------------------------------------------------------------	
VsOutput main(VsInput i)															
{																					
	// Output structure																
	VsOutput o;																		
																					
	// Convert our position to view space.											
	float4 pos = float4(i.pos, 1.0f);												
	o.pos = mul(pos, mViewProjection);												
																					
	// Pass along texture coordinate												
	o.texCoord.xy = i.texCoord.xy;													
																					
	// Pass along vertex color														
	o.diffuse = i.color.bgra / 255.0f;												
																					
	// All done																		
	return o;																		
}//mainVS

0x555FE9

    if (LightType != 2)
    {
        // This version only supports spotlights.
        ShadowOut = 1.0;
    }
    else
    {
        float3 LightToWorldPos = normalize(float3(WorldPos - LightPos));

        if (dot(LightDirection, LightToWorldPos) > CosOfCutoff)
        {
            float4 LightProjPos = mul(WorldPos, WorldToLightProjMat);
            float3 ShadowTexC = LightProjPos.xyz / LightProjPos.w;               
            ShadowTexC.xy =( 0.5 * ShadowTexC.xy) + float2( 0.5, 0.5 );
            ShadowTexC.y = 1.0f - ShadowTexC.y;

            float LightSpaceDepth = clamp(ShadowTexC.z - ShadowBias, 
                0.0, 1.0);
            
            float2 ShadowMapSizeInverse = 1.0 / ShadowMapSize;

            ShadowTexC.xy = ShadowTexC.xy - ShadowMapSizeInverse;
               
            ShadowOut = 0;
            float4 fOnes = float4(1.0, 1.0, 1.0, 1.0);
            float4 fKernels = float4(1.0, 1.0, 1.0, 1.0);
            float faKernels[4] = {1.0, 1.0, 1.0, 1.0};
           
            faKernels[0] = 1-frac(ShadowTexC.y * ShadowMapSize.y);
            faKernels[3]= frac(ShadowTexC.y  * ShadowMapSize.y); 
           
            fKernels.x = 1-frac(ShadowTexC.x * ShadowMapSize.x);
            fKernels.w = frac(ShadowTexC.x  * ShadowMapSize.x);
                              
            float fTotalPercent = 0;
            
            // This loop is manually unrolled here to avoid long
            // shader compilation times.            
            //for (int i=0; i < 4; i++)
            // i == 0
            {
                float4 shadowMapDepth = 0;
                float2 pos = ShadowTexC.xy;
                shadowMapDepth.x = tex2D(ShadowMap, pos).x; 
                pos.x += ShadowMapSizeInverse;
                shadowMapDepth.y = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;        
                shadowMapDepth.z = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;                
                shadowMapDepth.w = tex2D(ShadowMap, pos).x;
                
                float4 shad = (LightSpaceDepth <= shadowMapDepth);
                    
                ShadowOut += dot(shad, fKernels) * faKernels[0];
                fTotalPercent += dot(fOnes, fKernels) * faKernels[0];
            }
            // i == 1
            {
                float4 shadowMapDepth = 0;
                float2 pos = ShadowTexC.xy;
                pos.y += ShadowMapSizeInverse;
                shadowMapDepth.x = tex2D(ShadowMap, pos).x; 
                pos.x += ShadowMapSizeInverse;
                shadowMapDepth.y = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;        
                shadowMapDepth.z = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;                
                shadowMapDepth.w = tex2D(ShadowMap, pos).x;
                
                float4 shad = (LightSpaceDepth <= shadowMapDepth);
                    
                ShadowOut += dot(shad, fKernels) * faKernels[1];
                fTotalPercent += dot(fOnes, fKernels) * faKernels[1];
            }
            // i == 2
            {
                float4 shadowMapDepth = 0;
                float2 pos = ShadowTexC.xy;
                pos.y += 2 * ShadowMapSizeInverse;
                shadowMapDepth.x = tex2D(ShadowMap, pos).x; 
                pos.x += ShadowMapSizeInverse;
                shadowMapDepth.y = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;        
                shadowMapDepth.z = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;                
                shadowMapDepth.w = tex2D(ShadowMap, pos).x;
                
                float4 shad = (LightSpaceDepth <= shadowMapDepth);
                    
                ShadowOut += dot(shad, fKernels) * faKernels[2];
                fTotalPercent += dot(fOnes, fKernels) * faKernels[2];
            }
            // i == 3
            {
                float4 shadowMapDepth = 0;
                float2 pos = ShadowTexC.xy;
                pos.y += 3 * ShadowMapSizeInverse;
                shadowMapDepth.x = tex2D(ShadowMap, pos).x; 
                pos.x += ShadowMapSizeInverse;
                shadowMapDepth.y = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;        
                shadowMapDepth.z = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;                
                shadowMapDepth.w = tex2D(ShadowMap, pos).x;
                
                float4 shad = (LightSpaceDepth <= shadowMapDepth);
                    
                ShadowOut += dot(shad, fKernels) * faKernels[3];
                fTotalPercent += dot(fOnes, fKernels) * faKernels[3];
            }
           
            ShadowOut = ShadowOut / fTotalPercent;         
        }
        else
        {
            // Outside of the light cone is shadowed completely
            ShadowOut = 0.0;
        }
    }    
         
    if (LightType != 2)
    {
        // This version only supports spotlights.
        ShadowOut = 1.0;
    }
    else
    {
        float3 LightToWorldPos = normalize(float3(WorldPos - LightPos));

        if (dot(LightDirection, LightToWorldPos) > CosOfCutoff)
        {
            float4 LightProjPos = mul(WorldPos, WorldToLightProjMat);
            float3 ShadowTexC = LightProjPos.xyz / LightProjPos.w;               
            ShadowTexC.xy =( 0.5 * ShadowTexC.xy) + float2( 0.5, 0.5 );
            ShadowTexC.y = 1.0f - ShadowTexC.y;
            float LightSpaceDepth = clamp(ShadowTexC.z - ShadowBias, 
                0.0, 1.0);
            float2 ShadowMapSizeInverse = 1.0 / ShadowMapSize;
            float2 lerps = frac( ShadowTexC.xy * ShadowMapSize);

            float4 SourceVals;
            SourceVals.x = tex2D( ShadowMap, ShadowTexC.xy ).r;

            ShadowTexC.x += ShadowMapSizeInverse;
            SourceVals.y = tex2D( ShadowMap, ShadowTexC.xy).r;  

            ShadowTexC.y += ShadowMapSizeInverse;                
            SourceVals.w = tex2D( ShadowMap, ShadowTexC.xy).r;
                
            ShadowTexC.x -= ShadowMapSizeInverse;                
            SourceVals.z = tex2D( ShadowMap, ShadowTexC.xy).r;
                
            float4 Shade = (LightSpaceDepth <= SourceVals);

            // lerp between the shadow values to calculate our light amount
            ShadowOut = lerp(
                lerp(Shade.x, Shade.y, lerps.x),
                lerp(Shade.z, Shade.w, lerps.x), lerps.y );
        }
        else
        {
            // Outside of the light cone is shadowed completely
            ShadowOut = 0.0;
        }
    }    
     
    if (LightType == 0 || LightType == 2)
    {
        // This version only supports point lights.
        ShadowOut = 1.0;
    }
    else
    {
        float3 ViewVector = WorldPos - LightPos;    
        ViewVector.z = -ViewVector.z;
        float3 ViewVectorNrm = normalize(ViewVector);

        float fDepth = dot(ViewVector, ViewVector);
        fDepth = sqrt(fDepth) * ShadowBias;
        float ShadowLookup = texCUBE(ShadowMap, ViewVectorNrm).r;
         
        if (ShadowLookup == 0 || ShadowLookup > fDepth )
            ShadowOut = 1.0;
        else
            ShadowOut = 0.0;
    }
         
    if (LightType != 2)
    {
        // This version only supports spotlights.
        ShadowOut = 1.0;
    }
    else
    {
        float3 LightToWorldPos = normalize(float3(WorldPos - LightPos));

        if (dot(LightDirection, LightToWorldPos) > CosOfCutoff)
        {
            float4 LightProjPos = mul(WorldPos, WorldToLightProjMat);
            float3 ShadowTexC = LightProjPos.xyz / LightProjPos.w;               
            ShadowTexC.xy =( 0.5 * ShadowTexC.xy) + float2( 0.5, 0.5 );
            ShadowTexC.y = 1.0f - ShadowTexC.y;
            float LightSpaceDepth = clamp(ShadowTexC.z - ShadowBias, 
                0.0, 1.0);
                                                        
            float4 vVSM   = tex2D( ShadowMap, ShadowTexC.xy );
            float  fAvgZ  = vVSM.r; // Filtered z
            float  fAvgZ2 = vVSM.g; // Filtered z-squared
            
            // Standard shadow map comparison
            if( (LightSpaceDepth - ShadowBias) <= fAvgZ)
            {
                ShadowOut = 1.0f;
            }
            else
            {               
                // Use variance shadow mapping to compute the maximum 
                // probability that the pixel is in shadow
                float variance = ( fAvgZ2 ) - ( fAvgZ * fAvgZ );
                variance       = 
                    min( 1.0f, max( 0.0f, variance + ShadowVSMPowerEpsilon.y));
                ShadowOut = variance;
                
                float mean     = fAvgZ;
                float d        = LightSpaceDepth - mean;
                float p_max    = variance / ( variance + d*d );
                
                ShadowOut = pow( p_max, ShadowVSMPowerEpsilon.x);
            }

        }
        else
        {
            // Outside of the light cone is shadowed completely
            ShadowOut = 0.0;
        }
    }
           
    if (LightType != 2)
    {
        // This version only supports spotlights.
        ShadowOut = 1.0;
    }
    else
    {
        float3 LightToWorldPos = normalize(float3(WorldPos - LightPos));

        if (dot(LightDirection, LightToWorldPos) > CosOfCutoff)
        {
            float4 LightProjPos = mul(WorldPos, WorldToLightProjMat);

            float3 ShadowTexC = LightProjPos.xyz / LightProjPos.w;               
            ShadowTexC.xy =( 0.5 * ShadowTexC.xy) + float2( 0.5, 0.5 );
            ShadowTexC.y = 1.0f - ShadowTexC.y;

            float LightSpaceDepth = clamp(ShadowTexC.z - ShadowBias, 
                0.0, 1.0);
            float ShadowLookup = tex2D(ShadowMap, ShadowTexC.xy).r;                
            ShadowOut = ShadowLookup < LightSpaceDepth ? 0.0 : 1.0;
        }
        else
        {
            // Outside of the light cone is shadowed completely
            ShadowOut = 0.0;
        }
    }
        (0.0005)    CosOfCutoff     
    
    if ( LightType != 0)
    {
      // This fragment only supports directional lights.
        ShadowOut = 0.0;
    }
    else
    {
        float4 LightProjPos = mul(WorldPos, WorldToLightProjMat);
        float2 ShadowTexC = 0.5 * LightProjPos.xy / LightProjPos.w + 
                  float2( 0.5, 0.5 );
        
        ShadowTexC.y = 1.0f - ShadowTexC.y;
        
        float ShadowMapSizeInverse = 1.0f / ShadowMapSize;
        float LightSpaceDepth = (LightProjPos.z / LightProjPos.w);
        float2 borderTest = saturate(ShadowTexC) - ShadowTexC;

        if (any(borderTest))
        {
            ShadowOut = 1.0;
        }
        else
        {    
            LightSpaceDepth -= ShadowBias;
        
            ShadowOut = 0;
            float4 fOnes = float4(1.0, 1.0, 1.0, 1.0);
            float4 fKernels = float4(1.0, 1.0, 1.0, 1.0);
            float faKernels[4] = {1.0, 1.0, 1.0, 1.0};
            
            faKernels[0] = 1-frac(ShadowTexC.y * ShadowMapSize.y);
            faKernels[3]= frac(ShadowTexC.y  * ShadowMapSize.y); 
            
            fKernels.x = 1-frac(ShadowTexC.x * ShadowMapSize.x);
            fKernels.w = frac(ShadowTexC.x  * ShadowMapSize.x);
                      
            float fTotalPercent = 0;
            
            // This loop is manually unrolled here to avoid long
            // shader compilation times.
            //for (int i=0; i < 4; i++)
            // i == 0
            {
                float4 shadowMapDepth = 0;
                float2 pos = ShadowTexC;                
                shadowMapDepth.x = tex2D(ShadowMap, pos).x; 
                pos.x += ShadowMapSizeInverse;
                shadowMapDepth.y = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;        
                shadowMapDepth.z = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;                
                shadowMapDepth.w = tex2D(ShadowMap, pos).x;
                
                float4 shad = (LightSpaceDepth < shadowMapDepth);
    
                ShadowOut += dot(shad, fKernels) * faKernels[0];
                fTotalPercent += dot(fOnes, fKernels) * faKernels[0];
            }
            // i == 1
            {
                float4 shadowMapDepth = 0;
                float2 pos = ShadowTexC;                
                pos.y += ShadowMapSizeInverse;
                shadowMapDepth.x = tex2D(ShadowMap, pos).x; 
                pos.x += ShadowMapSizeInverse;
                shadowMapDepth.y = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;        
                shadowMapDepth.z = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;                
                shadowMapDepth.w = tex2D(ShadowMap, pos).x;
                
                float4 shad = (LightSpaceDepth < shadowMapDepth);
    
                ShadowOut += dot(shad, fKernels) * faKernels[1];
                fTotalPercent += dot(fOnes, fKernels) * faKernels[1];
            }
            // i == 2
            {
                float4 shadowMapDepth = 0;
                float2 pos = ShadowTexC;                
                pos.y += 2 * ShadowMapSizeInverse;
                shadowMapDepth.x = tex2D(ShadowMap, pos).x; 
                pos.x += ShadowMapSizeInverse;
                shadowMapDepth.y = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;        
                shadowMapDepth.z = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;                
                shadowMapDepth.w = tex2D(ShadowMap, pos).x;
                
                float4 shad = (LightSpaceDepth < shadowMapDepth);
    
                ShadowOut += dot(shad, fKernels) * faKernels[2];
                fTotalPercent += dot(fOnes, fKernels) * faKernels[2];
            }
            // i == 3
            {
                float4 shadowMapDepth = 0;
                float2 pos = ShadowTexC;                
                pos.y += 3 * ShadowMapSizeInverse;
                shadowMapDepth.x = tex2D(ShadowMap, pos).x; 
                pos.x += ShadowMapSizeInverse;
                shadowMapDepth.y = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;        
                shadowMapDepth.z = tex2D(ShadowMap, pos).x;
                pos.x += ShadowMapSizeInverse;                
                shadowMapDepth.w = tex2D(ShadowMap, pos).x;
                
                float4 shad = (LightSpaceDepth < shadowMapDepth);
    
                ShadowOut += dot(shad, fKernels) * faKernels[3];
                fTotalPercent += dot(fOnes, fKernels) * faKernels[3];
            }
            
            ShadowOut = ShadowOut / fTotalPercent;         
           }
       }

      ps_3_0/ps_4_0   DX9/D3D10/Xenon/PS3     
    
    if ( LightType != 0)
    {
      // This fragment only supports directional lights.
        ShadowOut = 0.0;
    }
    else
    {
        float4 LightProjPos = mul(WorldPos, WorldToLightProjMat);
        float2 ShadowTexC = 0.5 * LightProjPos.xy / LightProjPos.w + 
                  float2( 0.5, 0.5 );
    
        ShadowTexC.y = 1.0f - ShadowTexC.y;
    
        float ShadowMapSizeInverse = 1.0f / ShadowMapSize;
        float2 lerps = frac( ShadowTexC * ShadowMapSize);
        float LightSpaceDepth = (LightProjPos.z / LightProjPos.w);
        float2 borderTest = saturate(ShadowTexC) - ShadowTexC;

        if (any(borderTest))
        {
            ShadowOut = 1.0;
        }
        else
        {
            LightSpaceDepth -= ShadowBias;
                   
            float4 SourceVals;
            SourceVals.x = tex2D( ShadowMap, ShadowTexC ).r;
    
            ShadowTexC.x += ShadowMapSizeInverse;
            SourceVals.y = tex2D( ShadowMap, ShadowTexC).r;  
    
            ShadowTexC.y += ShadowMapSizeInverse;                
            SourceVals.w = tex2D( ShadowMap, ShadowTexC ).r;
                
            ShadowTexC.x -= ShadowMapSizeInverse;                
            SourceVals.z = tex2D( ShadowMap, ShadowTexC).r;
                
            float4 Shade = (LightSpaceDepth < SourceVals);
    
            // lerp between the shadow values to calculate our light amount
            ShadowOut = lerp(
                lerp(Shade.x, Shade.y, lerps.x),
                lerp(Shade.z, Shade.w, lerps.x), lerps.y );        
        }
    }

       
    
    if ( LightType != 0)
    {
      // This fragment only supports directional lights.
        ShadowOut = 0.0;
    }
    else
    { 
        float4 LightProjPos = mul(WorldPos, WorldToLightProjMat);
        float2 ShadowTexC = 0.5 * LightProjPos.xy / LightProjPos.w + 
            float2( 0.5, 0.5 );
        ShadowTexC.y = 1.0f - ShadowTexC.y;
        
        float LightSpaceDepth = (LightProjPos.z / LightProjPos.w);
        float2 borderTest = saturate(ShadowTexC) - ShadowTexC;

        float4 vVSM   = tex2D( ShadowMap, ShadowTexC.xy );
        float  fAvgZ  = vVSM.r; // Filtered z
        float  fAvgZ2 = vVSM.g; // Filtered z-squared
        
        // Standard shadow map comparison
        if((LightSpaceDepth) - ShadowBias <= fAvgZ || any(borderTest))
        {
            ShadowOut = 1.0f;
        }
        else
        {            
            // Use variance shadow mapping to compute the maximum probability 
            // that the pixel is in shadow
            float variance = ( fAvgZ2 ) - ( fAvgZ * fAvgZ );
            variance       = 
                min( 1.0f, max( 0.0f, variance + ShadowVSMPowerEpsilon.y ) );
            ShadowOut = variance;
            
            float mean     = fAvgZ;
            float d        = LightSpaceDepth - mean;
            float p_max    = variance / ( variance + d*d );
            
            ShadowOut = pow( p_max, ShadowVSMPowerEpsilon.x);
        }
    }

      (10.0, 0.001)       
    
    if ( LightType != 0)
    {
      // This fragment only supports directional lights.
        ShadowOut = 0.0;
    }
    else
    {
        float4 LightProjPos = mul(WorldPos, WorldToLightProjMat);
        float2 ShadowTexC = 0.5 * LightProjPos.xy / LightProjPos.w + 
                  float2( 0.5, 0.5 );
    
        ShadowTexC.y = 1.0f - ShadowTexC.y;

        float ShadowLookup = tex2D(ShadowMap, ShadowTexC.xy).r;
        float LightSpaceDepth = (LightProjPos.z / LightProjPos.w) ;
        float2 borderTest = saturate(ShadowTexC) - ShadowTexC;

        if ( (ShadowLookup > LightSpaceDepth - ShadowBias) || 
            any(borderTest))
        {
            ShadowOut = 1.0;
        }
        else
        {
            ShadowOut = 0.0;
        }
        
       }

      (0.005) (512,512)   
    This fragment is responsible for calculating the Shadow coefficient.
      
    Output = Input.r;
         
    This fragment implements the operation:
    Output = Input.r;
     
    Output = Input.rrrr;
      
    This fragment implements the operation:
    Output = float4(Input, Input, Input, Input);
      
    Output = Input.rrr;
           
    This fragment implements the operation:
    Output = float3(Input, Input, Input);
     
    Output = (V1 * V2) + V3;
      
    This fragment implements the equation:
    Output = (V1 * V2) + V3
        
    Output = V1 * saturate(V2.rgb + Scalar.rrr);
      
    This fragment is responsible for accumulating into the current color by
    multiplying the sampled texture color with the current color. The 
    original input alpha channel is preserved. The scalar value is added to the
    sampled color value and then clamped to the range [0.0, 1.0].
          
    This fragment is responsible for normalizing a float2.
            
    This fragment is responsible for normalizing a float3.
        
    VectorOut = normalize(VectorIn);
      
    This fragment is responsible for normalizing a float4.
            
    This fragment is responsible for linearly interpolating two floats.   
            
    This fragment is responsible for linearly interpolating two float2's.   
          
    This fragment is responsible for linearly interpolating two float3's. 
        
    Output = lerp(V1, V2, LerpAmount);
        (0.5)       
    This fragment is responsible for linearly interpolating two float4's. 
            
    This fragment is responsible for saturating a float. 
     
    This fragment is responsible for saturating a float2. 
            
    This fragment is responsible for saturating a float3. 
        
    Output = saturate(V1);
        
    This fragment is responsible for saturating a float4. 
            
    This fragment is responsible for scaling a float2 by a constant. 
             
    This fragment is responsible for scaling a float3 by a constant. 
     
    Output = Scale * V1;
      
    This fragment is responsible for scaling a float4 by a constant. 
         
    This fragment is responsible for multiplying two floats. 
         
    This fragment is responsible for multiplying two float2's. 
       
    This fragment is responsible for multiplying two float3's. 
       
    Output = V1 * V2;
         
    This fragment is responsible for multiplying two float4's. 
       
    This fragment is responsible for adding two floats. 
      
    This fragment is responsible for adding two float2's. 
            
    This fragment is responsible for adding two float3's. 
        
    Output = V1 + V2;
     
    This fragment is responsible for adding two float4's. 
            
    OutputColor.rgb = FinalColor.rgb;
    OutputColor.a = saturate(FinalOpacity);
     
    This fragment is responsible for computing the final RGBA color.
          
    OutputColor.rgb = DiffuseColor.rgb + SpecularColor.rgb;
           
    This fragment is responsible for computing the final RGB color.
           
    Red = ColorAndOpacity.r;
    Green = ColorAndOpacity.g;
    Blue = ColorAndOpacity.b;
    Alpha = ColorAndOpacity.a;
      
    Separate a float4 into 4 floats.   
       
    Color.rgb = ColorAndOpacity.rgb;
    Opacity = ColorAndOpacity.a;
     
    Separate a float4 into a float3 and a float.   
       
    Diffuse = MatEmissive + MatAmbient * LightAmbientAccum + 
        MatDiffuse * LightDiffuseAccum;
    Specular = MatSpecular * LightSpecularAccum;
    
    if (Saturate)
    {
        Diffuse = saturate(Diffuse);
        Specular = saturate(Specular);
    }
         
    This fragment is responsible for computing the coefficients for the 
    following equations:
    
    Kdiffuse = MatEmissive + 
        MatAmbient * Summation(0...N){LightAmbientContribution[N]} + 
        MatDiffuse * Summation(0..N){LightDiffuseContribution[N]}
        
    Kspecular = MatSpecular * Summation(0..N){LightSpecularContribution[N]}
    
        
    // These tests will evaluate to less than 0 if they are true.
    float fLessTest = (AlphaTestValue - AlphaTestRef);
    float fGreaterTest = -fLessTest;
    float fEqualTest = 0.0;
    if (fLessTest == 0.0)
        fEqualTest = -1.0;

    // Clip if AlphaTestValue < AlphaTestRef for:
    //  TEST_LESS 
    //  TEST_EQUAL 
    //  TEST_LESSEQUAL 
    clip(fGreaterTest * AlphaTestFunction.x);
    
    // Clip if AlphaTestValue > AlphaTestRef for:
    //  TEST_EQUAL 
    //  TEST_GREATER 
    //  TEST_GREATEREQUAL 
    clip(fLessTest * AlphaTestFunction.y);
    
    // Clip if AlphaTestValue == AlphaTestRef for:
    //  TEST_LESS 
    //  TEST_GREATER 
    //  TEST_NOTEQUAL 
    clip(fEqualTest * AlphaTestFunction.z);
     (0.0)   
    This fragment is responsible for alpha testing based on the alpha
    reference value and alpha test function.
            
    FoggedColor = lerp(FogColor, UnfoggedColor, FogAmount);
           
    This fragment is responsible for applying the fog based on the 
    calculations in the vertex shader.
    
       Pixel/Vertex       
    // Get the world space light vector.
    float3 LightVector;
    float DistanceToLight;
    float DistanceToLightSquared;
        
    if (LightType == 0)
    {
        LightVector = -LightDirection;
    }
    else
    {
        LightVector = LightPos - WorldPos;
        DistanceToLightSquared = dot(LightVector, LightVector);
        DistanceToLight = length(LightVector);
        LightVector = normalize(LightVector);
    }
    
    // Take N dot L as intensity.
    float LightNDotL = dot(LightVector, WorldNrm);
    float LightIntensity = max(0, LightNDotL);

    float Attenuate = Shadow;
    
    if (LightType != 0)
    {
        // Attenuate Here
        Attenuate = LightAttenuation.x +
            LightAttenuation.y * DistanceToLight +
            LightAttenuation.z * DistanceToLightSquared;
        Attenuate = max(1.0, Attenuate);
        Attenuate = 1.0 / Attenuate;
        Attenuate *= Shadow;

        if (LightType == 2)
        {
            // Get intensity as cosine of light vector and direction.
            float CosAlpha = dot(-LightVector, LightDirection);

            // Factor in inner and outer cone angles.
            CosAlpha = saturate((CosAlpha - LightSpotAttenuation.y) / 
                (LightSpotAttenuation.x - LightSpotAttenuation.y));

            // Power to falloff.
            CosAlpha = pow(CosAlpha, LightSpotAttenuation.z);

            // Multiply the spot attenuation into the overall attenuation.
            Attenuate *= CosAlpha;
        }

    }
    // Determine the interaction of diffuse color of light and material.
    // Scale by the attenuated intensity.
    DiffuseAccumOut = DiffuseAccum;
    DiffuseAccumOut.rgb += LightDiffuse.rgb * LightIntensity * Attenuate;

    // Determine ambient contribution - Is affected by shadow
    AmbientAccumOut = AmbientAccum;
    AmbientAccumOut.rgb += LightAmbient.rgb * Attenuate;

    SpecularAccumOut = SpecularAccum;
    if (SpecularEnable)
    {
        // Get the half vector.
        float3 LightHalfVector = LightVector + WorldViewVector;
        LightHalfVector = normalize(LightHalfVector);

        // Determine specular intensity.
        float LightNDotH = max(0, dot(WorldNrm, LightHalfVector));
        float LightSpecIntensity = pow(LightNDotH, SpecularPower.x);
        
        //if (LightNDotL < 0.0)
        //    LightSpecIntensity = 0.0;
        // Must use the code below rather than code above.
        // Using previous lines will cause the compiler to generate incorrect
        // output.
        float SpecularMultiplier = LightNDotL > 0.0 ? 1.0 : 0.0;
        
        // Attenuate Here
        LightSpecIntensity = LightSpecIntensity * Attenuate * 
            SpecularMultiplier;
        
        // Determine the interaction of specular color of light and material.
        // Scale by the attenuated intensity.
        SpecularAccumOut.rgb += LightSpecIntensity * LightSpecular;
    }       

    
       (-1.0, -1.0, 0.0)   (0.0, 1.0, 0.0) (0.0, 0.0, 0.0, 0.0)    Specularity     
    This fragment is responsible for accumulating the effect of a light
    on the current pixel.
    
    LightType can be one of three values:
        0 - Directional
        1 - Point 
        2 - Spot
        
    Note that the LightType must be a compile-time variable,
    not a runtime constant/uniform variable on most Shader Model 2.0 cards.
    
    The compiler will optimize out any constants that aren't used.
    
    Attenuation is defined as (const, linear, quad, range).
    Range is not implemented at this time.
    
    SpotAttenuation is stored as (cos(theta/2), cos(phi/2), falloff)
    theta is the angle of the inner cone and phi is the angle of the outer
    cone in the traditional DX manner. Gamebryo only allows setting of
    phi, so cos(theta/2) will typically be cos(0) or 1. To disable spot
    effects entirely, set cos(theta/2) and cos(phi/2) to -1 or lower.
                 
    float fDistance = dot(WorldClipPlane.xyz, WorldPos.xyz) - WorldClipPlane.w;
    if (InvertClip)
        Scalar = fDistance > 0.0 ? 0.0 : 1.0;
    else
        Scalar = fDistance > 0.0 ? 1.0 : 0.0;
       (1.0, 0.0, 0.0, 0.0)    
    This fragment is responsible for calculating whether or not the current
    position is on the positive or negative side of a clipping plane. If the
    point is on the positive side, the return value will be 1.0. If the value 
    is on the negative side, the return value will be 0.0. If the point is on
    the plane, the return value will be 0.0. If InvertClip is true, then the
    fragment returns the opposite of the above.
    
    A plane is assumed to be the points X satisfying the expression:
        X * normal = plane_constant
        
    The WorldClipPlane must match the form of NiPlane, which is of the form:
        (normal.x, normal.y, normal.z, plane_constant)
     
    WorldViewVector = CameraPos - WorldPos;
       CameraPosition  
    This fragment is responsible for calculating the camera view vector.
      
    if (NormalizeNormal)
        WorldNrm = normalize(WorldNrm);
    WorldReflect = reflect(-WorldViewVector, WorldNrm);
      
    This fragment is responsible for computing the reflection vector.
    The WorldViewVector is negated because the HLSL "reflect" function
    expects a world-to-camera vector, rather than a camera-to-world vector.
      
    float d;
    if (FogRange)
    {
        d = length(ViewPosition);
    }
    else
    {
        d = ViewPosition.z;
    }
    
    if (FogType == 0) // NONE
    {
        FogOut = 1.0;
    }
    else if (FogType == 1) // EXP
    {
        FogOut = 1.0 / exp( d * FogDensity);
    }
    else if (FogType == 2) // EXP2
    {
        FogOut = 1.0 / exp( pow( d * FogDensity, 2));
    }
    else if (FogType == 3) // LINEAR
    {
        FogOut = saturate( (FogStartEnd.y - d) / 
            (FogStartEnd.y - FogStartEnd.x));
    }
       (0.0, 1.0)  (1.0)   
    This fragment is responsible for handling fogging calculations.
    FogType can be one of 4 values:
    
        NONE   - 0
        EXP    - 1
        EXP2   - 2
        LINEAR - 3
      
    ColorOut.rgb = texCUBE(Sampler, TexCoord).rgb;
    if (Saturate)
    {
        ColorOut.rgb = saturate(ColorOut.rgb);
    }
       
    float4 ProjTexCoord = TexCoord.xyzz;
    ColorOut.rgb = tex2Dproj(Sampler, ProjTexCoord).rgb;
    if (Saturate)
    {
        ColorOut.rgb = saturate(ColorOut.rgb);
    }
        
    ColorOut = tex2D(Sampler, TexCoord);
    if (Saturate)
    {
        ColorOut = saturate(ColorOut);
    }
         
    This fragment is responsible for sampling a texture and returning its value
    as a RGB value and an A value.
            
    ColorOut.rgb = tex2D(Sampler, TexCoord).rgb;
    if (Saturate)
    {
        ColorOut.rgb = saturate(ColorOut.rgb);
    }
     Texture     
    This fragment is responsible for sampling a texture and returning its value
    as a RGB value.
           
  
    TexCoordOut = mul(float4(TexCoord, 1.0), TexTransform);
    
           
    This fragment is responsible for applying a projection to the input set
    of texture coordinates.
       
    
    TexCoordOut = mul(float4(TexCoord.x, TexCoord.y, 0.0, 1.0), TexTransform);
           
    This fragment is responsible for applying a transform to the input set
    of texture coordinates.
        
    TexCoordOut = TexCoordIn + 
        float4(TexCoordOffset.x, TexCoordOffset.y, 0.0, 0.0);
         
    TexCoordOut = TexCoordIn + float3(TexCoordOffset.x, TexCoordOffset.y, 0.0);
       
    TexCoordOut = TexCoordIn + TexCoordOffset;
        
    This fragment is responsible for applying a UV offset to a texture
    coordinate set.
            
    BumpOffset.x = DuDv.x * BumpMatrix[0] + DuDv.y * BumpMatrix[2];
    BumpOffset.y = DuDv.x * BumpMatrix[1] + DuDv.y * BumpMatrix[3];
       UVSet   (1.0, 1.0, 1.0, 1.0)    
    This fragment is responsible for calculating the UV offset to apply
    as a result of a bump map.
        
    // Calculate offset scaling constant bias.
    float2 Bias = float2(OffsetScale, OffsetScale) * -0.5;

    // Calculate offset
    float2 Offset = Height.rg * OffsetScale + Bias;

    // Get texcoord.
    ParallaxOffsetUV = TexCoord + Offset * TangentSpaceEyeVec.xy;
        (1.0, 0.0, 0.0) ViewVector  (0.05)  ParallaxOffsetScale 
    This fragment is responsible for calculating the UV offset to apply
    as a result of a parallax map.
            
    
    NormalMap = NormalMap * 2.0 - 1.0;
    
    // Do nothing extra for Standard
    // Handle compressed types:
    if (NormalMapType == 1) // DXN
    {
        NormalMap.rgb = float3(NormalMap.r, NormalMap.g, 
            sqrt(1 - NormalMap.r * NormalMap.r - NormalMap.g * NormalMap.g));
    }
    else if (NormalMapType == 2) // DXT5
    {
        NormalMap.rg = NormalMap.ag;
        NormalMap.b = sqrt(1 - NormalMap.r*NormalMap.r -  
            NormalMap.g * NormalMap.g);
    }
       
    float3x3 xForm = float3x3(WorldTangentIn, WorldBinormalIn, WorldNormalIn);
    xForm = transpose(xForm);
    WorldNormalOut = mul(xForm, NormalMap.rgb);
    
    WorldNormalOut = normalize(WorldNormalOut);
       ps_2_0/ps_4_0   (0) 
    This fragment is responsible for sampling a normal map to generate the
    new world-space normal.
    
    The normal map type is an enumerated value that indicates the following:
        0 - Standard (rgb = normal/binormal/tangent)
        1 - DXN (rg = normal.xy need to calculate z)
        2 - DXT5 (ag = normal.xy need to calculate z)
      
    DiffuseColorOut  = SHCoefficients[0];
    DiffuseColorOut += SHCoefficients[1] * WorldNormal.x;
    DiffuseColorOut += SHCoefficients[2] * WorldNormal.y;
    DiffuseColorOut += SHCoefficients[3] * WorldNormal.z;
    DiffuseColorOut += SHCoefficients[4] * WorldNormal.x * WorldNormal.z;
    DiffuseColorOut += SHCoefficients[5] * WorldNormal.y * WorldNormal.z;
    DiffuseColorOut += SHCoefficients[6] * WorldNormal.x * WorldNormal.y;
    DiffuseColorOut += SHCoefficients[7] * 
        (3.0 * WorldNormal.z * WorldNormal.z  - 1.0);
    DiffuseColorOut += SHCoefficients[8] * 
        (WorldNormal.x * WorldNormal.x  - WorldNormal.y * WorldNormal.y);
     DiffuseColorOut SHCoefficients      
    This fragment is responsible for generating the diffuse 
    lighting environment as compressed in spherical harmonics.
       9thOrderSphericalHarmonicLighting   
    ViewPos = mul(WorldPosition, ViewTransform);
    ProjPos = mul(ViewPos, ProjTransform);
       ProjMatrix  ViewMatrix  
    ProjPos = mul(WorldPosition, ViewProjection);
     ViewProjMatrix      
    This fragment is responsible for applying the view projection transform
    to the input world position.
          
    // TransformSkinnedPosition *********************************************
    // Transform the skinned position into world space
    // Composite the skinning transform which will take the vertex
    // and normal to world space.
    float fWeight3 = 1.0 - BlendWeights[0] - BlendWeights[1] - BlendWeights[2];
    float4x3 ShortSkinBoneTransform;
    ShortSkinBoneTransform  = Bones[0] * BlendWeights[0];
    ShortSkinBoneTransform += Bones[1] * BlendWeights[1];
    ShortSkinBoneTransform += Bones[2] * BlendWeights[2];
    ShortSkinBoneTransform += Bones[3] * fWeight3;
    SkinBoneTransform = float4x4(ShortSkinBoneTransform[0], 0.0f, 
        ShortSkinBoneTransform[1], 0.0f, 
        ShortSkinBoneTransform[2], 0.0f, 
        ShortSkinBoneTransform[3], 1.0f);

    // Transform into world space.
    WorldPos.xyz = mul(float4(Position, 1.0), ShortSkinBoneTransform);
    WorldPos = mul(float4(WorldPos.xyz, 1.0), SkinToWorldTransform);

     
    // TransformSkinnedPosition *********************************************
    // Transform the skinned position into world space
    // Composite the skinning transform which will take the vertex
    // and normal to world space.
    float fWeight3 = 1.0 - BlendWeights[0] - BlendWeights[1] - BlendWeights[2];
    float4x3 ShortSkinBoneTransform;
    ShortSkinBoneTransform  = Bones[BlendIndices[0]] * BlendWeights[0];
    ShortSkinBoneTransform += Bones[BlendIndices[1]] * BlendWeights[1];
    ShortSkinBoneTransform += Bones[BlendIndices[2]] * BlendWeights[2];
    ShortSkinBoneTransform += Bones[BlendIndices[3]] * fWeight3;
    SkinBoneTransform = float4x4(ShortSkinBoneTransform[0], 0.0f, 
        ShortSkinBoneTransform[1], 0.0f, 
        ShortSkinBoneTransform[2], 0.0f, 
        ShortSkinBoneTransform[3], 1.0f);

    // Transform into world space.
    WorldPos.xyz = mul(float4(Position, 1.0), ShortSkinBoneTransform);
    WorldPos = mul(float4(WorldPos.xyz, 1.0), SkinToWorldTransform);
      SkinBoneMatrix  
    This fragment is responsible for applying the view projection and skinning 
    transform to the input position. Additionally, this fragment applies the 
    computed world transform to the input position. The weighted world 
    transform defined by the blendweights is output for use in normals or
    other calculations as the new world matrix.
       
    float3x3 xForm = float3x3(WorldTangentIn, WorldBinormalIn, WorldNormalIn);
    VectorOut = mul(xForm, VectorIn.xyz);
      
    This fragment is responsible for transforming a vector from world space
    to tangent space.
     
    // Transform the position into world space for lighting, and projected 
    // space for display
    WorldPos = mul( float4(Position, 1.0f), World );
     
    This fragment is responsible for applying the view projection transform
    to the input position. Additionally, this fragment applies the world 
    transform to the input position. 
           
    // Transform the normal into world space for lighting
    WorldNrm      = mul( Normal, (float3x3)World );
    WorldBinormal = mul( Binormal, (float3x3)World );
    WorldTangent  = mul( Tangent, (float3x3)World );
    
    // Should not need to normalize here since we will normalize in the pixel 
    // shader due to linear interpolation across triangle not preserving
    // normality.
       
    This fragment is responsible for applying the world transform to the
    normal, binormal, and tangent.
           
    // Transform the normal into world space for lighting
    WorldNrm = mul( Normal, (float3x3)World );

    // Should not need to normalize here since we will normalize in the pixel 
    // shader due to linear interpolation across triangle not preserving
    // normality.
       vs_1_1/ps_2_0/vs_4_0/ps_4_0 D3D10/DX9/Xenon/PS3 hlsl/Cg WorldMatrix 
    This fragment is responsible for applying the world transform to the
    normal.
      Vertex/Pixel

0x55FD19

    Output1 = Input;
    Output2 = Input;
     
    This fragment splits and passes through a single float4 input into two 
    float4 outputs.
       
    float Depth = dot(WorldViewVector, WorldViewVector);
    OutputColor.x = sqrt(Depth);
    OutputColor.yzw = 1.0f;
         
    This fragment writes projected depth to all color component outputs.
      
    This fragment is responsible for linearly interpolating two float3's.   
          
    This fragment is responsible for linearly interpolating two float4's.   
          
    This fragment is responsible for saturating a float.   
           
    This fragment is responsible for saturating a float2.   
          
    This fragment is responsible for saturating a float3.   
          
    This fragment is responsible for saturating a float4.   
          
    This fragment is responsible for scaling a float2 by a constant.   
           
    This fragment is responsible for scaling a float3 by a constant.   
           
    This fragment is responsible for scaling a float4 by a constant.     
     
    This fragment is responsible for multiplying two floats.   
       
    This fragment is responsible for multiplying two float2's.   
     
    This fragment is responsible for multiplying two float3's.   
     
    This fragment is responsible for multiplying two float4's.   
     
    This fragment is responsible for adding two floats.   
            
    This fragment is responsible for adding two float2's.   
          
    This fragment is responsible for adding two float3's.   
          
    This fragment is responsible for adding two float4's.   
          
    ViewPos = mul(WorldPosition, ViewTransform );
    ProjPos = mul(ViewPos, ProjTransform );
     
    ProjPos = mul(WorldPosition, ViewProjection );
        
      Output1 = Input;
      Output2 = Input;
         
      This fragment splits and passes through a single float4 input into two
      float4 outputs.
            
    float Depth = WorldPosProjected.z / WorldPosProjected.w;
            
    OutputColor.x = Depth;
    OutputColor.y = Depth * Depth;
    OutputColor.zw = 1.0;
     
        
    float Depth = WorldPosProjected.z / WorldPosProjected.w;    
    OutputColor.x = Depth;
    OutputColor.yzw = 1.0f;
      
    float Depth = WorldPosProjected.z / WorldPosProjected.w;
    OutputColor.x = Depth;
    OutputColor.yzw = 1.0f;
    

0x562160

    ;
  In.     Out.     :      //---------------------------------------------------------------------------
  
}
 {
  )
  out     ,
      (   
void   
*/
    /*
         	// Function call #%d
  );  %s_CallOut%d    
           ,   €”~ ÀCu @—~ P„~ à€~ `€~ }

     return Out;
    
};

   Out.    Output Main(Input In)
{
    Output Out;
        //---------------------------------------------------------------------------
// Main():
//---------------------------------------------------------------------------

    struct Output
{
    //---------------------------------------------------------------------------
// Output:
//---------------------------------------------------------------------------

    struct Input
{
     //---------------------------------------------------------------------------
// Input:
//---------------------------------------------------------------------------

 //---------------------------------------------------------------------------
// Functions:
//---------------------------------------------------------------------------

     //---------------------------------------------------------------------------
// Constant variables:
//---------------------------------------------------------------------------

    
*/

   /*
Shader description:

    // Blurs the texel at vTexCoord in the Y direction.   
    float fInvTexSize = 1.0 / MapSize.y;
    float fHalfBlurKernelSize = KernelSize * 0.5f;
    float fInvTotalWeights = 1.0 / (KernelSize * KernelSize);    
    float fBlurWeight = 2;
   
    float4 fTotalColor = 0;   
    float2 vTexCoord = TexCoord;
    vTexCoord.y -= fInvTexSize * fHalfBlurKernelSize;    
    float i = 0;

    // Blur x2
    if ( 2 <= KernelSize)    
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.y += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.y += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }
    
    // Blur x4
    if ( 4 <= KernelSize)    
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.y += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.y += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }    

    // Blur x6
    if ( 6 <= KernelSize)    
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.y += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.y += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }

    // Blur x8
    if ( 8 <= KernelSize)    
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.y += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.y += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }

    // Blur x10
    if ( 10 <= KernelSize)    
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.y += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.y += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }

    // Blur x12
    if ( 12 <= KernelSize)    
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.y += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.y += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }
    
    // Blur x14
    if ( 14 <= KernelSize)    
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.y += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.y += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }    

    // Blur x16
    if ( 16 <= KernelSize)    
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.y += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.y += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }

    ColorOut = fTotalColor;
      

    // Blurs the texel at vTexCoord in the X direction.   
    float fInvTexSize = 1.0 / MapSize.x;
    float fHalfBlurKernelSize = KernelSize * 0.5f;
    float fInvTotalWeights = 1.0 / (KernelSize * KernelSize);    
    float fBlurWeight = 2;
   
    float4 fTotalColor = 0;   
    float2 vTexCoord = TexCoord;
    vTexCoord.x -= fInvTexSize * fHalfBlurKernelSize;    
    float i = 0;

    // Blur x2
    if ( 2 <= KernelSize)
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.x += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.x += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }

    // Blur x4
    if ( 4 <= KernelSize)
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.x += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.x += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }
    
    // Blur x6
    if ( 6 <= KernelSize)
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.x += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.x += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }    
    
    // Blur x8
    if ( 8 <= KernelSize)
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.x += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.x += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }    
    
    // Blur x10
    if ( 10 <= KernelSize)
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.x += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.x += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }

    // Blur x12
    if ( 12 <= KernelSize)
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.x += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.x += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }
       
    // Blur x14
    if ( 14 <= KernelSize)
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.x += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.x += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }    
    
    // Blur x16
    if ( 16 <= KernelSize)
    {
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;        
        vTexCoord.x += fInvTexSize;
        
        float fSign = sign( i + 1 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;
        
        fTotalColor += tex2D(Sampler, vTexCoord) * 
            fBlurWeight * fInvTotalWeights;
        vTexCoord.x += fInvTexSize;            
        
        fSign = sign( i + 2 - fHalfBlurKernelSize);
        fBlurWeight -= fSign * 4;        
        i+=2;
    }
        
    ColorOut = fTotalColor;
       ps_2_0/vs_4_0/ps_4_0        
    ColorOut.a = 1.0f;
    ColorOut.rgb = tex2D(Sampler, TexCoord).rgb;
    if (Saturate)
    {
        ColorOut.rgb = saturate(ColorOut.rgb);
    }
          
    ColorOut.a = 1.0f;
    ColorOut.rgb = texCUBE(Sampler, TexCoord).rgb;
    if (Saturate)
    {
        ColorOut.rgb = saturate(ColorOut.rgb);
    }
        
    float4 ProjTexCoord = TexCoord.xyzz;
    ColorOut.a = 1.0f;    
    ColorOut.rgb = tex2Dproj(Sampler, ProjTexCoord).rgb;    
    if (Saturate)
    {
        ColorOut.rgb = saturate(ColorOut.rgb);
    }
         
    float Depth = WorldPosProjected.z / WorldPosProjected.w;
            
    OutputColor.x = Depth;
    OutputColor.y = Depth * Depth;
    OutputColor.z = 1.0;
    OutputColor.w = 1.0;

            
    float Depth = WorldPosProjected.z / WorldPosProjected.w;
    OutputColor = Depth;
     BlurColor