source: GTP/trunk/App/Demos/Illum/IBRBillboardCloudTrees/3dsMax/indirectTexturing/indirectTexturingLighting.fx @ 954

// This is used by 3dsmax to load the correct parser
string ParamID = "0x0";

//DxMaterial specific 

// light direction (view space)
float3 g_LightDir : Direction <  
        string UIName = "Light"; 
        string Object = "TargetLight";
        int refID = 0;
> = {-0.577, -0.577, 0.577};

float4 g_LightCol : LIGHTCOLOR
<
        int LightRef = 0;
> = float4(0.0f, 0.0f, 0.0f, 0.0f);

// material reflectivity
float4 k_a  <
        string UIName = "Ambient";
> = float4( 0.47f, 0.47f, 0.47f, 1.0f );    // ambient
        
float4 k_d  <
        string UIName = "Diffuse";
> = float4( 0.47f, 0.47f, 0.47f, 1.0f );    // diffuse
        
float4 k_s  <
        string UIName = "Specular";
> = float4( 1.0f, 1.0f, 1.0f, 1.0f );    // diffuse    // specular

int n<
        string UIName = "Specular Power";
        string UIType = "IntSpinner";
        float UIMin = 0.0f;
        float UIMax = 50.0f;    
>  = 15;

bool g_AlphaVertex <
        string UIName = "Vertex Alpha";
> = true;

bool g_AddVertexColor <
        string UIName = "Add Vertex Color";
> =false;

bool g_UseParallax <
        string UIName = "Normal Map Parallax";
> =false;

float g_BumpScale <
        string UIName = "Bump Amount";
        float UIMin = 0.0f;
        float UIMax = 5.0f;
        float UIStep = 0.01f;
>   = 1.0f;


float g_ParallaxScale <
        string UIName = "Parallax Scale";
        float UIMin = -0.50f;
        float UIMax = 0.5f;
        float UIStep = 0.01f;
>   = 0.02f;
                                                                        
float g_ParallaxBias <
        string UIName = "Parallax Bias";
        float UIMin = -0.5f;
        float UIMax = 0.5f;
        float UIStep = 0.01f;
>   = 0.0f;

bool g_AmbientOccEnable <
        string UIName = "Ambient Occlusion Enable";
> = false;

texture g_AmbientOccTexture < 
        string UIName = "Ambient Occlusion";
>;

bool g_TopDiffuseEnable <
        string UIName = "Top Diffuse Color Enable";
> = false;

texture g_TopTexture : DiffuseMap< 
        string UIName = "Top Diffuse Map ";
>;

bool g_BottomDiffuseEnable <
        string UIName = "Bottom Diffuse Color Enable";
> = false;

texture g_BottomTexture < 
        string UIName = "Bottom Diffuse";
>;

bool g_SpecularEnable <
        string UIName = "Specular  Enable";
> = false;

texture g_SpecularTexture < 
        string UIName = "Specular";
>;

bool g_NormalEnable <
        string UIName = "Normal Enable";
> = false;

texture g_NormalTexture < 
        string UIName = "Normal";
>;

bool g_ReflectionEnable <
        string UIName = "Reflection Enable";
> = false;

texture g_ReflectionTexture < 
        string UIName = "Reflection";
        string Type = "CUBE";
>;


sampler2D g_AmbientOccSampler = sampler_state
{
        Texture = <g_AmbientOccTexture>;
        MinFilter = Linear;
        MagFilter = Linear;
        MipFilter = Linear;
};


sampler2D g_TopSampler = sampler_state
{
        Texture = <g_TopTexture>;
        MinFilter = Linear;
        MagFilter = Linear;
        MipFilter = Linear;
};
        
sampler2D g_BottomSampler = sampler_state
{
        Texture = <g_BottomTexture>;
        MinFilter = Linear;
        MagFilter = Linear;
        MipFilter = Linear;
};

sampler2D g_SpecularSampler = sampler_state
{
        Texture = <g_SpecularTexture>;
        MinFilter = Linear;
        MagFilter = Linear;
        MipFilter = Linear;
};

sampler2D g_NormalSampler = sampler_state
{
        Texture = <g_NormalTexture>;
        MinFilter = Linear;
        MagFilter = Linear;
        MipFilter = Linear;
};

samplerCUBE g_ReflectionSampler = sampler_state
{
        Texture = <g_ReflectionTexture>;
        MinFilter = Linear;
        MagFilter = Linear;
        MipFilter = Linear;
};

// light direction (view space)

// transformations
float4x4 World      :           WORLD;
float4x4 View       :           VIEW;
float4x4 Projection :           PROJECTION;
float4x4 WorldViewProj :        WORLDVIEWPROJ;
float4x4 WorldView :            WORLDVIEW;
float3  g_CamPos        :       WORLDCAMERAPOSITION;

