home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2005 April / Gamestar_72_2005-04_dvd.iso / Dema / Liquidator / Liquidator.tma / data / renderer / sfx.fx < prev    next >
Text File  |  2004-12-10  |  20KB  |  523 lines
  1. #ifndef __SFX_FX__
  2. #define __SFX_FX__
  3.  
  4. #define MESHARRAY_FADE_RANGE     arrayMeshArrayData[vsc_mesharray_const].x
  5. #define MESHARRAY_FADE_DISTANCE  arrayMeshArrayData[vsc_mesharray_const].y
  6.  
  7. #define MESHARRAY_CAM_POS        arrayMeshArrayData[vsc_mesharray_campos].xyz
  8.  
  9. //#define MESHARRAY_IN_INDEX       g_fFixedUser0.w
  10. #define MESHARRAY_IN_S           g_fFixedUser0.xyz
  11.  
  12. int Float2Int(float v)
  13. {
  14.   //return D3DCOLORtoUBYTE4((v + 0.2f)/ 255.001953f );
  15.   return floor(v);
  16. }
  17.  
  18. float GetDistanceFraction(float fDist, float fFadeDist, float fFadeRange){
  19.   float fFraction = (fDist - fFadeDist) / fFadeRange;
  20.   return clamp(fFraction, 0.0f, 1.0f);
  21. }
  22.  
  23. void MeshArrayTransform( uniform bool m_bNeedNormal, uniform bool m_bNeedTangent ){
  24.   int index = Float2Int(g_fFixedUser0.w);
  25.   float3 color = arrayMeshArrayData[index + vsc_mesharray_data + 3];
  26.   g_fColor0.xyz += color;
  27.   //g_fVertexLightColor.xyz += color;;
  28.   
  29.   float4 k1 = arrayMeshArrayData[index + vsc_mesharray_data];
  30.   float4 k2 = arrayMeshArrayData[index + vsc_mesharray_data + 1];
  31.   float4 k3 = arrayMeshArrayData[index + vsc_mesharray_data + 2];
  32.   float3 fPos;
  33.   g_fVertexPosition.w   = 1.0f;//1.0f;
  34.   fPos.x = dot(g_fVertexPosition, k1);
  35.   fPos.y = dot(g_fVertexPosition, k2);
  36.   fPos.z = dot(g_fVertexPosition, k3);
  37.   g_fVertexPosition.xyz = fPos;
  38.  
  39.   float fLenght = length(MESHARRAY_CAM_POS - g_fVertexPosition.xyz);
  40.   float fFadeDistance = MESHARRAY_FADE_DISTANCE;
  41.   float fFadeRange = MESHARRAY_FADE_RANGE;
  42.   float fFraction = GetDistanceFraction(fLenght, fFadeDistance, fFadeRange);// (fLenght - fCullDistance) / fFadeDistance;
  43.   g_fColor0.w = lerp( g_fColor0.w, 0.005f, fFraction);
  44.   
  45.   if (m_bNeedNormal) {
  46.       float3 fArrayNormal;
  47.       fArrayNormal.x = dot(g_fNormal, k1);
  48.     fArrayNormal.y = dot(g_fNormal, k2);
  49.     fArrayNormal.z = dot(g_fNormal, k3);    
  50.     g_fNormal = fArrayNormal;
  51.     //g_fNormal = normalize(g_fNormal);
  52.   }
  53.   if (m_bNeedTangent) {
  54.       float3 fArrayS;
  55.       fArrayS.x = dot(MESHARRAY_IN_S, k1);
  56.     fArrayS.y = dot(MESHARRAY_IN_S, k2);
  57.     fArrayS.z = dot(MESHARRAY_IN_S, k3);    
  58.   
  59.     g_fS = fArrayS;
  60.     g_fT = normalize(cross(g_fS, g_fNormal));  
  61.     g_fSxT = g_fNormal;
  62.   }
  63.   
  64. }
  65.  
  66.  
  67. #define VEGETATION_BEND_FACTOR    arrayVegetationData[vsc_vegetation_const].x
  68. #define VEGETATION_TIME           arrayVegetationData[vsc_vegetation_const].y
  69. #define VEGETATION_FADE_RANGE     arrayVegetationData[vsc_vegetation_const].z
  70. #define VEGETATION_FADE_DISTANCE  arrayVegetationData[vsc_vegetation_const].w
  71.  
  72. #define VEGETATION_CAM_POS        arrayVegetationData[vsc_vegetation_campos].xyz
  73.  
  74. //#define VEGETATION_IN_INDEX       g_fFixedUser0.x
  75. #define VEGETATION_IN_BEND        g_fFixedUser0.y
  76.  
  77.  
  78. void VegetationTransform( uniform bool m_bNeedNormal, uniform bool m_bNeedTangent ){
  79.   int index = Float2Int(g_fFixedUser0.x);
  80.   float3 posOffset = arrayVegetationData[index + vsc_vegetation_data];
  81.   g_fVertexPosition.xyz = g_fVertexPosition.xyz + posOffset;
  82.   g_fVertexPosition.w   = 1.0f;
  83.   float3 avmSumLight = arrayVegetationData[index + vsc_vegetation_data + 1];
  84.   g_fColor1.xyz += avmSumLight;
  85.   float fPhase = 6.2831853071795864f * (VEGETATION_TIME * 0.5f + (g_fVertexPosition.x + g_fVertexPosition.z) / 10.0f);
  86.   float s,c;    
  87.   sincos(fPhase,s,c);
  88.   float fBend = VEGETATION_BEND_FACTOR * VEGETATION_IN_BEND;
  89.   g_fVertexPosition.x += fBend * s;
  90.   g_fVertexPosition.z += fBend * c;
  91.   float fLenght = length(VEGETATION_CAM_POS - g_fVertexPosition.xyz);
  92.   float fFadeDistance = VEGETATION_FADE_DISTANCE;
  93.   float fFadeRange    = VEGETATION_FADE_RANGE;
  94.   float fFraction = GetDistanceFraction(fLenght, fFadeDistance, fFadeRange);// (fLenght - fCullDistance) / fFadeDistance;
  95.   g_fColor0.w = lerp( g_fColor0.w, 0.005f, fFraction);
  96. }
  97.  
  98. float2 CalculateVertexOffset(in float2 vTexCoord, in float fPolarity) 
  99. { 
  100.   float2 offset = -2.0f * vTexCoord + 1.0f;
  101.   offset.x *= fPolarity;
  102.   return offset;
  103. }
  104.  
  105. void AureolTransform( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  106.   
  107.   float fRadius = arrayAureolData[vsc_aureol_bbconst].x;
  108.   float fPolarity = arrayAureolData[vsc_aureol_bbconst].z;
  109.   float2 offset = fRadius * CalculateVertexOffset(g_fTexCoords[0].xy, fPolarity);
  110.  
  111.   float co = arrayAureolData[vsc_aureol_bbconst2].x;
  112.   float si = arrayAureolData[vsc_aureol_bbconst2].y;
  113.  
  114.   float3 offSetRot;
  115.   offSetRot.x = offset.x * co - offset.y * si;
  116.   offSetRot.y = offset.x * si + offset.y * co;
  117.   offSetRot.z = 0.0f;
  118.   
  119.   float3 viewOffset;
  120.   viewOffset.x = dot((float3)arrayAureolData[vsc_sfx_matViewInv4x3+0], offSetRot);
  121.   viewOffset.y = dot((float3)arrayAureolData[vsc_sfx_matViewInv4x3+1], offSetRot);
  122.   viewOffset.z = dot((float3)arrayAureolData[vsc_sfx_matViewInv4x3+2], offSetRot);
  123.   
  124.   g_fVertexPosition.xyz = arrayAureolData[vsc_aureol_origin].xyz + viewOffset.xyz;
  125.   g_fVertexPosition.w = 1.0f;
  126.  
  127.   float fFade = arrayAureolData[vsc_aureol_bbconst].y;
  128.   g_fColor0 = arrayAureolData[vsc_aureol_diffuse] * fFade;
  129. }
  130.  
  131.  
  132. void ProjectorTransform( uniform bool m_bNeedNormal, uniform bool m_bNeedTangent ){
  133.   float fHalfWidth = arrayProjectorData[vsc_projector_bbconst].x;
  134.   float3 eyePos;
  135.   eyePos.x = arrayProjectorData[vsc_sfx_matViewInv4x3+0].w;
  136.   eyePos.y = arrayProjectorData[vsc_sfx_matViewInv4x3+1].w;
  137.   eyePos.z = arrayProjectorData[vsc_sfx_matViewInv4x3+2].w;
  138.  
  139.   float3 up     = arrayProjectorData[vsc_projector_up];
  140.   float3 origin = arrayProjectorData[vsc_projector_origin];
  141.   float3 vEyeObjDir = eyePos - origin;
  142.   float3 right  = fHalfWidth * normalize( cross(up, vEyeObjDir) );
  143.  
  144.   float  fPolarity = arrayProjectorData[vsc_projector_bbconst].z;
  145.   float2 offset = CalculateVertexOffset(g_fTexCoords[0].xy, fPolarity);
  146.  
  147.   g_fVertexPosition.xyz = origin + offset.x * right + offset.y  * up;
  148.   g_fVertexPosition.w   = 1.0f;
  149.  
  150.   float fFade = arrayProjectorData[vsc_projector_bbconst].y;
  151.   g_fColor0 = arrayProjectorData[vsc_projector_diffuse] * fFade;
  152. }
  153.  
  154. void LensFlareTransform( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  155.   float fPolarity = arrayLensFlareData[vsc_lensflare_bbconst].z;
  156.   float fRadius = arrayLensFlareData[vsc_lensflare_bbconst].x;
  157.   float3 offset;
  158.   offset.xy = fRadius * CalculateVertexOffset(g_fTexCoords[0].xy, fPolarity);
  159.   offset.z = 0.0f;
  160.   float3 viewOffset;
  161.   viewOffset.x = dot((float3)arrayLensFlareData[vsc_sfx_matViewInv4x3+0], offset);
  162.   viewOffset.y = dot((float3)arrayLensFlareData[vsc_sfx_matViewInv4x3+1], offset);
  163.   viewOffset.z = dot((float3)arrayLensFlareData[vsc_sfx_matViewInv4x3+2], offset);
  164.   
  165.   g_fVertexPosition.xyz = arrayLensFlareData[vsc_lensflare_origin].xyz + viewOffset.xyz;
  166.   g_fVertexPosition.w = 1.0f;
  167.  
  168.   float fFade = arrayLensFlareData[vsc_lensflare_bbconst].y;
  169.   g_fColor0 = arrayLensFlareData[vsc_lensflare_diffuse] * fFade;
  170. }
  171.  
  172.  
  173. void LightingTransform( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  174.    
  175. #define vsc_lightning_startwidth      arrayLightingData[vsc_lightning_const1].xxxx
  176. #define vsc_lightning_endwidth        arrayLightingData[vsc_lightning_const1].yyyy
  177. #define vsc_lightning_half            arrayLightingData[vsc_lightning_const1].zzzz
  178. #define vsc_lightning_one             arrayLightingData[vsc_lightning_const1].wwww
  179.  
  180. #define vsc_lightning_numsegments     arrayLightingData[vsc_lightning_const2].xxxx
  181. #define vsc_lightning_srtradius       arrayLightingData[vsc_lightning_const2].yyyy
  182. #define vsc_lightning_midradius       arrayLightingData[vsc_lightning_const2].zzzz
  183. #define vsc_lightning_endradius       arrayLightingData[vsc_lightning_const2].wwww
  184.  
  185. #define in_pos                        g_fFixedUser0
  186. #define in_part                       g_fFixedUser1.x
  187. #define in_flag                       g_fFixedUser1.y
  188.  
  189.    float3 tmp0,tmp1,tmp2; 
  190.    
  191.    tmp1.x = arrayLightingData[vsc_lightning_const2].z - arrayLightingData[vsc_lightning_const2].y;
  192.    tmp1.y = arrayLightingData[vsc_lightning_const2].w - arrayLightingData[vsc_lightning_const2].z;
  193.    
  194.    tmp0.x = ( g_fFixedUser1.x >= 0.5f ) ? 1.0f : 0.0f;
  195.    tmp0.y = 1.0f - tmp0.x;
  196.    
  197.    //
  198.    tmp2.x = arrayLightingData[vsc_lightning_const2].z * tmp0.x;
  199.    tmp2.x =  arrayLightingData[vsc_lightning_const2].y * tmp0.y + tmp2.x;
  200. //
  201.    tmp1.y = tmp1.y * tmp0.x;
  202.    tmp1.x =  tmp1.x * tmp0.y + tmp1.y;
  203. //
  204.    tmp2.y = -0.5f * tmp0.x + in_part;
  205.    tmp2.y = tmp2.y * tmp1.x;
  206.    tmp2.y = tmp2.y + tmp2.y;
  207. //
  208.    tmp0.x = tmp2.x + tmp2.y;
  209.    tmp0.y = -tmp0.x;
  210.  
  211.    //tmp2.x = dot( arrayLightingData[vsc_lightning_const2].zy,tmp0.xy);
  212.    //tmp1.x = dot(tmp1.xy,tmp0.xy);
  213.     
  214.    //tmp2.y =  ( ( (-0.5 * tmp0.x) + g_fFixedUser1.x) * tmp1.x) * 2.0;
  215.    
  216.    //tmp0.x = tmp2.x + tmp2.y;
  217.    //tmp0.y = -tmp0.x;
  218.    
  219.    float3 vecPos,vDxyz,vDeltaCPS,vp,vDepth,vDxyzNormal; 
  220.    
  221.    vecPos = min(g_fFixedUser0, (float3)tmp0.x);
  222.    vecPos = max(vecPos,(float3)tmp0.y);  
  223.    
  224.    
  225.    vDxyz = arrayLightingData[vsc_lightning_endpos] - arrayLightingData[vsc_lightning_startpos];
  226.    vDeltaCPS = arrayLightingData[vsc_lightning_campos] - vDxyz;
  227.    
  228.    vp = normalize(cross(vDxyz,vDeltaCPS));
  229.    vDepth = normalize(cross(vDxyz,vp));
  230.    vDxyzNormal = normalize(vDxyz);
  231.    
  232.    tmp0.x = dot(vDxyzNormal,vecPos);
  233.    tmp1 = (-vDxyzNormal * (float3)tmp0.x) + vecPos;
  234.    tmp0.x = dot(vDepth, tmp1);
  235.    tmp1 = (-vDepth * (float3)tmp0.x) + tmp1;
  236.    
  237.    tmp0.x = lerp(arrayLightingData[vsc_lightning_const1].x,arrayLightingData[vsc_lightning_const1].y,g_fFixedUser1.x);
  238.    
  239.    tmp2.x =  g_fFixedUser1.y - 0.5f;
  240.    tmp1 = ((vp * (float3)tmp0.x) * (float3)tmp2.x) + tmp1;
  241.    
  242.    tmp2 =  lerp(arrayLightingData[vsc_lightning_startpos],arrayLightingData[vsc_lightning_endpos],(float3)g_fFixedUser1.x);
  243.    
  244.    g_fVertexPosition.xyz = tmp1 + tmp2;
  245.    g_fVertexPosition.w = 1.0f;
  246.    
  247.    g_fTexCoords[0].xy =  g_fFixedUser1.yx;
  248.    g_fTexCoords[0].z = 0.0f;
  249.    g_fTexCoords[0].w = 1.0f;
  250.    g_fColor0 = lerp( arrayLightingData[vsc_lightning_startcolor],arrayLightingData[vsc_lightning_endcolor],(float4)g_fFixedUser1.x);
  251. }
  252.  
  253. //--------------------------------------------------------------------------
  254. // Particle systems
  255. // ~~~~~~~~~~~~~~~~
  256.  
  257. void CalculateParticlePosAndVelocity(in float fDeltaTime, out float3 pos, out float3 vel)
  258. {
  259.   float3 pos0               = g_fFixedUser1.xyz;
  260.   float3 vel0               = g_fFixedUser2.xyz;
  261.   float  fCloneKefficient   = arrayParticlesData[vsc_particles_const2].z;
  262.   float3 gravity            = arrayParticlesData[vsc_particles_const3].xyz;
  263.   
  264.   vel = vel0 + gravity * fDeltaTime;
  265.   pos = vel0 * fDeltaTime + pos0 + gravity * fDeltaTime * fDeltaTime * 0.5f + vel * fCloneKefficient;
  266. }
  267.  
  268. void CalculateParticlePos(in float fDeltaTime, out float3 pos) 
  269. {
  270.   float3 vel;
  271.   CalculateParticlePosAndVelocity(fDeltaTime, pos, vel);
  272. }
  273.  
  274. float CalculateParticleRadius(in float fFraction) {
  275.   float fStartRadius      = arrayParticlesData[vsc_particles_const2].x;
  276.   float fEndRadius        = arrayParticlesData[vsc_particles_const2].y;
  277.  
  278.   return lerp(fStartRadius, fEndRadius, fFraction);
  279. }
  280.  
  281. float4 CalculateParticleColor(in float fFraction) {
  282.   float4 startColor = g_fFixedUser3;
  283.   float4 endColor   = g_fFixedUser4;
  284.   return lerp(startColor, endColor, fFraction);
  285. }
  286.  
  287. //--------------------------------------------------------------------------
  288.  
  289. void ParticleAxisBillBoardTransform( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  290.   float fCurrentTime      = arrayParticlesData[vsc_particles_const3].w;
  291.   float fTime0            = g_fFixedUser0.x;
  292.   float fDeltaTime        = fCurrentTime - fTime0;
  293.   float fLiveTime         = g_fFixedUser0.y - fTime0;
  294.   
  295.   float fFraction         = fDeltaTime / fLiveTime;
  296.   
  297.   float3 vel;
  298.   float3 origin;
  299.   CalculateParticlePosAndVelocity(fDeltaTime, origin, vel);
  300.   
  301.   g_fColor0 = CalculateParticleColor(fFraction);
  302.   
  303.   float fPolarity = arrayParticlesData[vsc_particles_const2].w;
  304.   float2 offset = CalculateVertexOffset(g_fTexCoords[0].xy, fPolarity);
  305.  
  306.   float3 eyePos;
  307.   eyePos.x = arrayParticlesData[vsc_sfx_matViewInv4x3+0].w;
  308.   eyePos.y = arrayParticlesData[vsc_sfx_matViewInv4x3+1].w;
  309.   eyePos.z = arrayParticlesData[vsc_sfx_matViewInv4x3+2].w;
  310.   
  311.   float fRadius = CalculateParticleRadius(fFraction);
  312.   
  313.   float3 up     = 0.5f * fRadius * normalize(vel);
  314.   float3 vEyeObjDir = eyePos - origin;
  315.   float3 right  = 0.5f * fRadius * normalize( cross(vEyeObjDir, up) );
  316.   
  317.   g_fVertexPosition.xyz = origin + offset.x * right + offset.y  * up;
  318.   g_fVertexPosition.w   = 1.0f;
  319.   
  320. }
  321.  
  322. //--------------------------------------------------------------------------
  323.  
  324. void ParticleBillBoardTransform( uniform bool bNeedNormal, uniform bool bNeedTangent){
  325.  
  326.   float fCurrentTime      = arrayParticlesData[vsc_particles_const3].w;
  327.   float fTime0            = g_fFixedUser0.x;
  328.   float fDeltaTime        = fCurrentTime - fTime0;
  329.   float fLiveTime         = g_fFixedUser0.y - fTime0;
  330.   float fFraction         = fDeltaTime / fLiveTime;
  331.  
  332.   CalculateParticlePos(fDeltaTime, g_fVertexPosition.xyz);
  333.   g_fVertexPosition.w = 1.0f;
  334.   g_fColor0 = CalculateParticleColor(fFraction);
  335.   
  336.   float fRadius = CalculateParticleRadius(fFraction);
  337.   float3 offset;
  338.   float fPolarity = arrayParticlesData[vsc_particles_const2].w;
  339.   offset.xy = fRadius * 0.5f * CalculateVertexOffset(g_fTexCoords[0].xy, fPolarity);
  340.   offset.z = 0.0f;
  341.   
  342.   float3 viewOffset;
  343.   viewOffset.x = dot((float3)arrayParticlesData[vsc_sfx_matViewInv4x3+0], offset);
  344.   viewOffset.y = dot((float3)arrayParticlesData[vsc_sfx_matViewInv4x3+1], offset);
  345.   viewOffset.z = dot((float3)arrayParticlesData[vsc_sfx_matViewInv4x3+2], offset);
  346.   
  347.   g_fVertexPosition.xyz += viewOffset.xyz;
  348. }
  349.  
  350. //--------------------------------------------------------------------------
  351.  
  352. void ParticlePointSpriteTransform( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  353.   
  354.   float fCurrentTime      = arrayParticlesData[vsc_particles_const3].w;
  355.   float fTime0            = g_fFixedUser0.x;
  356.   float fDeltaTime        = fCurrentTime - fTime0;
  357.   float fLiveTime         = g_fFixedUser0.y - fTime0;
  358.   float fFraction         = fDeltaTime / fLiveTime;
  359.  
  360.   CalculateParticlePos(fDeltaTime, g_fVertexPosition.xyz);
  361.   g_fVertexPosition.w = 1.0f;
  362.  
  363.   g_fColor0 = CalculateParticleColor(fFraction);
  364.  
  365.   float4 fWRow;
  366.   fWRow.x = matProjection[0][3];
  367.   fWRow.y = matProjection[1][3];
  368.   fWRow.z = matProjection[2][3];
  369.   fWRow.w = matProjection[3][3];
  370.   
  371.   float fRadius = CalculateParticleRadius(fFraction);
  372.   float fViewPortScale = arrayParticlesData[vsc_particles_const2].w;
  373.   g_fPSize = (fRadius * fViewPortScale) / dot(g_fVertexPosition, fWRow);
  374.  
  375.   g_fTexCoords[0].xyz = 0.0f;
  376.   g_fTexCoords[0].w = 1.0f;
  377. }
  378.  
  379. void GrassTransform( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  380.  
  381.  
  382.     float3 r_tmp,r_n,r_tan,r_bend;
  383.     float4 r_splineX,r_splineY,r_splineZ,r_nProj;
  384.     float4 r_bendProjected,ru,r_pos,r_u;
  385.     
  386.     r_n = cross(g_fFixedUser1,g_fFixedUser2);
  387.     r_bend = arrayGrassData[vsc_grass_bend];
  388.     
  389.     float3x4 rMat;
  390.     rMat[0] = arrayGrassData[vsc_grass_dynamicbendmatrix0];
  391.     rMat[1] = arrayGrassData[vsc_grass_dynamicbendmatrix1];
  392.     rMat[2] = arrayGrassData[vsc_grass_dynamicbendmatrix2];
  393.     
  394.     r_tmp.xyz = mul(rMat,g_fFixedUser0);
  395.     
  396.     r_tmp.y = -r_tmp.y;
  397.     r_bend = r_tmp * (float3)arrayGrassData[vsc_grass_bendparameters].x + r_bend;
  398.     
  399.     r_bendProjected.x = dot(r_bend,g_fFixedUser1);
  400.     r_bendProjected.y = dot(r_bend,g_fFixedUser2);
  401.     
  402.     r_bendProjected.xy = clamp(r_bendProjected.xy,-arrayGrassData[vsc_grass_bendparameters].yy,arrayGrassData[vsc_grass_bendparameters].yy);
  403.     r_bendProjected.zw = max(r_bendProjected.xy,-r_bendProjected.xy);
  404.     r_bendProjected.z  = max(r_bendProjected.z,-r_bendProjected.w);
  405.  
  406.     r_splineX = arrayGrassData[vsc_grass_spline0] * (float4)r_bendProjected.x;
  407.     r_splineY = arrayGrassData[vsc_grass_spline1] * (float4)r_bendProjected.y;
  408.     r_splineZ = arrayGrassData[vsc_grass_spline2];
  409.     
  410.     r_u.x = 1.0f;
  411.     r_u.y = g_fFixedUser4.x * g_fFixedUser4.x;
  412.     r_u.zw = g_fFixedUser4.x;
  413.     r_u.xw = r_u.yxxx * r_u.zxxx;
  414.     
  415.     r_pos.x = dot(r_u,r_splineX);
  416.     r_pos.y = dot(r_u,r_splineY);
  417.     r_pos.z = dot(r_u,r_splineZ);
  418.     r_pos.w = 1.0f;
  419.     r_pos.xyz = (float3)r_pos * (float3)g_fFixedUser4.z;
  420.             
  421.     r_tmp = (r_n * (float3)r_pos.z) + g_fFixedUser0;
  422.     r_tmp = (g_fFixedUser1 * (float3)r_pos.x) + r_tmp;
  423.     r_pos.xyz = (g_fFixedUser2 * (float3)r_pos.y) + r_tmp;
  424.  
  425.    r_nProj.y = dot((float3)arrayGrassData[vsc_grass_worldmatrix0],r_n);
  426.    r_nProj.x = dot((float3)arrayGrassData[vsc_grass_worldmatrix1],-r_n);
  427.    r_nProj.z = 0.0f;    
  428.    r_nProj.w = 1.0f;    
  429.  
  430.   float r_projRadius;
  431.   float r_projScale;
  432.     
  433.   r_projRadius =  g_fFixedUser4.y * arrayGrassData[vsc_grass_shaderparameters].x;
  434.   r_projScale = rsqrt( dot((float3)r_nProj,(float3)r_nProj)) * r_projRadius;
  435.   r_nProj = r_nProj * r_projScale;
  436.   
  437.   float4 r_outPos;
  438.   float4x4 rViewMatrix;
  439.   rViewMatrix[0] = arrayGrassData[vsc_grass_projectionmatrix0];
  440.   rViewMatrix[1] = arrayGrassData[vsc_grass_projectionmatrix1];
  441.   rViewMatrix[2] = arrayGrassData[vsc_grass_projectionmatrix2];
  442.   rViewMatrix[3] = arrayGrassData[vsc_grass_projectionmatrix3];    
  443.   r_outPos = mul(rViewMatrix,r_pos);
  444.   
  445.   g_fVertexPosition = (r_nProj * arrayGrassData[vsc_grass_constants].yyxx) +  r_outPos;
  446.   
  447.   g_fTexCoords[0].xy = g_fFixedUser3.xy;
  448.   g_fTexCoords[0].z = 0.0f;
  449.   g_fTexCoords[0].w = 1.0f;
  450.   g_fColor0 = arrayGrassData[vsc_grass_diffuse];
  451.   
  452.  
  453. }
  454. void SurfaceTransform( uniform bool bNeedNormal, uniform bool bNeedTangent  ){
  455.   if( bNeedNormal ){
  456.     g_fNormal = normalize(g_fNormal);
  457.   }
  458.   if( bNeedTangent ){
  459.     g_fSxT = normalize(g_fNormal - cross(g_fS,g_fT));    
  460.   }
  461. }
  462. void ShiningHClipTransform( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  463.     
  464.  float4 rPos;
  465.  rPos.xyz = arrayShiningData[vsc_position];
  466.  rPos.w = 1.0f;
  467.  
  468.  float4x4 rViewMat;
  469.  rViewMat[0] = arrayShiningData[vsc_vmat0+0];
  470.  rViewMat[1] = arrayShiningData[vsc_vmat0+1];
  471.  rViewMat[2] = arrayShiningData[vsc_vmat0+2];
  472.  rViewMat[3] = arrayShiningData[vsc_vmat0+3];
  473.  
  474.  rPos = mul(rViewMat,rPos);
  475.  
  476.  float2 rTmpPos = g_fFixedUser0.xy * arrayShiningData[vsc_constshine].zw; 
  477.  float2 rTmp1 = g_fFixedUser2.xx * arrayShiningData[vsc_constshine].yy + g_fFixedUser2.yy * arrayShiningData[vsc_constshine].xx;
  478.  rPos.xy = rTmpPos * rTmp1 + rPos.xy;
  479.  
  480.  //float2 rTmpPos,rTmp1;
  481.  //rTmpPos = g_fFixedUser0.xy * arrayShiningData[vsc_constshine].zw;
  482.  
  483.  //rTmp1 = dot( g_fFixedUser2.yx,arrayShiningData[vsc_constshine].xy);
  484.  //rPos.xy = rTmpPos * rTmp1 + rPos.xy;
  485.  //float4x4 rViewMat;
  486.  rViewMat[0] = arrayShiningData[vsc_pmat0+0];
  487.  rViewMat[1] = arrayShiningData[vsc_pmat0+1];
  488.  rViewMat[2] = arrayShiningData[vsc_pmat0+2];
  489.  rViewMat[3] = arrayShiningData[vsc_pmat0+3];
  490.  
  491.  g_fVertexPosition = mul(rViewMat,rPos );
  492.  
  493.  g_fColor0 = lerp( arrayShiningData[vsc_startshinediffuse],arrayShiningData[vsc_endshinediffuse],(float4)g_fFixedUser1.x);
  494.  g_fTexCoords[0].xy = g_fFixedUser1.xy;
  495.  g_fTexCoords[0].z = 0.0f;
  496.  g_fTexCoords[0].w = 1.0f; 
  497.  
  498. }
  499. void MarkTransform( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  500.  
  501.  float4x4 rViewMat;
  502.  rViewMat[0] = arrayMarkData[vsc_mark_wrldmtx+0];
  503.  rViewMat[1] = arrayMarkData[vsc_mark_wrldmtx+1];
  504.  rViewMat[2] = arrayMarkData[vsc_mark_wrldmtx+2];
  505.  rViewMat[3] = arrayMarkData[vsc_mark_wrldmtx+3];
  506.  
  507.  g_fVertexPosition = mul(rViewMat,g_fVertexPosition);
  508.  g_fVertexPosition.w = 1.0f;
  509.  g_fVertexPosition.xyz = ((arrayMarkData[vsc_mark_eyepos] - g_fVertexPosition) * (float3)arrayMarkData[vsc_mark_bbconst].y) + (float3)g_fVertexPosition;
  510.  g_fColor0 = lerp( arrayMarkData[vsc_mark_startcolor] ,arrayMarkData[vsc_mark_endcolor],(float4)arrayMarkData[vsc_mark_bbconst].x);
  511. }
  512. void ExtenedMeshDoffuse( uniform bool bNeedNormal, uniform bool bNeedTangent ){
  513.  g_fColor0 = arrayMarkData[vsc_mark_bbconst];    
  514. }
  515. #endif //__SFX_FX__
  516.  
  517.  
  518.  
  519.  
  520.  
  521.  
  522.  
  523.