source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/mrt.cg @ 3084

// input
struct vtxin 
{
  float4 position: POSITION;
  float4 normal: NORMAL;
  float4 color: COLOR0;
  float4 texCoord: TEXCOORD0;
};


// vtx output
struct vtxout
{
        float4 position: POSITION;
        float4 texCoord: TEXCOORD0;    

        float4 color: COLOR0;  
        float4 eyePos: TEXCOORD1; // eye position
        float4 normal: TEXCOORD2;
};


// fragment input
struct fragin
{
        float4 color: COLOR0;  
        //float4 position: POSITION;
        float4 texCoord: TEXCOORD0;    

        float4 winPos: WPOS;
        float4 eyePos: TEXCOORD1; // eye position
        float4 normal: TEXCOORD2;
};


struct pixel
{
        float4 col: COLOR0;
        float3 norm: COLOR1;
        float3 pos: COLOR2;
};


#pragma position_invariant vtx

vtxout vtx(vtxin IN)
{
        vtxout OUT;

        OUT.color = IN.color;
        OUT.texCoord = IN.texCoord;

        // transform the vertex position into eye space
        OUT.eyePos = mul(glstate.matrix.modelview[0], IN.position);
        // transform the vertex position into post projection space
        OUT.position = mul(glstate.matrix.mvp, IN.position);

        OUT.normal = mul(glstate.matrix.invtrans.modelview[0], IN.normal);

        return OUT;
}

#pragma position_invariant fragtex

pixel fragtex(fragin IN, 
                          uniform sampler2D tex,
                          uniform float4x4 viewMatrix
                          )
{
        float4 texColor = tex2D(tex, IN.texCoord.xy);

        // account for alpha blending
        if (texColor.w < 0.5f) discard;

        pixel pix;

        // save color in first render target
        // hack: use combination of emmisive + diffuse (emmisive used as constant ambient term)
        pix.col = (glstate.material.emission + glstate.material.diffuse) * texColor; 
        // save world space normal in rt => transform back into world space by
        // multiplying with inverse view. since transforming normal with T means to 
        // multiply with the inverse transpose of T, we multiple with Transp(Inv(Inv(view))) = Transp(view)
        pix.norm = mul(transpose(viewMatrix), IN.normal);
        // compute eye linear depth
        pix.col.w = length(IN.eyePos.xyz);
        // hack: squeeze some information about ambient into the texture
        //pix.col.w = glstate.material.emission.x;

        return pix;
}


#pragma position_invariant frag

pixel frag(fragin IN, uniform float4x4 viewMatrix)
{
        pixel pix;
        // hack: use comination of emmisive + diffuse (emmisive used as constant ambient term)
        pix.col = glstate.material.diffuse + glstate.material.emission;
        // save world space normal in rt => transform back into world space by
        // multiplying with inverse view. since transforming normal with T means to 
        // multiply with the inverse transpose of T, we multiple with Transp(Inv(Inv(view))) = Transp(view)
        pix.norm = mul(transpose(viewMatrix), IN.normal);
        // eye space depth
        pix.col.w = length(IN.eyePos.xyz);
        // hack: squeeze some information about the ambient term into the target
        //pix.col.w = glstate.material.emission.x;

        return pix;
}