source: GTP/trunk/App/Demos/Illum/Ogre/Media/Station/StationBase.hlsl @ 2474

//#define VARIANCE_SHADOW_MAPPING
#define MAX_LIGHT 2
#define MAX_CAU_CASTER 2
#define HIGH_QUALITY

struct Shaded_OUT
{
 float4 vPos : POSITION;
 float4 wNormal : TEXCOORD0;
 float4 wPos    : TEXCOORD1; 
};

Shaded_OUT MorphedSphere_VS(float4 position : POSITION,
                     float4 normal : NORMAL,
                     float2 texCoord : TEXCOORD0,
                     uniform float4x4 WorldViewProj,
                     uniform float4x4 World,
                     uniform float4x4 WorldInv,
                     uniform float t)
{
 Shaded_OUT OUT;
 
 float dist = sin(t + position.x * position.y * 5.0 + position.z) * 0.3; 
 float3 dist2 = sin(t + position.x * position.y * 5.0 + position.z + float3(0.005,0.005,0.001)) * 0.3;
 
 float3 pos2 = (position + float3(0.001,0.001,0.001));
 pos2 += normalize(pos2) * dist;
 position.xyz += normalize(position.xyz) * dist;
 
 normal.xyz = cross(cross(normalize(pos2 - position.xyz), normal.xyz), normalize(pos2 - position.xyz));
 if(length(normal.xyz < 0.01))
        normal = position;
        
 OUT.vPos = mul(WorldViewProj, position);
 
 OUT.wPos = mul(World, position);
 OUT.wNormal = mul(normal, WorldInv);
 return OUT; 
}

struct CPos_OUT
{
        float4 VPos : POSITION;
        float4 CPos : TEXCOORD0;
};

#ifdef HIGH_QUALITY
        
        CPos_OUT MorphedSphereSM_VS(float4 position : POSITION,
                      uniform float4x4 WorldViewProj,
                      uniform float4x4 WorldView,
                      uniform float t)
        {
         CPos_OUT OUT;
         float dist = sin(t + position.x * position.y * 5.0 + position.z) * 0.3; 
         position.xyz += normalize(position.xyz) * dist;
         
         OUT.VPos = mul(WorldViewProj, position);
         OUT.CPos = mul(WorldView, position);
         return OUT;
        }
        
        float4 MorphedSphereSM_PS(CPos_OUT IN,
                                uniform float farPlane) : COLOR
        {
                float dist = length(IN.CPos.xyz) / farPlane;
                return float4(dist, dist * dist, 1, dist);      
        }
        
#else

        struct VPos_OUT
        {
         float4 VPos : POSITION;
         float4 VPosition : TEXCOORD0;
        };
        
        VPos_OUT MorphedSphereSM_VS(float4 position : POSITION,
                      uniform float4x4 WorldViewProj,
                      uniform float t)
        {
         VPos_OUT OUT;
         float dist = sin(t + position.x * position.y * 5.0 + position.z) * 0.3; 
         position.xyz += normalize(position.xyz) * dist;
         OUT.VPos = OUT.VPosition = mul(WorldViewProj, position);
         return OUT;
        }
        
        float4 MorphedSphereSM_PS(VPos_OUT IN) : COLOR
        {
         float4 pos = IN.VPosition / IN.VPosition.w;
         return float4(pos.z, 0, 0, 1); 
        }

#endif
        
CPos_OUT MorphedSphereCDepth_VS(float4 position : POSITION,
                      uniform float4x4 WorldViewProj,
                      uniform float4x4 WorldView,
                      uniform float t)
{
        CPos_OUT OUT;
        float dist = sin(t + position.x * position.y * 5.0 + position.z) * 0.3; 
        position.xyz += normalize(position.xyz) * dist;
        OUT.VPos = mul(WorldViewProj, position);
        OUT.CPos = mul(WorldView, position);
        return OUT;
}

#include "stationIllum.hlsl"

uniform sampler2D colorTexture : register(s0);
uniform sampler2D obscuranceTexture : register(s1);
uniform sampler2D PathMap : register(s2);
uniform sampler2D WeightIndexMap : register(s3);
uniform sampler2D WeightMap : register(s4);
uniform samplerCUBE ShadowMap1Point : register(s5);
uniform samplerCUBE ShadowMap2Point : register(s6);
uniform sampler2D ShadowMap1 : register(s5);
uniform sampler2D ShadowMap2 : register(s6);
uniform samplerCUBE CausticCubeMap  : register(s7);
uniform samplerCUBE CausticCasterDepthMap  : register(s8);

uniform float4x4 WorldViewProj;
uniform float4x4 World;
uniform float4x4 WorldI;

uniform float3 wCamPos;

