source: GTP/trunk/App/Demos/Illum/HierRayEngine/rayEngine.fx @ 1481

// transformations
float4x4        WorldViewProj;
float4x4        ViewProj;
float4x4        ViewProjI;
float4x4        World;
float4x4        WorldIT;
float3          EyePos;
float3          TilePos;
float           RefractionIndex;
float           colOrder;

#define MIN_RAY_DEPTH   0.01
#define MAX_RAY_DEPTH   200.0
#define RAY_TABLE_SIZE  512.0

float4          ConePeak;
float4          ConeDirAndCosAngle;

texture rayDirTable;
sampler rayDirTableSampler = sampler_state
{
   Texture = <rayDirTable>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;
};

texture rayOriginTable;
sampler rayOriginTableSampler = sampler_state
{
   Texture = <rayOriginTable>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;
};

texture coneDirTable;
sampler coneDirTableSampler = sampler_state
{
   Texture = <coneDirTable>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;
};

texture conePeakTable;
sampler conePeakTableSampler = sampler_state
{
   Texture = <conePeakTable>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;
};

textureCUBE environmentTexture;
sampler environmentSampler = sampler_state
{
   Texture = <environmentTexture>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = None;
};

void PrimaryRaysVS (
                in float4       Pos                     : POSITION,
                in float3       Norm            : NORMAL,
                out float4      hPos            : POSITION,
                out float3      wNorm           : TEXCOORD0,
                out float3      wPos            : TEXCOORD1
                )
{
        hPos = mul(Pos, WorldViewProj);
        wNorm = mul(Norm, WorldIT);
        wPos = mul(Pos, World).xyz;
}

void PrimaryRaysPS (
        in float3       wNorm           : TEXCOORD0,
        in float3       wPos            : TEXCOORD1,
    out float4  Origin          : COLOR0,
    out float4  Dir                     : COLOR1)
{   
        Origin = float4(wPos, 1);
        wNorm = normalize(wNorm);
        float3 ViewDir =  wPos - EyePos;
        ViewDir = normalize(ViewDir);

        float3 refractedDir = refract(ViewDir, wNorm, RefractionIndex);
        if(dot(refractedDir, refractedDir) < 0.5)       //total internal reflection
                refractedDir = reflect(ViewDir, wNorm);

        Dir = float4(refractedDir, colOrder);
        Dir.xyz = normalize(Dir.xyz);
}

struct vsInputCopyBack
{
    float4      Pos                     : POSITION;
    float2      tex                     : TEXCOORD0;    
};

struct vsOutputCopyBack
{
    float4      Pos                     : POSITION;
    float2      tex                     : TEXCOORD0;
};

vsOutputCopyBack
        vsCopyBack(vsInputCopyBack input)
{
    vsOutputCopyBack output = (vsOutputCopyBack)0;
    output.Pos = input.Pos;
    output.tex = input.tex;
    return output;
}

void
        psCopyBack(vsOutputCopyBack input, out float4 c0 : COLOR0, out float4 c1 : COLOR1)
{
        c0 = tex2D(rayOriginTableSampler, input.tex);
        c1 = tex2D(rayDirTableSampler, input.tex);
}

struct vsInputShowTex
{
    float4      Pos                     : POSITION;
    float2      tex                     : TEXCOORD0;    
};

struct vsOutputShowTex
{
    float4      Pos                     : POSITION;
    float2      tex                     : TEXCOORD0;
};

vsOutputShowTex
        vsShowTex(vsInputShowTex input)
{
    vsOutputShowTex output = (vsOutputShowTex)0;
    output.Pos = input.Pos;
    output.tex = input.tex;

    return output;
}

