home *** CD-ROM | disk | FTP | other *** search
/ DarkBasic Professional / DarkBasicPro.iso / data1.cab / Lang_Files_(English) / Compiler / effects / bump.fx next >
Encoding:
Text File  |  2004-09-22  |  7.9 KB  |  344 lines
  1. //
  2. // Bump2
  3. //
  4.  
  5. // Constants
  6. float4 lhtDir < string UIDirectional = "Light Direction"; >; 
  7. float4 lhtPos < string UIPosition = "Light Position"; >;
  8. vector vCPS : CameraPosition;  
  9. matrix mTot : WorldViewProjection;
  10. matrix mWldInv : WorldIT;
  11. matrix mWld :  World; 
  12.  
  13. // Model and Texture Names
  14. string XFile = "default.x";
  15. texture tBase < string name = "base.tga"; >;
  16. texture tBump < string name = "bump.dds"; >;
  17.  
  18. struct VS_INPUT
  19. {
  20.     float4  Pos     : POSITION;
  21.     float3  Normal  : NORMAL;
  22.     float3  Tex0    : TEXCOORD0;
  23.     float3  Tangent : TANGENT;    
  24. };
  25.  
  26. struct VS_OUTPUT
  27. {
  28.     float4  Pos           : POSITION;
  29.     float3  tLight        : COLOR;
  30.     float3  tNormal       : TEXCOORD0;   
  31.     float3  depRead       : TEXCOORD1;    
  32.     float3  tH            : TEXCOORD2; 
  33.     float3  Tex0          : TEXCOORD3;    
  34. };
  35.  
  36. VS_OUTPUT VShade(VS_INPUT i, uniform int ShadeMethod)
  37. {
  38.     VS_OUTPUT   o;
  39.     float3      wNormal, wTangent, wBinorm, tLight;
  40.     
  41.     //tranform position    
  42.     o.Pos = mul( i.Pos, mTot); 
  43.            
  44.     //transform normal
  45.     //and tangent
  46.     wNormal = mul( i.Normal, mWld );
  47.     wTangent = mul( i.Tangent, mWld );
  48.  
  49.     //lee, normalize to defeat scaled world matrices
  50.     wNormal = normalize(wNormal);
  51.     wTangent = normalize(wTangent);
  52.  
  53.     //Cross product to create BiNormal
  54.     wBinorm = cross( wTangent, wNormal );
  55.  
  56.     // The first method is diffuse dot3 bumpmap
  57.     // transform the light vector into Tangent Space   
  58.     float3x3 tangentMatrix = {wTangent, wBinorm, wNormal};
  59.     tangentMatrix = transpose( tangentMatrix);
  60.     tLight = mul(-lhtDir, tangentMatrix);
  61.    
  62.     // all other methods are specular dot3 bump 
  63.     // and therefore use the half angle instead of the light       
  64.     // compute the half angle vector    
  65.     float3 wPos, H, tH;
  66.         
  67.     wPos = mul( i.Pos, mWld); 
  68.        
  69.     H = vCPS - wPos;
  70.     H = normalize(H);
  71.       
  72.     H = H -lhtDir.xyz;
  73.     H = normalize(H);
  74.  
  75.     //transform the half angle vector into tangent space
  76.     tH = mul(H, tangentMatrix);
  77.     o.tH = tH;
  78.     o.depRead = tH;    
  79.  
  80.     if (ShadeMethod==1)
  81.        tLight = tH;
  82.  
  83.     //mutiply by a half to bias, then add half
  84.     o.tLight = 0.5f + tLight * 0.5f;
  85.    
  86.     // Copy UVs
  87.     o.Tex0 = i.Tex0;                  
  88.     o.tNormal = i.Tex0;                  
  89.     
  90.     return o;
  91. }    
  92.  
  93. uniform sampler   sampler0 = 
  94. sampler_state 
  95. {
  96.     texture = <tBase>;
  97.     MinFilter = Linear;
  98.     MagFilter = Linear;
  99.     MipFilter = Linear;
  100.     AddressU = Wrap;
  101.     AddressV = Wrap;
  102.     AddressW = Wrap;
  103. };
  104.  
  105. uniform sampler   sampler1 = 
  106. sampler_state 
  107. {
  108.     texture = <tBump>;
  109.     MinFilter = Linear;
  110.     MagFilter = Linear;
  111.     MipFilter = Linear;
  112.     AddressU = Wrap;
  113.     AddressV = Wrap;
  114.     AddressW = Wrap;
  115. };
  116.  
  117. struct PS_INPUT
  118. {
  119.     float3  tLight        : COLOR;
  120.     float3  tNormal       : TEXCOORD0;    
  121.     float3  depRead       : TEXCOORD1;    
  122.     float3  tH            : TEXCOORD2;    
  123.     float3  Tex0          : TEXCOORD3;    
  124. };
  125.  
  126. struct PS_OUTPUT
  127. {
  128.     float4  Col        : COLOR;
  129. };
  130.               
  131. PS_OUTPUT PShade(PS_INPUT i, uniform int ShadeMethod)
  132. {
  133.     PS_OUTPUT o;
  134.     float4    cosang, t0, t1;
  135.     float3    tLight;
  136.     
  137.     // Sample diffuse texture and Normal map    
  138.     t0 = tex2D( sampler0, i.Tex0);
  139.     // _bx2 = 2 * source - 1
  140.     t1 = 2 * tex2D( sampler1, i.tNormal) - 1;
  141.     tLight = 2 * i.tLight - 1;
  142.        
  143.     // DP Lighting in tangent space (where normal map is based)
  144.     cosang = dot( t1, tLight );    
  145.     if (ShadeMethod==1) 
  146.     {
  147.           cosang = cosang * cosang;
  148.           cosang = cosang * cosang;
  149.           cosang = cosang * cosang;
  150.           cosang = cosang * cosang;                              
  151.     }        
  152.  
  153.     // Modulate with diffuse texture    
  154.     o.Col = t0 * cosang;
  155.    
  156.     return o;
  157. }
  158.  
  159. PS_OUTPUT PShade2(PS_INPUT i)
  160. {
  161.     PS_OUTPUT o;
  162.     float4    cosang, tDiffuse, tNormal, col;
  163.     float3    tLight;
  164.     
  165.     // Sample diffuse texture and Normal map    
  166.     tDiffuse = tex2D( sampler0, i.Tex0 );    
  167.  
  168.     // sample tLight
  169.     // _bx2 = 2 * source - 1
  170.     tNormal = 2 * tex2D( sampler1, i.tNormal) - 1;
  171.     tLight = 2 * i.tLight - 1;
  172.       
  173.     // DP Lighting in tangent space (where normal map is based)
  174.     col = dot( tNormal, tLight ) * tDiffuse;    
  175.     
  176.     cosang = dot( tNormal,i.tH );    
  177.     cosang = pow( cosang, 32);    
  178.  
  179.     // Modulate with diffuse texture    
  180.     col = col  + cosang;
  181.  
  182.     o.Col = col;
  183.    
  184.     return o;
  185. }
  186.  
  187. technique tec0
  188. { 
  189.     pass p0
  190.     {
  191.         VertexShaderConstant[0] = <mTot>; 
  192.         VertexShaderConstant[4] = <mWldInv>;
  193.         VertexShaderConstant[8] = <lhtPos>;
  194.         VertexShaderConstant[9] = <vCPS>;
  195.         VertexShaderConstant[10] = { 0, 0.5, 1, 2 };
  196.  
  197.         PixelShaderConstant[0] = { 0, 0.5, 1, -0.2 };
  198.         PixelShaderConstant[1] = { 66, 66, 66, 66 };
  199.         PixelShaderConstant[2] = { 0.985, 1, 0.945, 1 };
  200.         PixelShaderConstant[3] = { 1, 1, 1, 1 };
  201.         PixelShaderConstant[4] = { 2, 0.5, 4, 8 };
  202.  
  203.         Texture[0]   = <tBase>;
  204.         Texture[1]   = <tBump>;
  205.  
  206.         AddressU[0] = wrap;
  207.         AddressU[1] = wrap;
  208.  
  209.         MinFilter[0] = Linear;
  210.         MagFilter[0] = Linear;
  211.         MipFilter[0] = Linear;
  212.         MinFilter[1] = Linear;
  213.         MagFilter[1] = Linear;
  214.         MipFilter[1] = Linear;
  215.  
  216.         VertexShader = 
  217.         asm
  218.         {
  219.     vs.1.1
  220.  
  221.     dcl_position   v0
  222.     dcl_normal     v1
  223.     dcl_texcoord   v2
  224.     dcl_tangent    v3
  225.     dcl_binormal   v4
  226.  
  227.     ; xform and output vertex
  228.     m4x4 oPos, v0, c0
  229.  
  230.     ; base map and bump map texture coordinates
  231.     mov  oT0, v2
  232.     mov  oT1, v2
  233.  
  234.     ; find light position in object space 
  235.     mov r1, c8
  236.     m4x4 r0, r1, c4
  237.  
  238.     ; find light vector in object space
  239.     sub r0, r0, v0
  240.  
  241.     ; normalize light vector
  242.     dp3 r1.x, r0, r0
  243.     rsq r1.x, r1.x
  244.     mul r0, r0.xyz, r1.xxx
  245.  
  246.     ; move light vector into tangent space
  247.     dp3 r1.x, r0, v3  ; tangent
  248.     dp3 r1.y, r0, v4  ; binormal
  249.     dp3 r1.z, r0, v1  ; normal
  250.  
  251.     mov oT2, r1  ; light vector into tex coord2 (to index normalizer cubemap)
  252.     mov r5, r1   ; cache light vector in r5 for later use
  253.  
  254.     ; find eye position in object space 
  255.     mov r1, c9
  256.     m4x4 r0, r1, c4
  257.  
  258.     ; find view vector in object space
  259.     sub r0, r0, v0
  260.  
  261.     ; normalize view vector
  262.     dp3 r1.x, r0, r0
  263.     rsq r1.x, r1.x
  264.     mul r0, r0.xyz, r1.xxx
  265.  
  266.     ; move view vector into tangent space
  267.     dp3 r1.x, r0, v3  ; tangent
  268.     dp3 r1.y, r0, v4  ; binormal
  269.     dp3 r1.z, r0, v1  ; normal
  270.  
  271.     ; find half angle vector (L + V) / 2
  272.     add r2, r1, r5
  273.  
  274.     ; normalize half angle vector
  275.     dp3 r1.x, r2, r2
  276.     rsq r1.x, r1.x
  277.     mul r2, r2.xyz, r1.xxx
  278.  
  279.     mov oT3, r2  ; half angle vector into tex coord3 (to index normalizer cubemap)
  280.         };
  281.  
  282.  
  283.         PixelShader = 
  284.         asm
  285.         {
  286.        ps.2.0
  287.  
  288.        dcl t0
  289.        dcl t1
  290.        dcl t2
  291.        dcl t3
  292.  
  293.        dcl_2d   s0
  294.        dcl_2d   s1
  295.  
  296.        texld r0, t0, s0 ; base map
  297.        texld r1, t1, s1 ; bump map
  298.  
  299.        ; normalize L
  300.        dp3 r2.x, t2, t2
  301.        rsq r2.x, r2.x
  302.        mul r2, t2, r2.x
  303.  
  304.        ; normalize H
  305.        dp3 r3.x, t3, t3
  306.        rsq r3.x, r3.x
  307.        mul r3, t3, r3.x
  308.  
  309.        ; scale and bias N
  310.        sub r1, r1, c4.y
  311.        mul r1, r1, c4.x
  312.  
  313.        ; N.L
  314.        dp3_sat r2, r1, r2
  315.  
  316.        ; N.L * diffuse_light_color
  317.        mul r2, r2, c2
  318.    
  319.        ; (N.H)
  320.        dp3_sat r1, r1, r3
  321.  
  322.        ; (N.H)^k
  323.        pow r1, r1.x, c1.x
  324.  
  325.        ; (N.H)^k * specular_light_color
  326.         mul r1, r1, c3
  327.  
  328.        ; [(N.L) * base] + (N.H)^k
  329.        mad_sat r0, r0, r0, r1
  330.    
  331.        mov oC0, r0
  332.         };
  333.     }
  334. }
  335.  
  336. technique tec1
  337. { 
  338.     pass p0
  339.     {      
  340.         VertexShader = compile vs_1_1 VShade(0);
  341.         PixelShader = compile ps_1_1 PShade(0);
  342.     }
  343. }
  344.