source: data/branches/Shader_HS18/programs/Cg/Example_BumpMapping.cg @ 12216

// General functions

// Expand a range-compressed vector
float3 expand(float3 v)
{
        return (v - 0.5) * 2;
}


/* Bump mapping vertex program
   In this program, we want to calculate the tangent space light vector
   on a per-vertex level which will get passed to the fragment program,
   or to the fixed function dot3 operation, to produce the per-pixel
   lighting effect. 
*/
void main_vp(float4 position    : POSITION,
                         float3 normal          : NORMAL,
                         float2 uv                      : TEXCOORD0,
                         float4 tangent     : TANGENT,
                         // outputs
                         out float4 oPosition    : POSITION,
                         out float2 oUv                  : TEXCOORD0,
                         out float3 oTSLightDir  : TEXCOORD1,
                         // parameters
                         uniform float4 lightPosition, // object space
                         uniform float4x4 worldViewProj)
{
        // calculate output position
        oPosition = mul(worldViewProj, position);

        // pass the main uvs straight through unchanged
        oUv = uv;

        // calculate tangent space light vector
        // Get object space light direction
        // Non-normalised since we'll do that in the fragment program anyway
        float3 lightDir = lightPosition.xyz -  (position * lightPosition.w);

        // Calculate the binormal (NB we assume both normal and tangent are
        // already normalised)
        // NB looks like nvidia cross params are BACKWARDS to what you'd expect
        // this equates to NxT, not TxN

#if TANGENTS_HAVE_PARITY
        float3 binormal = cross(tangent.xyz, normal) * tangent.www;
#else
        // fixed handedness
        float3 binormal = cross(tangent.xyz, normal);
#endif
        
        // Form a rotation matrix out of the vectors
        float3x3 rotation = float3x3(tangent.xyz, binormal, normal);
        
        // Transform the light vector according to this matrix
        oTSLightDir = mul(rotation, lightDir);
        
        
}

/* Bump mapping vertex program for shadow receiving
   In this program, we want to calculate the tangent space light vector
   on a per-vertex level which will get passed to the fragment program,
   or to the fixed function dot3 operation, to produce the per-pixel
   lighting effect. 
*/
void main_shadowreceiver_vp(float4 position     : POSITION,
                         float3 normal          : NORMAL,
                         float2 uv                      : TEXCOORD0,
                         float3 tangent     : TANGENT,
                         
                         // outputs
                         out float4 oPosition    : POSITION,
                         out float4 uvproj               : TEXCOORD0,
                         out float2 oUv                  : TEXCOORD1,
                         out float3 oTSLightDir  : TEXCOORD2,
                         
                         // parameters
                         uniform float4 lightPosition, // object space
                         uniform float4x4 worldViewProj,
                         uniform float4x4 worldMatrix,
                         uniform float4x4 texViewProj)
{
        // calculate output position
        oPosition = mul(worldViewProj, position);

        // pass the main uvs straight through unchanged
        oUv = uv;

        // calculate tangent space light vector
        // Get object space light direction
        // Non-normalised since we'll do that in the fragment program anyway
        float3 lightDir = lightPosition.xyz -  (position * lightPosition.w);

        // Calculate the binormal (NB we assume both normal and tangent are
        // already normalised)
        // NB looks like nvidia cross params are BACKWARDS to what you'd expect
        // this equates to NxT, not TxN
        float3 binormal = cross(tangent, normal);
        
        // Form a rotation matrix out of the vectors
        float3x3 rotation = float3x3(tangent.xyz, binormal, normal);
        
        // Transform the light vector according to this matrix
        oTSLightDir = mul(rotation, lightDir);

        // Projection
    uvproj = mul(worldMatrix, position);
        uvproj = mul(texViewProj, uvproj);
        
}