float4
        psShowTex(vsOutputShowTex input) : COLOR0
{   
//      return abs(float4(tex2D(rayDirTableSampler, input.tex).xyz, 1));
        return float4(tex2D(rayOriginTableSampler, input.tex).xyz, 1);
//      return abs(float4(tex2D(conePeakTableSampler, input.tex).xyz, 1));      
//      return float4(1,1,0,1); 
//      return float4(input.tex.x,input.tex.y,0,1);     
//      return float4(1.0 - acos(tex2D(coneDirTableSampler, input.tex).aaa) / 3.14, 1); 
//       + float4(0, 0.7, 0, 0);
//              +       float4(tex2D(rayDirTableSampler, input.tex).xyz, 1);
        float3 relfDir = tex2D(rayDirTableSampler, input.tex);
        return float4((relfDir.x +1) / 2,
                (relfDir.y + 1) / 2,
                (relfDir.z + 1) / 2,   1);
}

void RayCastVS(
        in float4       Sphere          : POSITION,
    in float3   PlanePos        : NORMAL,
    in float3   Invmx0          : TEXCOORD0,
    in float3   Invmx1          : TEXCOORD1,
    in float3   Invmx2          : TEXCOORD2,
    in float3   Normals0        : TEXCOORD3,
        in float3       Normals1        : TEXCOORD4,
        in float3       Normals2        : TEXCOORD5,
        
        out float4      hPos            : POSITION,
        out float3      oPlanePos       : TEXCOORD6,
    out float3  oInvmx0         : TEXCOORD0,
    out float3  oInvmx1         : TEXCOORD1,
    out float3  oInvmx2         : TEXCOORD2,
    out float3  oNormals0       : TEXCOORD3,
        out float3      oNormals1       : TEXCOORD4,
        out float3      oNormals2       : TEXCOORD5
        )
{
        oPlanePos = PlanePos;
        oInvmx0 = Invmx0;
        oInvmx1 = Invmx1;
        oInvmx2 = Invmx2;
        oNormals0 = Normals0;
        oNormals1 = Normals1;
        oNormals2 = Normals2;

        hPos = float4(TilePos, 1);

        ConeDirAndCosAngle.xyz = mul(WorldIT, float4(ConeDirAndCosAngle.xyz, 0));
        ConePeak.xyz = mul(WorldIT, float4(ConePeak.xyz, 1));

        float3 sfc = Sphere.xyz - ConePeak.xyz;
        float lsfc = length(sfc);

        if(Sphere.w < lsfc)     // cone peak not in sphere
        {
                // angle difference between cone main direction and direction to sphere centre
                float angSpMidConeMid = acos(dot(ConeDirAndCosAngle.xyz, sfc) / lsfc);
                // the half of the opening angle at which the sphere is seen
                float angSpRad = asin(Sphere.w / lsfc);
                // cone opening angle
                float angCone = acos(ConeDirAndCosAngle.w);
                
                // if sphere direction not within (cone direction + sphere angle), discard tile for this triangle
                if(angCone + angSpRad < angSpMidConeMid)
                {
                        hPos = float4(10000000.0, 10000000.0, 10000000.0, 1.0);
                }
        }
}

