home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2005 May / Gamestar_73_2005-05_dvd.iso / Programy / ATITool_0.0.23.exe / ATITool.exe / 1031 / RCDATA / 150 < prev    next >
Encoding:
Text File  |  2005-01-10  |  10.6 KB  |  411 lines
  1. //
  2. // Fur effect using shells and fins
  3. //
  4. // Note: This effect file does not work with EffectEdit.
  5. //
  6. #define C_ZERO              0 
  7. #define C_ONE               1 
  8. #define C_HALF              2 
  9. #define C_MATTOTAL          4 
  10. #define C_MATWORLD          8 
  11. #define C_LIGHT_DIRECTION   20
  12. #define C_LIGHT_AMBIENT     21
  13. #define C_LIGHT_DIFFUSE     22
  14. #define C_LIGHT_SPECULAR    23
  15. #define C_MATERIAL_SPECULAR 26
  16. #define C_EYE_POSITION      27
  17. #define C_DISPLACEMENTS     30
  18.  
  19.  
  20.  
  21. // light direction
  22. float3 L = normalize(float3(-0.2182f, -0.8729f, 0.4364f));
  23.  
  24. // light intensity
  25. float4 I_a = float4(0.1f, 0.1f, 0.1f, 1.0f);    // ambient
  26. float4 I_d = float4(0.3f, 0.3f, 0.3f, 1.0f);    // diffuse
  27. float4 I_s = float4(0.9f, 0.9f, 1.0f, 1.0f);    // reflective
  28.  
  29. // material specular 
  30. float4 k_s = float4(1.0f, 1.0f, 1.0f, 1.0f);
  31.  
  32. // transformations
  33. float4x4 World      : WORLD;
  34. float4x4 View       : VIEW;
  35. float4x4 Projection : PROJECTION;
  36.  
  37. // eye position
  38. float3 Eye;
  39.  
  40. // textures
  41. texture FinTex;
  42. texture ShellTex;
  43.  
  44. // shell properties
  45. float ShellThickness = 0.5f;
  46. float ShellScalingFactor;
  47.  
  48. static const float4 vOne = float4(1, 1, 1, 1);
  49.  
  50. // vertex shaders
  51. VertexShader ShellVS = asm
  52. {
  53.     ;------------------------------------------------------------------------------
  54.     ; Constants specified by the app
  55.     ;    c0      = ( 0, 0, 0, 0 )
  56.     ;    c1      = ( 1, 1, 1, 1 )
  57.     ;    c4-c7   = matWorldViewProjection
  58.     ;    c8-c10  = matWorld
  59.     ;    c20     = light direction (in model space)
  60.     ;    c21     = light ambient
  61.     ;    c22     = light diffuse
  62.     ;    c23     = light specular
  63.     ;    c26     = material specular
  64.     ;    c27     = eye position (world space)
  65.     ;    c30.x   = normal displacement total
  66.     ;    c30.y   = normal displacement as a 0 to 1 pct of total
  67.     ;    c30.z   = self-shadowing factor
  68.     ;
  69.     ; Vertex components (as specified in the vertex DECL)
  70.     ;    v0    = Position
  71.     ;    v3    = Normal
  72.     ;    v4    = diffuse
  73.     ;    v6    = Texcoords
  74.     ;------------------------------------------------------------------------------
  75.     vs.1.1
  76.  
  77.     dcl_position v0
  78.     dcl_normal   v3
  79.     dcl_color0   v4
  80.     dcl_texcoord v6
  81.  
  82.     // OUTPUT POSITION
  83.     // in model space, add some normal to the position
  84.     mul r5.z, c30.x, c30.y
  85.     mul r5, r5.z, v3
  86.     add r5, r5, v0
  87.     mov r5.w, v0.w
  88.  
  89.     // transform vertex position by total matrix and output it
  90.     dp4 oPos.x, r5, c4
  91.     dp4 oPos.y, r5, c5
  92.     dp4 oPos.z, r5, c6
  93.     dp4 oPos.w, r5, c7
  94.  
  95.     // LIGHTING - WORK IN WORLD SPACE
  96.     // Lighting is Ka + Kd(1-NdotL^2) + Ks(1-NdotH^2)
  97.     // An alternative to calculating the total lighting here
  98.     // is to map the total light into a texture(u,v) where
  99.     // u maps to NdotL
  100.     // v maps to NdotH
  101.     // transform normal by world matrix
  102.     dp3 r6.x, v3, c8
  103.     dp3 r6.y, v3, c9
  104.     dp3 r6.z, v3, c10
  105.  
  106.     // normalize normal
  107.     dp3 r6.w, r6, r6
  108.     rsq r6.w, r6.w
  109.     mul r6, r6, r6.w
  110.  
  111.     // AMBIENT TERM 
  112.     // modulate light ambient by material ambient
  113.     mul r0, v4, c21
  114.  
  115.     // DIFFUSE TERM
  116.     // For lighing purposes, consider the hair "direction" to be equivalent to the vertex normal (v3-r6).
  117.     // For "directional" hair a second normal could be generated into Stream(1). This vector would contain
  118.     // the general direction of the hair (to be used for lighting).
  119.     // calculate light dot product with normal
  120.     dp3 r2, r6, -c20
  121.  
  122.     // take Kd(1-LdotN^2)
  123.     mad r2.x, r2.x, -r2.x, c1.x
  124.     // modulate by light diffuse
  125.     mul r2, r2.x, c22
  126.     // modulate by material diffuse
  127.     mad r0, r2, v4, r0
  128.  
  129.     // SPECULAR TERM
  130.     // rather than use the "infinite viewer" eyepoint we can calculate it on a per-vertex basis
  131.     // find eye direction
  132.     add r3, v0, -c27
  133.     // normalize the eye direction
  134.     dp3 r3.w, r3, r3
  135.     rsq r3.w, r3.w
  136.     mul r3, r3, r3.w
  137.  
  138.     // add eye normal - light direction
  139.     add r3, -c20, r3
  140.  
  141.     // normalize half-vector
  142.     dp3 r3.w, r3, r3
  143.     rsq r3.w, r3.w
  144.     mul r3, r3, r3.w
  145.  
  146.     // evaluate (1-NdotH^2)
  147.     dp3 r3.x, r6, r3
  148.     mad r3.x, r3.x, -r3.x, c1.x
  149.     // modulate by light specular
  150.     mul r3, r3.x, c23
  151.  
  152.     // modulate by material specular, and add accumulator to yield final color
  153.     mad r0, r3, c26, r0
  154.     // now self-shadow "final" color
  155.     mul oD0, c30.z, r0
  156.     // make the shell diffuse opaque
  157.     // this lets the texture control transparency by its alpha channel
  158.     mov oD0.w, c1.w
  159.  
  160.     // output the texture coordinates
  161.     mov oT0, v6
  162. };
  163.  
  164.  
  165. VertexShader FinVS = asm
  166. {
  167.     ;------------------------------------------------------------------------------
  168.     ; Constants specified by the app
  169.     ;    c0      = ( 0, 0, 0, 0 )
  170.     ;    c1      = ( 1, 1, 1, 1 )
  171.     ;    c2      = (.5,.5,.5,.5 )
  172.     ;    c4-c7   = matWorldViewProjection
  173.     ;    c8-c10  = matWorld
  174.     ;    c20     = light direction (in model space)
  175.     ;    c21     = light ambient
  176.     ;    c22     = light diffuse
  177.     ;    c23     = light specular
  178.     ;    c26     = material specular
  179.     ;    c27     = eye position (world space)
  180.     ;    c30.x   = normal displacement total
  181.     ;
  182.     ; Vertex components (as specified in the vertex DECL)
  183.     ;    v0    = Position
  184.     ;    v3    = Normal
  185.     ;    v4    = diffuse
  186.     ;    v6    = Texcoords    Note: v6.y is used as an extrusion factor
  187.     ;------------------------------------------------------------------------------
  188.     vs.1.1
  189.  
  190.     dcl_position    v0
  191.     dcl_normal      v3
  192.     dcl_color0      v4
  193.     dcl_texcoord    v6
  194.  
  195.     // OUTPUT POSITION
  196.     // in model space, extrude vertex out by texture v coord, inverting it's direction (v6'.y = 1 - v6.y)
  197.     mad r5.z, -c30.x, v6.y, c30.x
  198.     // multiply the normal by the extrusion value
  199.     mul r5, r5.z, v3
  200.     // add to v0
  201.     add r5, r5, v0
  202.     mov r5.w, v0.w
  203.  
  204.     // transform vertex position by total matrix and output it
  205.     dp4 oPos.x, r5, c4
  206.     dp4 oPos.y, r5, c5
  207.     dp4 oPos.z, r5, c6
  208.     dp4 oPos.w, r5, c7
  209.  
  210.     // LIGHTING - WORK IN WORLD SPACE
  211.     // Lighting is Ka + Kd(1-NdotL^2) + Ks(1-NdotH^2)
  212.     // An alternative to calculating the total lighting here
  213.     // is to map the total light into a texture(u,v) where
  214.     // u maps to NdotL
  215.     // v maps to NdotH
  216.     // transform normal by world matrix
  217.     dp3 r6.x, v3, c8
  218.     dp3 r6.y, v3, c9
  219.     dp3 r6.z, v3, c10
  220.  
  221.     // normalize normal
  222.     dp3 r6.w, r6, r6
  223.     rsq r6.w, r6.w
  224.     mul r6, r6, r6.w
  225.  
  226.     // AMBIENT TERM 
  227.     // modulate light ambient by material ambient
  228.     mul r0, v4, c21
  229.  
  230.     // DIFFUSE TERM
  231.     // For lighing purposes, consider the hair "direction" to be equivalent to the vertex normal (v3-r6).
  232.     // For "directional" hair a second normal could be generated into Stream(1). This vector would contain
  233.     // the general direction of the hair (to be used for lighting).
  234.     // calculate light dot product with normal
  235.     dp3 r2, r6, -c20
  236.  
  237.     // take Kd(1-LdotN^2)
  238.     mad r2.x, r2.x, -r2.x, c1.x
  239.     // modulate by light diffuse
  240.     mul r2, r2.x, c22
  241.     // modulate by material diffuse
  242.     mad r0, r2, v4, r0
  243.  
  244.     // SPECULAR TERM
  245.     // rather than use the "infinite viewer" eyepoint we can calculate it on a per-vertex basis
  246.     // find eye direction
  247.     add r3, v0, -c27
  248.     // normalize eye direction
  249.     dp3 r3.w, r3, r3
  250.     rsq r3.w, r3.w
  251.     mul r3, r3, r3.w
  252.  
  253.     // fade the fin in as it enters the model silhouette
  254.     dp3 r2.w, r3, r6
  255.     mad oD0.w, r2.w, -r2.w, c1.w
  256.  
  257.     // add eye normal - light direction
  258.     add r3, -c20, r3
  259.  
  260.     // normalize half-vector
  261.     dp3 r3.w, r3, r3
  262.     rsq r3.w, r3.w
  263.     mul r3, r3, r3.w
  264.  
  265.     // evaluate (1-LdotH^2)
  266.     dp3 r3.x, r6, r3
  267.     mad r3.x, r3.x, -r3.x, c1.x
  268.     // modulate by light specular
  269.     mul r3, r3.x, c23
  270.  
  271.     // modulate by material specular, and add accumulator to yield final color
  272.     mad r3, r3, c26, r0
  273.     // set self-shadowing to .5 -> 1.
  274.     max r7.y, c2.y, v6.y
  275.     mul oD0.xyz, r7.y, r3.xyz
  276.  
  277.     // output the texture coordinates
  278.     mov oT0, v6
  279. };
  280.  
  281. // sampler
  282. sampler ClampedLinear = 
  283. sampler_state
  284. {
  285.     Texture   = NULL;
  286.     AddressU  = CLAMP;
  287.     AddressV  = CLAMP;
  288.     MipFilter = LINEAR;
  289.     MinFilter = LINEAR;
  290.     MagFilter = LINEAR;
  291. };
  292.  
  293. // techniques
  294. technique Init
  295. {
  296.     pass P0
  297.     {
  298.         // render states
  299.         CullMode = NONE;
  300.  
  301.         AmbientMaterialSource = COLOR1;
  302.         DiffuseMaterialSource = COLOR1;
  303.  
  304.         BlendOp   = ADD;
  305.         SrcBlend  = SRCALPHA;
  306.         DestBlend = INVSRCALPHA;
  307.  
  308.         AlphaTestEnable = FALSE;
  309.         AlphaFunc       = GREATER;
  310.         AlphaRef        = 0;
  311.  
  312.         AlphaBlendEnable = TRUE;
  313.  
  314.         // texture stage states
  315.         AlphaOp[0]   = MODULATE;
  316.         AlphaArg1[0] = TEXTURE;
  317.         AlphaArg2[0] = CURRENT;
  318.  
  319.         // sampler
  320.         Sampler[0]  = (ClampedLinear);
  321.  
  322.         // lighting
  323.         LightType[0]      = DIRECTIONAL;
  324.         LightDirection[0] = (L);
  325.         LightAmbient[0]   = (I_a);
  326.         LightDiffuse[0]   = (I_d);
  327.         LightSpecular[0]  = (I_s);
  328.         LightEnable[0]    = TRUE;
  329.  
  330.         Lighting = FALSE;
  331.  
  332.         // vertex shader constants
  333.         VertexShaderConstantF[C_ZERO]              = (0.0f * vOne);
  334.         VertexShaderConstantF[C_ONE]               = (1.0f * vOne);
  335.         VertexShaderConstantF[C_HALF]              = (0.5f * vOne);
  336.         VertexShaderConstantF[C_LIGHT_DIRECTION]   = (L);
  337.         VertexShaderConstantF[C_LIGHT_AMBIENT]     = (I_a);
  338.         VertexShaderConstantF[C_LIGHT_DIFFUSE]     = (I_d);
  339.         VertexShaderConstantF[C_LIGHT_SPECULAR]    = (I_s);
  340.         VertexShaderConstantF[C_MATERIAL_SPECULAR] = (k_s);
  341.  
  342.         // transforms
  343.         ViewTransform       = (View);
  344.         ProjectionTransform = (Projection);
  345.     }
  346. }
  347.  
  348. technique Base
  349. {
  350.     pass P0
  351.     {
  352.         // render states
  353.         CullMode = CCW;
  354.  
  355.         AlphaBlendEnable = FALSE;
  356.  
  357.         // lighting
  358.         Lighting = TRUE;
  359.  
  360.         // fixed function
  361.         VertexShader = NULL;
  362.         FVF = XYZ | NORMAL | DIFFUSE;
  363.  
  364.         // transforms
  365.         WorldTransform[0]   = (World);
  366.     }
  367. }
  368.  
  369.  
  370. technique Fins
  371. {
  372.     pass P0
  373.     {
  374.         // render states
  375.         ZWriteEnable = FALSE;
  376.  
  377.         // texture
  378.         Texture[0] = (FinTex);
  379.  
  380.         // vertex shader
  381.         VertexShader = (FinVS);
  382.  
  383.         VertexShaderConstantF[C_DISPLACEMENTS] = float4(ShellThickness, 0.0f, 1.0f, 0.0f);
  384.         VertexShaderConstantF[C_EYE_POSITION]  = (Eye);
  385.         VertexShaderConstantF[C_MATTOTAL]      = (mul(mul(World, View), Projection));
  386.         VertexShaderConstantF[C_MATWORLD]      = (World);
  387.     }
  388. }
  389.  
  390.  
  391. technique Shells
  392. {
  393.     pass P0
  394.     {
  395.         // render states
  396.         AlphaTestEnable  = TRUE;
  397.  
  398.         // texture
  399.         Texture[0] = (ShellTex);
  400.  
  401.         // vertex shader
  402.         VertexShader = (ShellVS);
  403.  
  404.         VertexShaderConstantF[C_DISPLACEMENTS] = float4(0.5f * ShellThickness, ShellScalingFactor, 0.5f * (1 + ShellScalingFactor), 0.0f) ;
  405.         VertexShaderConstantF[C_EYE_POSITION]  = (Eye);
  406.         VertexShaderConstantF[C_MATTOTAL]      = (mul(mul(World, View), Projection));
  407.         VertexShaderConstantF[C_MATWORLD]      = (World);
  408.     }
  409. }
  410.  
  411.