void main_fp( float4 position   : POSITION, 
        float2 uv                       : TEXCOORD0,
                          float3 TSlightDir : TEXCOORD1,

                          out float4 colour     : COLOR,

                          uniform float4 lightDiffuse,
                          uniform sampler2D   normalMap : register(s0))
{
        // retrieve normalised light vector, expand from range-compressed
        float3 lightVec = normalize(TSlightDir).xyz;

        // get bump map vector, again expand from range-compressed
        float3 bumpVec = expand(tex2D(normalMap, uv).xyz);

        // Calculate dot product
        colour = lightDiffuse * dot(bumpVec, lightVec);
        
}

void main_shadowreceiver_fp( float4 position    : POSITION,
                          float4 uvproj         : TEXCOORD0,
                          float2 uv                     : TEXCOORD1,
                          float3 TSlightDir : TEXCOORD2,

                          out float4 colour     : COLOR,

                          uniform float4 lightDiffuse,
                          uniform sampler2D   shadowMap : register(s0),
                          uniform sampler2D   normalMap : register(s1))
{


        // retrieve normalised light vector, expand from range-compressed
        float3 lightVec = expand(normalize(TSlightDir).xyz);

        // get bump map vector, again expand from range-compressed
        float3 bumpVec = expand(tex2D(normalMap, uv).xyz);

        // get shadow value
        float3 shadow = tex2Dproj(shadowMap, uvproj).xyz;

        // Calculate dot product
        colour = float4(shadow * lightDiffuse * dot(bumpVec, lightVec), 1.0f);
        
}

/* Vertex program which includes specular component */
void specular_vp(float4 position        : POSITION,
                                 float3 normal          : NORMAL,
                                 float2 uv                      : TEXCOORD0,
                                 float3 tangent     : TANGENT,
                                 // outputs
                                 out float4 oPosition    : POSITION,
                                 out float2 oUv                  : TEXCOORD0,
                                 out float3 oTSLightDir  : TEXCOORD1,
                                 out float3 oTSHalfAngle : TEXCOORD2,
                                 // parameters
                                 uniform float4 lightPosition, // object space
                                 uniform float3 eyePosition,   // object space
                                 uniform float4x4 worldViewProj)
{
        // calculate output position
        oPosition = mul(worldViewProj, position);

        // pass the main uvs straight through unchanged
        oUv = uv;

        // calculate tangent space light vector
        // Get object space light direction
        float3 lightDir = normalize(lightPosition.xyz -  (position * lightPosition.w));

        // Calculate the binormal (NB we assume both normal and tangent are
        // already normalised)
        // NB looks like nvidia cross params are BACKWARDS to what you'd expect
        // this equates to NxT, not TxN
        float3 binormal = cross(tangent, normal);
        
        // Form a rotation matrix out of the vectors
        float3x3 rotation = float3x3(tangent, binormal, normal);
        
        // Transform the light vector according to this matrix
        oTSLightDir = mul(rotation, lightDir);

        // Calculate half-angle in tangent space
        float3 eyeDir = normalize(eyePosition - position.xyz);
        float3 halfAngle = normalize(eyeDir + lightDir);
        oTSHalfAngle = mul(rotation, halfAngle);
        
        
}

/* Fragment program which supports specular component */
void specular_fp( float4 position       : POSITION, 
        float2 uv                       : TEXCOORD0,
                          float3 TSlightDir : TEXCOORD1,
                          float3 TShalfAngle: TEXCOORD2,

                          out float4 colour     : COLOR,

                          uniform float4 lightDiffuse,
                          uniform float4 lightSpecular,
                          uniform sampler2D   normalMap : register(s0)) 
{
        // retrieve normalised light vector
        float3 lightVec = normalize(TSlightDir);

        // retrieve half angle and normalise
        float3 halfAngle = normalize(TShalfAngle);

        // get bump map vector, again expand from range-compressed
        float3 bumpVec = expand(tex2D(normalMap, uv).xyz);

        // Pre-raise the specular exponent to the eight power
        float specFactor = pow(saturate(dot(bumpVec, halfAngle)), 4);
        

        // Calculate dot product for diffuse
        colour = (lightDiffuse * saturate(dot(bumpVec, lightVec))) + 
                        (lightSpecular * specFactor);
        
}