home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2005 April / Gamestar_72_2005-04_dvd.iso / Dema / Liquidator / Liquidator.tma / data / renderer / pixelshaders.fx < prev    next >
Text File  |  2004-11-04  |  41KB  |  1,098 lines
  1. //--------------------------------------------------------------------------
  2. //  TMShaders
  3. //  Copyright (c) 2002 by Tools-Media Corp., All Right Reserved.
  4. //  Programmer: Tima Tcvetkov
  5. //
  6. //  pixelshaders.fx
  7. //  system pixel shaders
  8. //--------------------------------------------------------------------------
  9. #ifndef __PIXELSHADERS_FX__
  10. #define __PIXELSHADERS_FX__
  11.  
  12. extern float4 g_fSpecColor[8] : register(c0);          // specular color
  13. extern float4 g_fDiffuseColor[8] : register(c0);       // diffuse color
  14.  
  15. extern float4 g_fBlinnProperties : register(c0);     // blinn-bumpmap attenuation properties 
  16. extern float4 g_fProjectorColors[__MAX_TEXTCOORDS__] : register(c0); // projective light color array
  17.  
  18. // pixel shaders
  19. sampler2D g_samNormalMap : register(s0); // normal map
  20. sampler2D g_samAlphaMap; // alpha map 
  21. sampler2D g_samAlphaMap0 : register(s0);  // alpha map
  22. sampler2D g_samAlphaMap1 : register(s1); // alpha map 
  23. sampler2D g_samAlphaMap2 : register(s2); // alpha map 
  24. sampler2D g_samAlphaMap3 : register(s3); // alpha map 
  25.  
  26. sampler2D g_samProjectiveLights[__MAX_TEXTCOORDS__] : register(s0); // projective lights texture array
  27. sampler g_samProjectiveLights3D[__MAX_TEXTCOORDS__] : register(s0); // projective lights 3Dtexture array
  28. sampler3D g_samAttenuationMap : register(s1);   // distance attenuation map
  29. samplerCUBE g_samNormalizationMap : register(s2); // normalization cubemap
  30. samplerCUBE g_samCubeMap : register(s3);          // cubemap for blinn bump-mapping
  31.  
  32.  
  33.  
  34. sampler2D g_samLightMap0 : register(s0); // lightmap
  35. sampler2D g_samLightMap1 : register(s1); // lightmap
  36.  
  37.  
  38.  
  39. sampler2D g_samHeightMap0 : register(s0);
  40. sampler2D g_samHeightMap1 : register(s1);
  41. sampler2D g_samHeightMap2 : register(s2);
  42. sampler2D g_samHeightMap3 : register(s3);
  43. sampler2D g_samHeightMap4 : register(s4);
  44. sampler2D g_samHeightMap5 : register(s5);
  45.  
  46. samplerCUBE g_samAngleCubeMap0 : register(s0);    // cubemap for bump self shadow
  47. samplerCUBE g_samAngleCubeMap1 : register(s1);    // cubemap for bump self shadow
  48. samplerCUBE g_samAngleCubeMap2 : register(s2);    // cubemap for bump self shadow
  49. samplerCUBE g_samAngleCubeMap3 : register(s3);    // cubemap for bump self shadow
  50. samplerCUBE g_samAngleCubeMap4 : register(s4);    // cubemap for bump self shadow
  51. samplerCUBE g_samAngleCubeMap5 : register(s5);    // cubemap for bump self shadow
  52. samplerCUBE g_samAngleCubeMap6 : register(s6);    // cubemap for bump self shadow
  53. samplerCUBE g_samAngleCubeMap7 : register(s7);    // cubemap for bump self shadow
  54. samplerCUBE g_samAngleCubeMap8 : register(s8);    // cubemap for bump self shadow
  55.  
  56. sampler3D g_samHorMap0 : register(s0);    // horizon map for bump self shadow
  57. sampler3D g_samHorMap1 : register(s1);    // horizon map for bump self shadow
  58. sampler3D g_samHorMap2 : register(s2);    // horizon map for bump self shadow
  59. sampler3D g_samHorMap3 : register(s3);    // horizon map for bump self shadow
  60. sampler3D g_samHorMap4 : register(s4);    // horizon map for bump self shadow
  61. sampler3D g_samHorMap5 : register(s5);    // horizon map for bump self shadow
  62. sampler3D g_samHorMap6 : register(s6);    // horizon map for bump self shadow
  63. sampler3D g_samHorMap7 : register(s7);    // horizon map for bump self shadow
  64. sampler3D g_samHorMap8 : register(s8);    // horizon map for bump self shadow
  65.  
  66. extern float4 constCubeLights[6] : register(c0);
  67. extern float4 constBlurFadeFactor : register(c0);
  68.  
  69. float3 Bx2( float3 val ){
  70.  return val * (float3)2.0f - (float3)1.0f;
  71. }
  72. float SBx2( float val ){
  73.  return val * 2.0f - 1.0f;
  74. }
  75.  
  76. /*
  77.   Computes new tex. coords. based on Height-map for parallax bumpmapping
  78. */
  79. float2 ComputeHeightMapOffset( uniform int SamplerNumber, float2 TexCoords, float3 Eye,float HeightScale ){
  80.    
  81.    float fHeight;
  82.    if( SamplerNumber == 0 ){
  83.      fHeight = SBx2(tex2D(g_samHeightMap0,TexCoords).x);
  84.    }
  85.    if( SamplerNumber == 1 ){
  86.      fHeight = SBx2(tex2D(g_samHeightMap1,TexCoords).x);
  87.    }
  88.    if( SamplerNumber == 2 ){
  89.      fHeight = SBx2(tex2D(g_samHeightMap2,TexCoords).x);
  90.    }
  91.    if( SamplerNumber == 3 ){
  92.      fHeight = SBx2(tex2D(g_samHeightMap3,TexCoords).x);
  93.    }
  94.    if( SamplerNumber == 4 ){
  95.      fHeight = SBx2(tex2D(g_samHeightMap4,TexCoords).x);
  96.    }
  97.    if( SamplerNumber == 5 ){
  98.      fHeight = SBx2(tex2D(g_samHeightMap5,TexCoords).x);
  99.    }
  100.    float3 fEyeNorm = normalize(Eye);
  101.    float2 fOffset = fEyeNorm.xy * fHeight * HeightScale;
  102.    return (TexCoords.xy + fOffset);
  103. }
  104. /*
  105.   Computes bum self shadow term
  106. */
  107. float ComputeSelfShadow( uniform int AngleMapSampler, uniform int HorizonMapSampler, float3 LightVec, float2 TexCoords ){
  108.    
  109.    float2 fAngle;
  110.    float  fE,fHorizon;
  111.    
  112.    if( AngleMapSampler == 0 ){
  113.      fAngle = texCUBE(g_samAngleCubeMap0,LightVec);
  114.    }
  115.    if( AngleMapSampler == 1 ){
  116.      fAngle = texCUBE(g_samAngleCubeMap1,LightVec);
  117.    }
  118.    if( AngleMapSampler == 2 ){
  119.      fAngle = texCUBE(g_samAngleCubeMap2,LightVec);
  120.    }
  121.    if( AngleMapSampler == 3 ){
  122.      fAngle = texCUBE(g_samAngleCubeMap3,LightVec);
  123.    }
  124.    if( AngleMapSampler == 4 ){
  125.      fAngle = texCUBE(g_samAngleCubeMap4,LightVec);
  126.    }
  127.    if( AngleMapSampler == 5 ){
  128.      fAngle = texCUBE(g_samAngleCubeMap5,LightVec);
  129.    }
  130.    if( AngleMapSampler == 6 ){
  131.      fAngle = texCUBE(g_samAngleCubeMap6,LightVec);
  132.    }
  133.    if( AngleMapSampler == 7 ){
  134.      fAngle = texCUBE(g_samAngleCubeMap7,LightVec);
  135.    }
  136.    if( AngleMapSampler == 8 ){
  137.      fAngle = texCUBE(g_samAngleCubeMap8,LightVec);
  138.    }
  139.    
  140.     fE = 0.5f * sign(LightVec.y) * fAngle.y;
  141.    
  142.     if( HorizonMapSampler == 0 ){
  143.      fHorizon = tex3D(g_samHorMap0,float3(TexCoords,fE));
  144.    }
  145.    if( HorizonMapSampler == 1 ){
  146.      fHorizon = tex3D(g_samHorMap1,float3(TexCoords,fE));
  147.    }
  148.    if( HorizonMapSampler == 2 ){
  149.      fHorizon = tex3D(g_samHorMap2,float3(TexCoords,fE));
  150.    }
  151.    if( HorizonMapSampler == 3 ){
  152.      fHorizon = tex3D(g_samHorMap3,float3(TexCoords,fE));
  153.    }
  154.    if( HorizonMapSampler == 4 ){
  155.      fHorizon = tex3D(g_samHorMap4,float3(TexCoords,fE));
  156.    }
  157.    if( HorizonMapSampler == 5 ){
  158.      fHorizon = tex3D(g_samHorMap5,float3(TexCoords,fE));
  159.    }
  160.    if( HorizonMapSampler == 6 ){
  161.      fHorizon = tex3D(g_samHorMap6,float3(TexCoords,fE));
  162.    }
  163.    if( HorizonMapSampler == 7 ){
  164.      fHorizon = tex3D(g_samHorMap7,float3(TexCoords,fE));
  165.    }
  166.    if( HorizonMapSampler == 8 ){
  167.      fHorizon = tex3D(g_samHorMap8,float3(TexCoords,fE));
  168.    }
  169.    return saturate(5.0f * (fAngle.x - (fHorizon*0.7f )) + 0.5f);
  170.    
  171.    
  172. }
  173. /*
  174.   Computes per-pixel cube lighting
  175. */
  176. float3 ComputeCubeLight( float3 fTangentS, float3 fTangentT,float3 fTangentSxT, float3 fNormal  ){
  177.     float3 fTangentNormal;
  178.     fTangentNormal.x = dot(fTangentS, fNormal);
  179.     fTangentNormal.y = dot(fTangentT, fNormal);
  180.     fTangentNormal.z = dot(fTangentSxT, fNormal);
  181.  
  182.     fTangentNormal = normalize(fTangentNormal);
  183.  
  184.     float3 Scale = fTangentNormal * fTangentNormal;
  185.  
  186.     int3 Sample3 = (fTangentNormal < 0.0f);
  187.  
  188.     float3 c1 = constCubeLights[Sample3.x+0] * Scale.x;
  189.     float3 c2 = constCubeLights[Sample3.y+2] * Scale.y;
  190.     float3 c3 = constCubeLights[Sample3.z+4] * Scale.z;    
  191.     return (c1+c2+c3);
  192. }
  193.  
  194. /*
  195.   perpixel cube lighting with diffuse color, lightmap, and alphamask
  196. */
  197. float4 CubeAmbientLightingPS20( float4 TexCoord[8] : TEXCOORD0, 
  198.                                 float4 Color : COLOR0, uniform int Index ) : COLOR0
  199. {
  200.  
  201.  
  202.    float4 fFinalColor = Color;
  203.    
  204.    if( Index == 2 ){ // diffuse with alphatest0
  205.      fFinalColor.w = tex2D(g_samAlphaMap0,TexCoord[0]).w;
  206.      return fFinalColor;
  207.    }
  208.    if( Index == 3 ){ // diffuse with lightmap0, alphatest1
  209.      fFinalColor.xyz += tex2D(g_samLightMap0,TexCoord[0]);
  210.      fFinalColor.w = tex2D(g_samAlphaMap1,TexCoord[1]).w;
  211.      return fFinalColor;
  212.    }
  213.    if( Index == 4 ){ // diffuse with lightmap0
  214.      fFinalColor.xyz += tex2D(g_samLightMap0,TexCoord[0]);
  215.      return fFinalColor;
  216.    }
  217.    if( Index == 5 ){ // diffuse with cubelight0
  218.      
  219.      float3 Normal = Bx2(tex2D(g_samNormalMap,TexCoord[0]));
  220.      fFinalColor.xyz += ComputeCubeLight(TexCoord[1].xyz,TexCoord[2].xyz,TexCoord[3].xyz,Normal);
  221.      return fFinalColor;
  222.    }
  223.    if( Index == 6 ){ // diffuse with cubelight0 and lightmap1
  224.      float3 Normal = Bx2(tex2D(g_samNormalMap,TexCoord[0]));
  225.      fFinalColor.xyz += ComputeCubeLight(TexCoord[2].xyz,TexCoord[3].xyz,TexCoord[4].xyz,Normal);
  226.      fFinalColor.xyz += tex2D(g_samLightMap1,TexCoord[1]);
  227.      return fFinalColor;
  228.    
  229.    }
  230.    if( Index == 7 ){ // diffuse with cubelight0 and lightmap1 and alphatest2
  231.      float3 Normal = Bx2(tex2D(g_samNormalMap,TexCoord[0]));
  232.      fFinalColor.xyz += ComputeCubeLight(TexCoord[2].xyz,TexCoord[3].xyz,TexCoord[4].xyz,Normal);
  233.      fFinalColor.xyz += tex2D(g_samLightMap1,TexCoord[1]);
  234.      fFinalColor.w = tex2D(g_samAlphaMap2,TexCoord[0]).w;
  235.      return fFinalColor;
  236.    }
  237.     if( Index == 8 ){ // diffuse with cubelight0 and alphatest1
  238.      float3 Normal = Bx2(tex2D(g_samNormalMap,TexCoord[0]));
  239.      fFinalColor.xyz += ComputeCubeLight(TexCoord[1].xyz,TexCoord[2].xyz,TexCoord[3].xyz,Normal);
  240.      fFinalColor.w = tex2D(g_samAlphaMap1,TexCoord[0]).w;
  241.      return fFinalColor;
  242.    }
  243.    if( Index == 9 ){ // diffuse with cubelight0 and parallax
  244.      
  245.      float2 fTexCoord = ComputeHeightMapOffset(1,TexCoord[0],TexCoord[4],constCubeLights[0].w); 
  246.      float3 Normal = Bx2(tex2D(g_samNormalMap,fTexCoord));
  247.      fFinalColor.xyz += ComputeCubeLight(TexCoord[1].xyz,TexCoord[2].xyz,TexCoord[3].xyz,Normal);
  248.      return fFinalColor;
  249.    
  250.    }
  251.    if( Index == 10 ){ // diffuse with cubelight0 and lightmap1 and parallax
  252.      
  253.      float2 fTexCoord = ComputeHeightMapOffset(2,TexCoord[0],TexCoord[5],constCubeLights[0].w); 
  254.      float3 Normal = Bx2(tex2D(g_samNormalMap,fTexCoord));
  255.      fFinalColor.xyz += ComputeCubeLight(TexCoord[2].xyz,TexCoord[3].xyz,TexCoord[4].xyz,Normal);
  256.      fFinalColor.xyz += tex2D(g_samLightMap1,TexCoord[1]);
  257.      return fFinalColor;
  258.    
  259.    }
  260.    if( Index == 11 ){ // diffuse with cubelight0 and lightmap1 and alphatest2 and parallax
  261.      
  262.      float2 fTexCoord = ComputeHeightMapOffset(3,TexCoord[0],TexCoord[5],constCubeLights[0].w); 
  263.      float3 Normal = Bx2(tex2D(g_samNormalMap,fTexCoord));
  264.      fFinalColor.xyz += ComputeCubeLight(TexCoord[2].xyz,TexCoord[3].xyz,TexCoord[4].xyz,Normal);
  265.      fFinalColor.xyz += tex2D(g_samLightMap1,TexCoord[1]);
  266.      fFinalColor.w = tex2D(g_samAlphaMap2,fTexCoord).w;
  267.      return fFinalColor;
  268.    }
  269.     if( Index == 12 ){ // diffuse with cubelight0 and alphatest1 and parallax
  270.      float2 fTexCoord = ComputeHeightMapOffset(2,TexCoord[0],TexCoord[4],constCubeLights[0].w); 
  271.      float3 Normal = Bx2(tex2D(g_samNormalMap,fTexCoord));
  272.      fFinalColor.xyz += ComputeCubeLight(TexCoord[1].xyz,TexCoord[2].xyz,TexCoord[3].xyz,Normal);
  273.      fFinalColor.w = tex2D(g_samAlphaMap1,fTexCoord).w;
  274.      return fFinalColor;
  275.    }
  276.    // diffuse only
  277.    return fFinalColor;
  278.             
  279. }
  280.  
  281. float4 CubeAmbientLighting( float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0, 
  282.                             float4 Color : COLOR0, 
  283.                             uniform int Index ) : COLOR0
  284. {
  285.   
  286.    float4 fFinalColor = Color;
  287.    
  288.    if( Index == 2 ){ // diffuse with alphatest0
  289.      fFinalColor.w = tex2D(g_samAlphaMap0,TexCoord[0]).w;
  290.      return fFinalColor;
  291.    }
  292.    if( Index == 3 ){ // diffuse with lightmap0, alphatest1
  293.      fFinalColor.xyz += tex2D(g_samLightMap0,TexCoord[0]);
  294.      fFinalColor.w = tex2D(g_samAlphaMap1,TexCoord[1]).w;
  295.      return fFinalColor;
  296.    }
  297.    if( Index == 4 ){ // diffuse with lightmap0
  298.      fFinalColor.xyz += tex2D(g_samLightMap0,TexCoord[0]);
  299.      return fFinalColor;
  300.    }
  301.    // diffuse only
  302.    return fFinalColor;
  303.             
  304. }
  305.  
  306.  
  307. // projective light with alpha test
  308. float4 ProjectiveLightPS20( float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0,
  309.         uniform int NumLights, uniform bool bAlphaTest,uniform bool bSelfShadow ) : COLOR
  310. {
  311.     float4 fFinalColor = 0;
  312.     
  313.     if(  bAlphaTest ){
  314.         for( int i=0; i<NumLights; i++ ){
  315.            fFinalColor.xyz += tex2Dproj(g_samProjectiveLights[0],TexCoord[i]) * g_fProjectorColors[i];    
  316.         }
  317.         fFinalColor.w = tex2D(g_samProjectiveLights[1],TexCoord[NumLights]).w;    
  318.     }
  319.     else{
  320.         for( int i=0; i<NumLights; i++ ){
  321.             fFinalColor += tex2Dproj(g_samProjectiveLights[0],TexCoord[i]) * g_fProjectorColors[i];    
  322.         }
  323.     }
  324.     return fFinalColor;
  325. }
  326.  
  327. float4 ProjectiveLight( 
  328.  
  329. #ifdef __MIN_PS__
  330.         float2 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0,
  331. #else
  332.         float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0,
  333. #endif 
  334.         uniform int NumLights, uniform bool bAlphaTest, uniform bool bSelfShadow ) : COLOR
  335. {
  336.     float4 fFinalColor = 0;
  337.     
  338.     if(  bAlphaTest ){
  339.         for( int i=0; i<NumLights; i++ ){
  340. #ifdef __MIN_PS__
  341.             fFinalColor.xyz += tex2D(g_samProjectiveLights[i],TexCoord[i]) * g_fProjectorColors[i];    
  342. #else
  343.             fFinalColor.xyz += tex2Dproj(g_samProjectiveLights[i],TexCoord[i]) * g_fProjectorColors[i];    
  344. #endif
  345.         }
  346.         fFinalColor.w = tex2D(g_samProjectiveLights[NumLights],TexCoord[NumLights]).w;    
  347.     }
  348.     else{
  349.         for( int i=0; i<NumLights; i++ ){
  350. #ifdef __MIN_PS__
  351.             fFinalColor += tex2D(g_samProjectiveLights[i],TexCoord[i]) * g_fProjectorColors[i];    
  352. #else
  353.             fFinalColor += tex2Dproj(g_samProjectiveLights[i],TexCoord[i]) * g_fProjectorColors[i];    
  354. #endif
  355.         }
  356.     }
  357.     return fFinalColor;
  358. }
  359.  
  360. float4 ProjectiveLight3D20( float3 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0, uniform int NumLights, uniform bool bAlphaTest,uniform bool bSelfShadow ) : COLOR
  361. {
  362.     float4 fFinalColor = 0;
  363.     if(  bAlphaTest ){
  364.     
  365.         for( int i=0; i<NumLights; i++ ){
  366.            fFinalColor.xyz += tex3D(g_samProjectiveLights3D[0],TexCoord[i]) * g_fProjectorColors[i];    
  367.         }
  368.         //FIXME: we sample 2d map for alpha value
  369.         fFinalColor.w = tex2D(g_samAlphaMap1,TexCoord[NumLights]).w;    
  370.     }
  371.     else{
  372.         for( int i=0; i<NumLights; i++ ){
  373.              fFinalColor += tex3D(g_samProjectiveLights3D[0],TexCoord[i]) * g_fProjectorColors[i];    
  374.         }
  375.     }
  376.     return fFinalColor;
  377. }
  378. float4 ProjectiveLight3D( float3 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0, uniform int NumLights, uniform bool bAlphaTest,uniform bool bSelfShadow ) : COLOR
  379. {
  380.     float4 fFinalColor = 0;
  381.     if(  bAlphaTest ){
  382.     
  383.         for( int i=0; i<NumLights; i++ ){
  384.            fFinalColor.xyz += tex3D(g_samProjectiveLights3D[i],TexCoord[i]) * g_fProjectorColors[i];    
  385.         }
  386.         //FIXME: we sample 2d map for alpha value
  387.         fFinalColor.w = tex2D(g_samProjectiveLights3D[NumLights],TexCoord[NumLights]).w;    
  388.     }
  389.     else{
  390.         for( int i=0; i<NumLights; i++ ){
  391.              fFinalColor += tex3D(g_samProjectiveLights3D[i],TexCoord[i]) * g_fProjectorColors[i];    
  392.         }
  393.     }
  394.     return fFinalColor;
  395. }
  396.  
  397. float4 ProjectiveShadow( float3 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0, 
  398.                          float4 DirMask1 : COLOR0, 
  399.                          float4 DirMask2 : COLOR1, 
  400.                          uniform int NumShadows, 
  401.                          uniform bool bNeedAlphaTest,uniform bool bSelfShadow ):COLOR{
  402.   
  403.   float4 fFinalColor = 0.0f;
  404.  
  405.   for( int i=0; i<NumShadows; i++ ){
  406.     float4 fDirMaks;
  407.     if( i ==0 ){
  408.     fDirMaks = DirMask1;
  409.     }
  410.     else if( i == 1 ){
  411.     fDirMaks = (float4)DirMask1.w;
  412.     }
  413.     else if( i == 2 ){
  414.     fDirMaks = DirMask2;
  415.     }
  416.     else if( i == 3 ){
  417.     fDirMaks = (float4)DirMask2.w;
  418.     }
  419.     float4 ColorMasked = g_fProjectorColors[i] * fDirMaks;
  420.     fFinalColor += tex2D(g_samProjectiveLights[i],TexCoord[i]) * ColorMasked;    
  421.   }
  422.   
  423.   if( bNeedAlphaTest ){
  424.       fFinalColor.w = tex2D(g_samProjectiveLights[NumShadows],TexCoord[NumShadows]).w;
  425.    }
  426.    return fFinalColor;
  427. }
  428. float4 Blur( float2 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0 ):COLOR{
  429.  
  430.   float4 fFinalColor = 0.0f;
  431.     for( int i=0; i<4; i++ ){
  432.       fFinalColor += float4(0.25f, 0.25f, 0.25f, 0.25f) * tex2D(g_samProjectiveLights[i],TexCoord[i]);    
  433.     }
  434.     return saturate(fFinalColor);
  435. }
  436. float4 SpecularPointLight( uniform int NumLights,
  437.                            uniform bool bParallax,                                        
  438.                            uniform bool bSelfShadow,
  439.                            float2 NMCoords   : TEXCOORD0, 
  440.                            float3 AttCoords  : TEXCOORD1, 
  441.                            float3 HalfVector : TEXCOORD2, 
  442.                            float3 AttCoords2  : TEXCOORD3, 
  443.                            float3 HalfVector2 : TEXCOORD4, 
  444.                            float3 AttCoords3  : TEXCOORD5, 
  445.                            float3 HalfVector3 : TEXCOORD6, 
  446.                            float3 Eye        : TEXCOORD7, 
  447.                            float4 BackCull : COLOR0, 
  448.                            float4 BackCull2 : COLOR1  ):COLOR
  449. {
  450.    float2 fTexCoord;
  451.    if(bParallax){
  452.      if( NumLights == 1 ){
  453.       fTexCoord = ComputeHeightMapOffset(3,NMCoords.xy,AttCoords2,g_fSpecColor[0].w); 
  454.      }
  455.      if( NumLights == 2 ){
  456.       fTexCoord = ComputeHeightMapOffset(3,NMCoords.xy,AttCoords3,g_fSpecColor[0].w); 
  457.      }
  458.      if( NumLights == 3 ){
  459.       fTexCoord = ComputeHeightMapOffset(3,NMCoords.xy,Eye,g_fSpecColor[0].w); 
  460.      }
  461.    }else{
  462.      fTexCoord = NMCoords.xy;
  463.    }
  464.    // unpack normal and half vector
  465.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  466.    float3 fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector));
  467.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  468.    if( bSelfShadow ){
  469.      fDot *= ComputeSelfShadow(4,5,fHalfVector,fTexCoord);
  470.    }     
  471.    float4 fAttenuation = tex3D(g_samAttenuationMap,AttCoords);
  472.    float4 fFinalColor;
  473.    fFinalColor = (fAttenuation * (float4)fDot *  g_fSpecColor[0] * BackCull);
  474.    
  475.    if( NumLights > 1 ){
  476.     fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector2));
  477.     fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  478.     if( bSelfShadow ){
  479.      fDot *= ComputeSelfShadow(4,5,fHalfVector,fTexCoord);
  480.     }     
  481.     fAttenuation = tex3D(g_samAttenuationMap,AttCoords2);
  482.     fFinalColor.xyz += (fAttenuation * (float4)fDot *  g_fSpecColor[1] * BackCull.w);
  483.    }
  484.    if( NumLights > 2 ){
  485.     fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector3));
  486.     fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  487.     if( bSelfShadow ){
  488.      fDot *= ComputeSelfShadow(4,5,fHalfVector,fTexCoord);
  489.     }     
  490.     fAttenuation = tex3D(g_samAttenuationMap,AttCoords3);
  491.     fFinalColor.xyz += (fAttenuation * (float4)fDot *  g_fSpecColor[2] * BackCull2);
  492.    }
  493.    return fFinalColor;
  494. }
  495. float4 SpecularPointLightWithAlphaTest20( uniform int NumLights,
  496.                                         uniform bool bParallax,            
  497.                                         uniform bool bSelfShadow,        
  498.                                         float2 NMCoords        : TEXCOORD0, 
  499.                                         float3 AttCoords    : TEXCOORD1, 
  500.                                         float3 HalfVector    : TEXCOORD2, 
  501.                                         float3 Vector2        : TEXCOORD3, 
  502.                                         float3 Vector3        : TEXCOORD4, 
  503.                                         float3 Vector4        : TEXCOORD5, 
  504.                                         float3 Vector5        : TEXCOORD6, 
  505.                                         float3 Vector6        : TEXCOORD7, 
  506.                                         float4 BackCull        : COLOR0,
  507.                                         float4 BackCull2    : COLOR1  ):COLOR
  508.  
  509. {
  510.    float2 fTexCoord;
  511.    if(bParallax){
  512.      if( NumLights == 1 ){
  513.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector2,g_fSpecColor[0].w); 
  514.      }
  515.      if( NumLights == 2 ){
  516.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector4,g_fSpecColor[0].w); 
  517.      }
  518.      if( NumLights == 3 ){
  519.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector6,g_fSpecColor[0].w); 
  520.      }
  521.    }else{
  522.      fTexCoord = NMCoords.xy;
  523.    }
  524.    // unpack normal and half vector
  525.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  526.    float3 fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector));
  527.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  528.    if( bSelfShadow ){
  529.      fDot *= ComputeSelfShadow(5,6,fHalfVector,fTexCoord);
  530.    }     
  531.    float4 fAttenuation = tex3D(g_samAttenuationMap,AttCoords);
  532.    float4 fFinalColor;
  533.    fFinalColor = (fAttenuation * (float4)fDot *  g_fSpecColor[0] * BackCull);
  534.    
  535.    if( NumLights > 1 ){
  536.     fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,Vector3));
  537.     fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  538.     if( bSelfShadow ){
  539.      fDot *= ComputeSelfShadow(5,6,fHalfVector,fTexCoord);
  540.     }     
  541.     fAttenuation = tex3D(g_samAttenuationMap,Vector2);
  542.     fFinalColor.xyz += (fAttenuation * (float4)fDot *  g_fSpecColor[1] * BackCull.w);
  543.    }
  544.    if( NumLights > 2 ){
  545.     fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,Vector5));
  546.     fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  547.     if( bSelfShadow ){
  548.      fDot *= ComputeSelfShadow(5,6,fHalfVector,fTexCoord);
  549.     }     
  550.     fAttenuation = tex3D(g_samAttenuationMap,Vector4);
  551.     fFinalColor.xyz += (fAttenuation * (float4)fDot *  g_fSpecColor[2] * BackCull2);
  552.    }
  553.    fFinalColor.w = tex2D(g_samAlphaMap3,fTexCoord).w;
  554.    return fFinalColor;
  555. }
  556. float4 SpecularPointLightWithAlphaTest( uniform int NumLights,
  557.                                         float2 NMCoords        : TEXCOORD0, 
  558.                                         float3 AttCoords    : TEXCOORD1, 
  559.                                         float3 HalfVector    : TEXCOORD2, 
  560.                                         float3 Vector2        : TEXCOORD3, 
  561.                                         float4 BackCull        : COLOR0,
  562.                                         float4 BackCull2    : COLOR1  ):COLOR
  563.  
  564. {
  565.    // unpack normal and half vector
  566.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,NMCoords));
  567.    float3 fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector));
  568.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  569.    float4 fAttenuation = tex3D(g_samAttenuationMap,AttCoords);
  570.    float4 fFinalColor;
  571.    fFinalColor = (fAttenuation * (float4)fDot *  g_fSpecColor[0] * BackCull);
  572.    fFinalColor.w = tex2D(g_samAlphaMap3,Vector2).w;
  573.    return fFinalColor;
  574. }
  575. float4 SpecularPointLightWithGloss( uniform int NumLights,
  576.                                     uniform bool bParallax,                
  577.                                     uniform bool bSelfShadow,
  578.                                     float2 NMCoords   : TEXCOORD0, 
  579.                                     float3 AttCoords  : TEXCOORD1, 
  580.                                     float3 HalfVector : TEXCOORD2, 
  581.                                     float3 AttCoords2  : TEXCOORD3, 
  582.                                     float3 HalfVector2 : TEXCOORD4, 
  583.                                     float3 AttCoords3  : TEXCOORD5, 
  584.                                     float3 HalfVector3 : TEXCOORD6, 
  585.                                     float3 Eye        : TEXCOORD7, 
  586.                                     float4 BackCull : COLOR0, 
  587.                                     float4 BackCull2 : COLOR1  ):COLOR
  588.  
  589. {
  590.    float2 fTexCoord;
  591.    if(bParallax){
  592.      if( NumLights == 1 ){
  593.       fTexCoord = ComputeHeightMapOffset(3,NMCoords,AttCoords2,g_fSpecColor[0].w); 
  594.      }
  595.      if( NumLights == 2 ){
  596.       fTexCoord = ComputeHeightMapOffset(3,NMCoords,AttCoords3,g_fSpecColor[0].w); 
  597.      }
  598.      if( NumLights == 3 ){
  599.       fTexCoord = ComputeHeightMapOffset(3,NMCoords,Eye,g_fSpecColor[0].w); 
  600.      }
  601.    }else{
  602.      fTexCoord = NMCoords;
  603.    }
  604.    // unpack normal and half vector
  605.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  606.    float3 fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector));
  607. // FIXME: we can not value raise to power of 16, under ps1.1 in this case
  608.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),8);
  609.    if( bSelfShadow ){
  610.      fDot *= ComputeSelfShadow(4,5,fHalfVector,fTexCoord);
  611.    }     
  612.    float4 fAttenuation = tex3D(g_samAttenuationMap,AttCoords);
  613.    float4 fFinalColor;
  614.    fFinalColor = (fAttenuation * (float4)fDot *  g_fSpecColor[0] * BackCull);
  615.    
  616.    if( NumLights > 1 ){
  617.     fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector2));
  618.     fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  619.     if( bSelfShadow ){
  620.      fDot *= ComputeSelfShadow(4,5,fHalfVector,fTexCoord);
  621.     }     
  622.     fAttenuation = tex3D(g_samAttenuationMap,AttCoords2);
  623.     fFinalColor.xyz += (fAttenuation * (float4)fDot *  g_fSpecColor[1] * BackCull.w);
  624.    }
  625.    if( NumLights > 2 ){
  626.     fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector3));
  627.     fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  628.     if( bSelfShadow ){
  629.      fDot *= ComputeSelfShadow(4,5,fHalfVector,fTexCoord);
  630.     }     
  631.     fAttenuation = tex3D(g_samAttenuationMap,AttCoords3);
  632.     fFinalColor.xyz += (fAttenuation * (float4)fDot *  g_fSpecColor[2] * BackCull2);
  633.    }
  634.    return ( fFinalColor * tex2D(g_samNormalMap,fTexCoord).w);
  635. }
  636.  
  637. float4 SpecularPointLightWithAlphaTestAndGloss20( uniform int NumLights,
  638.                                         uniform bool bParallax,                
  639.                                         uniform bool bSelfShadow,
  640.                                         float2 NMCoords        : TEXCOORD0, 
  641.                                         float3 AttCoords    : TEXCOORD1, 
  642.                                         float3 HalfVector    : TEXCOORD2, 
  643.                                         float3 Vector2        : TEXCOORD3, 
  644.                                         float3 Vector3        : TEXCOORD4, 
  645.                                         float3 Vector4        : TEXCOORD5, 
  646.                                         float3 Vector5        : TEXCOORD6, 
  647.                                         float3 Vector6        : TEXCOORD7, 
  648.                                         float4 BackCull        : COLOR0,
  649.                                         float4 BackCull2    : COLOR1  ):COLOR
  650.  
  651. {
  652.    float2 fTexCoord;
  653.    if(bParallax){
  654.      if( NumLights == 1 ){
  655.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector2,g_fSpecColor[0].w); 
  656.      }
  657.      if( NumLights == 2 ){
  658.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector4,g_fSpecColor[0].w); 
  659.      }
  660.      if( NumLights == 3 ){
  661.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector6,g_fSpecColor[0].w); 
  662.      }
  663.    }else{
  664.      fTexCoord = NMCoords.xy;
  665.    }
  666.  // unpack normal and half vector
  667.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  668.    float3 fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector));
  669.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  670.    if( bSelfShadow ){
  671.      fDot *= ComputeSelfShadow(5,6,fHalfVector,fTexCoord);
  672.    }     
  673.    float4 fAttenuation = tex3D(g_samAttenuationMap,AttCoords);
  674.    float4 fFinalColor;
  675.    fFinalColor = (fAttenuation * (float4)fDot *  g_fSpecColor[0] * BackCull);
  676.    
  677.    if( NumLights > 1 ){
  678.     fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,Vector3));
  679.     fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  680.     if( bSelfShadow ){
  681.      fDot *= ComputeSelfShadow(5,6,fHalfVector,fTexCoord);
  682.     }     
  683.     fAttenuation = tex3D(g_samAttenuationMap,Vector2);
  684.     fFinalColor.xyz += (fAttenuation * (float4)fDot *  g_fSpecColor[1] * BackCull.w);
  685.    }
  686.    if( NumLights > 2 ){
  687.     fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,Vector5));
  688.     fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  689.     if( bSelfShadow ){
  690.      fDot *= ComputeSelfShadow(5,6,fHalfVector,fTexCoord);
  691.     }     
  692.     fAttenuation = tex3D(g_samAttenuationMap,Vector4);
  693.     fFinalColor.xyz += (fAttenuation * (float4)fDot *  g_fSpecColor[2] * BackCull2);
  694.    }
  695.    
  696.    fFinalColor.xyz *= tex2D(g_samNormalMap,fTexCoord).w;
  697.    fFinalColor.w = tex2D(g_samAlphaMap3,fTexCoord).w;
  698.    return fFinalColor;
  699. }
  700. float4 SpecularPointLightWithAlphaTestAndGloss( uniform int NumLights,
  701.                                         float2 NMCoords        : TEXCOORD0, 
  702.                                         float3 AttCoords    : TEXCOORD1, 
  703.                                         float3 HalfVector    : TEXCOORD2, 
  704.                                         float3 Vector2        : TEXCOORD3, 
  705.                                         float4 BackCull        : COLOR0,
  706.                                         float4 BackCull2    : COLOR1  ):COLOR
  707.  
  708. {
  709.  // unpack normal and half vector
  710.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,NMCoords));
  711.    float3 fHalfVector    = Bx2(texCUBE(g_samNormalizationMap,HalfVector));
  712.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  713.    float4 fAttenuation = tex3D(g_samAttenuationMap,AttCoords);
  714.    float4 fFinalColor;
  715.    fFinalColor = (fAttenuation * (float4)fDot *  g_fSpecColor[0] * BackCull);
  716.    fFinalColor.w = tex2D(g_samAlphaMap3,Vector2).w;
  717.    return fFinalColor;
  718.    
  719. }
  720. float4 SimpleSpecularPointLight( float2 NMCoords : TEXCOORD0, float4 HalfWithAttenuation : COLOR0  ):COLOR
  721. {
  722.    // unpack normal and half vector
  723.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,NMCoords));
  724.    float3 fHalfVector    = Bx2((float3)HalfWithAttenuation);
  725.    
  726.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  727.    return  (HalfWithAttenuation.w * (float4)fDot *  g_fSpecColor[0]);
  728. }
  729. float4 SimpleSpecularPointLight20( uniform int NumLights, uniform bool bParallax,uniform bool bSelfShadow,float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0   ):COLOR
  730. {
  731.    float2 fTexCoord;
  732.    if(bParallax){
  733.       fTexCoord = ComputeHeightMapOffset(1,TexCoord[0],TexCoord[NumLights+1],g_fSpecColor[0].w); 
  734.    }else{
  735.      fTexCoord = TexCoord[0].xy;
  736.    }
  737.    // unpack normal and half vector
  738.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  739.    float fDot = pow( saturate( dot(fNormal,TexCoord[1]) ),16);
  740.    if( bSelfShadow ){
  741.      fDot *= ComputeSelfShadow(2,3,TexCoord[1],fTexCoord);
  742.     }     
  743.    float4 fFinalColor;
  744.    fFinalColor = (TexCoord[1].w * (float4)fDot *  g_fSpecColor[0]);
  745.    
  746.    for( int i=1; i<NumLights; i++ ){
  747.     float fDot = pow( saturate( dot(fNormal,TexCoord[i+1]) ),16);
  748.     if( bSelfShadow ){
  749.      fDot *= ComputeSelfShadow(2,3,TexCoord[i+1],fTexCoord);
  750.     }     
  751.     fFinalColor += (TexCoord[i+1].w * (float4)fDot *  g_fSpecColor[i]);
  752.    }
  753.    return fFinalColor;
  754. }
  755. float4 SimpleSpecularPointLightWithAlphaTest20( uniform int NumLights, uniform bool bParallax, uniform bool bSelfShadow,float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0  ):COLOR
  756. {
  757.    float2 fTexCoord;
  758.    if(bParallax){
  759.      fTexCoord = ComputeHeightMapOffset(2,TexCoord[0],TexCoord[NumLights+1],g_fSpecColor[0].w); 
  760.    }else{
  761.      fTexCoord = TexCoord[0].xy;
  762.    }
  763.    // unpack normal and half vector
  764.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  765.    float fDot = pow( saturate( dot(fNormal,TexCoord[1]) ),16);
  766.    if( bSelfShadow ){
  767.      fDot *= ComputeSelfShadow(3,4,TexCoord[1],fTexCoord);
  768.    }     
  769.    float4 fFinalColor;
  770.    fFinalColor = (TexCoord[1].w * (float4)fDot *  g_fSpecColor[0]);
  771.    
  772.    for( int i=1; i<NumLights; i++ ){
  773.     float fDot = pow( saturate( dot(fNormal,TexCoord[i+1]) ),16);
  774.     if( bSelfShadow ){
  775.      fDot *= ComputeSelfShadow(3,4,TexCoord[i+1],fTexCoord);
  776.     }     
  777.     fFinalColor += (TexCoord[i+1].w * (float4)fDot *  g_fSpecColor[i]);
  778.    }
  779.    fFinalColor.w = tex2D(g_samAlphaMap1,fTexCoord).w;
  780.    return fFinalColor;
  781. }
  782. float4 SimpleSpecularPointLightWithGloss20( uniform int NumLights,uniform bool bParallax, uniform bool bSelfShadow, float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0  ):COLOR
  783. {
  784.    float2 fTexCoord;
  785.    if(bParallax){
  786.     fTexCoord = ComputeHeightMapOffset(1,TexCoord[0],TexCoord[NumLights+1],g_fSpecColor[0].w); 
  787.    }else{
  788.     fTexCoord = TexCoord[0].xy;
  789.    }
  790.    // unpack normal and half vector
  791.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  792.    float fDot = pow( saturate( dot(fNormal,TexCoord[1]) ),16);
  793.    if( bSelfShadow ){
  794.      fDot *= ComputeSelfShadow(2,3,TexCoord[1],fTexCoord);
  795.    }     
  796.    float4 fFinalColor;
  797.    fFinalColor = (TexCoord[1].w * (float4)fDot *  g_fSpecColor[0]);
  798.    
  799.    for( int i=1; i<NumLights; i++ ){
  800.     float fDot = pow( saturate( dot(fNormal,TexCoord[i+1]) ),16);
  801.     if( bSelfShadow ){
  802.      fDot *= ComputeSelfShadow(2,3,TexCoord[i+1],fTexCoord);
  803.     }     
  804.     fFinalColor += (TexCoord[i+1].w * (float4)fDot *  g_fSpecColor[i]);
  805.    }
  806.    fFinalColor *= tex2D(g_samNormalMap,fTexCoord).w;
  807.    return  fFinalColor;
  808. }
  809. float4 SimpleSpecularPointLightWithAlphaTestAndGloss20( uniform int NumLights,uniform bool bParallax, uniform bool bSelfShadow, float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0   ):COLOR
  810. {
  811.  float2 fTexCoord;
  812.   if(bParallax){
  813.    fTexCoord = ComputeHeightMapOffset(2,TexCoord[0],TexCoord[NumLights+1],g_fSpecColor[0].w); 
  814.   }else{
  815.    fTexCoord = TexCoord[0].xy;
  816.   }
  817.    // unpack normal and half vector
  818.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  819.    float fDot = pow( saturate( dot(fNormal,TexCoord[1]) ),16);
  820.    if( bSelfShadow ){
  821.      fDot *= ComputeSelfShadow(3,4,TexCoord[1],fTexCoord);
  822.    }     
  823.    float4 fFinalColor;
  824.    fFinalColor.xyz = (TexCoord[1].w * (float4)fDot *  g_fSpecColor[0]);
  825.    
  826.    for( int i=1; i<NumLights; i++ ){
  827.     float fDot = pow( saturate( dot(fNormal,TexCoord[i+1]) ),16);
  828.     if( bSelfShadow ){
  829.      fDot *= ComputeSelfShadow(3,4,TexCoord[i+1],fTexCoord);
  830.     }     
  831.     fFinalColor.xyz += (TexCoord[i+1].w * (float4)fDot *  g_fSpecColor[i]);
  832.    }
  833.    fFinalColor.w = tex2D(g_samAlphaMap1,fTexCoord).w;
  834.    fFinalColor.xyz *= tex2D(g_samNormalMap,fTexCoord).w;
  835.    return fFinalColor;
  836.    
  837. }
  838.  
  839.  
  840. float4 SimpleSpecularPointLightWithAlphaTest( float2 NMCoords : TEXCOORD0, float3 AlphaCoords : TEXCOORD1, float4 HalfWithAttenuation : COLOR0  ):COLOR
  841. {
  842.    // unpack normal and half vector
  843.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,NMCoords));
  844.    float3 fHalfVector    = Bx2((float3)HalfWithAttenuation);
  845.    
  846.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  847.    float4 fFinalColor;
  848.    fFinalColor.xyz = (HalfWithAttenuation.w * fDot *  g_fSpecColor[0]);
  849.    fFinalColor.w = tex2D(g_samAlphaMap1,AlphaCoords).w;
  850.    return fFinalColor;
  851. }
  852. float4 SimpleSpecularPointLightWithGloss( float2 NMCoords : TEXCOORD0, float4 HalfWithAttenuation : COLOR0  ):COLOR
  853. {
  854.    // unpack normal and half vector
  855.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,NMCoords));
  856.    float3 fHalfVector    = Bx2((float3)HalfWithAttenuation);
  857.    
  858.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  859.    return  (HalfWithAttenuation.w * (float4)fDot *  g_fSpecColor[0] * tex2D(g_samNormalMap,NMCoords).w );
  860. }
  861. float4 SimpleSpecularPointLightWithAlphaTestAndGloss( float2 NMCoords : TEXCOORD0, float3 AlphaCoords : TEXCOORD1, float4 HalfWithAttenuation : COLOR0  ):COLOR
  862. {
  863.    // unpack normal and half vector
  864.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,NMCoords));
  865.    float3 fHalfVector    = Bx2((float3)HalfWithAttenuation);
  866.    
  867.    float fDot = pow( saturate( dot(fNormal,fHalfVector) ),16);
  868.    float4 fFinalColor;
  869.    fFinalColor.xyz = (HalfWithAttenuation.w * fDot *  g_fSpecColor[0] * tex2D(g_samNormalMap,NMCoords).w);
  870.    fFinalColor.w = tex2D(g_samAlphaMap1,AlphaCoords).w;
  871.    return fFinalColor;
  872. }
  873. float4 DiffusePointLight( uniform int NumLights,
  874.                           uniform bool bParallax,    
  875.                           uniform bool bSelfShadow,        
  876.                           float2 NMCoords : TEXCOORD0, 
  877.                           float3 AttCoords : TEXCOORD1, 
  878.                           float3 LightVector : TEXCOORD2,
  879.                           float3 AttCoords2 : TEXCOORD3, 
  880.                           float3 LightVector2 : TEXCOORD4,
  881.                           float3 AttCoords3 : TEXCOORD5, 
  882.                           float3 LightVector3 : TEXCOORD6,
  883.                           float3 Eye : TEXCOORD7 ):COLOR
  884. {
  885.   float2 fTexCoord;
  886.    if( bParallax ){
  887.     if( NumLights == 1 ){
  888.       fTexCoord = ComputeHeightMapOffset(3,NMCoords,AttCoords2,g_fDiffuseColor[0].w); 
  889.      }
  890.      if( NumLights == 2 ){
  891.       fTexCoord = ComputeHeightMapOffset(3,NMCoords,AttCoords3,g_fDiffuseColor[0].w); 
  892.      }
  893.      if( NumLights == 3 ){
  894.       fTexCoord = ComputeHeightMapOffset(3,NMCoords,Eye,g_fDiffuseColor[0].w); 
  895.      }
  896.    }else{
  897.     fTexCoord = NMCoords.xy;
  898.    }
  899.    // unpack normal and half vector
  900.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  901.    
  902.    float3 fLightVector    = Bx2(texCUBE(g_samNormalizationMap,LightVector));
  903.    float fDot = saturate( dot(fNormal,fLightVector) );
  904.    if( bSelfShadow ){
  905.      fDot *= ComputeSelfShadow(4,5,fLightVector,fTexCoord);
  906.    }     
  907.    float4 Color1 = ( tex3D(g_samAttenuationMap,AttCoords) * (float4)fDot *  g_fDiffuseColor[0]);
  908.    
  909.    if( NumLights > 1){
  910.     fLightVector = Bx2(texCUBE(g_samNormalizationMap,LightVector2));
  911.     fDot = saturate( dot(fNormal,fLightVector) );
  912.     if( bSelfShadow ){
  913.      fDot *= ComputeSelfShadow(4,5,fLightVector,fTexCoord);
  914.     }     
  915.     Color1 += ( tex3D(g_samAttenuationMap,AttCoords2) * (float4)fDot *  g_fDiffuseColor[1]);
  916.      
  917.    }
  918.    if( NumLights > 2){
  919.     fLightVector    = Bx2(texCUBE(g_samNormalizationMap,LightVector3));
  920.     fDot = saturate( dot(fNormal,fLightVector) );
  921.     if( bSelfShadow ){
  922.      fDot *= ComputeSelfShadow(4,5,fLightVector,fTexCoord);
  923.     }     
  924.     Color1 += ( tex3D(g_samAttenuationMap,AttCoords3) * (float4)fDot *  g_fDiffuseColor[2]);
  925.    }
  926.    return Color1;
  927.    
  928. }
  929.                                     
  930. float4 DiffusePointLightWithAlphaTest20( uniform int NumLights,
  931.                                          uniform bool bParallax,            
  932.                                          uniform bool bSelfShadow,
  933.                                          float4 NMCoords : TEXCOORD0, 
  934.                                          float3 AttCoords : TEXCOORD1, 
  935.                                          float3 LightVector : TEXCOORD2,
  936.                                          float3 Vector3 : TEXCOORD3, 
  937.                                          float3 Vector4 : TEXCOORD4,
  938.                                          float3 Vector5 : TEXCOORD5, 
  939.                                          float3 Vector6 : TEXCOORD6, 
  940.                                          float3 Vector7 : TEXCOORD7 ):COLOR
  941.                                         
  942.                                 
  943. {
  944.   float2 fTexCoord;
  945.   if(bParallax){
  946.      if( NumLights == 1 ){
  947.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector3,g_fDiffuseColor[0].w); 
  948.      }
  949.      if( NumLights == 2 ){
  950.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector5,g_fDiffuseColor[0].w); 
  951.      }
  952.      if( NumLights == 3 ){
  953.       fTexCoord = ComputeHeightMapOffset(4,NMCoords,Vector7,g_fDiffuseColor[0].w); 
  954.      }
  955.   }else{
  956.    fTexCoord = NMCoords.xy;
  957.   }
  958.    // unpack normal and half vector
  959.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  960.    float3 fLightVector    = Bx2(texCUBE(g_samNormalizationMap,LightVector));
  961.    float fDot = saturate( dot(fNormal,fLightVector) );
  962.    if( bSelfShadow ){
  963.      fDot *= ComputeSelfShadow(5,6,fLightVector,fTexCoord);
  964.     }     
  965.    float4 Color1; 
  966.    Color1.xyz = ( tex3D(g_samAttenuationMap,AttCoords) * (float4)fDot *  g_fDiffuseColor[0]);
  967.    if( NumLights > 1){
  968.     fLightVector = Bx2(texCUBE(g_samNormalizationMap,Vector4));
  969.     fDot = saturate( dot(fNormal,fLightVector) );
  970.     if( bSelfShadow ){
  971.      fDot *= ComputeSelfShadow(5,6,fLightVector,fTexCoord);
  972.     }     
  973.     Color1.xyz += ( tex3D(g_samAttenuationMap,Vector3) * (float4)fDot *  g_fDiffuseColor[1]);
  974.    }
  975.    if( NumLights > 2){
  976.     fLightVector    = Bx2(texCUBE(g_samNormalizationMap,Vector6));
  977.     fDot = saturate( dot(fNormal,fLightVector) );
  978.     if( bSelfShadow ){
  979.      fDot *= ComputeSelfShadow(5,6,fLightVector,fTexCoord);
  980.     }     
  981.     Color1.xyz += ( tex3D(g_samAttenuationMap,Vector5) * (float4)fDot *  g_fDiffuseColor[2]);
  982.    }
  983.    Color1.w = tex2D(g_samAlphaMap3,fTexCoord).w;
  984.    return Color1; 
  985.    
  986. }
  987. float4 DiffusePointLightWithAlphaTest(    uniform int NumLights,
  988.                                         float4 NMCoords : TEXCOORD0, 
  989.                                         float3 AttCoords : TEXCOORD1, 
  990.                                         float3 LightVector : TEXCOORD2,
  991.                                         float3 Vector3 : TEXCOORD3    ):COLOR
  992.                                         
  993.                                 
  994. {
  995.  
  996.    float2 fTexCoord = NMCoords.xy;
  997.    // unpack normal and half vector
  998.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  999.    float3 fLightVector    = Bx2(texCUBE(g_samNormalizationMap,LightVector));
  1000.    float fDot = saturate( dot(fNormal,fLightVector) );
  1001.    float4 Color1; 
  1002.    Color1.xyz = ( tex3D(g_samAttenuationMap,AttCoords) * (float4)fDot *  g_fDiffuseColor[0]);
  1003.    Color1.w = tex2D(g_samAlphaMap3,Vector3).w;
  1004.    return Color1; 
  1005. }
  1006. float4 SimpleDiffusePointLight( float2 NMCoords : TEXCOORD0, float4 LightWithAttenuation : COLOR0  ):COLOR
  1007. {
  1008.    // unpack normal and half vector
  1009.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,NMCoords));
  1010.    float3 fLightVector    = Bx2((float3)LightWithAttenuation);
  1011.    float fDot = saturate( dot(fNormal,fLightVector) );
  1012.    return ((float4)fDot *  g_fDiffuseColor[0] * LightWithAttenuation.w);
  1013. }
  1014. float4 SimpleDiffusePointLight20( uniform int NumLights, uniform bool bParallax, uniform bool bSelfShadow, float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0  ):COLOR
  1015. {
  1016.   float2 fTexCoord;
  1017.   if(bParallax){
  1018.       fTexCoord = ComputeHeightMapOffset(1,TexCoord[0],TexCoord[NumLights+1],g_fDiffuseColor[0].w); 
  1019.   }else{
  1020.    fTexCoord = TexCoord[0].xy;
  1021.   }
  1022.    // unpack normal and half vector
  1023.    float3 fNormal        = Bx2(tex2D(g_samNormalMap,fTexCoord));
  1024.    float4 FinalColor;
  1025.    float fDot = saturate( dot(fNormal,TexCoord[1]) );
  1026.    if( bSelfShadow ){
  1027.      fDot *= ComputeSelfShadow(2,3,TexCoord[1],fTexCoord);
  1028.    }     
  1029.    FinalColor = ((float4)fDot *  g_fDiffuseColor[0] * TexCoord[1].w);
  1030.    
  1031.    for( int i=1; i<NumLights; i++ ){
  1032.     
  1033.     fDot = saturate( dot(fNormal,TexCoord[i+1]) );
  1034.     if( bSelfShadow ){
  1035.      fDot *= ComputeSelfShadow(2,3,TexCoord[i+1],fTexCoord);
  1036.     }     
  1037.     FinalColor += ((float4)fDot *  g_fDiffuseColor[i] * TexCoord[i+1].w);
  1038.    } 
  1039.    
  1040.    return FinalColor;
  1041. }
  1042.  
  1043. float4 SimpleDiffusePointLightWithAlphaTest( float2 NMCoords : TEXCOORD0, float2 AlphaCoords : TEXCOORD1,float4 LightWithAttenuation : COLOR0  ):COLOR
  1044. {
  1045.    // unpack normal and half vector
  1046.    float3 fNormal        = Bx2( tex2D(g_samNormalMap,NMCoords));
  1047.    float3 fLightVector    = Bx2( (float3)LightWithAttenuation);
  1048.    float fDot = saturate( dot(fNormal,fLightVector) );
  1049.    float4 fFinalColor;
  1050.    fFinalColor.xyz = ((float4)fDot *  g_fDiffuseColor[0] * LightWithAttenuation.w);
  1051.    fFinalColor.w = tex2D(g_samAlphaMap1,AlphaCoords).w;
  1052.    return fFinalColor;
  1053. }
  1054. float4 SimpleDiffusePointLightWithAlphaTest20( uniform int NumLights, uniform bool bParallax,uniform bool bSelfShadow, float4 TexCoord[__MAX_TEXTCOORDS__] : TEXCOORD0  ):COLOR
  1055. {
  1056.   float2 fTexCoord;
  1057.   
  1058.   if( bParallax ){
  1059.      fTexCoord = ComputeHeightMapOffset(2,TexCoord[0],TexCoord[NumLights+1],g_fDiffuseColor[0].w); 
  1060.   }
  1061.   else{
  1062.    fTexCoord = TexCoord[0].xy;
  1063.   }
  1064.   
  1065.    
  1066.    float3 fNormal        = Bx2( tex2D(g_samNormalMap,fTexCoord) );
  1067.    
  1068.    float4 FinalColor;
  1069.    float fDot = saturate( dot(fNormal,TexCoord[1]) );
  1070.    if( bSelfShadow ){
  1071.     fDot *= ComputeSelfShadow(3,4,TexCoord[1],fTexCoord);
  1072.    }     
  1073.    FinalColor = ((float4)fDot *  g_fDiffuseColor[0] * TexCoord[1].w);
  1074.    
  1075.    for( int i=1; i<NumLights; i++ ){
  1076.     fDot = saturate( dot(fNormal,TexCoord[i+1]) );
  1077.     if( bSelfShadow ){
  1078.      fDot *= ComputeSelfShadow(3,4,TexCoord[i+1],fTexCoord);
  1079.     }     
  1080.     FinalColor += ((float4)fDot *  g_fDiffuseColor[i] * TexCoord[i+1].w);
  1081.    } 
  1082.    
  1083.    FinalColor.w = tex2D(g_samAlphaMap1,fTexCoord).w;
  1084.    
  1085.    return FinalColor;
  1086. }
  1087. float4 BlinnBumpMapping( float2 TexCoord : TEXCOORD0, float3 EnvXform[3] : TEXCOORD1 ) : COLOR
  1088. {    
  1089.     float3 N = tex2D(g_samNormalMap, TexCoord);
  1090.     float3 Nworld;
  1091.     Nworld.x = dot(N*2-1, EnvXform[0]);
  1092.     Nworld.y = dot(N*2-1, EnvXform[1]);
  1093.     Nworld.z = dot(N*2-1, EnvXform[2]);
  1094.     float4 diffuse = texCUBE(g_samCubeMap, Nworld);
  1095.     return (diffuse * g_fBlinnProperties);
  1096. }
  1097. #endif //__PIXELSHADERS_FX__
  1098.