source: GTP/trunk/App/Games/Jungle_Rumble/src/shaders/depthImp.fx @ 1378

//------------------------------------
float4x4 g_mWorldView;                          // World View Matrix
float4x4 g_mView;                                       // View Matrix
float4x4 g_mProj;                                       // Projection Matrix
float4x4 g_mWorldViewProjection;        // World View Projection Matrix
float4x4 g_mViewProjection;

float ParticleSize;                     // Particle's size in world units.
float3 ParticlePos;                     //Position of Particle
float ReciprocalParticleSize; // 1/Particle size.
float NearPlaneDistance;        // Distance of the near plane.
float FarPlaneMinusNearPlane; // Distance of the far plane minus distance of the near plane.
bool animatedSprite;
bool useDepthImposter;
float invNbColumns;
float invNbRows;
int nbColumns;
int nbRows;
int nbFrame;

//CurrentValues
float4 argb;
float2 hWidthHeight;

texture g_txCurrentTexture;
texture g_txDepthBuffer;
texture preDistortion;
texture distortionMap1;
texture distortionMap2;
texture screenDistortionMap;

//------------------------------------
struct vertexInput {
    float3 position                             : POSITION;
    float4 texCoord                             : TEXCOORD0;
};

struct vertexOutput {
    float4 HPosition                    : POSITION;
    float4 ColorTextureCoord    : TEXCOORD0;
    float2 DepthBufferCoord             : TEXCOORD1;
    float ParticleDepth                 : TEXCOORD2;
};

struct cpVertexOutput {
    float4 HPosition                    : POSITION;
    float4 ColorTextureCoord    : TEXCOORD0;
};

struct pixelOutput
{
        float4 color                            : COLOR;
};


struct depthVertexInput {
    float4 position                             : POSITION;
    float4 texCoord                             : TEXCOORD0;
};

struct depthVertexOutput {
    float4 HPosition                    : POSITION;
    float4 texCoord                             : TEXCOORD0;
};

//------------------------------------
#define SAMPLER_LINEAR(g_samplerMap, g_txMap);  \
        sampler2D g_samplerMap = sampler_state {        \
    Texture = <g_txMap>;                                                \
    MinFilter = Linear;                                                 \
    MagFilter = Linear;                                                 \
    MipFilter = Linear;                                                 \
    AddressU  = BORDER;                                                 \
    AddressV  = BORDER;                                                 \
};

#define SAMPLER_POINT(g_samplerMap, g_txMap);   \
        sampler2D g_samplerMap = sampler_state {        \
    Texture = <g_txMap>;                                                \
    MinFilter = Point;                                                  \
    MagFilter = Point;                                                  \
    MipFilter = Point;                                                  \
    AddressU  = BORDER;                                                 \
    AddressV  = BORDER;                                                 \
};

#define SAMPLER_LINEAR_WRAP(g_samplerMap, g_txMap);     \
        sampler2D g_samplerMap = sampler_state {        \
    Texture = <g_txMap>;                                                \
    MinFilter = Linear;                                                 \
    MagFilter = Linear;                                                 \
    MipFilter = Linear;                                                 \
    AddressU  = WRAP;                                                   \
    AddressV  = WRAP;                                                   \
};

SAMPLER_LINEAR(g_samplerCurrentTexture, g_txCurrentTexture);
SAMPLER_POINT(g_samplerDepthBuffer, g_txDepthBuffer);
SAMPLER_POINT(samplerPreDistortion,     preDistortion);
SAMPLER_LINEAR_WRAP(samplerDistMap1, distortionMap1);
SAMPLER_LINEAR_WRAP(samplerDistMap2, distortionMap2);
SAMPLER_POINT(samplerScreenDistMap, screenDistortionMap);


//----------------------------------------------
depthVertexOutput DepthPassVS(depthVertexInput IN) 
{
    depthVertexOutput OUT;
    float4 vertexpos = float4(IN.position.xyz, 1.0);
        float4 eyespace = mul(vertexpos, g_mWorldViewProjection);
        OUT.HPosition = eyespace;
        float tempDepth = saturate(eyespace.z/FarPlaneMinusNearPlane);
        IN.texCoord.a = tempDepth;
        OUT.texCoord = IN.texCoord;
        return OUT;
}

pixelOutput DepthPassPS(depthVertexOutput IN)
{
        pixelOutput OUT;
        float depth = IN.texCoord.a;
        OUT.color = float4(depth, depth, depth, depth);
        return OUT;
}

//------------------------------------
vertexOutput DepthImposterVS(vertexInput IN) 
{
    vertexOutput OUT;
    
    //Billboarding
    float3 rightVec;
    rightVec.x = g_mView[0][0];
    rightVec.y = g_mView[1][0];
    rightVec.z = g_mView[2][0];
    float3 upVec;
    upVec.x = g_mView[0][1];
    upVec.y = g_mView[1][1];
    upVec.z = g_mView[2][1];
    float3 frontVec;
    frontVec.x = g_mView[0][2];
    frontVec.y = g_mView[1][2];
    frontVec.z = g_mView[2][2];
    float3 pos;
    pos = ParticlePos;
    
    pos += (hWidthHeight.x*IN.position.x*rightVec + hWidthHeight.y*IN.position.y*upVec);
    pos += ParticleSize*frontVec;
        float4 finalpos = mul(float4(pos,1), g_mViewProjection);
    OUT.HPosition = finalpos;
    
    if(useDepthImposter) {
                OUT.ParticleDepth = finalpos.z/FarPlaneMinusNearPlane; //Dividieren durch zfar usw
            
                // Apply w-division to get normalized device coordinates [-1,1].
                float2 devicecoords = finalpos.xy / finalpos.w;

                // No transform them into texture coordinates [0,1].
                devicecoords = devicecoords * 0.5 + 0.5;
                devicecoords.y = 1.0 - devicecoords.y;
                OUT.DepthBufferCoord = devicecoords;
    }
    
    // Texture coordinate depends on current pattern index and pattern size.
    if(!animatedSprite) {
                OUT.ColorTextureCoord = IN.texCoord;
        } else {
                int column = nbFrame%nbColumns;
                int framesSub = nbFrame - column;
                int row = framesSub/nbColumns;
                
                OUT.ColorTextureCoord.x = invNbColumns*(column+IN.texCoord.x);
                OUT.ColorTextureCoord.y = invNbRows*(row+IN.texCoord.y);
        }

    return OUT;
}