void
        RayCastPS(
//              in float3       PlanePos        : TEXCOORD6,
                in float3       Invmx0          : TEXCOORD0,
                in float3       Invmx1          : TEXCOORD1,
                in float3       Invmx2          : TEXCOORD2,
                in float3       Normals0        : TEXCOORD3,
                in float3       Normals1        : TEXCOORD4,
                in float3       Normals2        : TEXCOORD5,
        
                in float2       vPos            : VPOS,
                out float4      oOrigin         : COLOR0,
                out float4      oDir            : COLOR1,
                out float1      oDepth          : DEPTH)
{   

        float3  PlanePos = Invmx0 + Invmx1 + Invmx2;
        PlanePos /= dot(PlanePos, PlanePos);

        float2 pixpos = vPos.xy;
        pixpos /= RAY_TABLE_SIZE;       // to texture coordinates
        float3 rayOrigin = tex2D(rayOriginTableSampler, pixpos.xy);
        rayOrigin = mul(WorldIT, float4(rayOrigin, 1));
        float3 rayDir = tex2D(rayDirTableSampler, pixpos.xy);
        rayDir = mul(WorldIT, float4(rayDir, 0));
        
        float hitDepth = (dot(PlanePos, PlanePos) - dot(rayOrigin, PlanePos)) / dot(rayDir, PlanePos);
        if(hitDepth < MIN_RAY_DEPTH || hitDepth > MAX_RAY_DEPTH)
        {       
                oDepth = 1000000.0;
                oOrigin = oDir = 0;
        }
        else
        {
                float3 hitPoint = rayOrigin + (rayDir * hitDepth);

                float3 worldDist = mul(float4(hitPoint - rayOrigin, 0), World).xyz;
                 
                oDepth = length(worldDist)  / MAX_RAY_DEPTH;

                float baryA = dot(Invmx0, hitPoint);
                float baryB = dot(Invmx1, hitPoint);
                float baryC = dot(Invmx2, hitPoint);
                if(baryA > -0.001 && baryB > -0.001 && baryC > -0.001)
                {
                        oOrigin = mul(float4(hitPoint, 1), World);
                        
                        float3 normalAtHitPoint = Normals0 * baryA;
                        normalAtHitPoint += Normals1 * baryB;
                        normalAtHitPoint += Normals2 * baryC;
                        normalAtHitPoint = normalize(normalAtHitPoint);
                        if(dot(normalAtHitPoint, rayDir) > 0)
                        {
                                normalAtHitPoint = -normalAtHitPoint;
                                RefractionIndex = 1.0 / RefractionIndex;        // exiting ray
                        }
                        float3 refractedDir = refract(rayDir, normalAtHitPoint, RefractionIndex);
                        if(dot(refractedDir, refractedDir) < 0.5)       // total internal reflection
                                refractedDir = reflect(rayDir, normalAtHitPoint);
                        oDir = float4( mul(float4(refractedDir,0), World).xyz, 1);
                }
                else
                {
                        oOrigin = float4(10.0, 0, 0, 1);
                        oDir = float4(10.0, 0, 0, 1);
                        oDepth = 1000000.0;
                }
        }
}


struct vsInputBackGround
{
    float4 Pos  : POSITION; //Pos
    float2 tex  : TEXCOORD0;
};

struct vsOutputBackGround
{
    float4 Pos  : POSITION; //Pos
        float2 tex      : TEXCOORD0;
    float3 wPos : TEXCOORD1;
};

vsOutputBackGround vsBackground(vsInputBackGround input){
    vsOutputBackGround output = (vsOutputBackGround)0;
    output.Pos=input.Pos;
    float4 worldpos = mul(input.Pos, ViewProjI);
    worldpos /= worldpos.w;
    output.wPos = worldpos.xyz;
    output.tex = input.tex;
    return output;
}

void psBackground(vsOutputBackGround input, out float4 o0 : COLOR0) 
{   
        float4 dird = tex2D(rayDirTableSampler, input.tex);
        float3 Dir = dird.xyz;
        float3 col = 1 ;
                                                /*float3(pow(0.7, frac(dird.w / 10.0) * 10.0) ,
                                                pow(0.7, frac(dird.w / 100.0) * 10.0) ,
                                                pow(0.7, frac(dird.w / 1000.0) * 10.0));*/
        if(dot(Dir, Dir) < 0.5)
        {
                Dir = normalize(input.wPos.xyz - EyePos.xyz);
                col = float3(4, 4, 4);
        }
        o0 = float4(texCUBE(environmentSampler, Dir).xyz * col * 1.1, 0.0);
//      o0 = float4(dird.w / 5.0, dird.w / 2.0, dird.w / 10.0, 1.0);
        
//      o0 = float4(input.tex.x, input.tex.y, 1.0, 1.0);
}


