source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/demos/Standalone/Hierarchical Systems Demo [OpenGL]/src/Psystem_Multiply_Forward_Depth.cg @ 3255

struct VertexOut
{
        float4 VertexPosition           :POSITION;
        float2 TexCoord                         :TEXCOORD;
        float4 Position                         :TEXCOORD1;
        float4 EyePosition                      :TEXCOORD2;
        float2 BbSizeAngleCos           :TEXCOORD3;
        float4 LightSpacePos            :TEXCOORD4;     
        float4 Color                            :COLOR0;
};


//
//  Vertex program for displaying particle system with rectangle rendertexture 
//
VertexOut VertexProgram( float4 Position :POSITION,
                                                float4 Texcoord: TEXCOORD,
                                                float4 Color:COLOR0,
                                                uniform float4x4 LightModelViewProj,
                                                uniform float3 LightPosition,
                                                uniform float3 EyePosition,
                                                uniform float4x4 ModelViewProj  :state.matrix.mvp,
                                                uniform float4x4 ModelViewMatrix:state.matrix.modelview
                                                )                                                                       
{
        VertexOut Out;  
                        
        Out.Color=Color;
        
        Out.VertexPosition=mul(ModelViewProj, Position);
        Out.TexCoord=Texcoord.xy;
        
        Out.LightSpacePos=mul(LightModelViewProj, Position);
        Out.LightSpacePos.xyz=Out.LightSpacePos.xyz/Out.LightSpacePos.w;
        Out.LightSpacePos.xyz=(Out.LightSpacePos.xyz+1)/2;
        
        Out.Position=Out.VertexPosition;
        Out.BbSizeAngleCos.x=Texcoord.z;
        
        float3 LightToPoint=normalize(Position.xyz-LightPosition);
        float3 PointToEye=normalize(EyePosition-Position.xyz); 
        Out.BbSizeAngleCos.y=(dot(LightToPoint,PointToEye)+1.0)/2.0;
        
        Out.EyePosition=mul(ModelViewMatrix, Position);
        
        Out.Position.xyz=(Out.Position.xyz/Out.Position.w+1)/2;
        
        return Out;     
}

//
//  Fragment program for displaying particle system with rectangle rendertexture
//
void FragmentProgram(   VertexOut       In,
                                                uniform samplerRECT FrontTexture,
                                                uniform samplerRECT ObjTexture,
                                                uniform samplerRECT Illum1,
                                                uniform samplerRECT PhaseTexture,
                                                uniform float Albedo,
                                                uniform float Transparency,
                                                uniform float Symmetry,
                                                uniform float3 LightColor,
                                                float4 out Color:COLOR                                          
                                        )
{       
        float2 illumUV=In.LightSpacePos.xy;     
        illumUV*=256;
        In.TexCoord*=256;
        float z=In.LightSpacePos.z;
        
        float3 start;
        float3 end;
        float3 temp;    
        
        float objdepth=texRECT(ObjTexture,In.Position.xy*512).r;
        
        float depth=texRECT(FrontTexture,In.TexCoord).r;
        float density=1;                
        
        if(depth.x==1)
        {
                Color=float4(0,0,0,1);  
        }
        else
        {                                       
                float size=0.5*In.BbSizeAngleCos.x;
                float frontdepth=-In.EyePosition.z-size+texRECT(FrontTexture,In.TexCoord).r*size;
                float backdepth=-In.EyePosition.z-size+(1-texRECT(FrontTexture,In.TexCoord).g)*size;
                
                float d=backdepth-frontdepth;
                float o=-objdepth-frontdepth;
                                
                density*=texRECT(FrontTexture,In.TexCoord).a;//density  
                density*=saturate(o/d); 
                
                float4 planes=float4(0.33,0.5,0.66,1);          
                float t;
                        if(z<planes.x)
                        {
                                start=float3(1,1,1);
                                end=texRECT(Illum1,illumUV).r;
                                t=z/planes.x;
                                temp=lerp(start,end,t); 
                                //temp=float3(1,0,0);
                        }                       
                        if(z<planes.y&&z>=planes.x)
                        {
                                start=texRECT(Illum1,illumUV).r;
                                end=texRECT(Illum1,illumUV).g;
                                t=(z-planes.x)/(planes.y-planes.x);
                                temp=lerp(start,end,t);
                                //temp=float3(1,1,0);                   
                        }       
                        if(z>=planes.y&&z<planes.z)
                        {
                                start=texRECT(Illum1,illumUV).g;
                                end=texRECT(Illum1,illumUV).b;
                                t=(z-planes.y)/(planes.z-planes.y);
                                temp=lerp(start,end,t);         
                                //temp=float3(0,1,0);                   
                        }
                        if(z>=planes.z)
                        {       
                                start=texRECT(Illum1,illumUV).b;
                                end=texRECT(Illum1,illumUV).a;
                                t=(z-planes.z)/(1-planes.z);
                                temp=lerp(start,end,t); 
                                //temp=float3(0,1,1);                   
                        }
                                                
                        float phase=texRECT(PhaseTexture,float2(Symmetry,In.BbSizeAngleCos.y)*256);
                        float realdens=density*Transparency;
                        float scatter=realdens*Albedo;
                        float outcol=temp*phase*scatter;
                        //float3 outcol=temp;//*phase*scatter;
                
                        float scateeredforward=scatter*texRECT(PhaseTexture,float2(Symmetry,1)*256);
                        
                        Color+=float4((LightColor)*outcol*In.Color.rgb,1-realdens);
        }
                
}