/indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl

https://bitbucket.org/lindenlab/viewer-beta/ · GLSL · 146 lines · 76 code · 36 blank · 34 comment · 3 complexity · 0e63abd138d866aadff87091019a6227 MD5 · raw file

  1. /**
  2. * @file alphaV.glsl
  3. *
  4. * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  5. * Second Life Viewer Source Code
  6. * Copyright (C) 2007, Linden Research, Inc.
  7. *
  8. * This library is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU Lesser General Public
  10. * License as published by the Free Software Foundation;
  11. * version 2.1 of the License only.
  12. *
  13. * This library is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16. * Lesser General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU Lesser General Public
  19. * License along with this library; if not, write to the Free Software
  20. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21. *
  22. * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
  23. * $/LicenseInfo$
  24. */
  25. uniform mat3 normal_matrix;
  26. uniform mat4 texture_matrix0;
  27. uniform mat4 modelview_matrix;
  28. uniform mat4 modelview_projection_matrix;
  29. ATTRIBUTE vec3 position;
  30. void passTextureIndex();
  31. ATTRIBUTE vec3 normal;
  32. ATTRIBUTE vec4 diffuse_color;
  33. ATTRIBUTE vec2 texcoord0;
  34. vec4 calcLighting(vec3 pos, vec3 norm, vec4 color, vec4 baseCol);
  35. void calcAtmospherics(vec3 inPositionEye);
  36. float calcDirectionalLight(vec3 n, vec3 l);
  37. vec3 atmosAmbient(vec3 light);
  38. vec3 atmosAffectDirectionalLight(float lightIntensity);
  39. vec3 scaleDownLight(vec3 light);
  40. vec3 scaleUpLight(vec3 light);
  41. VARYING vec3 vary_ambient;
  42. VARYING vec3 vary_directional;
  43. VARYING vec3 vary_fragcoord;
  44. VARYING vec3 vary_position;
  45. VARYING vec3 vary_light;
  46. VARYING vec3 vary_pointlight_col;
  47. VARYING vec4 vertex_color;
  48. VARYING vec2 vary_texcoord0;
  49. uniform float near_clip;
  50. uniform float shadow_offset;
  51. uniform float shadow_bias;
  52. uniform vec4 light_position[8];
  53. uniform vec3 light_direction[8];
  54. uniform vec3 light_attenuation[8];
  55. uniform vec3 light_diffuse[8];
  56. float calcPointLightOrSpotLight(vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float fa, float is_pointlight)
  57. {
  58. //get light vector
  59. vec3 lv = lp.xyz-v;
  60. //get distance
  61. float d = length(lv);
  62. float da = 0.0;
  63. if (d > 0.0 && la > 0.0 && fa > 0.0)
  64. {
  65. //normalize light vector
  66. lv *= 1.0/d;
  67. //distance attenuation
  68. float dist2 = d*d/(la*la);
  69. da = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
  70. // spotlight coefficient.
  71. float spot = max(dot(-ln, lv), is_pointlight);
  72. da *= spot*spot; // GL_SPOT_EXPONENT=2
  73. //angular attenuation
  74. da *= calcDirectionalLight(n, lv);
  75. }
  76. return da;
  77. }
  78. void main()
  79. {
  80. //transform vertex
  81. vec4 vert = vec4(position.xyz, 1.0);
  82. passTextureIndex();
  83. vec4 pos = (modelview_matrix * vert);
  84. gl_Position = modelview_projection_matrix*vec4(position.xyz, 1.0);
  85. vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
  86. vec3 norm = normalize(normal_matrix * normal);
  87. float dp_directional_light = max(0.0, dot(norm, light_position[0].xyz));
  88. vary_position = pos.xyz + light_position[0].xyz * (1.0-dp_directional_light)*shadow_offset;
  89. calcAtmospherics(pos.xyz);
  90. //vec4 color = calcLighting(pos.xyz, norm, diffuse_color, vec4(0.));
  91. vec4 col = vec4(0.0, 0.0, 0.0, diffuse_color.a);
  92. // Collect normal lights
  93. col.rgb += light_diffuse[2].rgb*calcPointLightOrSpotLight(pos.xyz, norm, light_position[2], light_direction[2], light_attenuation[2].x, light_attenuation[2].y, light_attenuation[2].z);
  94. col.rgb += light_diffuse[3].rgb*calcPointLightOrSpotLight(pos.xyz, norm, light_position[3], light_direction[3], light_attenuation[3].x, light_attenuation[3].y, light_attenuation[3].z);
  95. col.rgb += light_diffuse[4].rgb*calcPointLightOrSpotLight(pos.xyz, norm, light_position[4], light_direction[4], light_attenuation[4].x, light_attenuation[4].y, light_attenuation[4].z);
  96. col.rgb += light_diffuse[5].rgb*calcPointLightOrSpotLight(pos.xyz, norm, light_position[5], light_direction[5], light_attenuation[5].x, light_attenuation[5].y, light_attenuation[5].z);
  97. col.rgb += light_diffuse[6].rgb*calcPointLightOrSpotLight(pos.xyz, norm, light_position[6], light_direction[6], light_attenuation[6].x, light_attenuation[6].y, light_attenuation[6].z);
  98. col.rgb += light_diffuse[7].rgb*calcPointLightOrSpotLight(pos.xyz, norm, light_position[7], light_direction[7], light_attenuation[7].x, light_attenuation[7].y, light_attenuation[7].z);
  99. vary_pointlight_col = col.rgb*diffuse_color.rgb;
  100. col.rgb = vec3(0,0,0);
  101. // Add windlight lights
  102. col.rgb = atmosAmbient(vec3(0.));
  103. vary_light = light_position[0].xyz;
  104. vary_ambient = col.rgb*diffuse_color.rgb;
  105. vary_directional.rgb = diffuse_color.rgb*atmosAffectDirectionalLight(max(calcDirectionalLight(norm, light_position[0].xyz), (1.0-diffuse_color.a)*(1.0-diffuse_color.a)));
  106. col.rgb = col.rgb*diffuse_color.rgb;
  107. vertex_color = col;
  108. pos = modelview_projection_matrix * vert;
  109. vary_fragcoord.xyz = pos.xyz + vec3(0,0,near_clip);
  110. }