source: GTP/trunk/App/Demos/Illum/IBRBillboardCloudTrees/OGRE/IBRTreesOGRE/media/oldgeneral/tree_idtexturing_directional_vp.cg @ 1493

/*
void main_vp(
      float4 position: POSITION,
      float4 normal: NORMAL,
      float2 texCoord : TEXCOORD0,

      out float3 lightpos : TEXCOORD3,
      out float3 eyePosition : TEXCOORD2,
      out float4 oPosition: POSITION,
      out float2 otexCoord : TEXCOORD0,
      //out float3 otexPos : TEXCOORD1,
      out float3 V : TEXCOORD1,
      out float3 L : TEXCOORD4,
      uniform float4 lightposition,             // world space
      uniform float4 cameraposition,            // world space
      uniform float3 camPosition : TEXCOORD2,   
      uniform float3 lightposi : TEXCOORD3,
      uniform float4x4 worldviewproj,
      uniform float4x4 worldmatrix,
      uniform float4x4 invworldmatrix,
      uniform float4x4 viewmatrix,
      uniform float4x4 projmatrix,
      uniform float4x4 viewprojmatrix,
      uniform float4x4 worldviewmatrix
      )
{
        oPosition = mul(worldviewproj,position);
        float4 pos = mul(worldviewmatrix,position);

        //float4 campos = mul(viewmatrix,float4(camPosition,1.0));
        float4 campos = mul(viewmatrix,cameraposition);
        eyePosition = campos.xyz;
        
        float4 lightp = mul(viewmatrix,float4(lightposi,1.0));
        //float4 lightp = mul(viewmatrix,lightposition);
        lightpos = lightp.xyz;

        V = -pos.xyz;
        L = lightpos - pos.xyz;

        otexCoord = texCoord;
}
*/
/*
void main_vp(
      float4 position : POSITION,
      float4 normal : NORMAL,
      float2 texCoord : TEXCOORD0,
      float2 texCoordNormalized : TEXCOORD1,

      out float4 oPosition : POSITION,
      out float2 otexCoord : TEXCOORD0,
      out float2 otexCoordNormalized : TEXCOORD1,
      uniform float4x4 worldviewproj
      )
{
        oPosition = mul(worldviewproj,position);
        otexCoord = texCoord;
        otexCoordNormalized = texCoordNormalized;
}
*/




struct VS_OUTPUT {
   float4 Pos:       POSITION;
   float3 normal:    TEXCOORD0;
   float3 lightVec : TEXCOORD1;
   float3 viewVec:   TEXCOORD2;
   float4 shadowCrd: TEXCOORD3;
   float2 texCoord:  TEXCOORD4;
   float2 texCoordNormalized: TEXCOORD5;
};

void main_vp(
      float4 position : POSITION,
      float4 normal : NORMAL,
      float2 texCoord : TEXCOORD0,
      float2 texCoordNormalized : TEXCOORD1,

      uniform float distanceScale,
      uniform float4 lightPosition,
      uniform float4 lightDirection,
      uniform float4 camera_pos,
      uniform float4x4 worldviewproj,
      uniform float4x4 proj_matrix,
      uniform float time_0_X,

      out float4 opos:       POSITION,
      out float3 onormal:    TEXCOORD0,
      out float3 olightVec : TEXCOORD1,
      out float3 oviewVec:   TEXCOORD2,
      out float4 oshadowCrd: TEXCOORD3,
      out float2 otexCoord:  TEXCOORD4,
      out float2 otexCoordNormalized: TEXCOORD5
      )
{
        opos = mul(worldviewproj, position);
        // World-space lighting
        onormal = normal;
        //olightVec = distanceScale * (lightPosition - position.xyz);
        olightVec = distanceScale * -lightDirection;
        oviewVec = camera_pos - position.xyz;
        otexCoord = texCoord;
        otexCoordNormalized = texCoordNormalized;

           // Create view vectors for the light, looking at (0,0,0)
           // In real applications this work is better done on
           // the CPU as it's constant for the whole scene.
           //float3 dirZ = -normalize(lightPosition);
           float3 dirZ = -normalize(lightDirection);
           float3 up = float3(0.0,0.0,1.0);
           float3 dirX = cross(up, dirZ);
           float3 dirY = cross(dirZ, dirX);

           // Transform into light's view space.
           // In real applications we would be better off using a 4x4
           // matrix instead, but for this shader it's cheaper to
           // just transpose and rotate into light's view space.
           float4 pos;
           //position.xyz -= lightPosition;
           position.xyz -= lightDirection;
           pos.x = dot(dirX, position);
           pos.y = dot(dirY, position);
           pos.z = dot(dirZ, position);
           pos.w = 1;

           // Project it. For this sample using the normal projection
           // matrix suffices, however, real applications will typically
           // use a separate projection matrix for each light depending
           // on its properties such as FOV and range.
           float4 sPos = mul(proj_matrix, pos);

           // Use projective texturing to map the position of each fragment
           // to its corresponding texel in the shadow map.
           sPos.z += 10;
           oshadowCrd.x = 0.5 * (sPos.z + sPos.x);
           oshadowCrd.y = 0.5 * (sPos.z - sPos.y);
           oshadowCrd.z = 0;
           oshadowCrd.w = sPos.z;
}