int color0 : Color
<
   int Color = 0;
   int VertexColor = 0;
>;

int texcoord0 : Texcoord
<
   int Texcoord = 0;
   int MapChannel = 0;
>;

int texcoord1 :Texcoord
<
   int Texcoord = 1;
   int MapChannel = 1;
   bool ColorChannel = true;
>;

int texcoord2 : Texcoord
<
        int Texcoord = 2;
        int MapChannel = 2;
>;

int texcoord3 : Texcoord
<
        int Texcoord = 3;
        int MapChannel = 3;
>;

int texcoord4 : Texcoord
<
        int Texcoord = 4;
        int MapChannel = 4;
>;

int texcoord5 : Texcoord
<
        int Texcoord = 5;
        int MapChannel = 5;
>;

int texcoord6 : Texcoord
<
        int Texcoord = 6;
        int MapChannel = 6;
>;

int texcoord7 : Texcoord
<
        int Texcoord = 7;
        int MapChannel = 7;
>;

float3 NormalCalc(float3 mapNorm, float BumpScale)
{
        float3 v = {0.5f,0.5f,1.0f};
        mapNorm = lerp(v, mapNorm, BumpScale );
        mapNorm = ( mapNorm * 2.0f ) - 1.0f;
        return mapNorm;
}

struct VSIn
{
        float3 Position         : POSITION;
        float3 Normal           : NORMAL;
        float3 Tangent          : TANGENT;
        float3 BiNormal         : BINORMAL;
        float3 Col              : COLOR0;
        float2 UV0              : TEXCOORD0;    
        float4 Colour           : TEXCOORD1;
        float3 Alpha            : TEXCOORD2;
        float3 Illum            : TEXCOORD3;
        float3 UV1              : TEXCOORD4;
        float3 UV2              : TEXCOORD5;
        float3 UV3              : TEXCOORD6;
        float3 UV4              : TEXCOORD7;

};

struct VSOut
{
        float4 Position         : POSITION;
        float4 Colour           : COLOR0;
        float2 UV0              : TEXCOORD0;
        float3 LightDir         : TEXCOORD1;
        float3 Normal           : TEXCOORD2;
        float3 ViewDir          : TEXCOORD3;
        float2 UV1              : TEXCOORD4;
        float2 UV2              : TEXCOORD5;
        float2 UV3              : TEXCOORD6;
        float2 UV4              : TEXCOORD7;
        
};

struct PSIn
{
        float4 Colour           : COLOR0;
        float2 UV0              : TEXCOORD0;
        float3 LightDir         : TEXCOORD1;
        float3 Normal           : TEXCOORD2;
        float3 ViewDir          : TEXCOORD3;
        float2 UV1              : TEXCOORD4;
        float2 UV2              : TEXCOORD5;
        float2 UV3              : TEXCOORD6;
        float2 UV4              : TEXCOORD7;

};

struct PSOut
{
        float4 Colour           : COLOR0;
};

texture it
< 
  string UIName = "Indirect Texture";   
>;
        
texture st 
< 
  string UIName = "Source Texture";     
>;

sampler2D indirectTexture = sampler_state
{
        Texture = <it>;
        MinFilter = POINT;
        MagFilter = POINT;
        MipFilter = NONE;
};


sampler2D sourceTexture = sampler_state
{
        Texture   = <st>;
        MinFilter = LINEAR;
        MagFilter = LINEAR;
        MipFilter = NONE;
};

VSOut VS(VSIn In)
{
    VSOut Out = (VSOut)0;

    Out.Position  = mul(float4(In.Position, 1.0),WorldViewProj);
    Out.Colour = float4(In.UV0.xy, 0.0, 1.0);
    Out.Normal = In.Normal;

    float4 WorldPos = mul(float4(In.Position, 1.0f),World);
    float3 ViewDir = g_CamPos - WorldPos.xyz;

    if(g_NormalEnable)
    {
        float3x3 objToTangent;

        objToTangent[0] = In.BiNormal;
        objToTangent[1] = In.Tangent;
        objToTangent[2] = In.Normal;
                
        Out.LightDir = mul(objToTangent, g_LightDir);
        Out.ViewDir = mul(objToTangent, ViewDir);               
    }
    else
    {
        Out.LightDir = g_LightDir;
        Out.ViewDir = ViewDir;
    }

    Out.UV0 = In.UV0.xy;
    Out.UV1 = In.Colour.xy;
    Out.UV2 = In.UV2;
    Out.UV3 = In.UV3;
    Out.UV4 = In.UV4;

    return Out;
    
}

float epsilonX <
        string UIName = "Epsilon X";
        float UIMin = -0.50f;
        float UIMax = 0.5f;
        float UIStep = 0.001f;
