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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file giF.glsl
  3.  *
  4.  * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
  5.  * $License$
  6.  */
  7. #extension GL_ARB_texture_rectangle : enable
  8. uniform sampler2DRect depthMap;
  9. uniform sampler2DRect normalMap;
  10. uniform sampler2DRect lightMap;
  11. uniform sampler2DRect specularRect;
  12. uniform sampler2D noiseMap;
  13. uniform sampler2D diffuseGIMap;
  14. uniform sampler2D specularGIMap;
  15. uniform sampler2D normalGIMap;
  16. uniform sampler2D depthGIMap;
  17. uniform sampler2D lightFunc;
  18. // Inputs
  19. varying vec2 vary_fragcoord;
  20. uniform vec2 screen_res;
  21. uniform vec4 sunlight_color;
  22. uniform mat4 inv_proj;
  23. uniform mat4 gi_mat;  //gPipeline.mGIMatrix - eye space to sun space
  24. uniform mat4 gi_mat_proj; //gPipeline.mGIMatrixProj - eye space to projected sun space
  25. uniform mat4 gi_norm_mat; //gPipeline.mGINormalMatrix - eye space normal to sun space normal matrix
  26. uniform mat4 gi_inv_proj; //gPipeline.mGIInvProj - projected sun space to sun space
  27. uniform float gi_sample_width;
  28. uniform float gi_noise;
  29. uniform float gi_attenuation;
  30. uniform float gi_range;
  31. vec4 getPosition(vec2 pos_screen)
  32. {
  33. float depth = texture2DRect(depthMap, pos_screen.xy).a;
  34. vec2 sc = pos_screen.xy*2.0;
  35. sc /= screen_res;
  36. sc -= vec2(1.0,1.0);
  37. vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
  38. vec4 pos = inv_proj * ndc;
  39. pos /= pos.w;
  40. pos.w = 1.0;
  41. return pos;
  42. }
  43. vec4 getGIPosition(vec2 gi_tc)
  44. {
  45. float depth = texture2D(depthGIMap, gi_tc).a;
  46. vec2 sc = gi_tc*2.0;
  47. sc -= vec2(1.0, 1.0);
  48. vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
  49. vec4 pos = gi_inv_proj*ndc;
  50. pos.xyz /= pos.w;
  51. pos.w = 1.0;
  52. return pos;
  53. }
  54. vec3 giAmbient(vec3 pos, vec3 norm)
  55. {
  56. vec4 gi_c = gi_mat_proj * vec4(pos, 1.0);
  57. gi_c.xyz /= gi_c.w;
  58. vec4 gi_pos = gi_mat*vec4(pos,1.0);
  59. vec3 gi_norm = (gi_norm_mat*vec4(norm,1.0)).xyz;
  60. gi_norm = normalize(gi_norm);
  61. vec4 c_spec = texture2DRect(specularRect, vary_fragcoord.xy);
  62. vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).rgb;
  63. gi_pos.xyz += nz.x*gi_noise*gi_norm.xyz;
  64. vec2 tcx = gi_norm.xy;
  65. vec2 tcy = gi_norm.yx;
  66. vec4 eye_pos = gi_mat*vec4(0,0,0,1.0);
  67. vec3 eye_dir = normalize(gi_pos.xyz-eye_pos.xyz);
  68. vec3 eye_ref = reflect(eye_dir, gi_norm);
  69. float da = 0.0; //texture2DRect(lightMap, vary_fragcoord.xy).r*0.5;
  70. vec3 fdiff = vec3(da);
  71. float fda = da;
  72. vec3 rcol = vec3(0,0,0);
  73. float fsa = 0.0;
  74. for (int i = -1; i <= 1; i += 2 )
  75. {
  76. for (int j = -1; j <= 1; j+= 2)
  77. {
  78. vec2 tc = vec2(i, j)*0.75+gi_norm.xy*nz.z;
  79. tc += nz.xy*2.0;
  80. tc *= gi_sample_width*0.25;
  81. tc += gi_c.xy;
  82. vec3 lnorm = -(texture2D(normalGIMap, tc.xy).xyz*2.0-1.0);
  83. vec3 lpos = getGIPosition(tc.xy).xyz;
  84. vec3 at = lpos-gi_pos.xyz;
  85. float dist = length(at);
  86. float dist_atten = clamp(1.0/(gi_attenuation*dist), 0.0, 1.0);
  87. if (dist_atten > 0.01)
  88. { //possible contribution of indirect light to this surface
  89. vec3 ldir = at;
  90. float ld = -dot(ldir, lnorm);
  91. if (ld < 0.0)
  92. {  
  93. float ang_atten = dot(ldir, gi_norm);
  94. if (ang_atten > 0.0)
  95. {  
  96. vec4 spec = texture2D(specularGIMap, tc.xy);
  97. at = normalize(at);
  98. vec3 diff;
  99. float da = 0.0;
  100. //contribution from indirect source to visible pixel
  101. vec3 ha = at;
  102. ha.z -= 1.0;
  103. ha = normalize(ha);
  104. if (spec.a > 0.0)
  105. {
  106. float sa = dot(ha,lnorm);
  107. da = texture2D(lightFunc, vec2(sa, spec.a)).a;
  108. }
  109. else
  110. {
  111. da = -lnorm.z;
  112. }
  113. diff = texture2D(diffuseGIMap, tc.xy).rgb+spec.rgb*spec.a*2.0;
  114. if (da > 0.0)
  115. { //contribution from visible pixel to eye
  116. vec3 ha = normalize(at-eye_dir);
  117. if (c_spec.a > 0.0)
  118. {
  119. float sa = dot(ha, gi_norm);
  120. da = dist_atten*texture2D(lightFunc, vec2(sa, c_spec.a)).a;
  121. }
  122. else
  123. {
  124. da = dist_atten*dot(gi_norm, normalize(ldir));
  125. }
  126. fda += da;
  127. fdiff += da*(c_spec.rgb*c_spec.a*2.0+vec3(1,1,1))*diff.rgb;
  128. }
  129. }
  130. }
  131. }
  132. }
  133. }
  134. fdiff *= sunlight_color.rgb;
  135. vec3 ret = fda*fdiff;
  136. return clamp(ret,vec3(0.0), vec3(1.0));
  137. }
  138. void main() 
  139. {
  140. vec2 pos_screen = vary_fragcoord.xy;
  141. vec4 pos = getPosition(pos_screen);
  142. float rad = gi_range*0.5;
  143. vec3 norm = texture2DRect(normalMap, pos_screen).xyz*2.0-1.0;
  144. float dist = max(length(pos.xyz)-rad, 0.0);
  145. float da = clamp(1.0-dist/rad, 0.0, 1.0);
  146. vec3 ambient = da > 0.0 ? giAmbient(pos.xyz, norm) : vec3(0);
  147. gl_FragData[0].xyz = mix(vec3(0), ambient, da);
  148. }