void ConeVS(
    in float4   Pos                     : POSITION,
    in float2   Tex                     : TEXCOORD0,
    out float4  oPos            : POSITION,
    out float2  oTex            : TEXCOORD0
    )
{
    oPos = Pos;
    oTex = Tex;
}

void
        ConePS(
                in float2       Tex             : TEXCOORD0,
                out float4      oConePeak       : COLOR0,
                out float4      oConeDir                : COLOR1)
{
        float3 peak = 0;
        float3 dir = 0;
        float cosAngle = 1.0;
        float sinAngle = 0.0;
        for(int i=0; i < 16; i++)
                for(int j=0; j < 16; j++)
                {
                        float3 currentRayDir = tex2D(rayDirTableSampler, Tex + float2((float)j/RAY_TABLE_SIZE, (float)i/RAY_TABLE_SIZE));
                        if(dot(currentRayDir, currentRayDir) > 0.5) // a valid ray
                        {
                                float3 currentRayOrigin = tex2D(rayOriginTableSampler, Tex + float2((float)j/RAY_TABLE_SIZE, (float)i/RAY_TABLE_SIZE));
                                if(dot(dir,dir) < 0.5) // no valid ray found before this one
                                {
                                        dir = currentRayDir;
                                        peak = currentRayOrigin;
                                }
                                else
                                {
                                        float ncos = dot(currentRayDir,dir);
                                        if(ncos < cosAngle)
                                        {
                                                float3 perpdir = normalize(currentRayDir - ncos * dir);
                                                float3 farConeEdge = cosAngle * dir - sinAngle * perpdir;
                                                dir = farConeEdge + currentRayDir;
                                                dir = normalize(dir);
                                                cosAngle = dot(dir, currentRayDir);
                                                sinAngle = sqrt(1.0 - cosAngle * cosAngle);
                                        }
                                        float3 pd = currentRayOrigin - peak;
                                        float3 ptop = normalize(pd);
                                        float cospp = dot(dir, ptop);
                                        if(cospp < cosAngle)
                                        {
                                                float3 perpdir = ptop - cospp * dir;
                                                perpdir = normalize(perpdir);
                                                float3 farConeEdge = (cosAngle * dir - sinAngle * perpdir);
                                                float3 nearConeEdge = (cosAngle * dir + sinAngle * perpdir);
                                                float3 g = currentRayOrigin - peak - nearConeEdge * dot(nearConeEdge, pd);
                                                peak += farConeEdge * dot(g,g) / dot(farConeEdge, g);
                                        }
                                }
                        }
                }
        oConePeak = float4(peak, 1.0);
        oConeDir = float4(dir, cosAngle);
        if(dot(dir, dir) < 0.5) // no valid rays in tile
        {
                //cone far away not intersecting anything
                oConePeak = float4(1000000.0, 0 , 0, 0.0);
                oConeDir = float4(1, 0, 0, 1.0);
        }
}


technique RenderPrimaryRayArray{
        pass P0
    {
        VertexShader = compile vs_3_0 PrimaryRaysVS();
        PixelShader  = compile ps_3_0 PrimaryRaysPS();
    }
}

technique RayCast{
        pass P0
    {
        VertexShader = compile vs_3_0 RayCastVS();
        PixelShader  = compile ps_3_0 RayCastPS();
    }
}

technique ShowTex{
        pass P0
    {
        VertexShader = compile vs_2_0 vsShowTex();
        PixelShader  = compile ps_2_0 psShowTex();
    }
}

technique Background{
        pass P0
    {
        VertexShader = compile vs_2_0 vsBackground();
        PixelShader  = compile ps_2_0 psBackground();
    }
}

technique CopyBack{
        pass P0
    {
        VertexShader = compile vs_2_0 vsCopyBack();
        PixelShader  = compile ps_2_0 psCopyBack();
    }
}

technique ComputeCones{
        pass P0
    {
        VertexShader = compile vs_3_0 ConeVS();
        PixelShader  = compile ps_3_0 ConePS();
    }
}