source: GTP/trunk/App/Demos/Illum/RayTraceEffects/RayTraceEffects.fx @ 754

#define SHADOWMAP_SIZE  512.0f                          // The size of ShadowMap

// Offsets in the ShadowMap
#define HALF    0.5f  / SHADOWMAP_SIZE
#define ONE             1.0f  / SHADOWMAP_SIZE
#define TWO             2.0f  / SHADOWMAP_SIZE
#define THREE   3.0f  / SHADOWMAP_SIZE
#define FIVE    5.0f  / SHADOWMAP_SIZE
#define TEN             10.0f / SHADOWMAP_SIZE

#define AMB float4(0.5,0.5,0.5,1)                       // Power of the ambient light
#define FI 1000                                                         // Summarized power of the light source

//----------------------------------------------
// GLOBAL VARIABLES
//---------------------------------------------
float3   g_vCameraPos3f;                                        // Camera position
float3   g_vLightPos3f;                                         // Light source position
int              g_iNumberOfIteration;                          // Number of iteration
int      g_iObjectID;                                           // ID of the current object
int              g_iPhotonMapSize;                                      // PhotonMap size
float    g_fFresnelFactor;                                      // Fresnel factor
float    g_fPower;                                                      // Power of light source
float    g_fRefractionIndex;                            // Refraction index     
float    g_fShadowIntensity;                            // Shadow intensity 
float    g_fCausticsIntensity;                          // The intensity of a caustics snippet                          
bool     g_bShadowON;                                           // Shadow is used?
bool     g_bShowHelp;                                           // Darken the scene if help is on

float4x4 g_mWorldView;                                          // WorldView transformation matrix
float4x4 g_mWorldViewProjection;                        // WorldViewProjection transformation matrix
float4x4 g_mWorldCenterObject;                          // World transformation matrix of CenterObject
float4x4 g_mLightViewTexBias;                           // Light space transformation matrix

texture  g_txRoomMap;                                           // Contains the original texture of the Room 
texture  g_txRoomCubeMapColorDistanceMap;       // Contains the color and distance information in a CubeMap 
texture  g_txRoomCubeMapUVMap;                          // Contains the UV and ID of the object in a CubeMap 
texture  g_txPhotonUVMap;                                       // Contains the photon hits UV and ID information
texture  g_txPowerOfSnippetMap;                         // Contains the Gaussian filter
texture  g_txRoomModifyMap;                                     // Contains the texture of the Room with shadow and Caustics effect and black edges
texture  g_txRoomLastMap;                                       // Contains the texture of the Room

// Contain the textures of the Columns with shadow and Caustics effect
texture g_txColumnModifyTexture0, g_txColumnLastTexture0;
texture g_txColumnModifyTexture1, g_txColumnLastTexture1;
texture g_txColumnModifyTexture2, g_txColumnLastTexture2;
texture g_txColumnModifyTexture3, g_txColumnLastTexture3;

texture g_txColumnOriginalTexture;                      // Contains the original texture of a Column
texture  g_txShadowMap;                                         // Contains the shadowMap


//-----------------------------------------------------------------------------
// SAMPLERS
// Each texture must have its own sampler
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// macro definition for filtered samplers
//-----------------------------------------------------------------------------

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

SAMPLER_LINEAR(g_samplerRoomMap,                        g_txRoomMap);
SAMPLER_LINEAR(g_samplerRoomLastMap,            g_txRoomLastMap);
SAMPLER_LINEAR(g_samplerPhotonUVMap,            g_txPhotonUVMap);
SAMPLER_LINEAR(g_samplerPowerOfSnippetMap,      g_txPowerOfSnippetMap);
SAMPLER_LINEAR(g_samplerColumnLast0Map,         g_txColumnLastTexture0);
SAMPLER_LINEAR(g_samplerColumnLast1Map,         g_txColumnLastTexture1);
SAMPLER_LINEAR(g_samplerColumnLast2Map,         g_txColumnLastTexture2);
SAMPLER_LINEAR(g_samplerColumnLast3Map,         g_txColumnLastTexture3);
SAMPLER_LINEAR(g_samplerColumnOriginalMap,      g_txColumnOriginalTexture);

//-----------------------------------------------------------------------------
// macro definition for non-filtered samplers
//-----------------------------------------------------------------------------