uniform float4 wLightPos1;
uniform float4 wLightPos2;
uniform float4 lightRange1;
uniform float4 lightRange2;
uniform float lightPower1;
uniform float lightPower2;
uniform float4 lightColor1;
uniform float4 lightColor2;
uniform float3 wLightDir1;
uniform float3 wLightDir2;
                                                
uniform float4x4 LightViewProj1;
uniform float4x4 LightViewProj2;
uniform float4x4 LightView1;
uniform float4x4 LightView2;
uniform float lightFarPlane1;
uniform float lightFarPlane2;

uniform float specularity;
uniform float4 specularColor;

uniform float causticReceiver;
uniform float3 causticCasterCenter1;
uniform float causticAttenuationRange1;

struct STATION_BASE_VSOUT
{
        float4 hPos : POSITION;
        float2 texCoord           : TEXCOORD0;
        float3 wView              : TEXCOORD1;
        float3 wNormal            : TEXCOORD2;
        float3 wPos                       : TEXCOORD3;  
        float4 lightVPos1         : TEXCOORD4;
        float4 lightVPos2         : TEXCOORD5;
        float3 lightCPos1         : TEXCOORD6;
        float3 lightCPos2         : TEXCOORD7;
};

STATION_BASE_VSOUT StationBase_VS(float4 position :POSITION,
                                                                                float3 normal :NORMAL,
                                                                                float2 texCoord : TEXCOORD0     )
{
        STATION_BASE_VSOUT OUT = (STATION_BASE_VSOUT) 0;
        
        OUT.texCoord = texCoord;        
                
        OUT.hPos = mul(WorldViewProj, position);
        OUT.wPos = mul(World, position);
        
        OUT.wView = wCamPos - OUT.wPos;
        
        OUT.wNormal = normalize(mul(float4(normal, 1),WorldI)).xyz;     
        
        OUT.lightVPos1 = mul(LightViewProj1, float4(OUT.wPos,1));
        OUT.lightVPos2 = mul(LightViewProj2, float4(OUT.wPos,1));

#ifdef HIGH_QUALITY     
        OUT.lightCPos1 = mul(LightView1, float4(OUT.wPos,1)).xyz;
        OUT.lightCPos2 = mul(LightView2, float4(OUT.wPos,1)).xyz;
#endif
                
        return OUT;
}

float4 StationBase_PS(STATION_BASE_VSOUT IN):COLOR0
{       
        float4 Color = 0;
        float3 N = normalize(IN.wNormal);
        float dist = length(IN.wView);
        float3 V = IN.wView / dist;
        // read textures
        float4 diffuseColor = tex2D(colorTexture, IN.texCoord);
        float4 obscurancescolor = tex2D(obscuranceTexture, IN.texCoord);
        float4 combinedColor = diffuseColor * obscurancescolor;
        
        //----------------------------------------------------------------------------------------------------------------
        //light1                
                //light dir
        float3 L;
        float4 col;
        float3 lightCPos = 0;
        float4 lightVPos = 0;
        float shadow;
        
        //if( dot(lightRange1, lightRange1) != 0)
        {
                L = wLightPos1.xyz - IN.wPos;
                //illumination
                col = Illumination(N, L, V, lightColor1 * lightPower1, lightRange1, normalize(wLightDir1), combinedColor, specularity, specularColor);
                lightVPos = IN.lightVPos1;
                lightCPos = IN.lightCPos1;
                shadow = shadowMap(ShadowMap1, lightVPos, lightCPos, lightFarPlane1);
                
                Color += col * shadow;                  
        }
        
        //----------------------------------------------------------------------------------------------------------------
        //light2                        
        if( dot(lightRange2, lightRange2) != 0 )
        {
                //light dir
                L = wLightPos2.xyz - IN.wPos;
                //illumination
                col = Illumination(N, L, V, lightColor2 * lightPower2, lightRange2, normalize(wLightDir2), combinedColor, specularity, specularColor);
                
                lightVPos = IN.lightVPos2;
                lightCPos = IN.lightCPos2;
                shadow = shadowMap(ShadowMap2, lightVPos, lightCPos, lightFarPlane2);
                Color += col * shadow;          
        }
        
        //do Path Map to gather indirect illumination
        
        float4 indirect = PathMapIndirect(PathMap, WeightIndexMap, WeightMap, IN.texCoord);
        indirect *= diffuseColor;
        Color = Color + indirect;
        
        if(causticReceiver)
        {
                //Color *= 0.00000000001;
                Color += diffuseColor * Caustics(CausticCubeMap, CausticCasterDepthMap, IN.wPos - causticCasterCenter1, causticAttenuationRange1);
        }
        //Color.a = dist;
        return Color;
}