softenLightF.glsl
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:8k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file softenLightF.glsl
  3.  *
  4.  * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
  5.  * $License$
  6.  */
  7. #extension GL_ARB_texture_rectangle : enable
  8. uniform sampler2DRect diffuseRect;
  9. uniform sampler2DRect specularRect;
  10. uniform sampler2DRect normalMap;
  11. uniform sampler2DRect lightMap;
  12. uniform sampler2D   noiseMap;
  13. uniform samplerCube environmentMap;
  14. uniform sampler2D   lightFunc;
  15. uniform vec3 gi_quad;
  16. uniform float blur_size;
  17. uniform float blur_fidelity;
  18. // Inputs
  19. uniform vec4 morphFactor;
  20. uniform vec3 camPosLocal;
  21. //uniform vec4 camPosWorld;
  22. uniform vec4 gamma;
  23. uniform vec4 lightnorm;
  24. uniform vec4 sunlight_color;
  25. uniform vec4 ambient;
  26. uniform vec4 blue_horizon;
  27. uniform vec4 blue_density;
  28. uniform vec4 haze_horizon;
  29. uniform vec4 haze_density;
  30. uniform vec4 cloud_shadow;
  31. uniform vec4 density_multiplier;
  32. uniform vec4 distance_multiplier;
  33. uniform vec4 max_y;
  34. uniform vec4 glow;
  35. uniform float scene_light_strength;
  36. uniform vec3 env_mat[3];
  37. uniform vec4 shadow_clip;
  38. uniform mat3 ssao_effect_mat;
  39. uniform sampler2DRect depthMap;
  40. uniform mat4 inv_proj;
  41. uniform vec2 screen_res;
  42. varying vec4 vary_light;
  43. varying vec2 vary_fragcoord;
  44. vec3 vary_PositionEye;
  45. vec3 vary_SunlitColor;
  46. vec3 vary_AmblitColor;
  47. vec3 vary_AdditiveColor;
  48. vec3 vary_AtmosAttenuation;
  49. uniform float gi_ambiance;
  50. vec4 getPosition(vec2 pos_screen)
  51. { //get position in screen space (world units) given window coordinate and depth map
  52. float depth = texture2DRect(depthMap, pos_screen.xy).a;
  53. vec2 sc = pos_screen.xy*2.0;
  54. sc /= screen_res;
  55. sc -= vec2(1.0,1.0);
  56. vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
  57. vec4 pos = inv_proj * ndc;
  58. pos /= pos.w;
  59. pos.w = 1.0;
  60. return pos;
  61. }
  62. vec3 getPositionEye()
  63. {
  64. return vary_PositionEye;
  65. }
  66. vec3 getSunlitColor()
  67. {
  68. return vary_SunlitColor;
  69. }
  70. vec3 getAmblitColor()
  71. {
  72. return vary_AmblitColor;
  73. }
  74. vec3 getAdditiveColor()
  75. {
  76. return vary_AdditiveColor;
  77. }
  78. vec3 getAtmosAttenuation()
  79. {
  80. return vary_AtmosAttenuation;
  81. }
  82. void setPositionEye(vec3 v)
  83. {
  84. vary_PositionEye = v;
  85. }
  86. void setSunlitColor(vec3 v)
  87. {
  88. vary_SunlitColor = v;
  89. }
  90. void setAmblitColor(vec3 v)
  91. {
  92. vary_AmblitColor = v;
  93. }
  94. void setAdditiveColor(vec3 v)
  95. {
  96. vary_AdditiveColor = v;
  97. }
  98. void setAtmosAttenuation(vec3 v)
  99. {
  100. vary_AtmosAttenuation = v;
  101. }
  102. void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
  103. vec3 P = inPositionEye;
  104. setPositionEye(P);
  105. //(TERRAIN) limit altitude
  106. if (P.y > max_y.x) P *= (max_y.x / P.y);
  107. if (P.y < -max_y.x) P *= (-max_y.x / P.y);
  108. vec3 tmpLightnorm = lightnorm.xyz;
  109. vec3 Pn = normalize(P);
  110. float Plen = length(P);
  111. vec4 temp1 = vec4(0);
  112. vec3 temp2 = vec3(0);
  113. vec4 blue_weight;
  114. vec4 haze_weight;
  115. vec4 sunlight = sunlight_color;
  116. vec4 light_atten;
  117. //sunlight attenuation effect (hue and brightness) due to atmosphere
  118. //this is used later for sunlight modulation at various altitudes
  119. light_atten = (blue_density * 1.0 + vec4(haze_density.r) * 0.25) * (density_multiplier.x * max_y.x);
  120. //I had thought blue_density and haze_density should have equal weighting,
  121. //but attenuation due to haze_density tends to seem too strong
  122. temp1 = blue_density + vec4(haze_density.r);
  123. blue_weight = blue_density / temp1;
  124. haze_weight = vec4(haze_density.r) / temp1;
  125. //(TERRAIN) compute sunlight from lightnorm only (for short rays like terrain)
  126. temp2.y = max(0.0, tmpLightnorm.y);
  127. temp2.y = 1. / temp2.y;
  128. sunlight *= exp( - light_atten * temp2.y);
  129. // main atmospheric scattering line integral
  130. temp2.z = Plen * density_multiplier.x;
  131. // Transparency (-> temp1)
  132. // ATI Bugfix -- can't store temp1*temp2.z*distance_multiplier.x in a variable because the ati
  133. // compiler gets confused.
  134. temp1 = exp(-temp1 * temp2.z * distance_multiplier.x);
  135. //final atmosphere attenuation factor
  136. setAtmosAttenuation(temp1.rgb);
  137. //compute haze glow
  138. //(can use temp2.x as temp because we haven't used it yet)
  139. temp2.x = dot(Pn, tmpLightnorm.xyz);
  140. temp2.x = 1. - temp2.x;
  141. //temp2.x is 0 at the sun and increases away from sun
  142. temp2.x = max(temp2.x, .03); //was glow.y
  143. //set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
  144. temp2.x *= glow.x;
  145. //higher glow.x gives dimmer glow (because next step is 1 / "angle")
  146. temp2.x = pow(temp2.x, glow.z);
  147. //glow.z should be negative, so we're doing a sort of (1 / "angle") function
  148. //add "minimum anti-solar illumination"
  149. temp2.x += .25;
  150. //increase ambient when there are more clouds
  151. vec4 tmpAmbient = ambient*gi_ambiance + (vec4(1.) - ambient*gi_ambiance) * cloud_shadow.x * 0.5;
  152. /*  decrease value and saturation (that in HSV, not HSL) for occluded areas
  153.  * // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html
  154.  * // The following line of code performs the equivalent of:
  155.  * float ambAlpha = tmpAmbient.a;
  156.  * float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis
  157.  * vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);
  158.  * tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat, ambAlpha);
  159.  */
  160. tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);
  161. //haze color
  162. setAdditiveColor(
  163. vec3(blue_horizon * blue_weight * (sunlight*(1.-cloud_shadow.x) + tmpAmbient)
  164.   + (haze_horizon.r * haze_weight) * (sunlight*(1.-cloud_shadow.x) * temp2.x
  165.   + tmpAmbient)));
  166. //brightness of surface both sunlight and ambient
  167. setSunlitColor(vec3(sunlight * .5));
  168. setAmblitColor(vec3(tmpAmbient * .25));
  169. setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
  170. }
  171. vec3 atmosLighting(vec3 light)
  172. {
  173. light *= getAtmosAttenuation().r;
  174. light += getAdditiveColor();
  175. return (2.0 * light);
  176. }
  177. vec3 atmosTransport(vec3 light) {
  178. light *= getAtmosAttenuation().r;
  179. light += getAdditiveColor() * 2.0;
  180. return light;
  181. }
  182. vec3 atmosGetDiffuseSunlightColor()
  183. {
  184. return getSunlitColor();
  185. }
  186. vec3 scaleDownLight(vec3 light)
  187. {
  188. return (light / scene_light_strength );
  189. }
  190. vec3 scaleUpLight(vec3 light)
  191. {
  192. return (light * scene_light_strength);
  193. }
  194. vec3 atmosAmbient(vec3 light)
  195. {
  196. return getAmblitColor() + light / 2.0;
  197. }
  198. vec3 atmosAffectDirectionalLight(float lightIntensity)
  199. {
  200. return getSunlitColor() * lightIntensity;
  201. }
  202. vec3 scaleSoftClip(vec3 light)
  203. {
  204. //soft clip effect:
  205. light = 1. - clamp(light, vec3(0.), vec3(1.));
  206. light = 1. - pow(light, gamma.xxx);
  207. return light;
  208. }
  209. void main() 
  210. {
  211. vec2 tc = vary_fragcoord.xy;
  212. vec3 pos = getPosition(tc).xyz;
  213. vec3 norm = texture2DRect(normalMap, tc).xyz*2.0-1.0;
  214. //vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).xyz;
  215. float da = max(dot(norm.xyz, vary_light.xyz), 0.0);
  216. vec4 diffuse = texture2DRect(diffuseRect, tc);
  217. vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
  218. da = texture2D(lightFunc, vec2(da, 0.0)).a;
  219. vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
  220. float scol = max(scol_ambocc.r, diffuse.a); 
  221. float ambocc = scol_ambocc.g;
  222. calcAtmospherics(pos.xyz, ambocc);
  223. vec3 col = atmosAmbient(vec3(0));
  224. col += atmosAffectDirectionalLight(max(min(da, scol), diffuse.a));
  225. col *= diffuse.rgb;
  226. if (spec.a > 0.0)
  227. {
  228. vec3 ref = normalize(reflect(pos.xyz, norm.xyz));
  229. float sa = dot(ref, vary_light.xyz);
  230. col.rgb += vary_SunlitColor*scol*spec.rgb*texture2D(lightFunc, vec2(sa, spec.a)).a;
  231. }
  232. col = atmosLighting(col);
  233. col = scaleSoftClip(col);
  234. gl_FragColor.rgb = col;
  235. //gl_FragColor.rgb = gi_col.rgb;
  236. gl_FragColor.a = 0.0;
  237. //gl_FragColor.rg = scol_ambocc.rg;
  238. //gl_FragColor.rgb = texture2DRect(lightMap, vary_fragcoord.xy).rgb;
  239. //gl_FragColor.rgb = norm.rgb*0.5+0.5;
  240. //gl_FragColor.rgb = vec3(ambocc);
  241. //gl_FragColor.rgb = vec3(scol);
  242. }