source: GTP/trunk/App/Games/Jungle_Rumble/src/shaders/simpleMesh.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 MatIP;                                               // Inverse Projection Matrix

//float3 ParticlePosition;      // Particle's center in world coordinates
//float2 CurrentPattern;                // Current pattern offset.
//float2 PatternSize;                   // Pattern size.
float ParticleSize;                     // Particle's size in world units.
float ReciprocalParticleSize; // 1/Particle size.
//float4 ParticleColor;         // Particle color and opacity.
//float ScreenSpaceRotation;    // Rotation of particle in radiants.
float NearPlaneDistance;        // Distance of the near plane.
float FarPlaneMinusNearPlane; // Distance of the far plane minus distance of the near plane.

texture g_txCurrentTexture;
texture g_txDepthBuffer;


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

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

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;                                                 \
};

SAMPLER_LINEAR(g_samplerCurrentTexture, g_txCurrentTexture);
//SAMPLER_POINT(g_samplerDepthBuffer, g_txDepthBuffer);
SAMPLER_LINEAR(g_samplerDepthBuffer, g_txDepthBuffer);
//sampler DepthBuffer;

//----------------------------------------------
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;
    
    // Calculate particle's center position in eye space.
        //float4 vertexpos = float4(ParticlePosition.xyz, 1.0);
        float4 vertexpos = float4(IN.position.xyz, 1.0);
        float4 eyespace = mul(vertexpos, g_mWorldView);
        
        // Calculate offset and size for this vertex depending on input position.       
        /*float2 offset = float2(IN.position.xy) * ParticleSize;
        
        // Include screen space rotation.
        float anglesin = sin(ScreenSpaceRotation);
        float anglecos = cos(ScreenSpaceRotation);
        float2x2 rotmatrix;
        rotmatrix[0][0] = anglecos;
        rotmatrix[1][0] = -anglesin;
        rotmatrix[0][1] = anglesin;
        rotmatrix[1][1] = anglecos;
        float2 rotate = mul(rotmatrix, offset);
        eyespace += float4(rotate.xy, -ParticleSize, 0.0);*/
    eyespace.z += ParticleSize;
    // Write linear depth of this vertex to the output.
    //OUT.ParticleDepth = (eyespace.z);
        
        // Multiplicate with projection matrix to get final vertex position.
        float4 finalpos = mul(eyespace, g_mProj);
    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 * float4(PatternSize.xy, 0.0, 1.0)
      + float4(CurrentPattern.xy, 0.0, 1.0);*/
    OUT.ColorTextureCoord = IN.texCoord;

    return OUT;
}


//------------------------------------
pixelOutput DepthImposterPS(vertexOutput IN)
{
        pixelOutput OUT;
        
        // Do a lookup in the depth buffer.
        float4 lookup = float4(IN.DepthBufferCoord.xy, 0.0, 1.0);
        float depth = tex2D(g_samplerDepthBuffer, lookup).a;
        
        // Calculate linear depth
        /*float4 transform;
        transform.x = IN.DepthBufferCoord.x * 2.0 - 1.0;
        transform.y = ((1.0 - IN.DepthBufferCoord.y) * 2.0 - 1.0);
        transform.z = depth;
        transform.w = 1.0;
        float4 aftertransform = mul(transform, MatIP);
        aftertransform.xyz /= aftertransform.w;*/

        // Calculate visible range of the particle.
        //float difference = abs(aftertransform.z - IN.ParticleDepth);
        float 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.rgb *= difference;
        //texturecolor.rgb = float3(1, 0, 0);
        OUT.color = texturecolor;// * ParticleColor;
        
        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 );