If you appreciate the work done within the wiki, please consider supporting The Cutting Room Floor on Patreon. Thanks for all your support!
Bully: Scholarship Edition (Windows)/Unused Text
Jump to navigation
Jump to search
This is a sub-page of Bully: Scholarship Edition (Windows).
Sub-Pages
 | Development Text Author: Bill Henderson Created 10/12/1999 |
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