>   = 0.02f;

float epsilonY <
        string UIName = "Epsilon X";
        float UIMin = -0.50f;
        float UIMax = 0.5f;
        float UIStep = 0.001f;
>   = 0.02f;

float sourceTextureSize <
        string UIName = "Source Texture Size";
        float UIMin = 0.0f;
        float UIMax = 1024.0f;
        float UIStep = 1.0f;
>   = 16.0f;

float sqrtNumSamples <
        string UIName = "SQRT Num.Samples";
        float UIMin = 0.0f;
        float UIMax = 64.0f;
        float UIStep = 1.0f;
>   = 4.0f;

PSOut PS( PSIn psIn )
{
   PSOut psOut;

   psOut.Colour = float4(0.0, 0.0, 0.0, 0.0);
   float2 epsilon = float2(epsilonX, epsilonY);
   float4 value = tex2D(indirectTexture, psIn.UV1.xy).xyzw;
   float2 coords = float2(0.0, 1.0) - abs(psIn.UV0.xy - ( value.xy - epsilon ) );

   if (value.w != 0.0) 
   {   
        float3 BottomCol = k_d.rgb; 
        float4 TopCol = k_d; 
        float3 LightCol = float3(1.0,1.0,1.0);
        float3 Normal = normalize(psIn.Normal);
        float3 LightDir = normalize(psIn.LightDir); 
        float3 ViewDir = normalize(psIn.ViewDir);
        float3 Ambient = k_a.rgb;
        float3 SpecLevel = float3(1.0,1.0,1.0);
        float Alpha; 
        
        float2 normalUV = psIn.UV4;
        
        float4 newCol;
        
        //if(g_AmbientOccEnable)
        //      Ambient *= tex2D(g_AmbientOccSampler, psIn.UV1);




        //if(g_BottomDiffuseEnable)
        //      BottomCol = tex2D(g_BottomSampler, psIn.UV2);
        

        //if(g_AlphaVertex)
        //      Alpha = psIn.Colour.a;
        //else
        //      Alpha = TopCol.a;
                
        //if(g_UseParallax)
        //{
        //      float height = tex2D(g_NormalSampler, psIn.UV4 ).a;
        //      float Altitude = height + g_ParallaxBias; 
        //      normalUV  = Altitude * g_ParallaxScale*ViewDir;
        //      normalUV +=  psIn.UV4;          
        //}
                
        //if(g_NormalEnable)
        //      Normal = NormalCalc(tex2D(g_NormalSampler, normalUV).xyz, g_BumpScale);
                
        //if(g_SpecularEnable)
        //      SpecLevel = tex2D(g_SpecularSampler, psIn.UV3).xyz;


        if(g_TopDiffuseEnable)
        {
                float2 newcoord = (float2(1.0, 1.0) - value.zw) + ((coords * sourceTextureSize) / sqrtNumSamples);
                //TopCol = float4(tex2D(sourceTexture, newcoord).xyzw);
                newCol = float4(tex2D(sourceTexture, newcoord).xyzw);           
                psOut.Colour.a = newCol.w;
        }

        //newCol.rgb = TopCol * Alpha;
        //newCol.rgb += BottomCol * (1.0f - Alpha);
        //if(g_AddVertexColor)
        //      newCol.rgb *= psIn.Colour.rgb;
        
        // Original version             
        //psOut.Colour.rgb = (Ambient + (g_LightCol * saturate(dot(Normal, LightDir)))) * newCol.rgb;           
        psOut.Colour.rgb = (Ambient + (g_LightCol * ( clamp(dot(Normal, LightDir), 0.0, 1.0) + clamp(-dot(Normal, LightDir), 0.0, 1.0) ) )) * newCol.rgb;               

        //if(g_ReflectionEnable)
        //{
        //      float3 CUV = normalize( reflect( ViewDir, Normal));
        //      float4 env = texCUBE(g_ReflectionSampler, CUV);
        //      psOut.Colour.rgb += env.rgb; 
        //}
        

        //float3 H = normalize(LightDir + ViewDir);
        //float Specular = pow(saturate(dot(Normal, H)), n);
        //psOut.Colour.rgb += (k_s.rgb * Specular) * SpecLevel.rgb;
   }
   
   return psOut;
}

technique indirectTexturing
{
    pass P0
    {
        //ZEnable = true;
        //ZWriteEnable = true;
        CullMode = NONE;
        AlphaFunc = GREATEREQUAL;
        AlphaRef = 0x110;
        AlphaBlendEnable = FALSE;
        AlphaTestEnable = TRUE;

        // shaders
        
        VertexShader = compile vs_1_1 VS();
        PixelShader = compile ps_2_0 PS();
    }  
}