If you appreciate the work done within the wiki, please consider supporting The Cutting Room Floor on Patreon. Thanks for all your support!
Ghostbusters: Sanctum of Slime/Shader Source Code
Jump to navigation
Jump to search
This is a sub-page of Ghostbusters: Sanctum of Slime.
Contents
Shader Source Code
These uncompiled C++ header files can be found inside the data\art\dxshaders\util folder within the data_common archives.
colorutils.h
float GetRimFading(float3 CamPos,float3 FragmentWorldPos,float3 Normal,float InvThreshold) { float3 nCminP = normalize(CamPos.xyz-FragmentWorldPos.xyz); float NdotCmP = dot(Normal,nCminP); return saturate(NdotCmP*InvThreshold); } void ComputeFog(inout float4 PixelColor,float3 FogColor,float DistancePixelToCamera,float MinDistanceToFog,float MaxMinusMinDistanceToFog) { #if defined(_PIXEL_FOG) float CamMinusFogMin = (DistancePixelToCamera-MinDistanceToFog); float FogFactor = 1-saturate(CamMinusFogMin/MaxMinusMinDistanceToFog); #if !defined(_ADDITIVE_PIXEL_FOG) PixelColor.rgb = lerp(FogColor, PixelColor.rgb, FogFactor); #elif defined(_ADDITIVE_PIXEL_FOG) PixelColor.rgb*=FogFactor; clip(MaxMinusMinDistanceToFog-CamMinusFogMin); #endif #endif }
lighting.h
/* CalculateSpecularLighting Calculates the specular lighting for an interest point */ float3 CalculateSpecularLighting( in float3 lightDirection, ///< Direction of the light MUST BE NORMALIZED! in float3 lightSpecularColor, ///< Specular color in float3 normalVector, ///< Normal vector of the intereset point in float3 viewVector ///< View vector of the interest point ) { float3 Half = normalize( lightDirection + viewVector); return lightSpecularColor.xyz * pow(saturate( dot( Half, normalVector) ), g_specularColor.a); } /* CalculatePointLightAttenuation Calculates the attenuation of a point light on a surface point */ float CalculatePointLightAttenuation( in float3 iLightDirection, ///< Direction NOT NORMALIZED, from the point to the light position float iLightInverseRange ///< Inverse range (1/r) of the point light ) { float3 attenuatedLightDirection = iLightDirection * iLightInverseRange; return saturate ( 1.0f - dot (attenuatedLightDirection, attenuatedLightDirection)); } void LightSpot_VS(float3 iDir, float invRange, out float3 oDir, out float oFactor) { oDir.xyz = iDir; //oFactor = length(iDir); //oFactor = ( 1.0f - (oFactor / Range) ); oFactor = saturate ( 1.0f - dot (iDir * invRange, iDir * invRange)); } void LightSpot_PS(half3 iDir, half3 normal, half3 view, float Factor, float3 iD, float4 iS, inout float3 oD, inout float3 oS, sampler2D spotMap, float4 spotTex) { half3 fvLightDir = iDir; float fNDotL = dot(normal, fvLightDir); float3 lightColor = tex2Dproj(spotMap, spotTex).rgb; oD += lightColor * iD * saturate(fNDotL) * Factor; #ifndef _MATERIAL_NOSPECULAR half3 Half = normalize(fvLightDir+view); oS += Factor * lightColor * iS.xyz * pow(saturate(dot(Half,normal)), iS.a); #endif } /* GetPointLightDirectionInTangentSpace Retrieves the direction of a point light in tangent space */ float3 GetPointLightDirectionInTangentSpace( float3 lightPosition, ///< Light position in world space float3 vertexPosition, ///< Vertex position in world space float3x3 worldToTangentTransform ///< World to Tangent space transformation ) { float3 lightDir = lightPosition - vertexPosition; lightDir = mul(worldToTangentTransform, lightDir); return lightDir; } /* GetPointLightDirectionInWorldSpace Calculates the point light direction in world space */ float3 GetPointLightDirectionInWorldSpace( float3 lightPosition, ///< Light position in world space float3 vertexPosition //< Vertex position in world space ) { return lightPosition - vertexPosition; } void OutLightDirSpotPPL(float3 iDir, float invRange, float3x3 TBN, out float3 oDir, out float oFactor) { oDir.xyz = iDir; //oFactor = length(iDir.xyz); //oFactor = ( 1.0f - (oFactor * invRange) ); oDir.xyz = mul(TBN, oDir.xyz); oFactor = saturate ( 1.0f - dot (iDir * invRange, iDir * invRange)); } void OutLightDirSpotPVL(float3 iDir, float invRange, out float3 oDir, out float oFactor) { oDir.xyz = iDir; //oFactor = length(iDir.xyz); //oFactor = ( 1.0f - (oFactor / Range) ); oFactor = saturate ( 1.0f - dot (iDir * invRange, iDir * invRange)); } void LightDirectional_PPL_PS(float3 iDir, float3 n, float3 v, float3 iD, float3 iS, inout float3 oD, inout float3 oS) { float3 fvLightDir = normalize(iDir); float fNDotL = dot(n, fvLightDir); oD += iD * saturate(fNDotL); #ifndef _MATERIAL_NOSPECULAR float3 Half = normalize(fvLightDir + v); oS.xyz += iS.xyz * pow(saturate(dot(Half, n)), g_specularColor.a); #endif } void LightDirectionalBB_PPL_PS( float3 iDir, ///< Direction of the light float3 n, ///< Normal vector float3 v, ///< View direction float3 iD, ///< Diffuse Color float4 iS, ///< Specular Color float4 vpos, ///< Vertex position on world coordinates float4 aaMin, ///< Minimum coordinate of the light aabox float4 aaMax, ///< Maximum coordinate of the light aabox inout float3 oD, ///< Result and input diffuse color inout float3 oS) ///< Result and input specular color { // First check that the vertex is on the AABB of the light if ( vpos.x > aaMin.x && vpos.y > aaMin.y && vpos.z > aaMin.z && vpos.x < aaMax.x && vpos.y < aaMax.y && vpos.z < aaMax.z ) { float3 fvLightDir = normalize(iDir); float fNDotL = dot(n, fvLightDir); oD += iD * saturate(fNDotL); #ifndef _MATERIAL_NOSPECULAR float3 Half = normalize(fvLightDir + v); oS.xyz += iS.xyz * pow(saturate(dot(Half, n)), g_specularColor.a); #endif } } /* AddPointLightContributionTangentSpace Adds the contribution diffuse and specular lighting of a point light to a point of a surface */ void AddPointLightContributionTangentSpace( in float3 iLightDirectionTangentSpace, ///< Direction to the light from the 3d point in tangent space in float3 iLightPositionWorldSpace, ///< Position of the point light in world space in float iLightInverseRange, ///< Inverse range of the point light (1/r) in float3 iLightDiffuseColor, ///< Diffuse color of the light in float3 iLightSpecularColor, ///< Specular color of the light in float3 iPointNormalTangentSpace, ///< Normal on the 3d point in tangent space in float3 iPointViewTangentSpace, ///< View vector on the 3d point in tangent space in float3 iPointPositionWorldSpace, ///< Position of the 3d point in world space inout float3 ioAcumulatedDiffuseLight, ///< Acumulated diffuse light inout float3 ioAcumulatedSpecularLight ///< Acumulated specular light ) { // Calculate attenuation of the spot light float lightAttenuation = CalculatePointLightAttenuation(iLightPositionWorldSpace - iPointPositionWorldSpace, iLightInverseRange ); // Calculate diffuse lighting contribution float3 lightDirectionNormalized = normalize( iLightDirectionTangentSpace ); float fNDotL = dot(iPointNormalTangentSpace, lightDirectionNormalized); ioAcumulatedDiffuseLight += iLightDiffuseColor * saturate(fNDotL) * lightAttenuation; // Calculate specular lighting contribution #ifndef _MATERIAL_NOSPECULAR ioAcumulatedSpecularLight += lightAttenuation * CalculateSpecularLighting(lightDirectionNormalized, iLightSpecularColor, iPointNormalTangentSpace, iPointViewTangentSpace ); #endif } void LightPoint_PPL_PS(float3 iDir, float3 n, float3 v, float Factor, float3 iD, float4 iS, inout float3 oD, inout float3 oS) { float3 fvLightDir = normalize(iDir); float fNDotL = dot(n, fvLightDir); oD += iD * saturate(fNDotL) * Factor; #ifndef _MATERIAL_NOSPECULAR float3 Half = normalize(fvLightDir+v); oS.rgb += Factor * iS.xyz * pow(saturate( dot(Half,n) ), g_specularColor.a); #endif } void LightSpot_PPL_PS(float3 iDir, float3 normal, float3 view, float Factor, float3 iD, float4 iS, inout float3 oD, inout float3 oS, sampler2D spotMap, float4 spotTex) { float3 fvLightDir = normalize(iDir); float fNDotL = dot(normal, fvLightDir); float3 lightColor = tex2Dproj(spotMap, spotTex).rgb; oD += saturate( lightColor * iD * saturate(fNDotL) * Factor ); #ifndef _MATERIAL_NOSPECULAR float3 Half = normalize(fvLightDir+view); oS += saturate( lightColor * Factor * iS.xyz * pow(saturate(dot(Half,normal)), g_specularColor.a) ); #endif } void LightDirectional_PVL_PS(float3 iDir, float3 normal, float3 view, float3 iD, float transColor, float3 iS, inout float3 oD, inout float3 oS) { float fNDotL = dot(normal, iDir); oD += iD.rgb * saturate(fNDotL); #ifdef _TRANSLUCENCY float fNDotL2 = dot(-normal, iDir); oD += iD.rgb * saturate(fNDotL2) * transColor; #endif #ifndef _MATERIAL_NOSPECULAR float3 Half = normalize(iDir + view); oS += iS.xyz * pow( saturate(dot(Half,normal)), g_specularColor.a); #endif } void LightDirectionalBB_PVL_PS( float3 iDir, ///< Direction of the light (world space) float3 normal, ///< Normal of the surface (world space) float3 view, ///< View direction (world space) float3 iD, ///< Diffuse color float transColor, ///< Factor for translucency float4 iS, ///< Speculat color float4 vpos, ///< Vertex position (world space) float4 aaMin, ///< Minimum coordinate of the light aabox float4 aaMax, ///< Maximum coordinate of the light aabox inout float3 oD, ///< Result and input diffuse color inout float3 oS) ///< Result and input specular color { // First check that the vertex is on the AABB of the light if ( vpos.x > aaMin.x && vpos.y > aaMin.y && vpos.z > aaMin.z && vpos.x < aaMax.x && vpos.y < aaMax.y && vpos.z < aaMax.z ) { float fNDotL = dot(normal, iDir); oD += iD.rgb * saturate(fNDotL); #ifdef _TRANSLUCENCY float fNDotL2 = dot(-normal, iDir); oD += iD.rgb * saturate(fNDotL2) * transColor; #endif #ifndef _MATERIAL_NOSPECULAR float3 Half = normalize(iDir + view); oS += iS.xyz * pow( saturate(dot(Half,normal)), g_specularColor.a); #endif } } void LightAmbientBB( float3 ambientColor, ///< The ambient color float4 vpos, ///< Vertex position on world space float4 aaMin, ///< Minimum vertex of the AABOX on world space float4 aaMax, ///< Maximum vertex of the AABOX on world space inout float3 outAmbient ///< accumulated ambient light ) { // Only apply the light check that the vertex is on the AABB of the light if ( vpos.x > aaMin.x && vpos.y > aaMin.y && vpos.z > aaMin.z && vpos.x < aaMax.x && vpos.y < aaMax.y && vpos.z < aaMax.z ) { outAmbient+=ambientColor; } } /* AddPointLightContributionWorldSpace Adds the contribution diffuse and specular lighting of a point light to a point of a surface */ void AddPointLightContributionWorldSpace( in float3 iLightPosition, ///< Light position in world space in float iLightInverseRange, ///< Inverse range of the point light (1/r) in float3 iLightDiffuseColor, ///< Diffuse color of the light in float3 iLightSpecularColor, ///< Specular color of the light in float3 iPointNormal, ///< Normal of the 3d point in world space in float3 iPointView, ///< View vector of the 3d point in world space in float3 iPointPosition, ///< Poisition of the 3d point in worls space inout float3 ioAcumulatedDiffuseLight, ///< Acumulated diffuse lighting inout float3 ioAcumulatedSpecularLight ///< Acumulated specular lighting ) { // Determiate the light direction, used for attenuation and light contribution float3 lightDirection = iLightPosition - iPointPosition; // Calculate attenuation of the spot light float lightAttenuation = CalculatePointLightAttenuation(lightDirection, iLightInverseRange); // Calculate diffuse lighting contribution lightDirection = normalize( lightDirection ); float fNDotL = dot(iPointNormal, lightDirection); ioAcumulatedDiffuseLight += iLightDiffuseColor * saturate(fNDotL) * lightAttenuation; // Calculate specular lighting contribution #ifndef _MATERIAL_NOSPECULAR ioAcumulatedSpecularLight += lightAttenuation * CalculateSpecularLighting(lightDirection, iLightSpecularColor, iPointNormal, iPointView); #endif } void LightSpot_PVL_PS(float3 iDir, float3 normal, float3 view, float Factor, float3 iD, float4 iS, inout float3 oD, inout float3 oS, sampler2D spotMap, float4 spotTex) { float3 fvLightDir = iDir; float fNDotL = dot(normal, fvLightDir); float3 lightColor = tex2Dproj(spotMap, spotTex).rgb; oD += lightColor * iD * saturate(fNDotL) * Factor; #ifndef _MATERIAL_NOSPECULAR float3 Half = normalize(fvLightDir+view); oS += lightColor * Factor * iS.xyz * pow(saturate(dot(Half,normal)), g_specularColor.a); #endif }
matrix.h
////////////////////////////////////// // MATRIX MULTIPLICATION ////////////////////////////////////// float3 Transform(float3x3 mat, float3 v) { #if defined(_XENON) [isolate] { return mul(mat, v); } #elif defined(_GCM) return mul(v, mat); #else return mul(mat, v); #endif } float4 Transform(float4x4 mat, float4 v) { #if defined(_XENON) [isolate] { return mul(mat, v); } #elif defined(_GCM) return mul(v, mat); #else return mul(mat, v); #endif } float2 Transform(float2x2 mat, float2 v) { #if defined(_XENON) [isolate] { return mul(mat, v); } #elif defined(_GCM) return mul(v, mat); #else return mul(mat, v); #endif } //this conversion will not deal with renormalizations because is a bad way to handle bad data passing to the shader. //the main problem is that cg-compiler isn't as smart as hlsl-compiler dealing with already normalized vectors float3x3 GetWorldToTangentMatrix(float3x3 worldmtx,float3 tangent, float3 normal) { float3x3 worldToTangent = 0; worldToTangent[0] = normalize(Transform(worldmtx, tangent)); worldToTangent[2] = normalize(Transform(worldmtx, normal)); worldToTangent[1] = normalize(cross(worldToTangent[0], worldToTangent[2])); return worldToTangent; } float4 TransformPlanarReflection(float4 inPos) { float4x4 matTexScale = 0; #if !defined(_GCM) matTexScale._m00 = 0.5f; matTexScale._m11 = -.5f; matTexScale._m22 = 0.0f; matTexScale._m03 = 0.5f; matTexScale._m13 = 0.5f; matTexScale._m23 = 1.0f; matTexScale._m33 = 1.0f; #else matTexScale._m00 = 0.5f; matTexScale._m11 = -0.5f; matTexScale._m22 = 0.0f; matTexScale._m30 = 0.5f; matTexScale._m31 = 0.5f; matTexScale._m32 = 1.0f; matTexScale._m33 = 1.0f; #endif return Transform(matTexScale,inPos); }
mrt.h
#if defined(_MRT3) && !defined(_MRT2) #define _MRT2 #endif #if defined(_MRT2) && !defined(_MRT1) #define _MRT1 #endif #if defined(_MRT1) && !defined(_MRT1_OUTMETHOD) #define _MRT1_OUTMETHOD pso_MRT_default_output #endif #if defined(_MRT2) && !defined(_MRT2_OUTMETHOD) #define _MRT2_OUTMETHOD pso_MRT_default_output #endif #if defined(_MRT3) && !defined(_MRT3_OUTMETHOD) #define _MRT3_OUTMETHOD pso_MRT_default_output #endif
mrtpsmethods.h
#define _MRT_DEFAULT_COLOR float4(0,0,0,0) #define _MRT_BLACK_COLOR float4(0,0,0,1) #ifndef _PIXEL_FOG float4 g_pixelFogOptions; #endif uniform float4 g_multilayerTextureOptions; float4 getBloomOutput(float2 uvCoords,uniform sampler2D tex) { float mulFactor = 0; if(g_emissiveColor.a>0) mulFactor = 1; #if !defined(_POINTSPRITE) float4 ret = float4(0,0,0,1); ret.g = g_emissiveColor.a; #else float4 ret = float4(0,1,0,1); #endif // Determinate the alpha color from the diffuse stage if (g_multilayerTextureOptions.x > 1) { /// Texture with additive blending float4 color = tex2D( tex, uvCoords ); ret.a*= (color.r + color.g + color.b)*0.3333 * color.a; } else if (g_multilayerTextureOptions.x > 0) { // Texture with alpha ret.a*= tex2D( tex, uvCoords ).a; } ret*=mulFactor; return ret; } #if !defined(_POINTSPRITE) float4 getFocusBloomOutput(float opacity,float3 pos,float2 uvCoords,uniform sampler2D tex) { float mulFactor = 0; if(g_emissiveColor.a>0) mulFactor = 1; if(opacity>=1) mulFactor = 1; float4 ret = float4(0,0,0,opacity); ret.g = g_emissiveColor.a*opacity; // Determinate the alpha color from the diffuse stage if (g_multilayerTextureOptions.x > 1) { /// Texture with additive blending float4 color = tex2D( tex, uvCoords ); ret.a*= (color.r + color.g + color.b)*0.3333 * color.a; } else if (g_multilayerTextureOptions.x > 0) { // Texture with alpha ret.a*= tex2D( tex, uvCoords ).a; } ret*=mulFactor; return ret; } #endif #if defined(_MULTILAYER_CGFX) //default output float4 pso_MRT_default_output(MultilayerPPLSpot_OutputVS IN,float4 mainColor) { return _MRT_DEFAULT_COLOR; } float4 pso_MRT_black_output(MultilayerPPLSpot_OutputVS IN,float4 mainColor) { return _MRT_BLACK_COLOR; } float4 pso_MRT_blackBoolAlpha_output(MultilayerPPLSpot_OutputVS IN,float4 mainColor) { return float4(_MRT_BLACK_COLOR.rgb,(mainColor.a>=1.0)?1.0:0.0); } float4 pso_MRT_default_output(MultilayerPPL_OutputVS IN,float4 mainColor) { return _MRT_DEFAULT_COLOR; } float4 pso_MRT_black_output(MultilayerPPL_OutputVS IN,float4 mainColor) { return _MRT_BLACK_COLOR; } float4 pso_MRT_blackBoolAlpha_output(MultilayerPPL_OutputVS IN,float4 mainColor) { return float4(_MRT_BLACK_COLOR.rgb,(mainColor.a>=1.0)?1.0:0.0); } float4 pso_MRT_default_output(MultilayerPVLSpot_OuputVS IN,float4 mainColor) { return _MRT_DEFAULT_COLOR; } float4 pso_MRT_black_output(MultilayerPVLSpot_OuputVS IN,float4 mainColor) { return _MRT_BLACK_COLOR; } float4 pso_MRT_blackBoolAlpha_output(MultilayerPVLSpot_OuputVS IN,float4 mainColor) { return float4(_MRT_BLACK_COLOR.rgb,(mainColor.a>=1.0)?1.0:0.0); } float4 pso_MRT_default_output(MultilayerPVL_OuputVS IN,float4 mainColor) { return _MRT_DEFAULT_COLOR; } float4 pso_MRT_black_output(MultilayerPVL_OuputVS IN,float4 mainColor) { return _MRT_BLACK_COLOR; } float4 pso_MRT_blackBoolAlpha_output(MultilayerPVL_OuputVS IN,float4 mainColor) { return float4(_MRT_BLACK_COLOR.rgb,(mainColor.a>=1.0)?1.0:0.0); } float4 pso_MRT_focusBloom_output(MultilayerPPLSpot_OutputVS IN,float4 mainColor) { #if !defined(_POINTSPRITE) return getFocusBloomOutput(mainColor.a,IN.vpos.xyz,IN.uv0.xy,g_diffuseMap); #else return getBloomOutput(IN.uv.xy,g_diffuseMap); #endif } float4 pso_MRT_focusBloom_output(MultilayerPPL_OutputVS IN,float4 mainColor) { return getFocusBloomOutput(mainColor.a,IN.vpos.xyz,IN.uvcoords.xy,g_diffuseMap); } float4 pso_MRT_focusBloom_output(MultilayerPVLSpot_OuputVS IN,float4 mainColor) { return getFocusBloomOutput(mainColor.a,IN.vpos.xyz,IN.uv0.xy,g_diffuseMap); } float4 pso_MRT_focusBloom_output(MultilayerPVL_OuputVS IN,float4 mainColor) { return getFocusBloomOutput(mainColor.a,IN.vpos.xyz,IN.uv0.xy,g_diffuseMap); } #endif //default output #if defined(_COMPOSITE_CGFX) #ifndef _POINTSPRITE float4 pso_MRT_default_output(Composite_OutputVS IN,float4 mainColor) { return _MRT_DEFAULT_COLOR; } float4 pso_MRT_black_output(Composite_OutputVS IN,float4 mainColor) { return _MRT_BLACK_COLOR; } float4 pso_MRT_blackBoolAlpha_output(Composite_OutputVS IN,float4 mainColor) { return float4(_MRT_BLACK_COLOR.rgb,(mainColor.a>=1.0)?1.0:0.0); } float4 pso_MRT_focusBloom_output(Composite_OutputVS IN,float4 mainColor) { return getFocusBloomOutput(mainColor.a,IN.vpos.xyz,IN.uv0.xy,g_layer0); } #else float4 pso_MRT_default_output(CompositeSprite_InputPS IN,float4 mainColor) { return _MRT_DEFAULT_COLOR; } float4 pso_MRT_black_output(CompositeSprite_InputPS IN,float4 mainColor) { return _MRT_BLACK_COLOR; } float4 pso_MRT_blackBoolAlpha_output(CompositeSprite_InputPS IN,float4 mainColor) { return float4(_MRT_BLACK_COLOR.rgb,(mainColor.a>=1.0)?1.0:0.0); } float4 pso_MRT_focusBloom_output(CompositeSprite_InputPS IN,float4 mainColor) { return getBloomOutput(IN.uv.xy,g_layer0); } #endif #endif
mrtpso.h
#if !defined(_MRT) float4 color : COLOR0; #else #if defined(_MRT_RT_0_1) float4 color : COLOR1; #elif defined(_MRT_RT_0_2) float4 color : COLOR2; #elif defined(_MRT_RT_0_3) float4 color : COLOR3; #else float4 color : COLOR0; #endif #if defined(_MRT1) #if defined(_MRT_RT_1_0) float4 color1 : COLOR0; #elif defined(_MRT_RT_1_2) float4 color1 : COLOR2; #elif defined(_MRT_RT_1_3) float4 color1 : COLOR3; #else float4 color1 : COLOR1; #endif #endif #if defined(_MRT2) #if defined(_MRT_RT_2_0) float4 color2 : COLOR0; #elif defined(_MRT_RT_2_1) float4 color2 : COLOR1; #elif defined(_MRT_RT_2_3) float4 color2 : COLOR3; #else float4 color2 : COLOR2; #endif #endif #if defined(_MRT3) #if defined(_MRT_RT_3_0) float4 color3 : COLOR0; #elif defined(_MRT_RT_3_1) float4 color3 : COLOR1; #elif defined(_MRT_RT_3_2) float4 color3 : COLOR2; #else float4 color3 : COLOR3; #endif #endif #endif
shadowmap.h
uniform float4x4 g_matTextureProjection; uniform float4 g_shadowmapOptions; uniform float4 g_texelSize89; #define g_ShadowmapFactor (1-g_shadowmapOptions.x) /// default 0.0 #define g_ShadowmapZBias (g_shadowmapOptions.y) /// default -0.001 uniform sampler2D g_shadowMap : register(s9); uniform samplerCUBE g_shadowCubeMap : register(s9); //////////////////////////////////// // DIRECTIONAL float SampleShadowTest(float4 ShadowTexC) { #if defined(_XENON) || defined(_SHADOWMAP_FLOAT) //Xenon & ATI return tex2D(g_shadowMap, ShadowTexC.xy).r >= ShadowTexC.z; #else //nVidia return tex2Dproj(g_shadowMap, ShadowTexC).r; #endif } float GetShadowDirectional(float4 TexCoords) { float4 ShadowTexC = TexCoords; ShadowTexC.xy = 0.5 * TexCoords.xy + float2( 0.5, 0.5 ); ShadowTexC.y = 1.f - ShadowTexC.y; #ifdef _PS3 ShadowTexC.z = ShadowTexC.z * .5f + .5f; #endif #ifdef _XENON ShadowTexC.xyz = ShadowTexC.xyz / ShadowTexC.w; // [BP] On xbox360 we are getting projected distances that are higher than 1 // as they are not being cut by the far plane of the light frustum // still we need to study more this effect, even check if it can be done on vertex // shader stage to save gpu process ShadowTexC.z = min(1,ShadowTexC.z); // Check that z the minimum value to 1 #endif #ifdef _DEBUG_SHADOWMAPS //Dark regions out of shadow projection if(ShadowTexC.x < 0 || ShadowTexC.y < 0 || ShadowTexC.x > 1 || ShadowTexC.y > 1) return 0; #endif ShadowTexC.z += g_ShadowmapZBias; ShadowTexC.w = 1; #if defined(SH_VERSION_SH2) || defined(_SHADOW_LOW) return saturate(SampleShadowTest(ShadowTexC) + g_ShadowmapFactor); #else float4 tX = float4(g_texelSize89.z, 0, 0, 0) * 1; float4 tY = float4(0, g_texelSize89.w, 0, 0) * 1; float accum = 0; #if defined(_SHADOW_MED) accum += SampleShadowTest(ShadowTexC + tX * -.5 + tY * -.5); accum += SampleShadowTest(ShadowTexC + tX * .5 + tY * -.5); accum += SampleShadowTest(ShadowTexC + tX * -.5 + tY * .5); accum += SampleShadowTest(ShadowTexC + tX * .5 + tY * .5); return saturate((accum/4.f) + g_ShadowmapFactor); #elif defined(_SHADOW_HI) accum += SampleShadowTest(ShadowTexC + tX * -1 + tY * -1); accum += SampleShadowTest(ShadowTexC + tX * 0 + tY * -1); accum += SampleShadowTest(ShadowTexC + tX * 1 + tY * -1); accum += SampleShadowTest(ShadowTexC + tX * -1 + tY * 0); accum += SampleShadowTest(ShadowTexC + tX * 0 + tY * 0); accum += SampleShadowTest(ShadowTexC + tX * 1 + tY * 0); accum += SampleShadowTest(ShadowTexC + tX * -1 + tY * 1); accum += SampleShadowTest(ShadowTexC + tX * 0 + tY * 1); accum += SampleShadowTest(ShadowTexC + tX * 1 + tY * 1); return saturate((accum/9.f) + g_ShadowmapFactor); #else return 1; #endif #endif } ///////////////////////////////// // SPOT //[VC]: why this is just a copy paste from spotdirectional??? float GetShadowSpotSample(float4 ShadowTexC) { float shadow; #if defined(_XENON) || defined(_SHADOWMAP_FLOAT) //Xenon & ATI float a = tex2D(g_shadowMap, ShadowTexC.xy).r > ShadowTexC.z; float b = tex2D(g_shadowMap, ShadowTexC.xy + float2(g_texelSize89.z, 0)).r > ShadowTexC.z; float c = tex2D(g_shadowMap, ShadowTexC.xy + float2(0, g_texelSize89.w)).r > ShadowTexC.z; float d = tex2D(g_shadowMap, ShadowTexC.xy + float2(g_texelSize89.z, g_texelSize89.w)).r > ShadowTexC.z; #if defined(SH_VERSION_SH2) return a; #endif // transform to texel space float2 texelpos = (1.f/g_texelSize89.zw) * ShadowTexC; // Determine the lerp amounts float2 lerps = frac( texelpos ); // lerp between the shadow values to calculate our light amount shadow = lerp( lerp( a, b, lerps.x ), lerp( c, d, lerps.x ), lerps.y ); return shadow; #else //nVidia shadow = tex2Dproj(g_shadowMap, ShadowTexC).r; #endif return shadow; } float GetShadowSpot(float4 TexCoords) { float4 ShadowTexC = TexCoords; ShadowTexC.xy = 0.5 * TexCoords.xy / TexCoords.w + float2( 0.5, 0.5 ); ShadowTexC.y = 1.0f - ShadowTexC.y; #ifdef _PS3 ShadowTexC.z = ShadowTexC.z * .5f + .5f; #endif #ifdef _DEBUG_SHADOWMAPS //Dark regions out of shadow projection if(ShadowTexC.x < 0 || ShadowTexC.y < 0 || ShadowTexC.x > 1 || ShadowTexC.y > 1) return 0; #endif ShadowTexC.z += g_ShadowmapZBias; ShadowTexC.z /= ShadowTexC.w; ShadowTexC.w = 1; #if defined(SH_VERSION_SH2) || defined(_SHADOW_LOW) return saturate(GetShadowSpotSample(ShadowTexC) + g_ShadowmapFactor); #endif float4 tX = float4(g_texelSize89.z, 0, 0, 0) * 1; float4 tY = float4(0, g_texelSize89.w, 0, 0) * 1; float accum = 0; #if defined(_SHADOW_MED) accum += GetShadowSpotSample(ShadowTexC + tX * -.5 + tY * -.5); accum += GetShadowSpotSample(ShadowTexC + tX * .5 + tY * -.5); accum += GetShadowSpotSample(ShadowTexC + tX * -.5 + tY * .5); accum += GetShadowSpotSample(ShadowTexC + tX * .5 + tY * .5); return saturate((accum/4.f) + g_ShadowmapFactor); #endif #if defined(_SHADOW_HI) accum += GetShadowSpotSample(ShadowTexC + tX * -1 + tY * -1); accum += GetShadowSpotSample(ShadowTexC + tX * 0 + tY * -1); accum += GetShadowSpotSample(ShadowTexC + tX * 1 + tY * -1); accum += GetShadowSpotSample(ShadowTexC + tX * -1 + tY * 0); accum += GetShadowSpotSample(ShadowTexC + tX * 0 + tY * 0); accum += GetShadowSpotSample(ShadowTexC + tX * 1 + tY * 0); accum += GetShadowSpotSample(ShadowTexC + tX * -1 + tY * 1); accum += GetShadowSpotSample(ShadowTexC + tX * 0 + tY * 1); accum += GetShadowSpotSample(ShadowTexC + tX * 1 + tY * 1); return saturate((accum/9.f) + g_ShadowmapFactor); #endif return 1; } ///////////////////////////////// // POINT float GetShadowPointSample(float3 Pos) { float shadow = 1; #ifdef _PS3 return 1; #endif #ifdef _LIGHT0_POINT shadow = texCUBE(g_shadowCubeMap, Pos.xyz-g_lightPosition0.xyz).r > (length(Pos.xyz-g_lightPosition0.xyz) * g_lightPosition0.w) + g_ShadowmapZBias; #endif return shadow; } float GetShadowPoint(float3 Pos) { return saturate(GetShadowPointSample(Pos) + g_ShadowmapFactor); }
skinning.h
uniform float4x4 g_skinMatrix[_MAXBONES]; ///< 128 Registers for skin bones struct SKINVERTEX { float4 P; half3 N; half3 T; }; SKINVERTEX SkinVertex(float3 p, half3 n, half3 t, float4 indices, float4 weights) { SKINVERTEX Out = (SKINVERTEX) 0; for(int i = 0; i < 4; i++) { Out.P.xyz += Transform(g_skinMatrix[indices.x], float4(p,1)).xyz * weights.x; Out.N += (half3)(Transform((float3x3) g_skinMatrix[indices.x], n) * weights.x); #if !defined(SH_VERSION_SH1) Out.T += (half3)(Transform((float3x3) g_skinMatrix[indices.x], t) * weights.x); #endif indices.xyzw = indices.yzwx; weights.xyzw = weights.yzwx; } Out.P.w = 1; Out.N = (half3)normalize(Out.N); #if !defined(SH_VERSION_SH1) Out.T = (half3)normalize(Out.T); #endif return Out; }