#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_POINT(g_samplerRoomModifyMap,           g_txRoomModifyMap);     // must be point, it will be used for filtering
SAMPLER_POINT(g_samplerColumnModify0Map,        g_txColumnModifyTexture0);      
SAMPLER_POINT(g_samplerColumnModify1Map,        g_txColumnModifyTexture1);      
SAMPLER_POINT(g_samplerColumnModify2Map,        g_txColumnModifyTexture2);      
SAMPLER_POINT(g_samplerColumnModify3Map,        g_txColumnModifyTexture3);      

sampler2D g_samplerShadowMap = sampler_state
{
    Texture = <g_txShadowMap>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
    AddressU  = CLAMP;
    AddressV  = CLAMP;
};

samplerCUBE g_samplerRoomCubeMapColorDistanceMap = sampler_state
{
    Texture = <g_txRoomCubeMapColorDistanceMap>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
    AddressU  = BORDER;
    AddressV  = BORDER;
};

samplerCUBE g_samplerRoomCubeMapUVMap = sampler_state
{
    Texture = <g_txRoomCubeMapUVMap>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
    AddressU  = BORDER;
    AddressV  = BORDER;
};

samplerCUBE g_samplerRoomCubeMapUVMap_NO_FILTER = sampler_state
{
    Texture = <g_txRoomCubeMapUVMap>;
    MinFilter = Point;
    MagFilter = Point;
    MipFilter = Point;
    AddressU  = BORDER;
    AddressV  = BORDER;
};

//-----------------------------------------------------------------------------
// FUNCTIONS
//-----------------------------------------------------------------------------

// This function is called several times.
float3 Hit( float3 x, float3 R, samplerCUBE mp )
{
        float rl = texCUBE( mp, R ).a;                                                  // |r|
        float ppp = length( x ) / texCUBE( mp, x ).a;                   // |p|/|p’|
        float dun = 0, pun = ppp, dov = 0, pov;
        float dl = rl * ( 1 - ppp );                                                    // eq. 2
        float3 l = x + R * dl;                                                                  // ray equation

        // iteration
        for( int i = 0; i < g_iNumberOfIteration; i++ )
        {
                float llp = length( l ) / texCUBE( mp,l ).a;            // |l|/|l’|
                if ( llp < 0.999f )                                                                     // undershooting
                {
                        dun = dl; pun = llp;                                                    // last undershooting
                        dl += ( dov == 0 ) ? rl * ( 1 - llp ) :                 // eq. 2
                                ( dl - dov ) * ( 1 - llp ) / ( llp - pov );     // eq. 3
                } else if ( llp > 1.001f )                                                      // overshooting
                {
                        dov = dl; pov = llp;                                                    // last overshooting
                        dl += ( dl -dun ) * ( 1 - llp ) / ( llp - pun );// eq. 3
                }
                l = x + R * dl;                                                                         // ray equation
        }
        return l;                                                                                               // computed hit point
}

//*****************************************************************************

// This function enlarges the usefull areas of the atlases.
float4 FlowLight( sampler2D mp, float2 Tex )
{
        // Reads the current pixel
        float4 preVal = tex2D( mp, Tex );
        // If it is an unused pixel (.a=0)
        if ( preVal.a == 0 )
        {
                float dist = ONE;
                if( g_iObjectID != -1 ) dist *= 3.0f;
        
                // Reads a neighbor
                float2 modTex = Tex + float2( dist, 0.0 );
                float4 candid = tex2D( mp, modTex );
                
                // Calculate its intensity.
                // If it is more intensive than the previous (original) one, it is stored.
                if( dot( candid.xyz, candid.xyz ) > dot( preVal.xyz, preVal.xyz ) )
                        preVal = candid;
                
                // Reads another neighbor
                modTex += float2( -dist, dist );
                candid = tex2D( mp, modTex );
                
                // Calculate its intensity.
                // If it is more intensive than the previous one, it is stored.
                if( dot( candid.xyz, candid.xyz ) > dot( preVal.xyz, preVal.xyz ) )
                        preVal = candid;
        
                // Reads another neighbor. If it is more intensive than the previous, it is stored. 
                modTex += float2( -dist, -dist );
                candid = tex2D( mp, modTex );
                if( dot( candid.xyz, candid.xyz ) > dot( preVal.xyz, preVal.xyz ) )
                        preVal = candid;
        
                // Reads another neighbor. If it is more intensive than the previous, it is stored.
                modTex += float2( dist, -dist );
                candid = tex2D( mp, modTex );
                if( dot( candid.xyz, candid.xyz ) > dot( preVal.xyz, preVal.xyz ) )
                        preVal = candid;
        }       
        return preVal;
}


