//-------------------------------------------------------------------------------------- // // File: RenderPCT.fx // //-------------------------------------------------------------------------------------- #define CB_RENDERPCT #include "PlatformAdapter.fxh" #include "ShaderParameters.fxh" //-------------------------------------------------------------------------------------- // Define //-------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------- // Texture samplers //-------------------------------------------------------------------------------------- #ifdef PIXEL_PROFILE REGISTER_SAMPLER(TextureSampler, 0) REGISTER_SAMPLER(TextureSampler, 1) // scene REGISTER_SAMPLER(TextureSampler, 2) // normal / diffuse_2 REGISTER_SAMPLER(TextureSampler, 3) // backlight REGISTER_SAMPLER(TextureSampler, 4) // separate alpha REGISTER_SAMPLER(TextureSampler, 5) // backlight_2 REGISTER_SAMPLER(FrontLightMaskSampler, 6) REGISTER_SAMPLER(BackLightMaskSampler, 7) #endif //-------------------------------------------------------------------------------------- // Vertex shader input structure //-------------------------------------------------------------------------------------- struct VS_DEFAULT_INPUT { float4 vPos : POSITION; #ifdef COLOR float4 fColor : COLOR0; #endif #ifdef SKINNING float4 SknBlendWeight : BLENDWEIGHT; #if defined(_CAFE_) || defined(_NX_) ||defined(DX11_SHADERS) int4 SknBlendIndices : BLENDINDICES; #else float4 SknBlendIndices : BLENDINDICES; #endif #endif #ifdef TEXTURE float2 TextureUV : TEXCOORD0; #ifdef TEXTUREUV2 float2 TextureUV2 : TEXCOORD3; #endif #endif }; //-------------------------------------------------------------------------------------- // Vertex shader output structure //-------------------------------------------------------------------------------------- struct VS_DEFAULT_OUTPUT { float4 Position : VS_OUT_POS; // vertex position #ifdef COLOR float4 Diffuse : COLOR0_C; // vertex diffuse color (note that COLOR0 is clamped from 0..1) #endif #ifdef TEXTURE float4 TextureUV : TEXCOORD0; // vertex texture coords #endif #ifdef FOGBOX1 float4 fog1 : TEXCOORD1; // xy : position in view space, z: alphaAttenuation #endif #ifdef FOGBOX2 float4 fog2 : TEXCOORD2; // xy : position in view space, z: alphaAttenuation #endif #ifdef VIEWPOS float4 viewPos : TEXCOORD4; #endif #if defined(REFLECTION) #ifndef DX11_SHADERS float4 screenPos : VPOS; #endif #endif }; struct VS_PCT_OUTPUT { float4 Position : VS_OUT_POS; // vertex position float4 Diffuse : COLOR0_C; // vertex diffuse color (note that COLOR0 is clamped from 0..1) float4 TextureUV : TEXCOORD0; // vertex texture coords : xy->UV1, zw->UV2 #ifdef FOGBOX1 float4 fog1 : TEXCOORD1; // xy : position in view space, z: alphaAttenuation #endif #ifdef FOGBOX2 float4 fog2 : TEXCOORD2; // xy : position in view space, z: alphaAttenuation #endif #ifdef VIEWPOS float4 viewPos : TEXCOORD4; #endif }; struct VS_PC2T_OUTPUT { float4 Position : VS_OUT_POS; // vertex position float4 Diffuse : COLOR0_C; // vertex diffuse color (note that COLOR0 is clamped from 0..1) float2 TextureUV : TEXCOORD0; // vertex texture coords #ifdef FOGBOX1 float4 fog1 : TEXCOORD1; // xy : position in view space, z: alphaAttenuation #endif #ifdef FOGBOX2 float4 fog2 : TEXCOORD2; // xy : position in view space, z: alphaAttenuation #endif float4 ScreenUV : TEXCOORD3; // vertex texture coords #ifdef VIEWPOS float4 viewPos : TEXCOORD4; #endif }; #ifdef VERTEX_PROFILE //-------------------------------------------------------------------------------------- // These shaders computes standard transform and lighting //-------------------------------------------------------------------------------------- float4 zinject(in float4 vpos) { #ifdef ZINJECT vpos.z = vs_zInject.x * vpos.w; #endif return vpos; } float4 computeDynFogColor_VS(in float3 _position, in VS_DynFogParam _fogParam ) { float2 boxDir = _fogParam.f4_BoxCenter.xy - _position.xy; float f_camDist = _fogParam.f4_CamFarNearDist.x - _position.z; float f_camFactor = _fogParam.f4_CamFarNearDist.y - f_camDist; f_camFactor = saturate(f_camFactor * _fogParam.f4_CamFarNearDist.z); f_camFactor = lerp(_fogParam.f4_AlphaAtt.y, _fogParam.f4_AlphaAtt.x, f_camFactor); return float4(boxDir,f_camFactor, 1.0f); } void fillCommonPCTOutput(inout VS_PCT_OUTPUT _output, float4 _position) { _output.Position = mul(_position, vs_mWorldViewProjection); _output.Diffuse = float4(0.0f, 0.0f, 0.0f, 0.0f); _output.TextureUV = float4(0.0f, 0.0f, 0.0f, 0.0f); #if defined(FOGBOX1) || defined(VIEWPOS) float3 viewPos = mul(_position, vs_mWorld).xyz; #endif #ifdef FOGBOX1 _output.fog1 = computeDynFogColor_VS(viewPos, vs_fog1Param); #ifdef FOGBOX2 _output.fog2 = computeDynFogColor_VS(viewPos, vs_fog2Param); #endif #endif #ifdef VIEWPOS _output.viewPos = float4(viewPos, 0.0f); #endif _output.Position = zinject(_output.Position); } VS_DEFAULT_OUTPUT default_VS( VS_DEFAULT_INPUT In ) { VS_DEFAULT_OUTPUT Output; #ifdef SKINNING float3 v; v = mul( In.vPos, vs_mBoneMatrix00[In.SknBlendIndices.x]) * In.SknBlendWeight.x; v += mul( In.vPos, vs_mBoneMatrix00[In.SknBlendIndices.y]) * In.SknBlendWeight.y; v += mul( In.vPos, vs_mBoneMatrix00[In.SknBlendIndices.z]) * In.SknBlendWeight.z; v += mul( In.vPos, vs_mBoneMatrix00[In.SknBlendIndices.w]) * In.SknBlendWeight.w; In.vPos = float4( v, 1); #endif // SKINNING Output.Position = mul(In.vPos, vs_mWorldViewProjection); #if defined(FOGBOX1) || defined(VIEWPOS) float3 viewPos = mul(In.vPos, vs_mWorld).xyz; #endif #if defined(VIEWPOS) Output.viewPos = float4(viewPos, 0.0f); #endif #ifdef FOGBOX1 Output.fog1 = computeDynFogColor_VS(viewPos, vs_fog1Param); #ifdef FOGBOX2 Output.fog2 = computeDynFogColor_VS(viewPos, vs_fog2Param); #endif #endif #ifdef COLOR Output.Diffuse = In.fColor * vs_globalColor; #endif #ifdef TEXTURE float2 vTexCoord0 = In.TextureUV; #ifdef UV1 float2x2 uvm = (float2x2)vs_mUVmat; vTexCoord0 = vTexCoord0 * 2.f - 1.f; vTexCoord0 += float2(vs_mUVmat[0][3], vs_mUVmat[1][3]); vTexCoord0 = mul(vTexCoord0, uvm); vTexCoord0 = ( vTexCoord0 + 1.f ) * 0.5f; vTexCoord0 += float2(vs_mUVmat[3][0], vs_mUVmat[3][1]); #endif Output.TextureUV = vTexCoord0.xyxy; #ifdef UV2 float2x2 uvm2 = (float2x2)vs_mUVmat2; #ifdef TEXTUREUV2 vTexCoord0 = In.TextureUV2 * 2.f - 1.f; #else vTexCoord0 = In.TextureUV * 2.f - 1.f; #endif vTexCoord0 += float2(vs_mUVmat2[0][3], vs_mUVmat2[1][3]); vTexCoord0 = mul(vTexCoord0, uvm2); vTexCoord0 = ( vTexCoord0 + 1.f ) * 0.5f; vTexCoord0 += float2(vs_mUVmat2[3][0], vs_mUVmat2[3][1]); Output.TextureUV.zw = vTexCoord0; #endif #endif Output.Position = zinject(Output.Position); return Output; } VS_PCT_OUTPUT default_PTambiant_VS( float4 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0 ) { VS_PCT_OUTPUT Output; fillCommonPCTOutput(Output, vPos); Output.TextureUV = vTexCoord0.xyxy; Output.Diffuse = vs_globalColor; return Output; } //-------------------------------------------------------------------------------------- // This shader computes Frize vertex anim. /* vs_vconst1.x = TimeCur vs_vconst1.y = global sync vs_vconst1.z = global speed vs_vconst1.w = global rotation uv2.x = speed X vertex uv2.y = speed Y vertex uv2.z = synchro X vertex uv2.w = synchro Y vertex uv3.x = amplitude X vertex uv3.y = amplitude Y vertex uv3.z = synchro Vertex uv3.w = angle Vertex */ //-------------------------------------------------------------------------------------- VS_PCT_OUTPUT frize_PNC3T_VS( float4 vPos : POSITION, float4 fColor : COLOR0, float2 vTexCoord0 : TEXCOORD0, float4 uv2 : TEXCOORD1, float4 uv3 : TEXCOORD2, float2 uv4 : TEXCOORD3 ) { VS_PCT_OUTPUT Output; float time = ( vs_frizeAnim.x * vs_frizeAnim.z ) + vs_frizeAnim.y + uv3.z; float angle = uv3.w + vs_frizeAnim.w; float x1 = cos( time * uv2.x + uv2.z) * uv3.x; float y1 = sin( time * uv2.y + uv2.w) * uv3.y; float cosAngle = cos(angle); float sinAngle = sin(angle); float x2 = x1 * cosAngle - y1 * sinAngle; float y2 = x1 * sinAngle + y1 * cosAngle; float4 posw = float4(vPos.x + x2, vPos.y + y2, vPos.z, 1.f); fillCommonPCTOutput(Output, posw); Output.Diffuse = fColor * vs_globalColor; float2x2 uvm = (float2x2)vs_mUVmat; Output.TextureUV = mul(vTexCoord0, uvm).xyxy; Output.TextureUV.xy += float2(vs_mUVmat[3][0], vs_mUVmat[3][1]); #ifdef UV2 float2x2 uvm2 = (float2x2)vs_mUVmat2; Output.TextureUV.zw = mul(vTexCoord0, uvm2); //vs_mUVmat Output.TextureUV.zw += float2(vs_mUVmat2[3][0], vs_mUVmat2[3][1]); #endif return Output; } //-------------------------------------------------------------------------------------- // This shader computes bezier patch for anim. //-------------------------------------------------------------------------------------- VS_PCT_OUTPUT default_PCT_Patch_VS( float4 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0) { VS_PCT_OUTPUT Output; int pos = vPos.z * 8; int colorpos = vPos.z; /// Vertex -> vector const xy. float2 PF1 = vs_va0[pos].xy * (1 - vTexCoord0.y) + vs_va0[pos + 4].xy * vTexCoord0.y; float2 PF1X = vs_va0[pos + 1].xy * (1 - vTexCoord0.y) + vs_va0[pos + 5].xy * vTexCoord0.y; float2 PFX2 = vs_va0[pos + 2].xy * (1 - vTexCoord0.y) + vs_va0[pos + 6].xy * vTexCoord0.y; float2 PF2 = vs_va0[pos + 3].xy * (1 - vTexCoord0.y) + vs_va0[pos + 7].xy * vTexCoord0.y; float UvInv = (1-vTexCoord0.x); float2 carreinv = UvInv*UvInv; float2 carre = vTexCoord0.x*vTexCoord0.x; float2 cube = vTexCoord0.x*vTexCoord0.x*vTexCoord0.x; float2 cubeinv = UvInv*UvInv*UvInv; float2 Position = PF1*cubeinv + 3*PF1X*vTexCoord0.x*carreinv+3*PFX2*carre*UvInv + PF2*cube; /// Uv -> vector const zw. PF1 = vs_va0[pos].zw * (1 - vTexCoord0.y) + vs_va0[pos + 4].zw * vTexCoord0.y; PF1X = vs_va0[pos + 1].zw * (1 - vTexCoord0.y) + vs_va0[pos + 5].zw * vTexCoord0.y; PFX2 = vs_va0[pos + 2].zw * (1 - vTexCoord0.y) + vs_va0[pos + 6].zw * vTexCoord0.y; PF2 = vs_va0[pos + 3].zw * (1 - vTexCoord0.y) + vs_va0[pos + 7].zw * vTexCoord0.y; float4 position = float4(Position.x,Position.y, vs_patchZ.x, 1.f); fillCommonPCTOutput(Output, position); float2 texUV = PF1*cubeinv + 3*PF1X*vTexCoord0.x*carreinv+3*PFX2*carre*UvInv + PF2*cube; Output.TextureUV = texUV.xyxy; // alpha. float a0 = vs_va1[colorpos].x; float a1 = vs_va1[colorpos].y; float a2 = vs_va1[colorpos].z; float a3 = vs_va1[colorpos].w; float l1 = lerp( a0, a1, vTexCoord0.x); float l2 = lerp( a2, a3, vTexCoord0.x); Output.Diffuse.a = lerp(l1, l2, vTexCoord0.y) * vs_globalColor.a; Output.Diffuse.rgb = vs_globalColor.rgb; return Output; } VS_PCT_OUTPUT fluid_PCT_VS( float4 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0 ) { VS_PCT_OUTPUT Output; float idx = vTexCoord0.y*vs_fluidVDiv; int idxInt1 = idx/2.f; int idxInt2 = idx/2.f + 0.5f; int factor = idxInt2 - idxInt1; float steps = vs_fluidParam.y; float delta1 = vs_fluidParam.z; float delta2 = vs_fluidParam.w; float interpolatedXOffset = delta1*(steps-idx)+delta2*idx; float colorInMap = vs_va0[idxInt1].x*(1-factor) + vs_va0[idxInt1].z*factor; int secondColorIndex = floor(colorInMap)*4; float4 position = vPos; position.y += (interpolatedXOffset)*(1.f-vTexCoord0.x); //position.y += (vs_va0[idxInt1].x*(1-factor) + vs_va0[idxInt1].z*factor)*(1.f-vTexCoord0.x); position.x -= (vs_va0[idxInt1].y*(1-factor) + vs_va0[idxInt1].w*factor)*(1.f-vTexCoord0.x); fillCommonPCTOutput(Output, position); float ratio = vTexCoord0.y*vs_fluidVDiv/vs_fluidParam.x; float2 texUV = (vs_fluidUV1.xy*(1 - ratio) + vs_fluidUV2.xy*ratio)*vTexCoord0.x + (vs_fluidUV1.zw*(1 - ratio) + vs_fluidUV2.zw*ratio)*(1-vTexCoord0.x); Output.TextureUV = texUV.xyxy; float4 color0 = vs_va1[secondColorIndex]; float4 color1 = vs_va1[secondColorIndex+1]; float4 color2 = vs_va1[secondColorIndex+2]; float4 color3 = vs_va1[secondColorIndex+3]; Output.Diffuse = (color0*(1 - ratio) + color2*ratio)*vTexCoord0.x + (color1*(1 - ratio) + color3*ratio)*(1-vTexCoord0.x); Output.Diffuse *= vs_globalColor; return Output; } VS_PCT_OUTPUT fluid2_PCT_VS( float4 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0 ) { VS_PCT_OUTPUT Output; float idx = vTexCoord0.y*vs_fluidVDiv; int idxInt1 = idx/2.f; int idxInt2 = idx/2.f + 0.5f; int factor = idxInt2 - idxInt1; float steps = vs_fluidParam.y; float delta1 = vs_fluidParam.z; float delta2 = vs_fluidParam.w; float interpolatedXOffset = delta1*(steps-idx)+delta2*idx; float colorInMap = vs_va0[idxInt1].x*(1-factor) + vs_va0[idxInt1].z*factor; int secondColorIndex = floor(colorInMap)*4; float4 position = vPos; position.y += interpolatedXOffset; //position.y += (vs_va0[idxInt1].x*(1-factor) + vs_va0[idxInt1].z*factor); position.z -= (vs_va0[idxInt1].y*(1-factor) + vs_va0[idxInt1].w*factor)*(1.f-vTexCoord0.x); fillCommonPCTOutput(Output, position); float ratio = vTexCoord0.y*vs_fluidVDiv/vs_fluidParam.x; float2 texUV = (vs_fluidUV1.xy*(1 - ratio) + vs_fluidUV2.xy*ratio)*vTexCoord0.x + (vs_fluidUV1.zw*(1 - ratio) + vs_fluidUV2.zw*ratio)*(1-vTexCoord0.x); Output.TextureUV = texUV.xyxy; float4 color0 = vs_va1[secondColorIndex]; float4 color1 = vs_va1[secondColorIndex+1]; float4 color2 = vs_va1[secondColorIndex+2]; float4 color3 = vs_va1[secondColorIndex+3]; Output.Diffuse = (color0*(1 - ratio) + color2*ratio)*vTexCoord0.x + (color1*(1 - ratio) + color3*ratio)*(1-vTexCoord0.x); Output.Diffuse *= vs_globalColor; return Output; } // -------------------------------------------------------------------------------------- // Trail 3D shader // -------------------------------------------------------------------------------------- VS_PCT_OUTPUT trail_PCT_VS( float4 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0 ) { VS_PCT_OUTPUT Output; int idxInt = vTexCoord0.y*vs_trailParam.x; float4 position = vPos; Output.TextureUV = vTexCoord0.xyxy; Output.Diffuse = float4(0,0,0,0); position.xy = vs_va0[idxInt].xy*(1-vTexCoord0.x) + vs_va0[idxInt].zw*vTexCoord0.x; int idxDec = idxInt % 4; int idxIn = idxInt / 4; if (idxDec == 0) position.z = vs_va1[idxIn].x; else if (idxDec == 1) position.z = vs_va1[idxIn].y; else if (idxDec == 2) position.z = vs_va1[idxIn].z; else position.z = vs_va1[idxIn].w; fillCommonPCTOutput(Output, position); float alpha = lerp(vs_trailAlpha.x, vs_trailAlpha.y, Output.TextureUV.x); Output.TextureUV.x = vTexCoord0.y*vs_trailParam.x/vs_trailParam.y; Output.TextureUV.y = vTexCoord0.x; Output.Diffuse = vs_globalColor * alpha; if (vs_trailParam.z > 0.f && idxInt > 0) { float alphaFactor = length(vs_va0[idxInt].xy + vs_va0[idxInt].zw - vs_va0[idxInt-1].xy - vs_va0[idxInt-1].zw)*0.5f/vs_trailParam.z; alphaFactor = clamp(alphaFactor, 0, 1); Output.Diffuse.w *= alphaFactor; } return Output; } // -------------------------------------------------------------------------------------- // Spline shader // -------------------------------------------------------------------------------------- VS_PCT_OUTPUT spline_PCT_VS( float4 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0 ) { VS_PCT_OUTPUT Output; float4 position = vPos; Output.TextureUV = vTexCoord0.xyxy; float _t = vTexCoord0.x * (vs_splineParam.x - 3) + 1; //vs_splineParam.x = bufferPoint int pos1 = (int)(vTexCoord0.x * (vs_splineParam.x - 3) + 1); int pos0 = pos1-1; int pos2 = pos1+1; int pos3 = pos1+2; float time1 = vs_va0[pos1].w; float time2 = vs_va0[pos2].w; if (time2 < 0) time2 = -time2 - 1; float3 tan; if (time1 < 0) { time1 = -time1 - 1; _t = time1*(1-(_t-pos1)) + time2*(_t-pos1); float deltaT = _t - time1; float deltaTime = time2-time1; float t = deltaT/deltaTime; float t2 = t * t; float t3 = t2 * t; float b0 = .5f * ( -t3 + 2*t2 - t); float b1 = .5f * ( 3*t3 - 5*t2 + 2); float b2 = .5f * (-3*t3 + 4*t2 + t); float b3 = .5f * ( t3 - t2 ); position.xyz = vs_va0[pos0].xyz*b0 + vs_va0[pos1].xyz*b1 + vs_va0[pos2].xyz*b2 + vs_va0[pos3].xyz*b3; float b0P = .5f * ( -3*t2 + 4*t - 1); float b1P = .5f * ( 9*t2 - 10*t ); float b2P = .5f * (-9*t2 + 8*t + 1); float b3P = .5f * ( 3*t2 - 2*t ); tan = vs_va0[pos0].xyz*b0P + vs_va0[pos1].xyz*b1P + vs_va0[pos2].xyz*b2P + vs_va0[pos3].xyz*b3P; tan = tan*(1.f/sqrt(tan.x*tan.x + tan.y*tan.y + tan.z*tan.z)); } else { position.xyz = vs_va0[pos1].xyz*(1-(_t-pos1)) + vs_va0[pos2].xyz*(_t-pos1); _t = time1*(1-(_t-pos1)) + time2*(_t-pos1); tan = vs_va0[pos2].xyz - vs_va0[pos1].xyz; tan = tan*(1.f/sqrt(tan.x*tan.x + tan.y*tan.y + tan.z*tan.z)); } float3 normal = float3(tan.y, -tan.x, tan.z); position.xyz += normal*((Output.TextureUV.y - .5f)*vs_splineParam.y); //vs_splineParam.y = _height fillCommonPCTOutput(Output, position); Output.TextureUV.x = _t*.5f; Output.Diffuse = vs_globalColor; return Output; } // -------------------------------------------------------------------------------------- // Refraction shader. // -------------------------------------------------------------------------------------- struct VS_PCT_INPUT { float4 vPos : POSITION; float4 fColor : COLOR0; int4 iIndex : BLENDINDICES; float2 vTexCoord0 : TEXCOORD0; }; VS_PCT_OUTPUT OVERLAY_PCBT_VS( VS_PCT_INPUT _in ) { VS_PCT_OUTPUT Output; float4 npos = _in.vPos; float4 vOffset; if (_in.iIndex.x == 0) vOffset = float4(0, 0, 0, 0); else vOffset = vs_va0[(_in.iIndex.x-1)/2]; if (((_in.iIndex.x-1)%2) == 0) npos.xy += vOffset.xy; else npos.xy += vOffset.zw; fillCommonPCTOutput(Output, npos); Output.Diffuse = _in.fColor * vs_globalColor; Output.TextureUV = _in.vTexCoord0.xyxy; return Output; } struct VS_QUAD_INSTANCING_INPUT { float2 vInstance : TEXCOORD0; float2 vPos2D : TEXCOORD3; float2 vPrevPos : TEXCOORD4; float4 fColor : COLOR0; }; VS_PCT_OUTPUT QUAD_INSTANCING_VS( VS_QUAD_INSTANCING_INPUT _in ) { VS_PCT_OUTPUT Output; float2 currentPos = _in.vPos2D.xy; float2 previousPos = _in.vPrevPos.xy; float2 diffPos = (currentPos - previousPos); // Position const float s_factor = 3.0f; float2 halfVec = diffPos * 0.5f * s_factor; float2 halfPos = previousPos + halfVec; float2 halfVecNorm = normalize(halfVec); float2 perpendicular = float2(-halfVecNorm.y, halfVecNorm.x) * vs_SpriteInstancing.x; halfVec += halfVecNorm * vs_SpriteInstancing.xx; float4 position; position.xy = halfPos + (halfVec * _in.vInstance.yy) + (perpendicular * _in.vInstance.xx); position.z = vs_SpriteInstancing.y; position.w = 1.0f; fillCommonPCTOutput(Output, position); // Color float speedColor = length(diffPos) * vs_SpriteInstancing.z; Output.Diffuse = _in.fColor; Output.Diffuse.r = speedColor; Output.Diffuse *= vs_globalColor; // UV float2 uv = _in.vInstance.xy * 0.5f + 0.5f; Output.TextureUV = uv.xyxy; return Output; } #endif // VERTEX_PROFILE //-------------------------------------------------------------------------------------- // Pixel shader output structure //-------------------------------------------------------------------------------------- struct PS_OUTPUT { float4 RGBColor : PS_OUT_COLOR; // Pixel color }; //-------------------------------------------------------------------------------------- // Pixels Shaders. //-------------------------------------------------------------------------------------- #ifdef PIXEL_PROFILE //-------------------------------------------------------------------------------------- // FOG functions float3 computeDynFog_PS(float3 _color, float4 _FogInterpolant, PS_DynFogParam _fogParam) { float f_DistAttenuation; #ifdef FULLFOGBOX f_DistAttenuation = _FogInterpolant.z; #else //formule : (att-X)/(size-att) + 1 float2 f2_ramp = (_fogParam.f4_BoxSizeAtt.zw - abs(_FogInterpolant.xy)) * _fogParam.f4_BoxSizeAtt.xy + 1; float2 f2_tmp = saturate( f2_ramp ); f_DistAttenuation = min( f2_tmp.x, f2_tmp .y ); f_DistAttenuation *= _FogInterpolant.z; #endif _color.rgb = lerp(_color.rgb, _fogParam.f4_Color.rgb, f_DistAttenuation); return _color.rgb; } float3 computeFOG(in float3 _colorIn, VS_DEFAULT_OUTPUT In) { float3 colorOut = _colorIn; #ifdef STATIC_FOG colorOut = lerp(_colorIn, ps_staticFog.xyz, ps_staticFog.w); //factor fog -> ps_staticFog.w #else #ifdef FOGBOX1 colorOut = computeDynFog_PS(_colorIn, In.fog1, ps_fog1Param); #ifdef FOGBOX2 colorOut = computeDynFog_PS(colorOut, In.fog2, ps_fog2Param); #endif #endif #endif return colorOut; } //-------------------------------------------------------------------------------------- // Lighting functions #ifdef TEXTURE void getDiffuseTexture(out float4 _albedo, in float _vertexAlpha, in float4 _uv, out float4 _backAlbedo) { _albedo = TEXTURE_READ_2D(TextureSampler, 0, _uv.xy); #ifdef BLEND_TEXTURE float3 albedo2 = TEXTURE_READ_2D(TextureSampler, 2, _uv.xy).rgb; _albedo.rgb = lerp(albedo2, _albedo.rgb, _vertexAlpha); #endif #ifdef SEPARATE_ALPHA _albedo.a = TEXTURE_READ_2D(TextureSampler, 4, _uv.zw).a; #endif _backAlbedo = float4(0.0f, 0.0f, 0.0f, 0.0f); } #endif //-------------------------------------------------------------------------------------- //PS Main Entry PS_OUTPUT default_PS( VS_DEFAULT_OUTPUT In ) { PS_OUTPUT Output; float4 result = float4(1.0f, 1.0f, 1.0f, 1.0f); #ifdef COLOR result = In.Diffuse; #endif float3 f3_viewPos = float3(0,0,0); float2 f2_Tangent = float2(0,0); #ifdef TEXTURE float4 texColor; float4 dumpColor; getDiffuseTexture(texColor, result.a, In.TextureUV, dumpColor); result *= texColor; #ifdef BLEND_TEXTURE result.a = texColor.a; #endif #ifdef REFLECTION #ifdef DX11_SHADERS float2 screenPos = In.Position.xy; #else float2 screenPos = In.screenPos.xy; #endif #ifdef _XBOX screenPos += ps_tillingVposOffset.xy; #endif float2 screenUV = screenPos * ps_viewportDimensions.zw; #if defined(ITF_PS3) screenUV.y = 1 + screenUV.y; #endif float4 colorReflection = TEXTURE_READ_2D(TextureSampler, 1, screenUV); result.xyz = lerp(result.rgb, colorReflection.rgb, colorReflection.a * ps_reflectionParam.x); #endif #endif result.xyz = computeFOG(result.xyz, In); #if !defined(ITF_X360) && !defined(ITF_DURANGO) if(result.a < 0.003921577) // rcp(1/255) { discard; } #endif // !defined(ITF_X360) && !defined(ITF_DURANGO) Output.RGBColor = result; return Output; } #endif // PIXEL_PROFILE