//------------------------------------
pixelOutput DepthImposterPS(vertexOutput IN)
{
        pixelOutput OUT;
        
        // Do a lookup in the depth buffer.
        float difference = 1.0f;
        if(useDepthImposter) {
                float4 lookup = float4(IN.DepthBufferCoord.xy, 0.0, 1.0);
                float depth = tex2D(g_samplerDepthBuffer, lookup).a;

                // Calculate visible range of the particle.
                difference = abs(depth - IN.ParticleDepth);
                difference *= ReciprocalParticleSize;
                
                difference = min(difference, 1.0);
        }
        // Multiply texel by input color.
        float4 texturecolor = tex2D(g_samplerCurrentTexture, IN.ColorTextureCoord);
        texturecolor.a *= difference;
        texturecolor*=argb;
        OUT.color = texturecolor;
        
        return OUT;
}

//------------------------------------
cpVertexOutput HeatHazeCopyVS(vertexInput IN) 
{
    cpVertexOutput OUT;
    
    OUT.HPosition = float4(IN.position,1);
    OUT.ColorTextureCoord = IN.texCoord;
    return OUT;
}


//------------------------------------
pixelOutput HeatHazeCopyPS(cpVertexOutput IN)
{
        pixelOutput OUT;
        float2 deviceCoord = IN.ColorTextureCoord.xy;
        float2 offset = tex2D(samplerScreenDistMap, deviceCoord).xy;
        offset = ((offset*2)-1)*0.005;
        OUT.color =  float4(tex2D(samplerPreDistortion, deviceCoord+offset).xyz, 1);
        return OUT;
}


//------------------------------------
vertexOutput HeatHazeVS(vertexInput IN) 
{
    vertexOutput OUT;
    
        //Billboarding
    float3 rightVec;
    rightVec.x = g_mView[0][0];
    rightVec.y = g_mView[1][0];
    rightVec.z = g_mView[2][0];
    float3 upVec;
    upVec.x = g_mView[0][1];
    upVec.y = g_mView[1][1];
    upVec.z = g_mView[2][1];
    float3 frontVec;
    frontVec.x = g_mView[0][2];
    frontVec.y = g_mView[1][2];
    frontVec.z = g_mView[2][2];
    float3 pos;
    pos = ParticlePos;
    
    pos += (hWidthHeight.x*IN.position.x*rightVec + hWidthHeight.y*IN.position.y*upVec);
    pos += ParticleSize*frontVec;
    //pos+=IN.position;
    
    
    // Calculate particle's center position in eye space.
        /*float4 vertexpos = float4(IN.position.xyz, 1.0);
        float4 eyespace = mul(vertexpos, g_mWorldView);
        
    eyespace.z += ParticleSize;
   
        // Multiplicate with projection matrix to get final vertex position.
        float4 finalpos = mul(eyespace, g_mProj);*/
        float4 finalpos = mul(float4(pos,1), g_mViewProjection);
    OUT.HPosition = finalpos;
    OUT.ParticleDepth = finalpos.z/FarPlaneMinusNearPlane; //Dividieren durch zfar usw
    
    // Apply w-division to get normalized device coordinates [-1,1].
    float2 devicecoords = finalpos.xy / finalpos.w;

    // No transform them into texture coordinates [0,1].
    devicecoords = devicecoords * 0.5 + 0.5;
    devicecoords.y = 1.0 - devicecoords.y;
    OUT.DepthBufferCoord = devicecoords;
    
    // Texture coordinate depends on current pattern index and pattern size.
    OUT.ColorTextureCoord = IN.texCoord;

    return OUT;
}


//------------------------------------
pixelOutput HeatHazePS(vertexOutput IN)
{
        pixelOutput OUT;
        float2 deviceCoord = IN.DepthBufferCoord.xy;
        float depth = tex2D(g_samplerDepthBuffer, deviceCoord).a;
        
        if(depth>IN.ParticleDepth) {
                float difference = abs(depth - IN.ParticleDepth);
                difference *= ReciprocalParticleSize;
                difference = min(difference, 1.0);
                float2 offset = tex2D(samplerDistMap1, IN.ColorTextureCoord.xy).xy;

                float fade = abs(offset.x-0.5)*2*difference;
                OUT.color = float4((offset-0.5)*difference, 0.5, fade);
        } else {
                OUT.color =  float4(0.5, 0.5, 0.5, 0);
        }
        return OUT;
}

// 
// Effect
//

#define Technique(name);                                                                \
        technique name                                                                          \
        {                                                                                                       \
            pass p0                                                                                     \
            {                                                                                           \
                    VertexShader = compile vs_3_0 name##VS();   \
                    PixelShader  = compile ps_3_0 name##PS();   \
                }                                                                                               \
        }
        
Technique( DepthImposter );
Technique( DepthPass );
Technique( HeatHazeCopy );
Technique( HeatHaze );