//-----------------------------------------------------------------------------
// SHADERS
// Here are the different shaders.
//-----------------------------------------------------------------------------


//*****************************************************************************
//-----------------------------------------------------------------------------
// RenderRoomColorDistance
// This shader stores the viewable object's color and its distance from the CenterObject's position.
// The result is stored in a CubeMap.
//-----------------------------------------------------------------------------
void RenderRoomColorDistanceVS(
        float4 Pos     : POSITION,
        float2 Tex     : TEXCOORD0,
    out float4 outhPos : POSITION,
    out float2 outTex  : TEXCOORD0,
    out float4 outPos  : TEXCOORD1 )
{
    outhPos = mul( Pos, g_mWorldViewProjection );
    outTex  = Tex;
    // Calculates the world position
    outPos  = mul( Pos, g_mWorldView );
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderRoomColorDistancePS( 
        float2 Tex : TEXCOORD0,
        float4 Pos : TEXCOORD1 ) : COLOR
{
    // The color of the viewable object in the current pixel.
    // In the scene there are 2 different textured object. (the room, and the Columns)
    // Every column has the same brdf texture.
    float3 retColor = float4(0,0,0,0);
    if ( g_iObjectID == -1 ) retColor = float4( tex2D(           g_samplerRoomMap, Tex ).xyz, 1);
    else                                         retColor = float4( tex2D( g_samplerColumnOriginalMap, Tex ).xyz, 1);
    
    // The distance from the Center object
    float Distance = (float) ( length( Pos.xyz ) );
    return float4( retColor, Distance );                // Color(x,y,z) + Distance(w)
}
//*****************************************************************************


//-----------------------------------------------------------------------------
// RenderRoomUV
// This shader stores the viewable object's UV and unique ObjectID.
// The ObjectID identify the object, because the UV pair is not enough.
// The result is stored in a CubeMap.
//-----------------------------------------------------------------------------
void RenderRoomUVVS(
        float4 Pos     : POSITION,
        float2 Tex     : TEXCOORD0,
    out float4 outhPos : POSITION,
    out float2 outTex  : TEXCOORD0 )
{
    outhPos = mul( Pos, g_mWorldViewProjection );
    outTex  = Tex;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderRoomUVPS( 
       float2 Tex : TEXCOORD0) : COLOR
{       // The UV value and the ID of the viewable object in the current pixel
                                                                                                // Here the "1" value is unnecessary
    return float4( Tex, g_iObjectID, 1 );               // Tex(x,y) + g_iObjectID(z) + "1"(w)
}
//*****************************************************************************


//-----------------------------------------------------------------------------
// RenderUmbra
// This shader copies the brdf color from the original texture Atlas of the Object to the
// actual texture Atlas of the Object.
// It is needed, because the brdf value is modified with shadow.
// If the pixel is in shadow, the brdf value is decreased.
// The distance from the light source is also a modifying factor.
// The result is stored in a 2D map (Atlas).
//-----------------------------------------------------------------------------
void RenderUmbraVS(
        float4 Pos     : POSITION,
        float2 Tex     : TEXCOORD0,
        float3 Normal  : NORMAL,
    out float4 outhPos : POSITION,
    out float2 outTex  : TEXCOORD0,
    out float3 outPos  : TEXCOORD1,
    out float  outCosT : TEXCOORD2,
    out float4 outLPos : TEXCOORD3)
{
        // The Room has no offset.
        // The Columns have offset from the world's center position.
        float4 PosWorld = Pos;
        if ( g_iObjectID > -0.1f ) PosWorld = mul( Pos, g_mWorldView );
        // Light vector
        float3 L = normalize( g_vLightPos3f - PosWorld.xyz );

        // Transformation between texture and screen space.
        // HALF is an offset between the two space.
    outhPos.x = Tex.x * 2.0f - 1.0f - HALF;
    outhPos.y = 1.0f - Tex.y * 2.0f + HALF;
    outhPos.z = 0;
    outhPos.w = 1;
    
    outTex  = Tex;
    outPos  = PosWorld.xyz;
    // The direction of the normal of the Room and the Columns are different.
    if (g_iObjectID < -0.5f)
                Normal = -Normal;
    outCosT = dot( Normal, L ); 
    outLPos = mul( PosWorld, g_mLightViewTexBias ); 
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderUmbraPS( 
       float2 Tex  : TEXCOORD0,
       float3 Pos  : TEXCOORD1,
       float  CosT : TEXCOORD2,
       float4 LPos : TEXCOORD3 ) : COLOR
{
        // return Color
        float4 retColor = float4(0,0,0,0);
        // ShadowMap distance values
        
        // Read the brdf from the atlas of the object
        // The Room and the Columns have 2 different brdf Atlas.
        if ( g_iObjectID == -1 )
                retColor = float4( tex2D(           g_samplerRoomMap, Tex ).xyz, 1);
        else
                retColor = float4( tex2D( g_samplerColumnOriginalMap, Tex ).xyz, 1);

        // Use shadow?
        if (g_bShadowON)
        {
                float visibility = 0;

                for (float y = -1.5f; y < 2.0f; y += 1.0f){
                        for (float x = -1.5f; x < 2.0f; x += 1.0f) {
                                float4 coord = float4( LPos.xyz / LPos.w, 0 );
                                coord.xy   += (float2(x,y)/(float)ONE);
                                if( LPos.z - tex2Dlod( g_samplerShadowMap, coord ).x < 0.2 )
                                {
                                        visibility++;
                                }
                        }
                }
                visibility = visibility / 16.0f;
                if( visibility < 16 )
                {
                        visibility = visibility + ( 0.01f + 1 - g_fShadowIntensity );
                }
                if( visibility > 1.0f )
                {
                        visibility = 1.0f;
                }
                retColor *= visibility;
        }
        
        // The intensity of the brdf depends on the position of the light source.
        
        float3 L = g_vLightPos3f;
        float pll2 = dot( ( Pos - L ), ( Pos - L ) );
        retColor *= AMB + ( FI / pll2 ) * CosT * g_fCausticsIntensity; 

        if (g_bShowHelp)        // light's effect is decreased to improve the visibility of help text
                retColor *= 0.5f;
        
    return retColor;
}
//*****************************************************************************


//-----------------------------------------------------------------------------
// RenderRoomAndColumnsScreen
// This shader render the scene's objects to the screen with their own atlas.
//-----------------------------------------------------------------------------
void RenderRoomAndColumnsScreenVS(

        float4 Pos         : POSITION,
        float2 Tex         : TEXCOORD0,
    out float4 outhPos : POSITION,
    out float2 outTex  : TEXCOORD0 )
{
    outhPos = mul( Pos, g_mWorldViewProjection );
    outTex  = Tex;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderRoomAndColumnsScreenPS( 
       float2 Tex : TEXCOORD0) : COLOR
{
        float4 retColor = float4(1,1,1,1);
        
        // Five different atlas for the five object.
        if (g_iObjectID == -1 ) retColor = float4( tex2D(    g_samplerRoomLastMap, Tex ).xyz, 1 );
        if (g_iObjectID ==  0 ) retColor = float4( tex2D( g_samplerColumnLast0Map, Tex ).xyz, 1 );
        if (g_iObjectID ==  1 ) retColor = float4( tex2D( g_samplerColumnLast1Map, Tex ).xyz, 1 );
        if (g_iObjectID ==  2 ) retColor = float4( tex2D( g_samplerColumnLast2Map, Tex ).xyz, 1 );
        if (g_iObjectID ==  3 ) retColor = float4( tex2D( g_samplerColumnLast3Map, Tex ).xyz, 1 );
        
        return retColor;
}
//*****************************************************************************


//-----------------------------------------------------------------------------
// RenderPhotonUVMap
// This shader creates the PhotonUVTexture with Hit function.
// It is a 2D map with the photon hits. It is created from the position of the light source.
// Every pixel stores the UV, and ObjectID information.
// The result is stored in a 2D map.
//-----------------------------------------------------------------------------
void RenderPhotonUVMapVS(
        float4 Pos     : POSITION,
        float3 Normal  : NORMAL,
        float3 Tex         : TEXCOORD0,
    out float4 outhPos : POSITION,
    out float3 outTex  : TEXCOORD0,
    out float3 outPos  : TEXCOORD1,
    out float3 outN    : TEXCOORD2, 
    out float3 outL    : TEXCOORD3)
{
        // The offset (+float4...) is needed to move the Center Object into the center of the PhotonMap.
    outhPos = mul( Pos, g_mWorldViewProjection ) + float4( -4.0f / (float)g_iPhotonMapSize , 4.0f / (float)g_iPhotonMapSize , 0, 0 );
    
    outTex  = Tex;
    outPos  = mul( Pos, g_mWorldCenterObject );
    outN    = Normal;   
    outL    = normalize( outPos - g_vLightPos3f ); 
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderPhotonUVMapPS(
        float3 Tex : TEXCOORD0,
        float3 Pos : TEXCOORD1,
        float3 N   : TEXCOORD2,
        float3 L   : TEXCOORD3 ) : COLOR
{
        // By default, there is no Hit.
        float a = -1;
        float4 hitSurf = float4(0,0,0,0);
        
        if ( dot( L, N ) < -0.1 ){
                L = normalize( L );
                N = normalize( N ); 
                float3 T = normalize( refract( L, N, g_fRefractionIndex ) );
                
                // Look up from the CubeMap
                // The return value is a vector. The CubeUVMap is read at that position.
                float3 TT = Hit( Pos, T, g_samplerRoomCubeMapColorDistanceMap );
                hitSurf = texCUBE( g_samplerRoomCubeMapUVMap, TT );
                // There is a Hit.
                a = 1;
        }
        return float4( hitSurf.xyz, a );
}
//*****************************************************************************


//-----------------------------------------------------------------------------
// RenderPhotonUVMapClassic
// This shader creates the PhotonUVTexture with classical method.
// It is a 2D map with the photon hits. It is created from the position of the light source.
// Every pixel stores the UV, and ObjectID information.
// The result is stored in a 2D map.
//-----------------------------------------------------------------------------
void RenderPhotonUVMapClassicVS(
        float4 Pos     : POSITION,
        float3 Normal  : NORMAL,
        float3 Tex         : TEXCOORD0,
    out float4 outhPos : POSITION,
    out float3 outTex  : TEXCOORD0,
    out float3 outPos  : TEXCOORD1,
    out float3 outN    : TEXCOORD2, 
    out float3 outL    : TEXCOORD3)
{
        // The offset (+float4...) is needed to move the Center Object into the center of the PhotonMap.
    outhPos = mul( Pos, g_mWorldViewProjection ) + float4( -4.0f / (float)g_iPhotonMapSize , 4.0f / (float)g_iPhotonMapSize , 0, 0 );
    
    outTex  = Tex;
    outPos  = mul( Pos, g_mWorldCenterObject );
    outN    = Normal;   
    outL    = normalize( outPos - g_vLightPos3f ); 
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderPhotonUVMapClassicPS(
        float3 Tex : TEXCOORD0,
        float3 Pos : TEXCOORD1,
        float3 N   : TEXCOORD2,
        float3 L   : TEXCOORD3 ) : COLOR
{
        // By default, there is no Hit.
        float a = -1;
        float4 hitSurf = float4(0,0,0,0);
        
        if ( dot( L, N ) < -0.1 ){
                L = normalize( L );
                N = normalize( N ); 
                float3 TT = normalize( refract( L, N, g_fRefractionIndex ) );
                
                hitSurf = texCUBE( g_samplerRoomCubeMapUVMap, TT );
                // There is a Hit.
                a = 1;
        }
        return float4( hitSurf.xyz, a );
}
//*****************************************************************************

 
        
//-----------------------------------------------------------------------------
// RenderPhotonHit
// This shader uses the PhotonUVTexture as an input.
// It renders as many snippets to the Object's atlas as many pixels the PhotonUVTexture has. 
// If a pixel in the PhotonUVTexture is not connected to the actual Object (not the same ObjectID),
// it will not be rendered.
// The result is blended into the Object's Atlas.
//-----------------------------------------------------------------------------
void RenderPhotonHitVS(
        float4 Pos          : POSITION,
        float4 Color        : COLOR0,
        float2 Tex                  : TEXCOORD0,
    out float4 outhPos      : POSITION,
    //out float2 outTex     : TEXCOORD0,
    out float2 outTexFilter : TEXCOORD1,
    out float  outPower     : TEXCOORD2,
    out float4 outPos       : TEXCOORD3,
    out float4 outColor     : TEXCOORD4 )
{
        // Reads back the PhotonHit's UV position and the ObjectID
        float4 ph = tex2Dlod(g_samplerPhotonUVMap, float4( Tex, 0, 0));

        // This enlarges the snippet's size if it is rendered into a Column's atlas.
        // It is needed because the Column's atlas contains more elements,
        // and the same distance (in world space) is bigger in the Column's atlas.
        if ( g_iObjectID > -0.5 ) Pos *= 3.3f;

        // Adds the snippet's offset to the UV coordinates
        outPos.x  = ph.x + Pos.x / 2.0;
        outPos.y  = ph.y - Pos.y / 2.0; 
        outPos.z = 0;
        outPos.w = 1;

        // Transforms the texture coordinates to screen coordinates
        // and adds the snippet's offset to it
    outhPos.x = ( ph.x * 2 ) - 1 + Pos.x + HALF;
    outhPos.y = 1 - ph.y * 2     + Pos.y - HALF;
    
    // Is it a real Hit? 
    // and are we render the right Object?
    if ( ( ph.a > 0 ) && ( ph.b == g_iObjectID ) )
    {
                // If YES
                outhPos.z = 0;
        }
        // If NO
        else outhPos.z = -100;
        
        outhPos.w = 1;
                
        //outTex = outhPos;
        outTexFilter = Tex;
        outPower = ph.w;
        outColor = Color;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderPhotonHitPS(
                //float2 Tex       : TEXCOORD0,
        float2 TexFilter : TEXCOORD1,
        float  Power     : TEXCOORD2,
        float4 Pos       : TEXCOORD3,
        float4 Color     : TEXCOORD4 ) : COLOR
{
        float4 retColor;
        float4 brdf = float4(0,0,0,0);
        
        // Room or Column?
        if ( g_iObjectID == -1 ) brdf = tex2D(           g_samplerRoomMap, Pos);
        else                                     brdf = tex2D( g_samplerColumnOriginalMap, Pos);
        
        // The Gausian weight of a snippet.
        float4 w = tex2D( g_samplerPowerOfSnippetMap, Color.yz );
        // The color of the snippet's pixel.
        retColor = g_fPower * brdf * w * g_fCausticsIntensity;
        return float4( retColor.xyz, 0 );
}
//*****************************************************************************

    
//-----------------------------------------------------------------------------
// RenderRefractObjectScreen
// This shader calculates the color of the CenterObject with Hit function.
// It has reflection and refraction effect.
// The result is displayed on the screen.
//-----------------------------------------------------------------------------
void RenderRefractObjectScreenVS(
                float4 Pos     : POSITION,
        float3 Normal  : NORMAL,
        float2 Tex         : TEXCOORD0,
    out float4 outhPos : POSITION,
    out float3 outPos  : TEXCOORD1,
    out float3 outN    : TEXCOORD2, 
    out float3 outV    : TEXCOORD3 )
{
    outhPos = mul( Pos, g_mWorldViewProjection );
    outPos  = mul( Pos, g_mWorldCenterObject );
    outN    = normalize( Normal );
    outV    = normalize( outPos - g_vCameraPos3f );
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderRefractObjectScreenPS(
        float3 p0 : TEXCOORD1,
        float3 N  : TEXCOORD2,
        float3 V  : TEXCOORD3 ) : COLOR
{       
        V = normalize( V );
        N = normalize( N ); 

          // Calculates reflection
        float3 R = reflect( V, N );
        float3 RR = Hit(p0, R, g_samplerRoomCubeMapColorDistanceMap);
        
          // Calculates refraction
        float3 T = refract(V, N, g_fRefractionIndex);
        float3 TT = Hit(p0, T, g_samplerRoomCubeMapColorDistanceMap);

          // Calculates reflected color
        float4 hitSurf = texCUBE( g_samplerRoomCubeMapUVMap_NO_FILTER, RR );    // UV position where the Atlas must be read
        float4 reflectColor = float4( 1,0,0,0 );
        if (hitSurf.b == -1) reflectColor = tex2D(    g_samplerRoomLastMap, hitSurf.xy );
        if (hitSurf.b ==  0) reflectColor = tex2D( g_samplerColumnLast0Map, hitSurf.xy );
        if (hitSurf.b ==  1) reflectColor = tex2D( g_samplerColumnLast1Map, hitSurf.xy );
        if (hitSurf.b ==  2) reflectColor = tex2D( g_samplerColumnLast2Map, hitSurf.xy );
        if (hitSurf.b ==  3) reflectColor = tex2D( g_samplerColumnLast3Map, hitSurf.xy );
        
        
          // Calculates refracted color
        hitSurf = texCUBE( g_samplerRoomCubeMapUVMap_NO_FILTER, TT );
        float4 refractColor = float4( 1,0,0,0 );
        if (hitSurf.b == -1) refractColor = tex2D(    g_samplerRoomLastMap, hitSurf.xy );
        if (hitSurf.b ==  0) refractColor = tex2D( g_samplerColumnLast0Map, hitSurf.xy );
        if (hitSurf.b ==  1) refractColor = tex2D( g_samplerColumnLast1Map, hitSurf.xy );
        if (hitSurf.b ==  2) refractColor = tex2D( g_samplerColumnLast2Map, hitSurf.xy );
        if (hitSurf.b ==  3) refractColor = tex2D( g_samplerColumnLast3Map, hitSurf.xy );
        
          // Calculates return color modified by Fresnel function.
        float F = g_fFresnelFactor + ( 1 - g_fFresnelFactor ) * pow( 1 - dot( N, -V ), 5 );
        return float4( F * reflectColor + ( 1 - F ) * refractColor );
}

//*****************************************************************************


//-----------------------------------------------------------------------------
// RenderRefractObjectScreenClassic
// This shader calculates the color of the CenterObject with classical method.
// It has reflection and refraction effect.
// The result is displayed on the screen.
//-----------------------------------------------------------------------------
void RenderRefractObjectScreenClassicVS(
                float4 Pos     : POSITION,
        float3 Normal  : NORMAL,
        float2 Tex         : TEXCOORD0,
    out float4 outhPos : POSITION,
    out float3 outPos  : TEXCOORD1,
    out float3 outN    : TEXCOORD2, 
    out float3 outV    : TEXCOORD3 )
{
    outhPos = mul( Pos, g_mWorldViewProjection );
    outPos  = mul( Pos, g_mWorldCenterObject );
    outN    = normalize( Normal );
    outV    = normalize( outPos - g_vCameraPos3f );
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderRefractObjectScreenClassicPS(
        float3 p0 : TEXCOORD1,
        float3 N  : TEXCOORD2,
        float3 V  : TEXCOORD3 ) : COLOR
{       
        V = normalize( V );
        N = normalize( N ); 

          // Calculates reflection
        float3 RR = reflect( V, N );
        
          // Calculates refraction
        float3 TT = refract(V, N, g_fRefractionIndex);


          // Calculates reflected color
        float4 hitSurf = texCUBE( g_samplerRoomCubeMapUVMap_NO_FILTER, RR );    // UV position where the Atlas must be read
        float3 reflectColor = float4(0,0,0,0);
        if (hitSurf.b == -1) reflectColor = tex2D(    g_samplerRoomLastMap, hitSurf.xy );
        if (hitSurf.b ==  0) reflectColor = tex2D( g_samplerColumnLast0Map, hitSurf.xy );
        if (hitSurf.b ==  1) reflectColor = tex2D( g_samplerColumnLast1Map, hitSurf.xy );
        if (hitSurf.b ==  2) reflectColor = tex2D( g_samplerColumnLast2Map, hitSurf.xy );
        if (hitSurf.b ==  3) reflectColor = tex2D( g_samplerColumnLast3Map, hitSurf.xy );
        
          // Calculates refracted color
        hitSurf = texCUBE( g_samplerRoomCubeMapUVMap_NO_FILTER, TT );
        float3 refractColor = float4(0,0,0,0);
        if (hitSurf.b == -1) refractColor = tex2D(    g_samplerRoomLastMap, hitSurf.xy );
        if (hitSurf.b ==  0) refractColor = tex2D( g_samplerColumnLast0Map, hitSurf.xy );
        if (hitSurf.b ==  1) refractColor = tex2D( g_samplerColumnLast1Map, hitSurf.xy );
        if (hitSurf.b ==  2) refractColor = tex2D( g_samplerColumnLast2Map, hitSurf.xy );
        if (hitSurf.b ==  3) refractColor = tex2D( g_samplerColumnLast3Map, hitSurf.xy );
        
          // Calculates return color modified by Fresnel function.
        float F = g_fFresnelFactor + ( 1 - g_fFresnelFactor ) * pow( 1 - dot( N, -V ), 5 );
        return float4( F * reflectColor + ( 1 - F ) * refractColor, 1 );
}

//*****************************************************************************



//-----------------------------------------------------------------------------
// RenderLightScreen
// This shader renders the light source's object to the screen with a diffuse color.
//-----------------------------------------------------------------------------
void RenderLightScreenVS(
        float4 Pos    : POSITION,
    out float4 outPos : POSITION )
{
    outPos = mul( Pos, g_mWorldViewProjection );
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderLightScreenPS() : COLOR
{
    return float4( 1, 1, 0.7f, 1 );
}
//*****************************************************************************


//-----------------------------------------------------------------------------
// RenderShadow
// This shader calculates the ShadowMapTexture's depth values.
// The result is stored in g_pShadowMapTexture.
//-----------------------------------------------------------------------------
void RenderShadowVS(
                float4 Pos     : POSITION,
    out float4 outhPos : POSITION,
    out float2 outPos  : TEXCOORD1 )
{
    outhPos = mul( Pos, g_mWorldViewProjection );
    outPos  = mul( Pos, g_mLightViewTexBias ).zw;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 RenderShadowPS(
                float2 Pos : TEXCOORD1 ) : COLOR
{
    return float4(Pos.x, 0, 0, 1);
}
//*****************************************************************************


//-----------------------------------------------------------------------------
// FullScreenQuad
// This shader modifies the atlases of Room and Columns.
// It removes the black edges from the atlases.
// The result is stored in the Object's atlas.
//-----------------------------------------------------------------------------
void FullScreenQuadVS(
                float4 Pos     : POSITION,
    out float4 outhPos : POSITION,
    out float2 outTex  : TEXCOORD0 )
{
        outhPos = float4( Pos.xy, 0, 1 );
    outTex.x = Pos.x * 0.5f + 0.5f;
    outTex.y = -Pos.y * 0.5f + 0.5f;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 FullScreenQuadPS(
                float2 Tex : TEXCOORD0 ) : COLOR
{
    float4 preVal = float4(1,1,1,1);
    
    if( g_iObjectID ==-1 ) preVal = FlowLight(    g_samplerRoomModifyMap, Tex );
    if( g_iObjectID == 0 ) preVal = FlowLight( g_samplerColumnModify0Map, Tex );
    if( g_iObjectID == 1 ) preVal = FlowLight( g_samplerColumnModify1Map, Tex );
    if( g_iObjectID == 2 ) preVal = FlowLight( g_samplerColumnModify2Map, Tex );
    if( g_iObjectID == 3 ) preVal = FlowLight( g_samplerColumnModify3Map, Tex );
        
        return preVal;  
}
//*****************************************************************************


//-----------------------------------------------------------------------------
// PhotonMapScreen
// This shader renders the PhotonMap texture (g_txPhotonUVMap) into the screen lower left corner.
// This texture contains the PhotonHits positions and ObjectIDs.
// The result is displayed on the screen.
//-----------------------------------------------------------------------------

void PhotonMapScreenVS(
                float4 Pos     : POSITION,
    out float4 outhPos : POSITION,
    out float2 outTex  : TEXCOORD0 )
{
        outhPos = float4( Pos.xy * 0.2f + float2( -0.7f, -0.7f ), 0, 1 );
    outTex.x = Pos.x * 0.5f + 0.5f;
    outTex.y = -Pos.y * 0.5f + 0.5f;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

float4 PhotonMapScreenPS(
                float2 Tex : TEXCOORD0 ) : COLOR
{
        return tex2D( g_samplerPhotonUVMap, Tex );      
}
//*****************************************************************************





//-----------------------------------------------------------------------------
// TECHNIQUES
// Here are the different Techniques.
//-----------------------------------------------------------------------------

// Technique(AnyRenderPass):
//              VertexShader = compile vs_3_0 AnyRenderPassVS()
//              PixelShader  = compile vs_3_0 AnyRenderPassPS()

// if using the name convention above to name vertex/pixel shaders,
// you can use the following macro definition to quickly define a technique:

// note: ## stands for concatenation

#define Technique(name);                                                                \
        technique name                                                                          \
        {                                                                                                       \
            pass p0                                                                                     \
            {                                                                                           \
                    VertexShader = compile vs_3_0 name##VS();   \
                    PixelShader  = compile ps_3_0 name##PS();   \
                }                                                                                               \
        }
        
Technique( RenderRoomColorDistance );
Technique( RenderRoomUV );
Technique( RenderUmbra );
Technique( RenderRoomAndColumnsScreen );
Technique( RenderLightScreen );
Technique( RenderPhotonUVMap );
Technique( RenderPhotonUVMapClassic );
Technique( RenderPhotonHit );
Technique( RenderRefractObjectScreen );
Technique( RenderRefractObjectScreenClassic );
Technique( RenderShadow );
Technique( FullScreenQuad );
Technique( PhotonMapScreen );