中国战地技术资源网

 找回密码
 立即加入

扫一扫,访问微社区

搜索
查看: 95|回复: 0

[游戏] 战地2地图出现黑斑、黑点等问题的解决方案

[复制链接]

41

主题

110

帖子

1038

积分

站长

Rank: 9Rank: 9Rank: 9

积分
1038

赞助勋章

发表于 2020-9-16 16:36:09 | 显示全部楼层 |阅读模式
赞助bfmil
由于种种原因,部分玩家在玩战地2可能会出现地图、模型上的黑点、黑块或黑斑问题,对此通过收集网络各种资料,整理以下办法:

1,某些显卡驱动会导致游戏崩溃或者出现地图黑斑
尝试解决办法:更新自己的电脑显卡驱动为最新版本;

2,使用了非英文的游戏安装目录或改动了bf2.exe的文件名称:
尝试解决办法:重新安装游戏,将游戏安装到不含特殊字符、中文的目录中(推荐以英文命名文件夹),并不要改动游戏目录的bf2.exe这个文件名称;

3,画质渲染导致
尝试解决办法:进入游戏设置选项中,可以将 图像选项各栏目调节画质为:低(如果不行,也可以反之全部调节为高试一试);

4,使用非官方的着色器来解决此问题(使用此方法,可能影响您联机,因为会被检测到非法文件)
尝试解决办法:
  • a1,下载由第三方模组移植的地形着色器文件:TerrainShader.fx(下载);
  • a2,打开自己的战地2游戏目录下的mods/bf2文件夹,(例如:x:/战地2/mods/bf2/),复制备份自己的官方原始版文件 shaders_client.zip(备份方法:将其复制并改名为:shaders_client原始备份-20200916.zip);
  • a3,然后将刚才下载的TerrainShader.fx 拖拽到当前的shaders_client.zip压缩包中,并覆盖替换里面的这个TerrainShader.fx文件。
  • a3,删除C盘你的用户文档目录中战地2中的cache缓存文件夹,例如C:\Users\Administrator\Documents\Battlefield 2\mods\bf2\,如果你不知道怎么进入这个文件夹,可以复制 %USERPROFILE%\Documents\Battlefield 2\mods\bf2\ 然后粘贴到计算机地址栏回车即可找到它,进入这个文件夹后,删除这个文件夹里面的所有文件和文件夹。
  • 重新进入游戏尝试!
  • * 注意,使用第三方着色器的缺点是,如果你进行联机时候,将会被PunkBuster 受保护的服务器直接踢出。


下载地址:

通过Moddb下载:https://www.moddb.com/games/battlefield-2/addons/shaders-client-fix
通过百度网盘:

代码如下,仅供参考:
  1. #line 2 "TerrainShader_Hi.fx"
  2. //
  3. // -- Hi Terrain
  4. //


  5. //Special samplers for dynamic filtering types
  6. sampler dsampler3Wrap = sampler_state {
  7.         Texture                        = (texture3);
  8.         AddressU                = WRAP;
  9.         AddressV                = WRAP;
  10.         MipFilter                = FILTER_TRN_MIP;
  11.         MinFilter                 = FILTER_TRN_DIFF_MIN;
  12.         MagFilter                 = FILTER_TRN_DIFF_MAG;
  13. #ifdef FILTER_TRN_DIFF_MAX_ANISOTROPY
  14.         MaxAnisotropy         = FILTER_TRN_DIFF_MAX_ANISOTROPY;
  15. #endif
  16. };

  17. sampler dsampler4Wrap = sampler_state {
  18.         Texture                        = (texture4);
  19.         AddressU                = WRAP;
  20.         AddressV                = WRAP;
  21.         MipFilter                = FILTER_TRN_MIP;
  22.         MinFilter                 = FILTER_TRN_DIFF_MIN;
  23.         MagFilter                 = FILTER_TRN_DIFF_MAG;
  24. #ifdef FILTER_TRN_DIFF_MAX_ANISOTROPY
  25.         MaxAnisotropy         = FILTER_TRN_DIFF_MAX_ANISOTROPY;
  26. #endif
  27. };

  28. sampler dsampler6Wrap = sampler_state {
  29.         Texture                        = (texture6);
  30.         AddressU                = WRAP;
  31.         AddressV                = WRAP;
  32.         MipFilter                = FILTER_TRN_MIP;
  33.         MinFilter                 = FILTER_TRN_DIFF_MIN;
  34.         MagFilter                 = FILTER_TRN_DIFF_MAG;
  35. #ifdef FILTER_TRN_DIFF_MAX_ANISOTROPY
  36.         MaxAnisotropy         = FILTER_TRN_DIFF_MAX_ANISOTROPY;
  37. #endif
  38. };


  39. #if NVIDIA
  40.         #define SHADOWPSMODEL LOWPSMODEL
  41.         #define SHADOWVERSION 14
  42. #else
  43.         #define SHADOWPSMODEL PS2_EXT
  44.         #define SHADOWVERSION 20
  45. #endif

  46. struct Hi_VS2PS_FullDetail
  47. {
  48.     vec4        Pos : POSITION;
  49.     vec4        Tex0 : TEXCOORD0;
  50.     vec4        Tex1 : TEXCOORD1;
  51.     vec4        BlendValueAndFade : TEXCOORD2; //tl: texcoord because we don't want clamping
  52.     vec4        Tex3 : TEXCOORD3;
  53.     vec2        Tex5 : TEXCOORD4;
  54.     vec2        Tex6 : TEXCOORD5;
  55.     vec4        FogAndFade2 : COLOR0;
  56. };

  57. //#define LIGHTONLY 1
  58. vec4 Hi_PS_FullDetail(Hi_VS2PS_FullDetail indata) : COLOR
  59. {
  60. //        return vec4(0,0,0.25,1);
  61. #if LIGHTONLY
  62.         vec4 accumlights = tex2Dproj(sampler1ClampPoint, indata.Tex1);
  63.         vec4 light = 2 * accumlights.w * vSunColor + accumlights;
  64.         vec4 component = tex2D(sampler2Clamp, indata.Tex0.xy);
  65.         scalar chartcontrib = dot(vComponentsel, component);
  66.         return chartcontrib*light;
  67. #else
  68. #if DEBUGTERRAIN
  69.         return vec4(0,0,1,1);
  70. #endif
  71.         vec3 colormap = tex2D(sampler0Clamp, indata.Tex0.xy);
  72.         
  73.         vec4 accumlights = tex2Dproj(sampler1Clamp, indata.Tex1);
  74.         
  75.         //tl: 2* moved later in shader to avoid clamping at -+2.0 in ps1.4
  76.         vec3 light = 2*accumlights.w * vSunColor.rgb + accumlights.rgb;

  77.         vec4 component = tex2D(sampler2Clamp, indata.Tex6);
  78.         scalar chartcontrib = dot(vComponentsel, component);
  79.         vec3 detailmap = tex2D(dsampler3Wrap, indata.Tex3.xy);

  80. #if HIGHTERRAIN
  81.         vec4 lowComponent = tex2D(sampler5Clamp, indata.Tex6);
  82.         vec4 yplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex5);
  83.         vec4 xplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex3.xy);
  84.         vec4 zplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex0.wz);
  85.         scalar lowDetailmap = lerp(0.5, yplaneLowDetailmap.z, lowComponent.x*indata.FogAndFade2.y);
  86. #else
  87.         vec4 yplaneLowDetailmap = tex2D(ssampler4Wrap, indata.Tex5);

  88.         //tl: do lerp in 1 MAD by precalculating constant factor in vShader
  89. //        scalar lowDetailmap = yplaneLowDetailmap.z * indata.BlendValueAndFade.y + indata.FogAndFade2.z;
  90.         scalar lowDetailmap = lerp(yplaneLowDetailmap.x, yplaneLowDetailmap.z, indata.BlendValueAndFade.y);
  91. #endif

  92. #if HIGHTERRAIN
  93.         scalar mounten =        (xplaneLowDetailmap.y * indata.BlendValueAndFade.x) +
  94.                                                 (yplaneLowDetailmap.x * indata.BlendValueAndFade.y) +
  95.                                                 (zplaneLowDetailmap.y * indata.BlendValueAndFade.z)        ;

  96.         lowDetailmap *= (4 * lerp(0.5, mounten, lowComponent.z));

  97.         vec3 bothDetailmap = detailmap * lowDetailmap;
  98.         vec3 detailout = lerp(2*bothDetailmap, lowDetailmap, indata.BlendValueAndFade.w);
  99. #else
  100.         //tl: lerp optimized to handle 2*c*low + (2-2c)*detail, factors sent from vs
  101.         vec3 detailout = lowDetailmap*indata.BlendValueAndFade.x + detailmap*indata.BlendValueAndFade.z;
  102. #endif

  103.         vec3 outColor = detailout * colormap * light;
  104.         //tl: this 2* is the one missing from the light calculation above!
  105.         vec3 fogOutColor = lerp(FogColor, outColor*2, indata.FogAndFade2.x);
  106.         return vec4(chartcontrib * fogOutColor, chartcontrib);
  107. #endif        
  108. }

  109. Hi_VS2PS_FullDetail Hi_VS_FullDetail(Shared_APP2VS_Default indata)
  110. {
  111.         Hi_VS2PS_FullDetail outdata = (Hi_VS2PS_FullDetail)0;
  112.         
  113.         vec4 wPos;
  114.         wPos.xz = (indata.Pos0.xy * vScaleTransXZ.xy) + vScaleTransXZ.zw;
  115.         wPos.yw = (indata.Pos1.xw * vScaleTransY.xy);// + vScaleTransY.zw;

  116. #if DEBUGTERRAIN
  117.         outdata.Pos = mul(wPos, mViewProj);
  118.         outdata.Tex0 = vec4(0,0,0,0);
  119.         outdata.Tex1 = vec4(0,0,0,0);
  120.         outdata.BlendValueAndFade = vec4(0,0,0,0);
  121.         outdata.Tex3 = vec4(0,0,0,0);
  122.         outdata.Tex5.xy = vec2(0,0);
  123.         outdata.FogAndFade2 = vec4(0,0,0,0);
  124.         return outdata;
  125. #endif

  126.         scalar yDelta, interpVal;
  127. //        geoMorphPosition(wPos, indata.MorphDelta, yDelta, interpVal);
  128.         geoMorphPosition(wPos, indata.MorphDelta, indata.Pos0.z, yDelta, interpVal);
  129.         
  130.         //tl: output HPos as early as possible.
  131.          outdata.Pos = mul(wPos, mViewProj);
  132.          
  133.          //tl: uncompress normal
  134.          indata.Normal = indata.Normal * 2 - 1;

  135.         vec3 tex = vec3(indata.Pos0.y * vTexScale.z, wPos.y * vTexScale.y, indata.Pos0.x * vTexScale.x);
  136.         vec2 yPlaneTexCord = tex.zx;
  137. #if HIGHTERRAIN
  138.         vec2 xPlaneTexCord = tex.xy;
  139.         vec2 zPlaneTexCord = tex.zy;
  140. #endif
  141.         
  142.          outdata.Tex0.xy = (yPlaneTexCord*vColorLightTex.x) + vColorLightTex.y;
  143.          outdata.Tex6 = (yPlaneTexCord*vDetailTex.x) + vDetailTex.y;

  144.         //tl: Switched tex0.wz for tex3.xy to easier access it from 1.4
  145.         outdata.Tex3.xy = yPlaneTexCord.xy * vNearTexTiling.z;
  146.         
  147.          outdata.Tex5 = yPlaneTexCord * vFarTexTiling.z;

  148. #if HIGHTERRAIN
  149.         outdata.Tex0.wz = xPlaneTexCord.xy * vFarTexTiling.xy;
  150.         outdata.Tex0.z += vFarTexTiling.w;
  151.         outdata.Tex3.wz = zPlaneTexCord.xy * vFarTexTiling.xy;
  152.         outdata.Tex3.z += vFarTexTiling.w;
  153. #endif

  154.         outdata.FogAndFade2.x = calcFog(outdata.Pos.w);
  155.         outdata.FogAndFade2.yzw = 0.5+interpVal*0.5;

  156. #if HIGHTERRAIN
  157.         outdata.BlendValueAndFade.w = interpVal;
  158. #elif MIDTERRAIN
  159.         //tl: optimized so we can do more advanced lerp in same number of instructions
  160.         //    factors are 2c and (2-2c) which equals a lerp()*2
  161.         //    Don't use w, it's harder to access from ps1.4
  162.         outdata.BlendValueAndFade.xz = interpVal * vec2(2, -2) + vec2(0, 2);
  163. #endif

  164. #if HIGHTERRAIN
  165.         outdata.BlendValueAndFade.xyz = saturate(abs(indata.Normal) - vBlendMod);
  166.         scalar tot = dot(1, outdata.BlendValueAndFade.xyz);
  167.         outdata.BlendValueAndFade.xyz /= tot;
  168. #elif MIDTERRAIN
  169.         //tl: use squared yNormal as blend val. pre-multiply with fade value.
  170.         outdata.BlendValueAndFade.yw = pow(indata.Normal.y,8) /** indata.Normal.y*/ * outdata.FogAndFade2.y;

  171.         //tl: pre calculate half-lerp against constant, result is 2 ps instruction lerp distributed
  172.         //    to 1 vs MAD and 1 ps MAD
  173.         outdata.FogAndFade2.z = outdata.BlendValueAndFade.y*-0.5 + 0.5;
  174. #endif

  175.         outdata.Tex1 = projToLighting(outdata.Pos);

  176. //        outdata.Tex1 = vec4(vMorphDeltaAdder[indata.Pos0.z*256], 1) * 256*256;

  177.         return outdata;
  178. }

  179. struct Hi_VS2PS_FullDetailMounten
  180. {
  181.     vec4         Pos : POSITION;
  182.     vec4         Tex0 : TEXCOORD0;
  183.     vec4         Tex1 : TEXCOORD1;
  184.     vec4         BlendValueAndFade : TEXCOORD2; //tl: texcoord because we don't want clamping
  185. #if HIGHTERRAIN   
  186.     vec4         Tex3 : TEXCOORD6;
  187. #endif   
  188.     vec2         Tex5 : TEXCOORD5;
  189.     vec4         Tex6 : TEXCOORD3;
  190.     vec2         Tex7 : TEXCOORD4;
  191.     vec4         FogAndFade2 : COLOR0;
  192. };

  193. vec4 Hi_PS_FullDetailMounten(Hi_VS2PS_FullDetailMounten indata) : COLOR
  194. {
  195. #if LIGHTONLY
  196.           vec4 accumlights = tex2Dproj(sampler1ClampPoint, indata.Tex1);
  197.           vec4 light = 2 * accumlights.w * vSunColor + accumlights;
  198.           vec4 component = tex2D(sampler2Clamp, indata.Tex0.xy);
  199.           scalar chartcontrib = dot(vComponentsel, component);
  200.           return chartcontrib*light;
  201. #else
  202. #if DEBUGTERRAIN
  203.           return vec4(1,0,0,1);
  204. #endif
  205.           vec3 colormap = tex2D(sampler0Clamp, indata.Tex0.xy);

  206.           vec4 accumlights = tex2Dproj(sampler1Clamp, indata.Tex1);

  207.           //tl: 2* moved later in shader to avoid clamping at -+2.0 in ps1.4
  208.           vec3 light = 2*accumlights.w * vSunColor.rgb + accumlights.rgb;

  209.           vec4 component = tex2D(sampler2Clamp, indata.Tex7);
  210.           scalar chartcontrib = dot(vComponentsel, component);

  211. #if HIGHTERRAIN
  212.           vec3 yplaneDetailmap = tex2D(dsampler3Wrap, indata.Tex6.xy);
  213.           vec3 xplaneDetailmap = tex2D(dsampler6Wrap, indata.Tex0.wz);
  214.           vec3 zplaneDetailmap = tex2D(dsampler6Wrap, indata.Tex6.wz);
  215.           vec3 yplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex5.xy);
  216.           vec3 xplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex3.xy);
  217.           vec3 zplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex3.wz);

  218.           vec3 lowComponent = tex2D(sampler5Clamp, indata.Tex7);

  219.           vec3 detailmap = (xplaneDetailmap * indata.BlendValueAndFade.x) +
  220.                              (yplaneDetailmap * indata.BlendValueAndFade.y) +
  221.                              (zplaneDetailmap * indata.BlendValueAndFade.z);

  222.           scalar lowDetailmap = lerp(0.5, yplaneLowDetailmap.z, lowComponent.x*indata.FogAndFade2.y);
  223.           scalar mounten = (xplaneLowDetailmap.y * indata.BlendValueAndFade.x) +
  224.                              (yplaneLowDetailmap.x * indata.BlendValueAndFade.y) +
  225.                              (zplaneLowDetailmap.y * indata.BlendValueAndFade.z);
  226.           lowDetailmap *= (4 * lerp(0.5, mounten, lowComponent.z));

  227.           vec3 bothDetailmap = detailmap * lowDetailmap;
  228.           vec3 detailout = lerp(2*bothDetailmap, lowDetailmap, indata.BlendValueAndFade.w);
  229. #else
  230.           vec3 yplaneDetailmap = tex2D(ssampler3Wrap, indata.Tex6.xy);
  231.           vec3 yplaneLowDetailmap = tex2D(ssampler4Wrap, indata.Tex5);

  232.           scalar lowDetailmap = lerp(yplaneLowDetailmap.x, yplaneLowDetailmap.z, indata.BlendValueAndFade.y);

  233.           //tl: lerp optimized to handle 2*c*low + (2-2c)*detail, factors sent from vs
  234.           //tl: dont use detail mountains
  235.        vec3 detailout = lowDetailmap*indata.BlendValueAndFade.x + lowDetailmap*yplaneDetailmap*indata.BlendValueAndFade.z;
  236. //          vec3 detailout = lowDetailmap*2;
  237. #endif
  238.          
  239.           vec3 outColor = detailout * colormap * light;
  240.           //tl: this 2* is the one missing from the light calculation above!
  241.           vec3 fogOutColor = lerp(FogColor, outColor*2, indata.FogAndFade2.x);
  242.           return vec4(chartcontrib * fogOutColor, chartcontrib);
  243. #endif
  244. }

  245. Hi_VS2PS_FullDetailMounten Hi_VS_FullDetailMounten(Shared_APP2VS_Default indata)
  246. {
  247.           Hi_VS2PS_FullDetailMounten outdata;
  248.          
  249.           vec4 wPos;
  250.           wPos.xz = (indata.Pos0.xy * vScaleTransXZ.xy) + vScaleTransXZ.zw;
  251.           //tl: Trans is always 0, and MADs cost more than MULs in certain cards.
  252.           wPos.yw = indata.Pos1.xw * vScaleTransY.xy;

  253. #if DEBUGTERRAIN
  254.           outdata.Pos = mul(wPos, mViewProj);
  255.           outdata.Tex0 = vec4(0,0,0,0);
  256.           outdata.Tex1 = vec4(0,0,0,0);
  257.           outdata.BlendValueAndFade = vec4(0,0,0,0);
  258.           outdata.Tex3 = vec4(0,0,0,0);
  259.           outdata.Tex5 = vec4(0,0,0,0);
  260.           outdata.Tex6 = vec4(0,0,0,0);
  261.           outdata.FogAndFade2 = vec4(0,0,0,0);
  262.           return outdata;
  263. #endif

  264.           scalar yDelta, interpVal;
  265. //          geoMorphPosition(wPos, indata.MorphDelta, yDelta, interpVal);
  266.         geoMorphPosition(wPos, indata.MorphDelta, indata.Pos0.z, yDelta, interpVal);
  267.          
  268.           //tl: output HPos as early as possible.
  269.           outdata.Pos = mul(wPos, mViewProj);

  270.           //tl: uncompress normal
  271.           indata.Normal = indata.Normal * 2 - 1;

  272.           vec3 tex = vec3(indata.Pos0.y * vTexScale.z, wPos.y * vTexScale.y, indata.Pos0.x * vTexScale.x);
  273.           vec2 xPlaneTexCord = tex.xy;
  274.           vec2 yPlaneTexCord = tex.zx;
  275.           vec2 zPlaneTexCord = tex.zy;
  276.          
  277.           outdata.Tex0.xy = (yPlaneTexCord*vColorLightTex.x) + vColorLightTex.y;
  278.           outdata.Tex7 = (yPlaneTexCord*vDetailTex.x) + vDetailTex.y;

  279.           outdata.Tex6.xy = yPlaneTexCord.xy * vNearTexTiling.z;
  280.           outdata.Tex0.wz = xPlaneTexCord.xy * vNearTexTiling.xy;
  281.           outdata.Tex0.z += vNearTexTiling.w;
  282.           outdata.Tex6.wz = zPlaneTexCord.xy * vNearTexTiling.xy;
  283.           outdata.Tex6.z += vNearTexTiling.w;

  284.           outdata.Tex5 = yPlaneTexCord * vFarTexTiling.z;

  285.           outdata.FogAndFade2.x = calcFog(outdata.Pos.w);
  286.           outdata.FogAndFade2.yzw = 0.5+interpVal*0.5;

  287. #if HIGHTERRAIN
  288.           outdata.Tex3.xy = xPlaneTexCord.xy * vFarTexTiling.xy;
  289.           outdata.Tex3.y += vFarTexTiling.w;
  290.           outdata.Tex3.wz = zPlaneTexCord.xy * vFarTexTiling.xy;
  291.           outdata.Tex3.z += vFarTexTiling.w;

  292.           outdata.BlendValueAndFade.w = interpVal;
  293. #else
  294.           //tl: optimized so we can do more advanced lerp in same number of instructions
  295.           //    factors are 2c and (2-2c) which equals a lerp()*2
  296.           //    Don't use w, it's harder to access from ps1.4
  297. //       outdata.BlendValueAndFade.xz = interpVal * vec2(2, -2) + vec2(0, 2);
  298.           outdata.BlendValueAndFade.xz = interpVal * vec2(1, -2) + vec2(1, 2);
  299. //       outdata.BlendValueAndFade = interpVal * vec4(2, 0, -2, 0) + vec4(0, 0, 2, 0);
  300. //outdata.BlendValueAndFade.w = interpVal;
  301. #endif

  302. #if HIGHTERRAIN
  303.           outdata.BlendValueAndFade.xyz = saturate(abs(indata.Normal) - vBlendMod);
  304.           scalar tot = dot(1, outdata.BlendValueAndFade.xyz);
  305.           outdata.BlendValueAndFade.xyz /= tot;
  306. #else
  307.           //tl: use squared yNormal as blend val. pre-multiply with fade value.
  308. //       outdata.BlendValueAndFade.yw = indata.Normal.y * indata.Normal.y * outdata.FogAndFade2.y;
  309.           outdata.BlendValueAndFade.yw = pow(indata.Normal.y,8);

  310.           //tl: pre calculate half-lerp against constant, result is 2 ps instruction lerp distributed
  311.           //    to 1 vs MAD and 1 ps MAD
  312. //       outdata.FogAndFade2.z = outdata.BlendValueAndFade.y*-0.5 + 0.5;
  313. #endif
  314.           outdata.Tex1 = projToLighting(outdata.Pos);

  315.           return outdata;
  316. }

  317. struct Hi_VS2PS_FullDetailWithEnvMap
  318. {
  319.     vec4        Pos : POSITION;
  320.     vec4        Tex0 : TEXCOORD0;
  321.     vec4        Tex1 : TEXCOORD1;
  322.     vec4        Tex3 : TEXCOORD3;
  323.     vec4        BlendValueAndFade : COLOR0;
  324.     vec2        Tex5 : TEXCOORD2;
  325.     vec2        Tex6 : TEXCOORD5;
  326.     vec3        EnvMap : TEXCOORD4;
  327.     vec4        FogAndFade2 : COLOR1;
  328. };

  329. vec4 Hi_PS_FullDetailWithEnvMap(Hi_VS2PS_FullDetailWithEnvMap indata) : COLOR
  330. {
  331. #if LIGHTONLY
  332.         vec4 accumlights = tex2Dproj(sampler1ClampPoint, indata.Tex1);
  333.         vec4 light = 2 * accumlights.w * vSunColor + accumlights;
  334.         vec4 component = tex2D(sampler2Clamp, indata.Tex0.xy);
  335.         scalar chartcontrib = dot(vComponentsel, component);
  336.         return chartcontrib*light;
  337. #else
  338. #if DEBUGTERRAIN
  339.         return vec4(0,1,0,1);
  340. #endif
  341.         vec3 colormap = tex2D(sampler0Clamp, indata.Tex0.xy);
  342.         
  343.         vec4 accumlights = tex2Dproj(sampler1Clamp, indata.Tex1);
  344.         
  345.         //tl: 2* moved later in shader to avoid clamping at -+2.0 in ps1.4
  346.         vec3 light = 2*accumlights.w * vSunColor.rgb + accumlights.rgb;

  347.         vec4 component = tex2D(sampler2Clamp, indata.Tex6);
  348.         scalar chartcontrib = dot(vComponentsel, component);
  349.         vec4 detailmap = tex2D(dsampler3Wrap, indata.Tex3.xy);

  350. #if HIGHTERRAIN
  351.         vec4 lowComponent = tex2D(sampler5Clamp, indata.Tex6);
  352.         vec4 yplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex5);
  353.         vec4 xplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex3.xy);
  354.         vec4 zplaneLowDetailmap = tex2D(sampler4Wrap, indata.Tex0.wz);
  355.         scalar lowDetailmap = lerp(0.5, yplaneLowDetailmap.z, lowComponent.x*indata.FogAndFade2.y);
  356. #else
  357.         vec4 yplaneLowDetailmap = tex2D(ssampler4Wrap, indata.Tex5);

  358.         //tl: do lerp in 1 MAD by precalculating constant factor in vShader
  359.         scalar lowDetailmap = 2*yplaneLowDetailmap.z * indata.BlendValueAndFade.y + indata.FogAndFade2.z;
  360. #endif

  361. #if HIGHTERRAIN
  362.         scalar mounten =        (xplaneLowDetailmap.y * indata.BlendValueAndFade.x) +
  363.                                                 (yplaneLowDetailmap.x * indata.BlendValueAndFade.y) +
  364.                                                 (zplaneLowDetailmap.y * indata.BlendValueAndFade.z)        ;

  365.         lowDetailmap *= (4 * lerp(0.5, mounten, lowComponent.z));

  366.         vec3 bothDetailmap = detailmap * lowDetailmap;
  367.         vec3 detailout = lerp(2*bothDetailmap, lowDetailmap, indata.BlendValueAndFade.w);
  368. #else
  369.         //tl: lerp optimized to handle 2*c*low + (2-2c)*detail, factors sent from vs
  370.         vec3 detailout = lowDetailmap*indata.BlendValueAndFade.x + 2*detailmap*indata.BlendValueAndFade.z;
  371. #endif

  372.         vec3 outColor = detailout * colormap * light;

  373.         vec4 envmapColor = texCUBE(sampler6Cube, indata.EnvMap);
  374. #if HIGHTERRAIN
  375.         outColor = lerp(outColor, envmapColor, detailmap.w * (1-indata.BlendValueAndFade.w));
  376. #else
  377.         outColor = lerp(outColor, envmapColor, detailmap.w * (1-indata.FogAndFade2.y));
  378. #endif
  379.         
  380.         //tl: this 2* is the one missing from the light calculation above!
  381.         vec3 fogOutColor = lerp(FogColor, outColor*2, indata.FogAndFade2.x);
  382.         return vec4(chartcontrib * fogOutColor, chartcontrib);
  383. #endif        
  384. }

  385. Hi_VS2PS_FullDetailWithEnvMap Hi_VS_FullDetailWithEnvMap(Shared_APP2VS_Default indata)
  386. {
  387.         Hi_VS2PS_FullDetailWithEnvMap outdata = (Hi_VS2PS_FullDetailWithEnvMap)0;
  388.         
  389.         vec4 wPos;
  390.         wPos.xz = (indata.Pos0.xy * vScaleTransXZ.xy) + vScaleTransXZ.zw;
  391.         wPos.yw = (indata.Pos1.xw * vScaleTransY.xy);// + vScaleTransY.zw;

  392. #if DEBUGTERRAIN
  393.         outdata.Pos = mul(wPos, mViewProj);
  394.         outdata.Tex0 = vec4(0,0,0,0);
  395.         outdata.Tex1 = vec4(0,0,0,0);
  396.         outdata.BlendValueAndFade = vec4(0,0,0,0);
  397.         outdata.Tex3 = vec4(0,0,0,0);
  398.         outdata.Tex5 = vec2(0,0);
  399.         outdata.EnvMap = vec3(0,0,0);
  400.         outdata.FogAndFade2 = vec4(0,0,0,0);
  401.         return outdata;
  402. #endif

  403.         scalar yDelta, interpVal;
  404. //        geoMorphPosition(wPos, indata.MorphDelta, yDelta, interpVal);
  405.         geoMorphPosition(wPos, indata.MorphDelta, indata.Pos0.z, yDelta, interpVal);
  406.         
  407.         //tl: output HPos as early as possible.
  408.          outdata.Pos = mul(wPos, mViewProj);

  409.          //tl: uncompress normal
  410.          indata.Normal = indata.Normal * 2 - 1;

  411.         vec3 tex = vec3(indata.Pos0.y * vTexScale.z, wPos.y * vTexScale.y, indata.Pos0.x * vTexScale.x);
  412.         vec2 yPlaneTexCord = tex.zx;
  413. #if HIGHTERRAIN
  414.         vec2 xPlaneTexCord = tex.xy;
  415.         vec2 zPlaneTexCord = tex.zy;
  416. #endif
  417.         
  418.          outdata.Tex0.xy = (yPlaneTexCord*vColorLightTex.x) + vColorLightTex.y;
  419.          outdata.Tex6 = (yPlaneTexCord*vDetailTex.x) + vDetailTex.y;

  420.         //tl: Switched tex0.wz for tex3.xy to easier access it from 1.4
  421.         outdata.Tex3.xy = yPlaneTexCord.xy * vNearTexTiling.z;
  422.         
  423.          outdata.Tex5 = yPlaneTexCord * vFarTexTiling.z;

  424. #if HIGHTERRAIN
  425.         outdata.Tex0.wz = xPlaneTexCord.xy * vFarTexTiling.xy;
  426.         outdata.Tex0.z += vFarTexTiling.w;
  427.         outdata.Tex3.wz = zPlaneTexCord.xy * vFarTexTiling.xy;
  428.         outdata.Tex3.z += vFarTexTiling.w;
  429. #endif

  430.         outdata.FogAndFade2.x = calcFog(outdata.Pos.w);
  431.         outdata.FogAndFade2.yzw = 0.5+interpVal*0.5;

  432. #if HIGHTERRAIN
  433.         outdata.BlendValueAndFade.w = interpVal;
  434. #elif MIDTERRAIN
  435.         //tl: optimized so we can do more advanced lerp in same number of instructions
  436.         //    factors are 2c and (2-2c) which equals a lerp()*2
  437.         //    Don't use w, it's harder to access from ps1.4
  438.         outdata.BlendValueAndFade.xz = interpVal * vec2(2, -2) + vec2(0, 2);
  439. #endif

  440. #if HIGHTERRAIN
  441.         outdata.BlendValueAndFade.xyz = saturate(abs(indata.Normal) - vBlendMod);
  442.         scalar tot = dot(1, outdata.BlendValueAndFade.xyz);
  443.         outdata.BlendValueAndFade.xyz /= tot;
  444. #elif MIDTERRAIN
  445.         //tl: use squared yNormal as blend val. pre-multiply with fade value.
  446.         outdata.BlendValueAndFade.yw = indata.Normal.y * indata.Normal.y * outdata.FogAndFade2.y;

  447.         outdata.FogAndFade2.y = interpVal;
  448.         outdata.FogAndFade2.z = outdata.BlendValueAndFade.y*-0.5 + 0.5;
  449. #endif

  450.         outdata.Tex1 = projToLighting(outdata.Pos);

  451.         // Environment map
  452.         //tl: no need to normalize, reflection works with long vectors,
  453.         //    and cube maps auto-normalize.
  454.         //outdata.EnvMap = reflect(wPos.xyz - vCamerapos.xyz, vec3(0,1,0));
  455.         //outdata.EnvMap = vec3(1,-1,1)*wPos.xyz - vec3(1,-1,1)*vCamerapos.xyz;
  456.         outdata.EnvMap = reflect(wPos.xyz - vCamerapos.xyz, vec3(0,1,0));

  457.         return outdata;
  458. }








  459. struct Hi_VS2PS_PerPixelPointLight
  460. {
  461.     vec4        Pos : POSITION;
  462.     vec3        wPos : TEXCOORD0;
  463.     vec3        Normal : TEXCOORD1;
  464. };

  465. vec4 Hi_PS_PerPixelPointLight(Hi_VS2PS_PerPixelPointLight indata) : COLOR
  466. {
  467.          return vec4(calcPVPointTerrain(indata.wPos, indata.Normal), 0) * 0.5;
  468. }

  469. Hi_VS2PS_PerPixelPointLight Hi_VS_PerPixelPointLight(Shared_APP2VS_Default indata)
  470. {
  471.         Hi_VS2PS_PerPixelPointLight outdata;
  472.         
  473.         vec4 wPos;
  474.         wPos.xz = (indata.Pos0.xy * vScaleTransXZ.xy) + vScaleTransXZ.zw;
  475.         //tl: Trans is always 0, and MADs cost more than MULs in certain cards.
  476.         wPos.yw = indata.Pos1.xw * vScaleTransY.xy;

  477.         scalar yDelta, interpVal;
  478. //        geoMorphPosition(wPos, indata.MorphDelta, yDelta, interpVal);
  479.         geoMorphPosition(wPos, indata.MorphDelta, indata.Pos0.z, yDelta, interpVal);
  480.         
  481.         //tl: output HPos as early as possible.
  482.          outdata.Pos = mul(wPos, mViewProj);

  483.          //tl: uncompress normal
  484.          indata.Normal = indata.Normal * 2 - 1;
  485.          
  486.          outdata.Normal = indata.Normal;
  487.          outdata.wPos = wPos.xyz;

  488.         return outdata;
  489. }


  490. vec4 Hi_PS_DirectionalLightShadows(Shared_VS2PS_DirectionalLightShadows indata) : COLOR
  491. {
  492.         vec4 lightmap = tex2D(sampler0Clamp, indata.Tex0);
  493.         
  494.         vec4 avgShadowValue = getShadowFactor(ShadowMapSampler, indata.ShadowTex);

  495.         vec4 light = saturate(lightmap.z * vGIColor*2) * 0.5;
  496.         if (avgShadowValue.z < lightmap.y)
  497.                 //light.w = 1-saturate(4-indata.Z.x)+avgShadowValue.x;
  498.                 light.w = avgShadowValue.z;
  499.         else
  500.                 light.w = lightmap.y;

  501.         return light;
  502. }














  503. technique Hi_Terrain
  504. {
  505.         pass ZFillLightmap        //p0
  506.         {
  507.                 CullMode = CW;
  508.                 ZEnable = TRUE;
  509.                 ZWriteEnable = TRUE;
  510.                 ZFunc = LESS;
  511.                 AlphaBlendEnable = FALSE;
  512.                 FogEnable = false;
  513.                
  514. #if IS_NV4X
  515.                 StencilEnable                = true;
  516.                 StencilFunc                        = NOTEQUAL;
  517.                 StencilRef                        = 0xa;
  518.                 StencilPass                        = KEEP;
  519.                 StencilZFail                = KEEP;
  520.                 StencilFail                        = KEEP;
  521. #endif

  522.                 VertexShader = compile vs_1_1 Shared_VS_ZFillLightmap();

  523.                 //tl: Using a 1.4 profile shortens this shader considerably (from 4 to 1
  524.                 //    instructions because of arbitrary component select), however HLSL
  525.                 //    is unable to compile this optimally hence the inline assembly... :-|
  526.                 PixelShaderConstantF[0] = (vGIColor);
  527.                 Sampler[1] = (sampler0Clamp);
  528.                 PixelShader = asm {
  529. ps_1_4
  530. texld r1, t0
  531. mul r0.xyz, r1.z, c0
  532. +mov_sat r0.w, r1.y
  533.                 };
  534.         }
  535.         pass pointlight                //p1
  536.         {
  537.                 CullMode = CW;
  538.                 ZEnable = TRUE;
  539.                 ZWriteEnable = FALSE;
  540.                 ZFunc = LESSEQUAL;
  541.                 AlphaBlendEnable = TRUE;
  542.                 SrcBlend = ONE;
  543.                 DestBlend = ONE;
  544.                
  545. #if IS_NV4X
  546.                 StencilEnable                = true;
  547.                 StencilFunc                        = NOTEQUAL;
  548.                 StencilRef                        = 0xa;
  549.                 StencilPass                        = KEEP;
  550.                 StencilZFail                = KEEP;
  551.                 StencilFail                        = KEEP;
  552. #endif

  553.                 VertexShader = compile vs_1_1 Shared_VS_PointLight();
  554.                 PixelShader = compile ps_1_1 Shared_PS_PointLight();
  555.         }
  556.         pass {} // spotlight (removed) p2
  557.         pass LowDiffuse                //p3
  558.         {
  559.                 CullMode = CW;
  560.                 ZEnable = TRUE;
  561.                 ZWriteEnable = FALSE;
  562.                 ZFunc = LESSEQUAL;
  563.                 FogEnable = true;
  564.                 AlphaBlendEnable = FALSE;
  565.                 AlphaTestEnable = FALSE;
  566. //                FillMode                = WireFrame;
  567.                
  568. #if IS_NV4X
  569.                 StencilEnable                = true;
  570.                 StencilFunc                        = NOTEQUAL;
  571.                 StencilRef                        = 0xa;
  572.                 StencilPass                        = KEEP;
  573.                 StencilZFail                = KEEP;
  574.                 StencilFail                        = KEEP;
  575. #endif

  576.                 VertexShader = compile vs_1_1 Shared_VS_LowDetail();
  577. #if 1               
  578.                 PixelShader = compile LOWPSMODEL Shared_PS_LowDetail();
  579. #else               
  580.                
  581.                 Sampler[0] = (sampler0Clamp); // colormap
  582.                 Sampler[1] = (sampler1Clamp); // lightmap
  583.                 Sampler[3] = (sampler4Wrap); // lowDetailTexture
  584.                 PixelShaderConstantF[0] = (vSunColor);
  585.                 PixelShaderConstantF[1] = (terrainWaterColor);

  586.                 PixelShader = asm {
  587.                         ps_1_4
  588.                         def c2, 0, 0, 0, 1
  589. //                mov r0, v0.y
  590. //              mov r0.w, c2.w
  591.                
  592.                         texld r1, t1_dw.xyww
  593.                         texld r0, t0
  594.                         texld r3, t3
  595.                         mad r1.xyz, r1_x2.w, c0, r1
  596.                         mul r0.xyz, r1, r0
  597.                       + lrp r1.w, v0.y, r3.z, r3.x
  598.                         mul r0.xyz, r0_x2, r1.w
  599.                         lrp r0.xyz, v0.w, c1, r0_x2
  600.                       + mov r0.w, c2.w
  601.                      
  602.                 };
  603. #endif               
  604.         }
  605.         pass FullDetail        //p4
  606.         {
  607.                 CullMode = CW;
  608.                 ZEnable = TRUE;
  609.                 ZWriteEnable = FALSE;
  610.                 ZFunc = LESSEQUAL;
  611.                 AlphaBlendEnable = TRUE;
  612.                 SrcBlend = ONE;
  613.                 DestBlend = ONE;
  614.                 AlphaTestEnable = TRUE;
  615.                 AlphaFunc = GREATER;
  616.                 AlphaRef = 0;
  617.                 //ColorWriteEnable = RED|BLUE|GREEN|ALPHA;
  618.                 FogEnable = false;
  619. //                FillMode                = WireFrame;
  620.                
  621.                
  622. #if IS_NV4X
  623.                 StencilEnable                = true;
  624.                 StencilFunc                        = NOTEQUAL;
  625.                 StencilRef                        = 0xa;
  626.                 StencilPass                        = KEEP;
  627.                 StencilZFail                = KEEP;
  628.                 StencilFail                        = KEEP;
  629. #endif

  630.                 VertexShader = compile vs_1_1 Hi_VS_FullDetail();
  631. #if HIGHTERRAIN
  632.                 PixelShader = compile PS2_EXT Hi_PS_FullDetail();
  633. #elif MIDTERRAIN
  634.         #if 1
  635.                 PixelShader = compile LOWPSMODEL Hi_PS_FullDetail();
  636.         #else
  637.                 //tl: Once again hand written is required to take advantage of 1.4
  638.                 PixelShaderConstantF[0] = (FogColor);
  639.                 PixelShaderConstantF[1] = (vComponentsel);
  640.                 PixelShaderConstantF[2] = (vSunColor);
  641.                 Sampler[0] = (sampler1Clamp);
  642.                 Sampler[1] = (sampler2Clamp);
  643.                 Sampler[2] = (ssampler4Wrap);
  644.                 Sampler[3] = (dsampler3Wrap);
  645.                 Sampler[4] = (sampler0Clamp);
  646.                 PixelShader = asm {
  647.             //   FogColor      c0       1
  648.             //   vComponentsel c1       1
  649.             //   vSunColor     c2       1
  650.             //   sampler1Clamp s0       1
  651.             //   sampler2Clamp s1       1
  652.             //   ssampler4Wrap s2       1
  653.             //   dsampler3Wrap s3       1
  654.             //   sampler0Clamp s4       1

  655.                 ps_1_4
  656. //                texcrd r0.xyz, t2
  657. //               mov r0, r0.y
  658.             
  659.                 texld r0, t1_dw.xyww
  660.                 texld r1, t0
  661.                 mad r5.xyz, r0_x2.w, c2, r0
  662.                 dp3 r1.x, c1, r1
  663.                 phase
  664.                 texcrd r0.xyz, t2
  665.                 texld r2, t4
  666.                 texld r3, t3
  667.                 texld r4, t0
  668.                 mad r2.w, r2.z, r0.y, v0.z
  669.               + mul r3.xyz, r3, r0.z
  670.                 mad r0.xyz, r2.w, r0.x, r3
  671.                 mul r0.xyz, r4, r0
  672.                 mul r0.xyz, r0, r5
  673.                 lrp r0.xyz, v0.x, r0_x2, c0
  674.                 mul r0.xyz, r0, r1.x
  675.               + mov r0.w, r1.x
  676.             
  677.                 };
  678.         #endif
  679. #endif
  680.         }
  681.         pass FullDetailMounten        //p5
  682.         {
  683.                 CullMode = CW;
  684.                 ZEnable = TRUE;
  685.                 ZWriteEnable = FALSE;
  686.                 ZFunc = LESSEQUAL;
  687.                 AlphaBlendEnable = TRUE;
  688.                 SrcBlend = ONE;
  689.                 DestBlend = ONE;
  690.                 FogEnable = false;
  691.                
  692. #if IS_NV4X
  693.                 StencilEnable                = true;
  694.                 StencilFunc                        = NOTEQUAL;
  695.                 StencilRef                        = 0xa;
  696.                 StencilPass                        = KEEP;
  697.                 StencilZFail                = KEEP;
  698.                 StencilFail                        = KEEP;
  699. #endif

  700.                 VertexShader = compile vs_1_1 Hi_VS_FullDetailMounten();
  701. #if HIGHTERRAIN
  702.                 PixelShader = compile PS2_EXT Hi_PS_FullDetailMounten();               
  703. #elif MIDTERRAIN
  704. #if 0
  705.                 PixelShader = compile LOWPSMODEL Hi_PS_FullDetailMounten();
  706. #else
  707.             PixelShaderConstantF[0] = (FogColor);
  708.             PixelShaderConstantF[1] = (vComponentsel);
  709.             PixelShaderConstantF[2] = (vSunColor);
  710.             Sampler[0] = (ssampler4Wrap);
  711.             Sampler[1] = (ssampler3Wrap);
  712.             Sampler[2] = (sampler0Clamp);
  713.             Sampler[3] = (sampler1Clamp);
  714.             Sampler[4] = (sampler2Clamp);

  715.             PixelShader = asm {
  716.                 ps_1_4
  717.                 def c3, 0, 0, 0, 1
  718.                 texld r0, t5
  719.                 texld r1, t3
  720.                 texcrd r2.xyz, t2
  721.                 mad r1.xyz, r1, r2.z, r2.x
  722.                                 +lrp r0.w, r2.y, r0.z, r0.x
  723.                 mul r0.xyz, r0.w, r1
  724.                 phase
  725.                 texld r2, t0
  726.                 texld r3, t1_dw.xyww
  727.                 texld r4, t4
  728.                 mul r0.xyz, r2, r0
  729.                 mad r1.xyz, r3_x2.w, c2, r3
  730.                 mul r0.xyz, r0, r1
  731.                                 lrp r0.xyz, v0.x, r0_x2, c0
  732.                 dp3 r0.w, c1, r4
  733.                 mul r0.xyz, r0, r0.w
  734.                 };
  735. #endif
  736. #endif
  737.         }
  738.         pass {} // p6 tunnels (removed)
  739.         pass DirectionalLightShadows        //p7
  740.         {
  741.                 CullMode = CW;
  742.                 //ColorWriteEnable = RED|BLUE|GREEN|ALPHA;
  743.                 ZEnable = TRUE;
  744.                 ZWriteEnable = TRUE;
  745.                 ZFunc = LESSEQUAL;
  746.                  AlphaBlendEnable = FALSE;
  747.                
  748. #if IS_NV4X
  749.                 StencilEnable                = true;
  750.                 StencilFunc                        = NOTEQUAL;
  751.                 StencilRef                        = 0xa;
  752.                 StencilPass                        = KEEP;
  753.                 StencilZFail                = KEEP;
  754.                 StencilFail                        = KEEP;
  755. #endif

  756.                 VertexShader = compile vs_1_1 Shared_VS_DirectionalLightShadows();
  757.                 PixelShader = compile SHADOWPSMODEL Hi_PS_DirectionalLightShadows();
  758.         }

  759.         pass {} // DirectionalLightShadowsNV (removed)        //p8

  760.         pass DynamicShadowmap        //p9
  761.         {
  762.         //obsolete
  763.         }

  764.         pass {} // p10
  765.         
  766.         pass FullDetailWithEnvMap        //p11
  767.         {
  768.                 CullMode = CW;
  769.                 ZEnable = TRUE;
  770.                 ZWriteEnable = FALSE;
  771.                 ZFunc = LESSEQUAL;
  772.                 AlphaBlendEnable = TRUE;
  773.                 SrcBlend = ONE;
  774.                 DestBlend = ONE;
  775.                 AlphaTestEnable = TRUE;
  776.                 AlphaFunc = GREATER;
  777.                 AlphaRef = 0;
  778.                 //ColsorWriteEnable = RED|BLUE|GREEN|ALPHA;
  779.                 FogEnable = false;
  780.                
  781. #if IS_NV4X
  782.                 StencilEnable                = true;
  783.                 StencilFunc                        = NOTEQUAL;
  784.                 StencilRef                        = 0xa;
  785.                 StencilPass                        = KEEP;
  786.                 StencilZFail                = KEEP;
  787.                 StencilFail                        = KEEP;
  788. #endif

  789.                 VertexShader = compile vs_1_1 Hi_VS_FullDetailWithEnvMap();
  790. #if HIGHTERRAIN
  791.                 PixelShader = compile PS2_EXT Hi_PS_FullDetailWithEnvMap();
  792. #elif MIDTERRAIN
  793.                 //tl: Assembly to fit into 1.4, because HLSL can't do it. :-(
  794.                 PixelShaderConstantF[0] = (FogColor);
  795.                 PixelShaderConstantF[1] = (vComponentsel);
  796.                 PixelShaderConstantF[2] = (vSunColor);
  797.                 Sampler[0] = (sampler1Clamp);
  798.                 Sampler[1] = (ssampler4Wrap);
  799.                 Sampler[2] = (dsampler3Wrap);
  800.                 Sampler[3] = (sampler0Clamp);
  801.                 Sampler[4] = (sampler2Clamp);
  802.                 Sampler[5] = (sampler6Cube);
  803.                 PixelShader = asm {
  804.             //   Name          Reg   Size
  805.             //   ------------- ----- ----
  806.             //   FogColor      c0       1
  807.             //   vComponentsel c1       1
  808.             //   vSunColor     c2       1
  809.             //   sampler1Clamp s0       1
  810.             //   ssampler4Wrap s1       1
  811.             //   dsampler3Wrap s2       1
  812.             //   sampler0Clamp s3       1
  813.             //   sampler2Clamp s4       1
  814.             
  815.                 ps_1_4
  816.                 def c3, 0, 0, 1, 1
  817.                 texld r0, t1_dw.xyww                        //sample lights
  818.                 texld r3, t0                                        //sample colormap
  819.                 texld r4, t0                                        //sample component
  820.                 texld r5, t4                                        //sample envmap
  821.                 mad r0.xyz, r0_x2.w, c2, r0                //get light factor
  822.                 dp3 r4.x, c1, r4                                //calc component selector
  823.                 phase
  824.                 texld r1, t2                                        //sample ydetailmap
  825.                 texld r2, t3                                        //sample detailmap

  826.                                 //scalar lowDetailmap = 2*yplaneLowDetailmap.z * indata.BlendValueAndFade.y + indata.FogAndFade2.z;
  827.                 mad r1.w, r1_x2.z, v0.y, v1.z

  828.                                 //vec3 detailout = lowDetailmap*indata.BlendValueAndFade.x + 2*detailmap*indata.BlendValueAndFade.z;
  829.               + mul r2.xyz, r2, v0.z
  830.                 mad r1.xyz, r1.w, v0.x, r2_x2
  831.                
  832.                                 //vec3 outColor = detailout * colormap * light;
  833.                 mul r1.xyz, r3, r1
  834.                 mul r0.xyz, r1, r0
  835.                
  836.                                 //outColor = lerp(outColor, envmapColor, detailmap.w * (1-indata.FogAndFade2.y));
  837.                 +mul r2.w, r2.w, 1-v1.y
  838.                 lrp r0.xyz, r2.w, r5, r0
  839.                
  840.                                 //vec3 fogOutColor = lerp(FogColor, outColor*2, indata.FogAndFade2.x);
  841.                 lrp r0.xyz, v1.x, r0_x2, c0

  842.                                 //return vec4(chartcontrib * fogOutColor, chartcontrib);
  843.                 mul r0.xyz, r0, r4.x
  844.               + mov r0.w, r4.x
  845.                 };
  846. #endif
  847.         }
  848.         
  849.         pass {} // mulDiffuseFast (removed) p12

  850.         pass PerPixelPointlight                //p13
  851.         {
  852.                 CullMode = CW;
  853.                 ZEnable = TRUE;
  854.                 ZWriteEnable = FALSE;
  855.                 ZFunc = LESSEQUAL;
  856.                 AlphaBlendEnable = TRUE;
  857.                 SrcBlend = ONE;
  858.                 DestBlend = ONE;
  859.                
  860. #if IS_NV4X
  861.                 StencilEnable                = true;
  862.                 StencilFunc                        = NOTEQUAL;
  863.                 StencilRef                        = 0xa;
  864.                 StencilPass                        = KEEP;
  865.                 StencilZFail                = KEEP;
  866.                 StencilFail                        = KEEP;
  867. #endif

  868.                 VertexShader = compile vs_1_1 Hi_VS_PerPixelPointLight();
  869.                 PixelShader = compile PS2_EXT Hi_PS_PerPixelPointLight();
  870.         }

  871.         pass underWater // p14
  872.         {
  873.                 CullMode = CW;
  874.                 ZEnable = TRUE;
  875.                 ZWriteEnable = FALSE;
  876.                 ZFunc = LESSEQUAL;
  877.                 AlphaTestEnable = TRUE;
  878.                 AlphaRef = 15;        //tl: leave cap above 0 for better results
  879.                 AlphaFunc = GREATER;
  880.                 AlphaBlendEnable = TRUE;
  881.                 SrcBlend = SRCALPHA;
  882.                 DestBlend = INVSRCALPHA;
  883.                 FogEnable = false;
  884.                
  885. #if IS_NV4X
  886.                 StencilEnable                = true;
  887.                 StencilFunc                        = NOTEQUAL;
  888.                 StencilRef                        = 0xa;
  889.                 StencilPass                        = KEEP;
  890.                 StencilZFail                = KEEP;
  891.                 StencilFail                        = KEEP;
  892. #endif

  893.                 VertexShader = compile vs_1_1 Shared_VS_UnderWater();
  894.                 PixelShader = compile LOWPSMODEL Shared_PS_UnderWater();
  895.         }
  896.         pass ZFillLightmap2        //p15
  897.         {
  898.                 //note: ColorWriteEnable is disabled in code for this
  899.                 CullMode = CW;
  900.                 ZEnable = TRUE;
  901.                 ZWriteEnable = TRUE;
  902.                 ZFunc = LESS;
  903.                 AlphaBlendEnable = FALSE;
  904.                 FogEnable = false;
  905.                 VertexShader = compile vs_1_1 Shared_VS_ZFillLightmap();
  906.                 PixelShader = asm
  907.                 {
  908.                         ps.1.1
  909.                         mov r0, c0
  910.                 };
  911.         }
  912. }

复制代码



战地资源网技术顾问,原战地2中文网站长
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即加入

本版积分规则

Archiver|禁闭室|bfmil

GMT+8, 2020-9-27 20:34 , Processed in 0.121484 second(s), 30 queries .

Powered by Discuz! X3.4

© 2009-2020, 阿里云计算

快速回复 返回顶部 返回列表