port of LL renderpipeline/Kirstens S19 pipeline for bridging to Viewer 2 texture system

16 files changed, 1654 insertions, 0 deletions

diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
new file mode 100644
index 0000000..0055a73
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
@@ -0,0 +1,112 @@
+/** 
+ * @file alphaF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2D diffuseMap;
+uniform sampler2DRectShadow shadowMap0;
+uniform sampler2DRectShadow shadowMap1;
+uniform sampler2DRectShadow shadowMap2;
+uniform sampler2DRectShadow shadowMap3;
+uniform sampler2D noiseMap;
+uniform sampler2DRect depthMap;
+
+uniform mat4 shadow_matrix[6];
+uniform vec4 shadow_clip;
+uniform vec2 screen_res;
+
+vec3 atmosLighting(vec3 light);
+vec3 scaleSoftClip(vec3 light);
+
+varying vec3 vary_ambient;
+varying vec3 vary_directional;
+varying vec3 vary_fragcoord;
+varying vec3 vary_position;
+varying vec3 vary_light;
+
+uniform float alpha_soften;
+
+uniform mat4 inv_proj;
+
+vec4 getPosition(vec2 pos_screen)
+{
+        float depth = texture2DRect(depthMap, pos_screen.xy).a;
+        vec2 sc = pos_screen.xy*2.0;
+        sc /= screen_res;
+        sc -= vec2(1.0,1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = inv_proj * ndc;
+        pos /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+void main() 
+{
+        vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
+        frag *= screen_res;
+        
+        vec3 samp_pos = getPosition(frag).xyz;
+        
+        float shadow = 1.0;
+        vec4 pos = vec4(vary_position, 1.0);
+        
+        vec4 spos = pos;
+        
+        if (spos.z > -shadow_clip.w)
+        {       
+                vec4 lpos;
+                
+                if (spos.z < -shadow_clip.z)
+                {
+                        lpos = shadow_matrix[3]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap3, lpos).x;
+                        shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
+                }
+                else if (spos.z < -shadow_clip.y)
+                {
+                        lpos = shadow_matrix[2]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap2, lpos).x;
+                }
+                else if (spos.z < -shadow_clip.x)
+                {
+                        lpos = shadow_matrix[1]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap1, lpos).x;
+                }
+                else
+                {
+                        lpos = shadow_matrix[0]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap0, lpos).x;
+                }
+        }
+        
+        vec4 col = vec4(vary_ambient + vary_directional.rgb*shadow, gl_Color.a);
+        vec4 color = texture2D(diffuseMap, gl_TexCoord[0].xy) * col;
+        
+        color.rgb = atmosLighting(color.rgb);
+
+        color.rgb = scaleSoftClip(color.rgb);
+
+        if (samp_pos.z != 0.0)
+        {
+                float dist_factor = alpha_soften;
+                float a = gl_Color.a;
+                a *= a;
+                dist_factor *= 1.0/(1.0-a);
+                color.a *= min((pos.z-samp_pos.z)*dist_factor, 1.0);
+        }
+        
+        //gl_FragColor = gl_Color;
+        gl_FragColor = color;
+        //gl_FragColor = vec4(1,0,1,1)*shadow;
+        
+}
+
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/alphaV.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/alphaV.glsl
new file mode 100644
index 0000000..ab60b65
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/alphaV.glsl
@@ -0,0 +1,75 @@
+/** 
+ * @file alphaV.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+vec4 calcLighting(vec3 pos, vec3 norm, vec4 color, vec4 baseCol);
+void calcAtmospherics(vec3 inPositionEye);
+
+float calcDirectionalLight(vec3 n, vec3 l);
+float calcPointLight(vec3 v, vec3 n, vec4 lp, float la);
+
+vec3 atmosAmbient(vec3 light);
+vec3 atmosAffectDirectionalLight(float lightIntensity);
+vec3 scaleDownLight(vec3 light);
+vec3 scaleUpLight(vec3 light);
+
+varying vec3 vary_ambient;
+varying vec3 vary_directional;
+varying vec3 vary_fragcoord;
+varying vec3 vary_position;
+varying vec3 vary_light;
+
+uniform float near_clip;
+uniform float shadow_offset;
+uniform float shadow_bias;
+
+void main()
+{
+        //transform vertex
+        gl_Position = ftransform(); 
+        
+        gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
+        
+        vec4 pos = (gl_ModelViewMatrix * gl_Vertex);
+        vec3 norm = normalize(gl_NormalMatrix * gl_Normal);
+        
+        vary_position = vec4(pos.xyz + norm.xyz * (-pos.z/64.0*shadow_offset+shadow_bias), 1.0);
+                
+        calcAtmospherics(pos.xyz);
+
+        //vec4 color = calcLighting(pos.xyz, norm, gl_Color, vec4(0.));
+        vec4 col;
+        col.a = gl_Color.a;
+        
+        // Add windlight lights
+        col.rgb = atmosAmbient(vec3(0.));
+        col.rgb = scaleUpLight(col.rgb);
+
+        // Collect normal lights (need to be divided by two, as we later multiply by 2)
+        col.rgb += gl_LightSource[2].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[2].position, gl_LightSource[2].linearAttenuation);
+        col.rgb += gl_LightSource[3].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[3].position, gl_LightSource[3].linearAttenuation);
+        col.rgb += gl_LightSource[4].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[4].position, gl_LightSource[4].linearAttenuation);
+        col.rgb += gl_LightSource[5].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[5].position, gl_LightSource[5].linearAttenuation);
+        col.rgb += gl_LightSource[6].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[6].position, gl_LightSource[6].linearAttenuation);
+        col.rgb += gl_LightSource[7].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[7].position, gl_LightSource[7].linearAttenuation);
+        col.rgb += gl_LightSource[1].diffuse.rgb*calcDirectionalLight(norm, gl_LightSource[1].position.xyz);
+        col.rgb = scaleDownLight(col.rgb);
+        
+        vary_light = gl_LightSource[0].position.xyz;
+        
+        vary_ambient = col.rgb*gl_Color.rgb;
+        vary_directional.rgb = gl_Color.rgb*atmosAffectDirectionalLight(max(calcDirectionalLight(norm, gl_LightSource[0].position.xyz), (1.0-gl_Color.a)*(1.0-gl_Color.a)));
+        
+        col.rgb = min(col.rgb*gl_Color.rgb, 1.0);
+        
+        gl_FrontColor = col;
+
+        gl_FogFragCoord = pos.z;
+        
+        pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+        vary_fragcoord.xyz = pos.xyz + vec3(0,0,near_clip);
+        
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaF.glsl
new file mode 100644
index 0000000..fe83c3c
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaF.glsl
@@ -0,0 +1,77 @@
+/** 
+ * @file avatarAlphaF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2D diffuseMap;
+uniform sampler2DRectShadow shadowMap0;
+uniform sampler2DRectShadow shadowMap1;
+uniform sampler2DRectShadow shadowMap2;
+uniform sampler2DRectShadow shadowMap3;
+uniform sampler2D noiseMap;
+
+uniform mat4 shadow_matrix[6];
+uniform vec4 shadow_clip;
+uniform vec2 screen_res;
+
+vec3 atmosLighting(vec3 light);
+vec3 scaleSoftClip(vec3 light);
+
+varying vec3 vary_ambient;
+varying vec3 vary_directional;
+varying vec4 vary_position;
+varying vec3 vary_normal;
+
+void main() 
+{
+        float shadow = 1.0;
+        vec4 pos = vary_position;
+        vec3 norm = normalize(vary_normal);
+        
+        vec3 nz = texture2D(noiseMap, gl_FragCoord.xy/128.0).xyz;
+
+        vec4 spos = pos;
+        
+        if (spos.z > -shadow_clip.w)
+        {       
+                vec4 lpos;
+                
+                if (spos.z < -shadow_clip.z)
+                {
+                        lpos = shadow_matrix[3]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap3, lpos).x;
+                        shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
+                }
+                else if (spos.z < -shadow_clip.y)
+                {
+                        lpos = shadow_matrix[2]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap2, lpos).x;
+                }
+                else if (spos.z < -shadow_clip.x)
+                {
+                        lpos = shadow_matrix[1]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap1, lpos).x;
+                }
+                else
+                {
+                        lpos = shadow_matrix[0]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap0, lpos).x;
+                }
+        }
+        
+        
+        vec4 col = vec4(vary_ambient + vary_directional*shadow, gl_Color.a);    
+        vec4 color = texture2D(diffuseMap, gl_TexCoord[0].xy) * col;
+        
+        color.rgb = atmosLighting(color.rgb);
+
+        color.rgb = scaleSoftClip(color.rgb);
+
+        gl_FragColor = color;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaV.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaV.glsl
new file mode 100644
index 0000000..c1988d3
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaV.glsl
@@ -0,0 +1,78 @@
+/** 
+ * @file avatarAlphaV.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+vec4 calcLighting(vec3 pos, vec3 norm, vec4 color, vec4 baseCol);
+mat4 getSkinnedTransform();
+void calcAtmospherics(vec3 inPositionEye);
+
+float calcDirectionalLight(vec3 n, vec3 l);
+float calcPointLight(vec3 v, vec3 n, vec4 lp, float la);
+
+vec3 atmosAmbient(vec3 light);
+vec3 atmosAffectDirectionalLight(float lightIntensity);
+vec3 scaleDownLight(vec3 light);
+vec3 scaleUpLight(vec3 light);
+
+varying vec4 vary_position;
+varying vec3 vary_ambient;
+varying vec3 vary_directional;
+varying vec3 vary_normal;
+
+void main()
+{
+        gl_TexCoord[0] = gl_MultiTexCoord0;
+                                
+        vec4 pos;
+        vec3 norm;
+        
+        mat4 trans = getSkinnedTransform();
+        pos.x = dot(trans[0], gl_Vertex);
+        pos.y = dot(trans[1], gl_Vertex);
+        pos.z = dot(trans[2], gl_Vertex);
+        pos.w = 1.0;
+        
+        norm.x = dot(trans[0].xyz, gl_Normal);
+        norm.y = dot(trans[1].xyz, gl_Normal);
+        norm.z = dot(trans[2].xyz, gl_Normal);
+        norm = normalize(norm);
+                
+        gl_Position = gl_ProjectionMatrix * pos;
+        vary_position = pos;
+        vary_normal = norm;     
+        
+        calcAtmospherics(pos.xyz);
+
+        //vec4 color = calcLighting(pos.xyz, norm, gl_Color, vec4(0.));
+        vec4 col;
+        col.a = gl_Color.a;
+        
+        // Add windlight lights
+        col.rgb = atmosAmbient(vec3(0.));
+        col.rgb = scaleUpLight(col.rgb);
+
+        // Collect normal lights (need to be divided by two, as we later multiply by 2)
+        col.rgb += gl_LightSource[2].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[2].position, gl_LightSource[2].linearAttenuation);
+        col.rgb += gl_LightSource[3].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[3].position, gl_LightSource[3].linearAttenuation);
+        col.rgb += gl_LightSource[4].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[4].position, gl_LightSource[4].linearAttenuation);
+        col.rgb += gl_LightSource[5].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[5].position, gl_LightSource[5].linearAttenuation);
+        col.rgb += gl_LightSource[6].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[6].position, gl_LightSource[6].linearAttenuation);
+        col.rgb += gl_LightSource[7].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[7].position, gl_LightSource[7].linearAttenuation);
+        col.rgb += gl_LightSource[1].diffuse.rgb*calcDirectionalLight(norm, gl_LightSource[1].position.xyz);
+        col.rgb = scaleDownLight(col.rgb);
+        
+        vary_ambient = col.rgb*gl_Color.rgb;
+        vary_directional = gl_Color.rgb*atmosAffectDirectionalLight(max(calcDirectionalLight(norm, gl_LightSource[0].position.xyz), (1.0-gl_Color.a)*(1.0-gl_Color.a)));
+        
+        col.rgb = min(col.rgb*gl_Color.rgb, 1.0);
+        
+        gl_FrontColor = col;
+
+        gl_FogFragCoord = pos.z;
+
+}
+
+
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/blurLightF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/blurLightF.glsl
new file mode 100644
index 0000000..1713fe9
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/blurLightF.glsl
@@ -0,0 +1,71 @@
+/** 
+ * @file blurLightF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2DRect lightMap;
+
+uniform float dist_factor;
+uniform float blur_size;
+uniform vec2 delta;
+uniform vec3 kern[32];
+uniform int kern_length;
+uniform float kern_scale;
+
+varying vec2 vary_fragcoord;
+
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+
+vec4 getPosition(vec2 pos_screen)
+{
+        float depth = texture2DRect(depthMap, pos_screen.xy).a;
+        vec2 sc = pos_screen.xy*2.0;
+        sc /= screen_res;
+        sc -= vec2(1.0,1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = inv_proj * ndc;
+        pos /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+void main() 
+{
+        vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
+        vec3 pos = getPosition(vary_fragcoord.xy).xyz;
+        vec4 ccol = texture2DRect(lightMap, vary_fragcoord.xy).rgba;
+        
+        vec2 dlt = kern_scale * delta / (1.0+norm.xy*norm.xy);
+        
+        dlt /= max(-pos.z*dist_factor, 1.0);
+        
+        vec2 defined_weight = kern[0].xy; // special case the first (centre) sample's weight in the blur; we have to sample it anyway so we get it for 'free'
+        vec4 col = defined_weight.xyxx * ccol;
+        
+        for (int i = 1; i < kern_length; i++)
+        {
+                vec2 tc = vary_fragcoord.xy + kern[i].z*dlt;
+                vec3 samppos = getPosition(tc).xyz; 
+                float d = dot(norm.xyz, samppos.xyz-pos.xyz);// dist from plane
+                if (d*d <= 0.003)
+                {
+                        col += texture2DRect(lightMap, tc)*kern[i].xyxx;
+                        defined_weight += kern[i].xy;
+                }
+        }
+
+
+
+        col /= defined_weight.xyxx;
+        
+        gl_FragColor = col;
+        
+        //gl_FragColor = ccol;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/blurLightV.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/blurLightV.glsl
new file mode 100644
index 0000000..b7f07e5
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/blurLightV.glsl
@@ -0,0 +1,17 @@
+/** 
+ * @file blurLightF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+varying vec2 vary_fragcoord;
+uniform vec2 screen_res;
+
+void main()
+{
+        //transform vertex
+        gl_Position = ftransform(); 
+        vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+        vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
new file mode 100644
index 0000000..6519594
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
@@ -0,0 +1,188 @@
+/** 
+ * @file multiSpotLightF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#version 120
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform samplerCube environmentMap;
+uniform sampler2DRect lightMap;
+uniform sampler2D noiseMap;
+uniform sampler2D lightFunc;
+uniform sampler2D projectionMap;
+
+uniform mat4 proj_mat; //screen space to light space
+uniform float proj_near; //near clip for projection
+uniform vec3 proj_p; //plane projection is emitting from (in screen space)
+uniform vec3 proj_n;
+uniform float proj_focus; //distance from plane to begin blurring
+uniform float proj_lod;  //(number of mips in proj map)
+uniform float proj_range; //range between near clip and far clip plane of projection
+uniform float proj_ambient_lod;
+uniform float proj_ambiance;
+uniform float near_clip;
+uniform float far_clip;
+
+uniform vec3 proj_origin; //origin of projection to be used for angular attenuation
+uniform float sun_wash;
+uniform int proj_shadow_idx;
+uniform float shadow_fade;
+
+varying vec4 vary_light;
+
+varying vec4 vary_fragcoord;
+uniform vec2 screen_res;
+
+uniform mat4 inv_proj;
+
+vec4 getPosition(vec2 pos_screen)
+{
+        float depth = texture2DRect(depthMap, pos_screen.xy).a;
+        vec2 sc = pos_screen.xy*2.0;
+        sc /= screen_res;
+        sc -= vec2(1.0,1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = inv_proj * ndc;
+        pos /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+void main() 
+{
+        vec4 frag = vary_fragcoord;
+        frag.xyz /= frag.w;
+        frag.xyz = frag.xyz*0.5+0.5;
+        frag.xy *= screen_res;
+        
+        vec3 pos = getPosition(frag.xy).xyz;
+        vec3 lv = vary_light.xyz-pos.xyz;
+        float dist2 = dot(lv,lv);
+        dist2 /= vary_light.w;
+        if (dist2 > 1.0)
+        {
+                discard;
+        }
+        
+        float shadow = 1.0;
+        
+        if (proj_shadow_idx >= 0)
+        {
+                vec4 shd = texture2DRect(lightMap, frag.xy);
+                float sh[2];
+                sh[0] = shd.b;
+                sh[1] = shd.a;
+                shadow = min(sh[proj_shadow_idx]+shadow_fade, 1.0);
+        }
+        
+        vec3 norm = texture2DRect(normalMap, frag.xy).xyz*2.0-1.0;
+        
+        norm = normalize(norm);
+        float l_dist = -dot(lv, proj_n);
+        
+        vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
+        if (proj_tc.z < 0.0)
+        {
+                discard;
+        }
+        
+        proj_tc.xyz /= proj_tc.w;
+        
+        float fa = gl_Color.a+1.0;
+        float dist_atten = min(1.0-(dist2-1.0*(1.0-fa))/fa, 1.0);
+        if (dist_atten <= 0.0)
+        {
+                discard;
+        }
+        
+        lv = proj_origin-pos.xyz;
+        lv = normalize(lv);
+        float da = dot(norm, lv);
+                
+        vec3 col = vec3(0,0,0);
+                
+        vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
+                
+        float noise = texture2D(noiseMap, frag.xy/128.0).b;
+        if (proj_tc.z > 0.0 &&
+                proj_tc.x < 1.0 &&
+                proj_tc.y < 1.0 &&
+                proj_tc.x > 0.0 &&
+                proj_tc.y > 0.0)
+        {
+                float lit = 0.0;
+                float amb_da = proj_ambiance;
+                
+                if (da > 0.0)
+                {
+                        float diff = clamp((l_dist-proj_focus)/proj_range, 0.0, 1.0);
+                        float lod = diff * proj_lod;
+                        
+                        vec4 plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
+                
+                        vec3 lcol = gl_Color.rgb * plcol.rgb * plcol.a;
+                        
+                        lit = da * dist_atten * noise;
+                        
+                        col = lcol*lit*diff_tex*shadow;
+                        amb_da += (da*0.5)*(1.0-shadow)*proj_ambiance;
+                }
+                
+                //float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
+                vec4 amb_plcol = texture2DLod(projectionMap, proj_tc.xy, proj_ambient_lod);
+                                                        
+                amb_da += (da*da*0.5+0.5)*proj_ambiance;
+                                
+                amb_da *= dist_atten * noise;
+                        
+                amb_da = min(amb_da, 1.0-lit);
+                        
+                col += amb_da*gl_Color.rgb*diff_tex.rgb*amb_plcol.rgb*amb_plcol.a;
+        }
+        
+        
+        vec4 spec = texture2DRect(specularRect, frag.xy);
+        if (spec.a > 0.0)
+        {
+                vec3 ref = reflect(normalize(pos), norm);
+                
+                //project from point pos in direction ref to plane proj_p, proj_n
+                vec3 pdelta = proj_p-pos;
+                float ds = dot(ref, proj_n);
+                
+                if (ds < 0.0)
+                {
+                        vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
+                        
+                        vec4 stc = (proj_mat * vec4(pfinal.xyz, 1.0));
+
+                        if (stc.z > 0.0)
+                        {
+                                stc.xy /= stc.w;
+                                        
+                                if (stc.x < 1.0 &&
+                                        stc.y < 1.0 &&
+                                        stc.x > 0.0 &&
+                                        stc.y > 0.0)
+                                {
+                                        vec4 scol = texture2DLod(projectionMap, stc.xy, proj_lod-spec.a*proj_lod);
+                                        col += dist_atten*scol.rgb*gl_Color.rgb*scol.a*spec.rgb*shadow;
+                                }
+                        }
+                }
+        }
+        
+        //attenuate point light contribution by SSAO component
+        col *= texture2DRect(lightMap, frag.xy).g;
+        
+        gl_FragColor.rgb = col; 
+        gl_FragColor.a = 0.0;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/postDeferredF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/postDeferredF.glsl
new file mode 100644
index 0000000..ee0e9d6
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/postDeferredF.glsl
@@ -0,0 +1,59 @@
+/** 
+ * @file postDeferredF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect localLightMap;
+uniform sampler2DRect sunLightMap;
+uniform sampler2DRect giLightMap;
+uniform sampler2D         luminanceMap;
+uniform sampler2DRect lightMap;
+
+uniform vec3 gi_lum_quad;
+uniform vec3 sun_lum_quad;
+uniform vec3 lum_quad;
+uniform float lum_lod;
+uniform vec4 ambient;
+
+uniform vec3 gi_quad;
+
+uniform vec2 screen_res;
+varying vec2 vary_fragcoord;
+
+void main() 
+{
+        vec2 tc = vary_fragcoord.xy;
+        vec3 lcol = texture2DLod(luminanceMap, tc/screen_res, lum_lod).rgb;
+
+        float lum = sqrt(lcol.r)*lum_quad.x+lcol.r*lcol.r*lum_quad.y+lcol.r*lum_quad.z;
+        
+        vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
+
+        float ambocc = texture2DRect(lightMap, vary_fragcoord.xy).g;
+                        
+        vec3 gi_col = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+        gi_col = gi_col*gi_col*gi_quad.x + gi_col*gi_quad.y+gi_quad.z*ambocc*ambient.rgb;
+        gi_col *= diff;
+        
+        vec4 sun_col =  texture2DRect(sunLightMap, vary_fragcoord.xy);
+        
+        vec3 local_col = texture2DRect(localLightMap, vary_fragcoord.xy).rgb;
+                
+
+        float sun_lum = 1.0-lum;
+        sun_lum = sun_lum*sun_lum*sun_lum_quad.x + sun_lum*sun_lum_quad.y+sun_lum_quad.z;
+                
+        float gi_lum = lum;
+        gi_lum = gi_lum*gi_lum*gi_lum_quad.x+gi_lum*gi_lum_quad.y+gi_lum_quad.z;
+        gi_col *= 1.0/gi_lum;
+                
+        vec3 col = sun_col.rgb*(1.0+max(sun_lum,0.0))+gi_col+local_col;
+        
+        gl_FragColor.rgb = col.rgb;
+        gl_FragColor.a = max(sun_lum*min(sun_col.r+sun_col.g+sun_col.b, 1.0), sun_col.a);
+        
+        //gl_FragColor.rgb = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/postDeferredV.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/postDeferredV.glsl
new file mode 100644
index 0000000..9819232
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/postDeferredV.glsl
@@ -0,0 +1,17 @@
+/** 
+ * @file postDeferredV.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+varying vec2 vary_fragcoord;
+uniform vec2 screen_res;
+
+void main()
+{
+        //transform vertex
+        gl_Position = ftransform(); 
+        vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+        vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
new file mode 100644
index 0000000..52b79e3
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
@@ -0,0 +1,294 @@
+/** 
+ * @file softenLightF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+uniform sampler2DRect normalMap;
+uniform sampler2DRect lightMap;
+uniform sampler2D         noiseMap;
+uniform samplerCube environmentMap;
+uniform sampler2D         lightFunc;
+uniform vec3 gi_quad;
+
+uniform float blur_size;
+uniform float blur_fidelity;
+
+// Inputs
+uniform vec4 morphFactor;
+uniform vec3 camPosLocal;
+//uniform vec4 camPosWorld;
+uniform vec4 gamma;
+uniform vec4 lightnorm;
+uniform vec4 sunlight_color;
+uniform vec4 ambient;
+uniform vec4 blue_horizon;
+uniform vec4 blue_density;
+uniform vec4 haze_horizon;
+uniform vec4 haze_density;
+uniform vec4 cloud_shadow;
+uniform vec4 density_multiplier;
+uniform vec4 distance_multiplier;
+uniform vec4 max_y;
+uniform vec4 glow;
+uniform float scene_light_strength;
+uniform vec3 env_mat[3];
+uniform vec4 shadow_clip;
+uniform mat3 ssao_effect_mat;
+
+uniform sampler2DRect depthMap;
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+
+varying vec4 vary_light;
+varying vec2 vary_fragcoord;
+
+vec3 vary_PositionEye;
+
+vec3 vary_SunlitColor;
+vec3 vary_AmblitColor;
+vec3 vary_AdditiveColor;
+vec3 vary_AtmosAttenuation;
+
+vec4 getPosition(vec2 pos_screen)
+{ //get position in screen space (world units) given window coordinate and depth map
+        float depth = texture2DRect(depthMap, pos_screen.xy).a;
+        vec2 sc = pos_screen.xy*2.0;
+        sc /= screen_res;
+        sc -= vec2(1.0,1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = inv_proj * ndc;
+        pos /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+vec3 getPositionEye()
+{
+        return vary_PositionEye;
+}
+vec3 getSunlitColor()
+{
+        return vary_SunlitColor;
+}
+vec3 getAmblitColor()
+{
+        return vary_AmblitColor;
+}
+vec3 getAdditiveColor()
+{
+        return vary_AdditiveColor;
+}
+vec3 getAtmosAttenuation()
+{
+        return vary_AtmosAttenuation;
+}
+
+
+void setPositionEye(vec3 v)
+{
+        vary_PositionEye = v;
+}
+
+void setSunlitColor(vec3 v)
+{
+        vary_SunlitColor = v;
+}
+
+void setAmblitColor(vec3 v)
+{
+        vary_AmblitColor = v;
+}
+
+void setAdditiveColor(vec3 v)
+{
+        vary_AdditiveColor = v;
+}
+
+void setAtmosAttenuation(vec3 v)
+{
+        vary_AtmosAttenuation = v;
+}
+
+void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
+
+        vec3 P = inPositionEye;
+        setPositionEye(P);
+        
+        //(TERRAIN) limit altitude
+        if (P.y > max_y.x) P *= (max_y.x / P.y);
+        if (P.y < -max_y.x) P *= (-max_y.x / P.y);
+
+        vec3 tmpLightnorm = lightnorm.xyz;
+
+        vec3 Pn = normalize(P);
+        float Plen = length(P);
+
+        vec4 temp1 = vec4(0);
+        vec3 temp2 = vec3(0);
+        vec4 blue_weight;
+        vec4 haze_weight;
+        vec4 sunlight = sunlight_color;
+        vec4 light_atten;
+
+        //sunlight attenuation effect (hue and brightness) due to atmosphere
+        //this is used later for sunlight modulation at various altitudes
+        light_atten = (blue_density * 1.0 + vec4(haze_density.r) * 0.25) * (density_multiplier.x * max_y.x);
+                //I had thought blue_density and haze_density should have equal weighting,
+                //but attenuation due to haze_density tends to seem too strong
+
+        temp1 = blue_density + vec4(haze_density.r);
+        blue_weight = blue_density / temp1;
+        haze_weight = vec4(haze_density.r) / temp1;
+
+        //(TERRAIN) compute sunlight from lightnorm only (for short rays like terrain)
+        temp2.y = max(0.0, tmpLightnorm.y);
+        temp2.y = 1. / temp2.y;
+        sunlight *= exp( - light_atten * temp2.y);
+
+        // main atmospheric scattering line integral
+        temp2.z = Plen * density_multiplier.x;
+
+        // Transparency (-> temp1)
+        // ATI Bugfix -- can't store temp1*temp2.z*distance_multiplier.x in a variable because the ati
+        // compiler gets confused.
+        temp1 = exp(-temp1 * temp2.z * distance_multiplier.x);
+
+        //final atmosphere attenuation factor
+        setAtmosAttenuation(temp1.rgb);
+        
+        //compute haze glow
+        //(can use temp2.x as temp because we haven't used it yet)
+        temp2.x = dot(Pn, tmpLightnorm.xyz);
+        temp2.x = 1. - temp2.x;
+                //temp2.x is 0 at the sun and increases away from sun
+        temp2.x = max(temp2.x, .03);    //was glow.y
+                //set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
+        temp2.x *= glow.x;
+                //higher glow.x gives dimmer glow (because next step is 1 / "angle")
+        temp2.x = pow(temp2.x, glow.z);
+                //glow.z should be negative, so we're doing a sort of (1 / "angle") function
+
+        //add "minimum anti-solar illumination"
+        temp2.x += .25;
+        
+        //increase ambient when there are more clouds
+        vec4 tmpAmbient = ambient + (vec4(1.) - ambient) * cloud_shadow.x * 0.5;
+        
+        /*  decrease value and saturation (that in HSV, not HSL) for occluded areas
+         * // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html
+         * // The following line of code performs the equivalent of:
+         * float ambAlpha = tmpAmbient.a;
+         * float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis
+         * vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);
+         * tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat, ambAlpha);
+         */
+        tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);
+
+        //haze color
+        setAdditiveColor(
+                vec3(blue_horizon * blue_weight * (sunlight*(1.-cloud_shadow.x) + tmpAmbient)
+          + (haze_horizon.r * haze_weight) * (sunlight*(1.-cloud_shadow.x) * temp2.x
+                  + tmpAmbient)));
+
+        //brightness of surface both sunlight and ambient
+        setSunlitColor(vec3(sunlight * .5));
+        setAmblitColor(vec3(tmpAmbient * .25));
+        setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
+}
+
+vec3 atmosLighting(vec3 light)
+{
+        light *= getAtmosAttenuation().r;
+        light += getAdditiveColor();
+        return (2.0 * light);
+}
+
+vec3 atmosTransport(vec3 light) {
+        light *= getAtmosAttenuation().r;
+        light += getAdditiveColor() * 2.0;
+        return light;
+}
+vec3 atmosGetDiffuseSunlightColor()
+{
+        return getSunlitColor();
+}
+
+vec3 scaleDownLight(vec3 light)
+{
+        return (light / scene_light_strength );
+}
+
+vec3 scaleUpLight(vec3 light)
+{
+        return (light * scene_light_strength);
+}
+
+vec3 atmosAmbient(vec3 light)
+{
+        return getAmblitColor() + light / 2.0;
+}
+
+vec3 atmosAffectDirectionalLight(float lightIntensity)
+{
+        return getSunlitColor() * lightIntensity;
+}
+
+vec3 scaleSoftClip(vec3 light)
+{
+        //soft clip effect:
+        light = 1. - clamp(light, vec3(0.), vec3(1.));
+        light = 1. - pow(light, gamma.xxx);
+
+        return light;
+}
+
+void main() 
+{
+        vec2 tc = vary_fragcoord.xy;
+        vec3 pos = getPosition(tc).xyz;
+        vec3 norm = texture2DRect(normalMap, tc).xyz*2.0-1.0;
+        vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).xyz;
+        
+        float da = max(dot(norm.xyz, vary_light.xyz), 0.0);
+        
+        vec4 diffuse = texture2DRect(diffuseRect, tc);
+        vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+        
+        vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
+        float scol = max(scol_ambocc.r, diffuse.a); 
+        float ambocc = scol_ambocc.g;
+        
+        calcAtmospherics(pos.xyz, ambocc);
+        
+        vec3 col = atmosAmbient(vec3(0));
+        col += atmosAffectDirectionalLight(max(min(da, scol), diffuse.a));
+        
+        col *= diffuse.rgb;
+        
+        if (spec.a > 0.0)
+        {
+                vec3 ref = normalize(reflect(pos.xyz, norm.xyz));
+                float sa = dot(ref, vary_light.xyz);
+                col.rgb += vary_SunlitColor*scol*spec.rgb*texture2D(lightFunc, vec2(sa, spec.a)).a;
+        }
+        
+        col = atmosLighting(col);
+        col = scaleSoftClip(col);
+                
+        gl_FragColor.rgb = col;
+        
+        //gl_FragColor.rgb = gi_col.rgb;
+        gl_FragColor.a = 0.0;
+        
+        //gl_FragColor.rg = scol_ambocc.rg;
+        //gl_FragColor.rgb = texture2DRect(lightMap, vary_fragcoord.xy).rgb;
+        //gl_FragColor.rgb = norm.rgb*0.5+0.5;
+        //gl_FragColor.rgb = vec3(ambocc);
+        //gl_FragColor.rgb = vec3(scol);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl
new file mode 100644
index 0000000..ad8af47
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl
@@ -0,0 +1,24 @@
+/** 
+ * @file softenLightF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform vec2 screen_res;
+
+varying vec4 vary_light;
+varying vec2 vary_fragcoord;
+void main()
+{
+        //transform vertex
+        gl_Position = ftransform(); 
+        
+        vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+        vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+                
+        vec4 tex = gl_MultiTexCoord0;
+        tex.w = 1.0;
+        
+        vary_light = gl_MultiTexCoord0;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl
new file mode 100644
index 0000000..d653408
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl
@@ -0,0 +1,199 @@
+/** 
+ * @file spotLightF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#version 120
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform samplerCube environmentMap;
+uniform sampler2DRect lightMap;
+uniform sampler2D noiseMap;
+uniform sampler2D lightFunc;
+uniform sampler2D projectionMap;
+
+uniform mat4 proj_mat; //screen space to light space
+uniform float proj_near; //near clip for projection
+uniform vec3 proj_p; //plane projection is emitting from (in screen space)
+uniform vec3 proj_n;
+uniform float proj_focus; //distance from plane to begin blurring
+uniform float proj_lod;  //(number of mips in proj map)
+uniform float proj_range; //range between near clip and far clip plane of projection
+uniform float proj_ambiance;
+uniform float near_clip;
+uniform float far_clip;
+
+uniform vec3 proj_origin; //origin of projection to be used for angular attenuation
+uniform float sun_wash;
+uniform int proj_shadow_idx;
+uniform float shadow_fade;
+
+varying vec4 vary_light;
+
+varying vec4 vary_fragcoord;
+uniform vec2 screen_res;
+
+uniform mat4 inv_proj;
+
+vec4 getPosition(vec2 pos_screen)
+{
+        float depth = texture2DRect(depthMap, pos_screen.xy).a;
+        vec2 sc = pos_screen.xy*2.0;
+        sc /= screen_res;
+        sc -= vec2(1.0,1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = inv_proj * ndc;
+        pos /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+void main() 
+{
+        vec4 frag = vary_fragcoord;
+        frag.xyz /= frag.w;
+        frag.xyz = frag.xyz*0.5+0.5;
+        frag.xy *= screen_res;
+        
+        float shadow = 1.0;
+        
+        if (proj_shadow_idx >= 0)
+        {
+                vec4 shd = texture2DRect(lightMap, frag.xy);
+                float sh[2];
+                sh[0] = shd.b;
+                sh[1] = shd.a;
+                shadow = min(sh[proj_shadow_idx]+shadow_fade, 1.0);
+        }
+        
+        vec3 pos = getPosition(frag.xy).xyz;
+        vec3 lv = vary_light.xyz-pos.xyz;
+        float dist2 = dot(lv,lv);
+        dist2 /= vary_light.w;
+        if (dist2 > 1.0)
+        {
+                discard;
+        }
+        
+        vec3 norm = texture2DRect(normalMap, frag.xy).xyz*2.0-1.0;
+        
+        norm = normalize(norm);
+        float l_dist = -dot(lv, proj_n);
+        
+        vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
+        if (proj_tc.z < 0.0)
+        {
+                discard;
+        }
+        
+        proj_tc.xyz /= proj_tc.w;
+        
+        float fa = gl_Color.a+1.0;
+        float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
+        
+        lv = proj_origin-pos.xyz;
+        lv = normalize(lv);
+        float da = dot(norm, lv);
+                
+        vec3 col = vec3(0,0,0);
+                
+        vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
+                
+        float noise = texture2D(noiseMap, frag.xy/128.0).b;
+        if (proj_tc.z > 0.0 &&
+                proj_tc.x < 1.0 &&
+                proj_tc.y < 1.0 &&
+                proj_tc.x > 0.0 &&
+                proj_tc.y > 0.0)
+        {
+                float lit = 0.0;
+                if (da > 0.0)
+                {
+                        float diff = clamp((l_dist-proj_focus)/proj_range, 0.0, 1.0);
+                        float lod = diff * proj_lod;
+                        
+                        vec4 plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
+                
+                        vec3 lcol = gl_Color.rgb * plcol.rgb * plcol.a;
+                        
+                        lit = da * dist_atten * noise;
+                        
+                        col = lcol*lit*diff_tex*shadow;
+                }
+                
+                float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
+                float lod = diff * proj_lod;
+                vec4 amb_plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
+                //float amb_da = mix(proj_ambiance, proj_ambiance*max(-da, 0.0), max(da, 0.0));
+                float amb_da = proj_ambiance;
+                if (da > 0.0)
+                {
+                        amb_da += (da*0.5)*(1.0-shadow)*proj_ambiance;
+                }
+                
+                amb_da += (da*da*0.5+0.5)*proj_ambiance;
+                        
+                amb_da *= dist_atten * noise;
+                
+                amb_da = min(amb_da, 1.0-lit);
+                
+                col += amb_da*gl_Color.rgb*diff_tex.rgb*amb_plcol.rgb*amb_plcol.a;
+        }
+        
+        
+        vec4 spec = texture2DRect(specularRect, frag.xy);
+        if (spec.a > 0.0)
+        {
+                vec3 ref = reflect(normalize(pos), norm);
+                
+                //project from point pos in direction ref to plane proj_p, proj_n
+                vec3 pdelta = proj_p-pos;
+                float ds = dot(ref, proj_n);
+                
+                if (ds < 0.0)
+                {
+                        vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
+                        
+                        vec3 stc = (proj_mat * vec4(pfinal.xyz, 1.0)).xyz;
+
+                        if (stc.z > 0.0)
+                        {
+                                stc.xy /= stc.z+proj_near;
+                                        
+                                if (stc.x < 1.0 &&
+                                        stc.y < 1.0 &&
+                                        stc.x > 0.0 &&
+                                        stc.y > 0.0)
+                                {
+                                        vec4 scol = texture2DLod(projectionMap, stc.xy, proj_lod-spec.a*proj_lod);
+                                        col += dist_atten*scol.rgb*gl_Color.rgb*scol.a*spec.rgb*shadow;
+                                }
+                        }
+                }
+        }
+        
+        /*if (spec.a > 0.0)
+        {
+                //vec3 ref = reflect(normalize(pos), norm);
+                float sa = dot(normalize(lv-normalize(pos)),norm);;
+                //sa = max(sa, 0.0);
+                //sa = pow(sa, 128.0 * spec.a*spec.a/dist_atten)*min(dist_atten*4.0, 1.0);
+                sa = texture2D(lightFunc, vec2(sa, spec.a)).a * min(dist_atten*4.0, 1.0);
+                sa *= noise;
+                col += da*sa*lcol*spec.rgb;
+        }*/
+        
+        //attenuate point light contribution by SSAO component
+        col *= texture2DRect(lightMap, frag.xy).g;
+        
+
+        gl_FragColor.rgb = col; 
+        gl_FragColor.a = 0.0;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl
new file mode 100644
index 0000000..8ced94e
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl
@@ -0,0 +1,203 @@
+/** 
+ * @file sunLightF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2DRectShadow shadowMap0;
+uniform sampler2DRectShadow shadowMap1;
+uniform sampler2DRectShadow shadowMap2;
+uniform sampler2DRectShadow shadowMap3;
+uniform sampler2DRectShadow shadowMap4;
+uniform sampler2DRectShadow shadowMap5;
+uniform sampler2D noiseMap;
+
+uniform sampler2D               lightFunc;
+
+
+// Inputs
+uniform mat4 shadow_matrix[6];
+uniform vec4 shadow_clip;
+uniform float ssao_radius;
+uniform float ssao_max_radius;
+uniform float ssao_factor;
+uniform float ssao_factor_inv;
+
+varying vec2 vary_fragcoord;
+varying vec4 vary_light;
+
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+
+uniform float shadow_bias;
+uniform float shadow_offset;
+
+vec4 getPosition(vec2 pos_screen)
+{
+        float depth = texture2DRect(depthMap, pos_screen.xy).a;
+        vec2 sc = pos_screen.xy*2.0;
+        sc /= screen_res;
+        sc -= vec2(1.0,1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = inv_proj * ndc;
+        pos /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+//calculate decreases in ambient lighting when crowded out (SSAO)
+float calcAmbientOcclusion(vec4 pos, vec3 norm)
+{
+        vec2 kern[8];
+        // exponentially (^2) distant occlusion samples spread around origin
+        kern[0] = vec2(-1.0, 0.0) * 0.125*0.125;
+        kern[1] = vec2(1.0, 0.0) * 0.250*0.250;
+        kern[2] = vec2(0.0, 1.0) * 0.375*0.375;
+        kern[3] = vec2(0.0, -1.0) * 0.500*0.500;
+        kern[4] = vec2(0.7071, 0.7071) * 0.625*0.625;
+        kern[5] = vec2(-0.7071, -0.7071) * 0.750*0.750;
+        kern[6] = vec2(-0.7071, 0.7071) * 0.875*0.875;
+        kern[7] = vec2(0.7071, -0.7071) * 1.000*1.000;
+
+        vec2 pos_screen = vary_fragcoord.xy;
+        vec3 pos_world = pos.xyz;
+        vec2 noise_reflect = texture2D(noiseMap, vary_fragcoord.xy/128.0).xy;
+        
+        float angle_hidden = 0.0;
+        int points = 0;
+        
+        float scale = min(ssao_radius / -pos_world.z, ssao_max_radius);
+        
+        // it was found that keeping # of samples a constant was the fastest, probably due to compiler optimizations (unrolling?)
+        for (int i = 0; i < 8; i++)
+        {
+                vec2 samppos_screen = pos_screen + scale * reflect(kern[i], noise_reflect);
+                vec3 samppos_world = getPosition(samppos_screen).xyz; 
+                
+                vec3 diff = pos_world - samppos_world;
+                float dist2 = dot(diff, diff);
+                
+                // assume each sample corresponds to an occluding sphere with constant radius, constant x-sectional area
+                // --> solid angle shrinking by the square of distance
+                //radius is somewhat arbitrary, can approx with just some constant k * 1 / dist^2
+                //(k should vary inversely with # of samples, but this is taken care of later)
+                
+                //if (dot((samppos_world - 0.05*norm - pos_world), norm) > 0.0)  // -0.05*norm to shift sample point back slightly for flat surfaces
+                //      angle_hidden += min(1.0/dist2, ssao_factor_inv); // dist != 0 follows from conditional.  max of 1.0 (= ssao_factor_inv * ssao_factor)
+                angle_hidden = angle_hidden + float(dot((samppos_world - 0.05*norm - pos_world), norm) > 0.0) * min(1.0/dist2, ssao_factor_inv);
+                
+                // 'blocked' samples (significantly closer to camera relative to pos_world) are "no data", not "no occlusion" 
+                points = points + int(diff.z > -1.0);
+        }
+        
+        angle_hidden = min(ssao_factor*angle_hidden/float(points), 1.0);
+        
+        return (1.0 - (float(points != 0) * angle_hidden));
+}
+
+void main() 
+{
+        vec2 pos_screen = vary_fragcoord.xy;
+        
+        //try doing an unproject here
+        
+        vec4 pos = getPosition(pos_screen);
+        
+    vec3 norm = texture2DRect(normalMap, pos_screen).xyz*2.0-1.0;
+        
+        /*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
+        {
+                gl_FragColor = vec4(0.0); // doesn't matter
+                return;
+        }*/
+        
+        float shadow = 1.0;
+    float dp_directional_light = max(0.0, dot(norm, vary_light.xyz));
+
+        vec4 spos = vec4(pos.xyz + norm.xyz * (-pos.z/64.0*shadow_offset+shadow_bias), 1.0);
+        
+        //vec3 debug = vec3(0,0,0);
+        
+        if (spos.z > -shadow_clip.w)
+        {       
+                if (dp_directional_light == 0.0)
+                {
+                        // if we know this point is facing away from the sun then we know it's in shadow without having to do a squirrelly shadow-map lookup
+                        shadow = 0.0;
+                }
+                else
+                {
+                        vec4 lpos;
+                        
+                        if (spos.z < -shadow_clip.z)
+                        {
+                                lpos = shadow_matrix[3]*spos;
+                                lpos.xy *= screen_res;
+                                shadow = shadow2DRectProj(shadowMap3, lpos).x;
+                                shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
+                        }
+                        else if (spos.z < -shadow_clip.y)
+                        {
+                                lpos = shadow_matrix[2]*spos;
+                                lpos.xy *= screen_res;
+                                shadow = shadow2DRectProj(shadowMap2, lpos).x;
+                        }
+                        else if (spos.z < -shadow_clip.x)
+                        {
+                                lpos = shadow_matrix[1]*spos;
+                                lpos.xy *= screen_res;
+                                shadow = shadow2DRectProj(shadowMap1, lpos).x;
+                        }
+                        else
+                        {
+                                lpos = shadow_matrix[0]*spos;
+                                lpos.xy *= screen_res;
+                                shadow = shadow2DRectProj(shadowMap0, lpos).x;
+                        }
+
+                        // take the most-shadowed value out of these two:
+                        //  * the blurred sun shadow in the light (shadow) map
+                        //  * an unblurred dot product between the sun and this norm
+                        // the goal is to err on the side of most-shadow to fill-in shadow holes and reduce artifacting
+                        shadow = min(shadow, dp_directional_light);
+                }
+                
+                /*debug.r = lpos.y / (lpos.w*screen_res.y);
+                
+                lpos.xy /= lpos.w*32.0;
+                if (fract(lpos.x) < 0.1 || fract(lpos.y) < 0.1)
+                {
+                        debug.gb = vec2(0.5, 0.5);
+                }
+                
+                debug += (1.0-shadow)*0.5;*/
+                
+        }
+        else
+        {
+                // more distant than the shadow map covers
+                shadow = 1.0;
+        }
+        
+        gl_FragColor[0] = shadow;
+        gl_FragColor[1] = calcAmbientOcclusion(pos, norm);
+        
+        //spotlight shadow 1
+        vec4 lpos = shadow_matrix[4]*spos;
+        lpos.xy *= screen_res;
+        gl_FragColor[2] = shadow2DRectProj(shadowMap4, lpos).x; 
+        
+        //spotlight shadow 2
+        lpos = shadow_matrix[5]*spos;
+        lpos.xy *= screen_res;
+        gl_FragColor[3] = shadow2DRectProj(shadowMap5, lpos).x; 
+
+        //gl_FragColor.rgb = pos.xyz;
+        //gl_FragColor.b = shadow;
+        //gl_FragColor.rgb = debug;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl
new file mode 100644
index 0000000..5081485
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl
@@ -0,0 +1,25 @@
+/** 
+ * @file sunLightF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+varying vec4 vary_light;
+varying vec2 vary_fragcoord;
+
+uniform vec2 screen_res;
+
+void main()
+{
+        //transform vertex
+        gl_Position = ftransform(); 
+        vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+        vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;       
+        vec4 tex = gl_MultiTexCoord0;
+        tex.w = 1.0;
+        
+        vary_light = gl_MultiTexCoord0;
+                
+        gl_FrontColor = gl_Color;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/waterF.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/waterF.glsl
new file mode 100644
index 0000000..7342186
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/waterF.glsl
@@ -0,0 +1,139 @@
+/** 
+ * @file waterF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+vec3 scaleSoftClip(vec3 inColor);
+vec3 atmosTransport(vec3 inColor);
+
+uniform sampler2D bumpMap;   
+uniform sampler2D screenTex;
+uniform sampler2D refTex;
+uniform sampler2DRectShadow shadowMap0;
+uniform sampler2DRectShadow shadowMap1;
+uniform sampler2DRectShadow shadowMap2;
+uniform sampler2DRectShadow shadowMap3;
+uniform sampler2D noiseMap;
+
+uniform mat4 shadow_matrix[6];
+uniform vec4 shadow_clip;
+
+uniform float sunAngle;
+uniform float sunAngle2;
+uniform vec3 lightDir;
+uniform vec3 specular;
+uniform float lightExp;
+uniform float refScale;
+uniform float kd;
+uniform vec2 screenRes;
+uniform vec3 normScale;
+uniform float fresnelScale;
+uniform float fresnelOffset;
+uniform float blurMultiplier;
+uniform vec2 screen_res;
+uniform mat4 norm_mat; //region space to screen space
+
+//bigWave is (refCoord.w, view.w);
+varying vec4 refCoord;
+varying vec4 littleWave;
+varying vec4 view;
+varying vec4 vary_position;
+
+void main() 
+{
+        vec4 color;
+        float dist = length(view.xy);
+        
+        //normalize view vector
+        vec3 viewVec = normalize(view.xyz);
+        
+        //get wave normals
+        vec3 wave1 = texture2D(bumpMap, vec2(refCoord.w, view.w)).xyz*2.0-1.0;
+        vec3 wave2 = texture2D(bumpMap, littleWave.xy).xyz*2.0-1.0;
+        vec3 wave3 = texture2D(bumpMap, littleWave.zw).xyz*2.0-1.0;
+        //get base fresnel components   
+        
+        vec3 df = vec3(
+                                        dot(viewVec, wave1),
+                                        dot(viewVec, (wave2 + wave3) * 0.5),
+                                        dot(viewVec, wave3)
+                                 ) * fresnelScale + fresnelOffset;
+        df *= df;
+                    
+        vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5;
+        
+        float dist2 = dist;
+        dist = max(dist, 5.0);
+        
+        float dmod = sqrt(dist);
+        
+        vec2 dmod_scale = vec2(dmod*dmod, dmod);
+        
+        //get reflected color
+        vec2 refdistort1 = wave1.xy*normScale.x;
+        vec2 refvec1 = distort+refdistort1/dmod_scale;
+        vec4 refcol1 = texture2D(refTex, refvec1);
+        
+        vec2 refdistort2 = wave2.xy*normScale.y;
+        vec2 refvec2 = distort+refdistort2/dmod_scale;
+        vec4 refcol2 = texture2D(refTex, refvec2);
+        
+        vec2 refdistort3 = wave3.xy*normScale.z;
+        vec2 refvec3 = distort+refdistort3/dmod_scale;
+        vec4 refcol3 = texture2D(refTex, refvec3);
+
+        vec4 refcol = refcol1 + refcol2 + refcol3;
+        float df1 = df.x + df.y + df.z;
+        refcol *= df1 * 0.333;
+        
+        vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5;
+        //wavef.z *= max(-viewVec.z, 0.1);
+        wavef = normalize(wavef);
+        
+        float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset;
+        
+        vec2 refdistort4 = wavef.xy*0.125;
+        refdistort4.y -= abs(refdistort4.y);
+        vec2 refvec4 = distort+refdistort4/dmod;
+        float dweight = min(dist2*blurMultiplier, 1.0);
+        vec4 baseCol = texture2D(refTex, refvec4);
+        refcol = mix(baseCol*df2, refcol, dweight);
+
+        //get specular component
+        //float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
+                
+        //harden specular
+        //spec = pow(spec, 128.0);
+
+        //figure out distortion vector (ripply)   
+        vec2 distort2 = distort+wavef.xy*refScale/max(dmod*df1, 1.0);
+                
+        vec4 fb = texture2D(screenTex, distort2);
+        
+        //mix with reflection
+        // Note we actually want to use just df1, but multiplying by 0.999999 gets around and nvidia compiler bug
+        color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.99999);
+        
+        float shadow = 1.0;
+        vec4 pos = vary_position;
+        
+        vec3 nz = texture2D(noiseMap, gl_FragCoord.xy/128.0).xyz;
+        vec4 spos = pos;
+                
+        //spec *= shadow;
+        //color.rgb += spec * specular;
+        
+        //color.rgb = atmosTransport(color.rgb);
+        //color.rgb = scaleSoftClip(color.rgb);
+        //color.a = spec * sunAngle2;
+
+        //wavef.z *= 0.1f;
+        wavef = normalize(wavef);
+        wavef = (norm_mat*vec4(wavef, 1.0)).xyz;
+        
+        gl_FragData[0] = vec4(color.rgb, 0.75);
+        gl_FragData[1] = vec4(1,1,1, 0.8);
+        gl_FragData[2] = vec4(wavef*0.5+0.5, 0.f);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class2/deferred/waterV.glsl b/linden/indra/newview/app_settings/shaders/class2/deferred/waterV.glsl
new file mode 100644
index 0000000..b45e5c5
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class2/deferred/waterV.glsl
@@ -0,0 +1,76 @@
+/** 
+ * @file waterV.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+void calcAtmospherics(vec3 inPositionEye);
+
+uniform vec2 d1;
+uniform vec2 d2;
+uniform float time;
+uniform vec3 eyeVec;
+uniform float waterHeight;
+
+varying vec4 refCoord;
+varying vec4 littleWave;
+varying vec4 view;
+
+varying vec4 vary_position;
+
+float wave(vec2 v, float t, float f, vec2 d, float s) 
+{
+   return (dot(d, v)*f + t*s)*f;
+}
+
+void main()
+{
+        //transform vertex
+        vec4 position = gl_Vertex;
+        mat4 modelViewProj = gl_ModelViewProjectionMatrix;
+        
+        vec4 oPosition;
+                    
+        //get view vector
+        vec3 oEyeVec;
+        oEyeVec.xyz = position.xyz-eyeVec;
+                
+        float d = length(oEyeVec.xy);
+        float ld = min(d, 2560.0);
+        
+        position.xy = eyeVec.xy + oEyeVec.xy/d*ld;
+        view.xyz = oEyeVec;
+                
+        d = clamp(ld/1536.0-0.5, 0.0, 1.0);     
+        d *= d;
+                
+        oPosition = position;
+        oPosition.z = mix(oPosition.z, max(eyeVec.z*0.75, 0.0), d);
+        vary_position = gl_ModelViewMatrix * oPosition;
+        oPosition = modelViewProj * oPosition;
+        
+        refCoord.xyz = oPosition.xyz + vec3(0,0,0.2);
+        
+        //get wave position parameter (create sweeping horizontal waves)
+        vec3 v = position.xyz;
+        v.x += (cos(v.x*0.08/*+time*0.01*/)+sin(v.y*0.02))*6.0;
+            
+        //push position for further horizon effect.
+        position.xyz = oEyeVec.xyz*(waterHeight/oEyeVec.z);
+        position.w = 1.0;
+        position = position*gl_ModelViewMatrix;
+        
+        calcAtmospherics((gl_ModelViewMatrix * gl_Vertex).xyz);
+        
+        
+        //pass wave parameters to pixel shader
+        vec2 bigWave =  (v.xy) * vec2(0.04,0.04)  + d1 * time * 0.055;
+        //get two normal map (detail map) texture coordinates
+        littleWave.xy = (v.xy) * vec2(0.45, 0.9)   + d2 * time * 0.13;
+        littleWave.zw = (v.xy) * vec2(0.1, 0.2) + d1 * time * 0.1;
+        view.w = bigWave.y;
+        refCoord.w = bigWave.x;
+        
+        gl_Position = oPosition;
+}