79 files changed, 4159 insertions, 128 deletions

diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index a91e9fa..f90d91f 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -13,9 +13,9 @@ uniform sampler2DShadow shadowMap1;
 uniform sampler2DShadow shadowMap2;
 uniform sampler2DShadow shadowMap3;
 uniform sampler2D noiseMap;
-uniform sampler2DRect positionMap;
+uniform sampler2DRect depthMap;
 
-uniform mat4 shadow_matrix[4];
+uniform mat4 shadow_matrix[6];
 uniform vec4 shadow_clip;
 uniform vec2 screen_res;
 
@@ -26,15 +26,31 @@ 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 = texture2DRect(positionMap, frag).xyz;
+        vec3 samp_pos = getPosition(frag).xyz;
         
         float shadow = 1.0;
         vec4 pos = vec4(vary_position, 1.0);
@@ -82,7 +98,7 @@ void main()
         
         //gl_FragColor = gl_Color;
         gl_FragColor = color;
-        //gl_FragColor = vec4(1,0,1,1);
+        //gl_FragColor = vec4(1,0,1,1)*shadow;
         
 }
 
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl
index b496bd6..48baf77 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl
@@ -20,8 +20,11 @@ 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()
 {
@@ -32,8 +35,9 @@ void main()
         
         vec4 pos = (gl_ModelViewMatrix * gl_Vertex);
         vec3 norm = normalize(gl_NormalMatrix * gl_Normal);
-        vary_position = pos.xyz;
-        
+        // KL this works around ATI not compiling the shader but maintains shadow offset and bias vec3 not vec4
+        vary_position = pos.xyz + norm.xyz * (-pos.z/64.0*shadow_offset+shadow_bias);
+                
         calcAtmospherics(pos.xyz);
 
         //vec4 color = calcLighting(pos.xyz, norm, gl_Color, vec4(0.));
@@ -54,6 +58,8 @@ void main()
         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)));
         
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaF.glsl
index 6c94f5c..ff64a6b 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaF.glsl
@@ -12,7 +12,7 @@ uniform sampler2DShadow shadowMap2;
 uniform sampler2DShadow shadowMap3;
 uniform sampler2D noiseMap;
 
-uniform mat4 shadow_matrix[4];
+uniform mat4 shadow_matrix[6];
 uniform vec4 shadow_clip;
 
 vec3 atmosLighting(vec3 light);
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl
index 58aa5a9..4b9cca2 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl
@@ -8,13 +8,18 @@
 uniform sampler2D diffuseMap;
 
 varying vec3 vary_normal;
-varying vec4 vary_position;
 
 void main() 
 {
-        gl_FragData[0] = gl_Color * texture2D(diffuseMap, gl_TexCoord[0].xy);
+        vec4 diff = gl_Color*texture2D(diffuseMap, gl_TexCoord[0].xy);
+        // Viewer 2.0 uses 0.2 but for KL's viewer if i want a complete avatar need this to be 0.0 for now.
+        if (diff.a < 0.0)
+        {
+                discard;
+        }
+        
+        gl_FragData[0] = vec4(diff.rgb, 1.0);
         gl_FragData[1] = vec4(0,0,0,0);
-        gl_FragData[2] = vec4(normalize(vary_normal), 0.0);
-        gl_FragData[3] = vary_position;
+        gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
 }
 
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl
index 27c09db..00083eb 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl
@@ -10,6 +10,7 @@ uniform sampler2D diffuseMap;
 
 void main() 
 {
-        gl_FragColor = vec4(1,1,1,gl_Color.a * texture2D(diffuseMap, gl_TexCoord[0].xy));
+        gl_FragColor = vec4(1,1,1,gl_Color.a * texture2D(diffuseMap, gl_TexCoord[0].xy).a);
+        //gl_FragColor = vec4(1,1,1,1);
 }
 
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarShadowV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarShadowV.glsl
index 14da6b1..8c8489d 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarShadowV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarShadowV.glsl
@@ -28,8 +28,7 @@ void main()
         norm = normalize(norm);
         
         pos = gl_ProjectionMatrix * pos;
-        //smash geometry against near clip plane
-        pos.z = max(pos.z, -1.0);
+        pos.z = max(pos.z, -pos.w+0.01);
         gl_Position = pos;
         
         gl_FrontColor = gl_Color;
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarV.glsl
index 12a7ff7..471a1f0 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/avatarV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/avatarV.glsl
@@ -10,7 +10,6 @@ mat4 getSkinnedTransform();
 attribute vec4 weight;
 
 varying vec3 vary_normal;
-varying vec4 vary_position;
 
 void main()
 {
@@ -30,7 +29,6 @@ void main()
         norm.z = dot(trans[2].xyz, gl_Normal);
         norm = normalize(norm);
         
-        vary_position = pos;
         vary_normal = norm;
         
         gl_Position = gl_ProjectionMatrix * pos;
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
index 3c6700a..1713fe9 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
@@ -7,10 +7,11 @@
 
 #extension GL_ARB_texture_rectangle : enable
 
-uniform sampler2DRect positionMap;
+uniform sampler2DRect depthMap;
 uniform sampler2DRect normalMap;
 uniform sampler2DRect lightMap;
 
+uniform float dist_factor;
 uniform float blur_size;
 uniform vec2 delta;
 uniform vec3 kern[32];
@@ -19,30 +20,52 @@ 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;
-        vec3 pos = texture2DRect(positionMap, vary_fragcoord.xy).xyz;
-        vec2 ccol = texture2DRect(lightMap, vary_fragcoord.xy).rg;
+        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'
-        vec2 col = defined_weight * ccol;
+        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 = texture2DRect(positionMap, tc).xyz;
+                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).rg*kern[i].xy;
+                        col += texture2DRect(lightMap, tc)*kern[i].xyxx;
                         defined_weight += kern[i].xy;
                 }
         }
 
-        col /= defined_weight;
 
-        gl_FragColor = vec4(col.r, col.g, 0.0, 1.0);
+
+        col /= defined_weight.xyxx;
+        
+        gl_FragColor = col;
+        
+        //gl_FragColor = ccol;
 }
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl
index a8712bc..1c29dae 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl
@@ -11,7 +11,6 @@ uniform sampler2D bumpMap;
 varying vec3 vary_mat0;
 varying vec3 vary_mat1;
 varying vec3 vary_mat2;
-varying vec4 vary_position;
 
 void main() 
 {
@@ -22,8 +21,7 @@ void main()
                                           dot(norm,vary_mat1),
                                           dot(norm,vary_mat2));
                                                 
-        gl_FragData[0].rgb = gl_Color.rgb*col;
-        gl_FragData[1] = vec4(col*(gl_Color.a*1.5), gl_Color.a);
-        gl_FragData[2] = vec4(normalize(tnorm), 0.0);
-        gl_FragData[3] = vary_position;
+        gl_FragData[0] = vec4(gl_Color.rgb*col, 0.0);
+        gl_FragData[1] = vec4(col*gl_Color.a, gl_Color.a);
+        gl_FragData[2] = vec4(normalize(tnorm)*0.5+0.5, 0.0);
 }
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/bumpV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/bumpV.glsl
index ba18092..9589912 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/bumpV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/bumpV.glsl
@@ -8,7 +8,6 @@
 varying vec3 vary_mat0;
 varying vec3 vary_mat1;
 varying vec3 vary_mat2;
-varying vec4 vary_position;
 
 void main()
 {
@@ -16,8 +15,6 @@ void main()
         gl_Position = ftransform(); 
         gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
         
-        vary_position = gl_ModelViewMatrix * gl_Vertex;
-        
         vec3 n = normalize(gl_NormalMatrix * gl_Normal);
         vec3 b = normalize(gl_NormalMatrix * gl_MultiTexCoord2.xyz);
         vec3 t = cross(b, n);
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl
index f2ba2df..919dd5d 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl
@@ -8,13 +8,11 @@
 uniform sampler2D diffuseMap;
 
 varying vec3 vary_normal;
-varying vec4 vary_position;
 
 void main() 
 {
         vec3 col = texture2D(diffuseMap, gl_TexCoord[0].xy).rgb;
-        gl_FragData[0] = vec4(gl_Color.rgb*col, 1.0);
+        gl_FragData[0] = vec4(gl_Color.rgb*col, 1.0); // KL viewer 2.0 has 0.0 but this is not working right yet besides i like to see my eyes :)
         gl_FragData[1] = vec4(col*(gl_Color.a*1.5), gl_Color.a);
-        gl_FragData[2] = vec4(normalize(vary_normal), 0.0);
-        gl_FragData[3] = vary_position;
+        gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
 }
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/diffuseV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/diffuseV.glsl
index 3413a7f..44468cd 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/diffuseV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/diffuseV.glsl
@@ -6,16 +6,13 @@
  */
 
 varying vec3 vary_normal;
-varying vec4 vary_position;
 
 void main()
 {
         //transform vertex
-        gl_Position = ftransform(); 
+        gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; 
         gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
         
-        vary_position = gl_ModelViewMatrix * gl_Vertex;
-        
         vary_normal = normalize(gl_NormalMatrix * gl_Normal);
 
         gl_FrontColor = gl_Color;
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
index 2a811c5..e518bdd 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
@@ -8,14 +8,9 @@
 #extension GL_ARB_texture_rectangle : enable
 
 uniform sampler2D diffuseMap;
-uniform sampler2DShadow shadowMap0;
-uniform sampler2DShadow shadowMap1;
-uniform sampler2DShadow shadowMap2;
-uniform sampler2DShadow shadowMap3;
+uniform sampler2DRect depthMap;
 uniform sampler2D noiseMap;
-uniform sampler2DRect positionMap;
 
-uniform mat4 shadow_matrix[4];
 uniform vec4 shadow_clip;
 uniform vec2 screen_res;
 
@@ -30,12 +25,27 @@ varying vec3 vary_fragcoord;
 
 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 = texture2DRect(positionMap, frag).xyz;
+        vec3 samp_pos = getPosition(frag).xyz; 
         
         float shadow = 1.0;
         vec4 pos = vary_position;
@@ -46,10 +56,10 @@ void main()
 
         color.rgb = fullbrightScaleSoftClip(color.rgb);
 
-        if (samp_pos.z != 0.0)
+        if (samp_pos.z != 0.0 && color.a < 1.0)
         {
                 float dist_factor = alpha_soften;
-                float a = gl_Color.a;
+                float a = color.a;
                 a *= a;
                 dist_factor *= 1.0/(1.0-a);
                 color.a *= min((pos.z-samp_pos.z)*dist_factor, 1.0);
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
index 6381a1c..aff5117 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
@@ -12,12 +12,12 @@ 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;
 varying vec3 vary_fragcoord;
 uniform float near_clip;
+varying vec4 vary_position;
 
 void main()
 {
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/giF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/giF.glsl
new file mode 100644
index 0000000..b351eec
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/giF.glsl
@@ -0,0 +1,165 @@
+/** 
+ * @file giF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2D noiseMap;
+
+uniform sampler2D               diffuseGIMap;
+uniform sampler2D               normalGIMap;
+uniform sampler2D               depthGIMap;
+
+uniform sampler2D               lightFunc;
+
+// Inputs
+varying vec2 vary_fragcoord;
+
+uniform vec2 screen_res;
+
+uniform mat4 inv_proj;
+uniform mat4 gi_mat;  //gPipeline.mGIMatrix - eye space to sun space
+uniform mat4 gi_mat_proj; //gPipeline.mGIMatrixProj - eye space to projected sun space
+uniform mat4 gi_norm_mat; //gPipeline.mGINormalMatrix - eye space normal to sun space normal matrix
+uniform mat4 gi_inv_proj; //gPipeline.mGIInvProj - projected sun space to sun space
+uniform float gi_radius;
+uniform float gi_intensity;
+uniform int gi_samples;
+uniform vec2 gi_kern[25];
+uniform vec2 gi_scale;
+uniform vec3 gi_quad;
+uniform vec3 gi_spec;
+uniform float gi_direction_weight;
+uniform float gi_light_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;
+}
+
+vec4 getGIPosition(vec2 gi_tc)
+{
+        float depth = texture2D(depthGIMap, gi_tc).a;
+        vec2 sc = gi_tc*2.0;
+        sc -= vec2(1.0, 1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = gi_inv_proj*ndc;
+        pos.xyz /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+vec3 giAmbient(vec3 pos, vec3 norm)
+{
+        vec4 gi_c = gi_mat_proj * vec4(pos, 1.0);
+        gi_c.xyz /= gi_c.w;
+
+        vec4 gi_pos = gi_mat*vec4(pos,1.0);
+        vec3 gi_norm = (gi_norm_mat*vec4(norm,1.0)).xyz;
+        gi_norm = normalize(gi_norm);
+        
+        vec2 tcx = gi_norm.xy;
+        vec2 tcy = gi_norm.yx;
+        
+        vec4 eye_pos = gi_mat*vec4(0,0,0,1.0);
+        
+        vec3 eye_dir = normalize(gi_pos.xyz-eye_pos.xyz/eye_pos.w);
+        
+        //vec3 eye_dir = vec3(0,0,-1);
+        //eye_dir = (gi_norm_mat*vec4(eye_dir, 1.0)).xyz;
+        //eye_dir = normalize(eye_dir);
+        
+        //float round_x = gi_scale.x;
+        //float round_y = gi_scale.y;
+        
+        vec3 debug = texture2D(normalGIMap, gi_c.xy).rgb*0.5+0.5;
+        debug.xz = vec2(0.0,0.0);
+        //debug = fract(debug);
+        
+        float round_x = 1.0/64.0;
+        float round_y = 1.0/64.0;
+        
+        //gi_c.x = floor(gi_c.x/round_x+0.5)*round_x;
+        //gi_c.y = floor(gi_c.y/round_y+0.5)*round_y;
+        
+        float fda = 0.0;
+        vec3 fdiff = vec3(0,0,0);
+        
+        vec3 rcol = vec3(0,0,0);
+        
+        float fsa = 0.0;
+        
+        for (int i = -1; i < 2; i+=2 )
+        {
+                for (int j = -1; j < 2; j+=2)
+                {
+                        vec2 tc = vec2(i, j)*0.75;
+                        vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0+tc*0.5).xyz;
+                        //tc += gi_norm.xy*nz.z;
+                        tc += nz.xy*2.0;
+                        tc /= gi_samples;
+                        tc += gi_c.xy;
+                        
+                        vec3 lnorm = -normalize(texture2D(normalGIMap, tc.xy).xyz*2.0-1.0);
+                        vec3 lpos = getGIPosition(tc.xy).xyz;
+                                                        
+                        vec3 at = lpos-gi_pos.xyz;
+                        float dist = dot(at,at);
+                        float da = clamp(1.0/(gi_spec.x*dist), 0.0, 1.0);
+                        
+                        if (da > 0.0)
+                        {
+                                //add angular attenuation
+                                vec3 ldir = at;
+                                float ang_atten = clamp(dot(ldir, gi_norm), 0.0, 1.0);
+                        
+                                float ld = -dot(ldir, lnorm);
+                                
+                                if (ang_atten > 0.0 && ld < 0.0)
+                                {
+                                        vec3 diff = texture2D(diffuseGIMap, tc.xy).xyz;
+                                        da = da*ang_atten;
+                                        fda += da;
+                                        fdiff += diff*da;
+                                }
+                        }
+                }
+        }
+
+        fdiff /= max(gi_spec.y*fda, gi_quad.z);
+        fdiff = clamp(fdiff, vec3(0), vec3(1));
+        
+        vec3 ret = fda*fdiff;
+        //ret = ret*ret*gi_quad.x+ret*gi_quad.y+gi_quad.z;                      
+
+        //fda *= nz.z;
+        
+        //rcol.rgb *= gi_intensity;
+        //return rcol.rgb+vary_AmblitColor.rgb*0.25;
+        //return vec4(debug, 0.0);
+        //return vec4(fda*fdiff, 0.0);
+        return clamp(ret,vec3(0.0), vec3(1.0));
+        //return debug.xyz;
+}
+
+void main() 
+{
+        vec2 pos_screen = vary_fragcoord.xy;
+        vec4 pos = getPosition(pos_screen);
+        vec3 norm = texture2DRect(normalMap, pos_screen).xyz*2.0-1.0;
+        
+        gl_FragData[0].xyz = giAmbient(pos, norm);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/giV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/giV.glsl
new file mode 100644
index 0000000..71dcea9
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/giV.glsl
@@ -0,0 +1,22 @@
+/** 
+ * @file giV.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;       
+        vec4 tex = gl_MultiTexCoord0;
+        tex.w = 1.0;
+
+        gl_FrontColor = gl_Color;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl
new file mode 100644
index 0000000..e8b53b0
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl
@@ -0,0 +1,15 @@
+/** 
+ * @file luminanceF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect diffuseMap;
+
+varying vec2 vary_fragcoord;
+
+void main() 
+{
+        gl_FragColor = texture2DRect(diffuseMap, vary_fragcoord.xy);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/luminanceV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/luminanceV.glsl
new file mode 100644
index 0000000..db8775f
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/luminanceV.glsl
@@ -0,0 +1,20 @@
+/** 
+ * @file giV.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;       
+
+        gl_FrontColor = gl_Color;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
index 3689d12..ce0494c 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
@@ -7,13 +7,15 @@
 
 #extension GL_ARB_texture_rectangle : enable
 
+uniform sampler2DRect depthMap;
 uniform sampler2DRect diffuseRect;
 uniform sampler2DRect specularRect;
-uniform sampler2DRect positionMap;
 uniform sampler2DRect normalMap;
 uniform samplerCube environmentMap;
 uniform sampler2DRect lightMap;
 uniform sampler2D noiseMap;
+uniform sampler2D lightFunc;
+
 
 uniform vec3 env_mat[3];
 uniform float sun_wash;
@@ -23,24 +25,48 @@ uniform int light_count;
 uniform vec4 light[16];
 uniform vec4 light_col[16];
 
-varying vec3 vary_fragcoord;
+varying vec4 vary_fragcoord;
 uniform vec2 screen_res;
 
+uniform float far_z;
+
+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*0.5+0.5)*screen_res;
-        vec3 pos = texture2DRect(positionMap, frag.xy).xyz;
-        vec3 norm = normalize(texture2DRect(normalMap, frag.xy).xyz);
+        vec3 pos = getPosition(frag.xy).xyz;
+        if (pos.z < far_z)
+        {
+                discard;
+        }
+        
+        vec3 norm = normalize(texture2DRect(normalMap, frag.xy).xyz*2.0-1.0);
         vec4 spec = texture2DRect(specularRect, frag.xy);
         vec3 diff = texture2DRect(diffuseRect, frag.xy).rgb;
         float noise = texture2D(noiseMap, frag.xy/128.0).b;
         vec3 out_col = vec3(0,0,0);
+        vec3 npos = normalize(-pos);
         
         for (int i = 0; i < light_count; ++i)
         {
                 vec3 lv = light[i].xyz-pos;
                 float dist2 = dot(lv,lv);
-                if (dist2 > light[i].w)
+                dist2 /= light[i].w;
+                if (dist2 > 1.0)
                 {
                         continue;
                 }
@@ -55,29 +81,41 @@ void main()
                 da = dot(norm, lv);
                                 
                 float fa = light_col[i].a+1.0;
-                float dist_atten = clamp(1.0-(dist2-light[i].w*(1.0-fa))/(light[i].w*fa), 0.0, 1.0);
+                float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
                 dist_atten *= noise;
 
                 float lit = da * dist_atten;
                 
                 vec3 col = light_col[i].rgb*lit*diff;
+                //vec3 col = vec3(dist2, light_col[i].a, lit);
                 
                 if (spec.a > 0.0)
                 {
-                        vec3 ref = reflect(normalize(pos), norm);
-                        float sa = dot(ref,lv);
-                        sa = max(sa, 0.0);
-                        sa = pow(sa, 128.0 * spec.a*spec.a/dist_atten)*min(dist_atten*4.0, 1.0);
-                        sa *= noise;
-                        col += da*sa*light_col[i].rgb*spec.rgb;
+                        //vec3 ref = dot(pos+lv, norm);
+                        
+                        float sa = dot(normalize(lv+npos),norm);
+                        
+                        if (sa > 0)
+                        {
+                                sa = texture2D(lightFunc,vec2(sa, spec.a)).a * min(dist_atten*4.0, 1.0);
+                                sa *= noise;
+                                col += da*sa*light_col[i].rgb*spec.rgb;
+                        }
                 }
                 
                 out_col += col; 
         }
         
+        if (dot(out_col, out_col) <= 0.0)
+        {
+                discard;
+        }
+        
         //attenuate point light contribution by SSAO component
         out_col *= texture2DRect(lightMap, frag.xy).g;
         
         gl_FragColor.rgb = out_col;
         gl_FragColor.a = 0.0;
+        
+        //gl_FragColor = vec4(0.1, 0.025, 0.025/4.0, 0.0);
 }
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
new file mode 100644
index 0000000..021e8a2
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
@@ -0,0 +1,184 @@
+/** 
+ * @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 = 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;
+                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/class1/deferred/pointLightF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
index 52bad1f..d8ccfd4 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
@@ -9,33 +9,54 @@
 
 uniform sampler2DRect diffuseRect;
 uniform sampler2DRect specularRect;
-uniform sampler2DRect positionMap;
 uniform sampler2DRect normalMap;
 uniform samplerCube environmentMap;
 uniform sampler2DRect lightMap;
 uniform sampler2D noiseMap;
+uniform sampler2D lightFunc;
+uniform sampler2DRect depthMap;
 
 uniform vec3 env_mat[3];
 uniform float sun_wash;
 
 varying vec4 vary_light;
 
-varying vec3 vary_fragcoord;
+varying vec4 vary_fragcoord;
 uniform vec2 screen_res;
 
+uniform mat4 inv_proj;
+uniform vec4 viewport;
+
+vec4 getPosition(vec2 pos_screen)
+{
+        float depth = texture2DRect(depthMap, pos_screen.xy).a;
+        vec2 sc = (pos_screen.xy-viewport.xy)*2.0;
+        sc /= viewport.zw;
+        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 pos = texture2DRect(positionMap, frag).xyz;
+        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;
         float dist2 = dot(lv,lv);
-        if (dist2 > vary_light.w)
+        dist2 /= vary_light.w;
+        if (dist2 > 1.0)
         {
                 discard;
         }
         
-        vec3 norm = texture2DRect(normalMap, frag).xyz;
+        vec3 norm = texture2DRect(normalMap, frag.xy).xyz*2.0-1.0;
         float da = dot(norm, lv);
         if (da < 0.0)
         {
@@ -46,24 +67,30 @@ void main()
         lv = normalize(lv);
         da = dot(norm, lv);
         
-        float noise = texture2D(noiseMap, frag/128.0).b;
+        float noise = texture2D(noiseMap, frag.xy/128.0).b;
         
-        vec3 col = texture2DRect(diffuseRect, frag).rgb;
+        vec3 col = texture2DRect(diffuseRect, frag.xy).rgb;
         float fa = gl_Color.a+1.0;
-        float dist_atten = clamp(1.0-(dist2-vary_light.w*(1.0-fa))/(vary_light.w*fa), 0.0, 1.0);
+        float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
         float lit = da * dist_atten * noise;
         
         col = gl_Color.rgb*lit*col;
 
-        vec4 spec = texture2DRect(specularRect, frag);
+        vec4 spec = texture2DRect(specularRect, frag.xy);
         if (spec.a > 0.0)
         {
-                vec3 ref = reflect(normalize(pos), norm);
-                float sa = dot(ref,lv);
-                sa = max(sa, 0.0);
-                sa = pow(sa, 128.0 * spec.a*spec.a/dist_atten)*min(dist_atten*4.0, 1.0);
-                sa *= noise;
-                col += da*sa*gl_Color.rgb*spec.rgb;
+                float sa = dot(normalize(lv-normalize(pos)),norm);
+                if (sa > 0.0)
+                {
+                        sa = texture2D(lightFunc, vec2(sa, spec.a)).a * min(dist_atten*4.0, 1.0);
+                        sa *= noise;
+                        col += da*sa*gl_Color.rgb*spec.rgb;
+                }
+        }
+        
+        if (dot(col, col) <= 0.0)
+        {
+                discard;
         }
         
         //attenuate point light contribution by SSAO component
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/pointLightV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/pointLightV.glsl
index a4edb88..e815ca2 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/pointLightV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/pointLightV.glsl
@@ -6,7 +6,7 @@
  */
 
 varying vec4 vary_light;
-varying vec3 vary_fragcoord;
+varying vec4 vary_fragcoord;
 
 uniform vec2 screen_res;
 uniform float near_clip;
@@ -14,10 +14,10 @@ uniform float near_clip;
 void main()
 {
         //transform vertex
-        gl_Position = ftransform(); 
+        gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; 
 
         vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
-        vary_fragcoord.xyz = pos.xyz + vec3(0,0,near_clip);
+        vary_fragcoord = pos;
                 
         vec4 tex = gl_MultiTexCoord0;
         tex.w = 1.0;
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl
new file mode 100644
index 0000000..71de036
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl
@@ -0,0 +1,57 @@
+/** 
+ * @file postDeferredF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect localLightMap;
+uniform sampler2DRect sunLightMap;
+uniform sampler2DRect giLightMap;
+uniform sampler2D         luminanceMap;
+uniform sampler2DRect lightMap;
+
+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 lum = texture2DLod(luminanceMap, tc/screen_res, lum_lod).rgb;
+        float luminance = lum.r;
+        luminance = luminance*lum_quad.y+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;
+                
+                
+        sun_col *= 1.0/min(luminance, 1.0);
+        gi_col *= 1.0/luminance;
+                
+        vec3 col = sun_col.rgb+gi_col+local_col;
+        
+        gl_FragColor.rgb = col.rgb;
+        col.rgb = max(col.rgb-vec3(1.0,1.0,1.0), vec3(0.0, 0.0, 0.0)); 
+        
+        gl_FragColor.a = 0.0; // max(dot(col.rgb,col.rgb)*lum_quad.x, sun_col.a);
+        
+        //gl_FragColor.rgb = vec3(lum_lod);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl
new file mode 100644
index 0000000..9819232
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/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/class1/deferred/postgiF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl
new file mode 100644
index 0000000..3556c7b
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl
@@ -0,0 +1,107 @@
+/** 
+ * @file postgiF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2D               diffuseGIMap;
+uniform sampler2D               normalGIMap;
+uniform sampler2D               depthGIMap;
+uniform sampler2D               diffuseMap;
+
+uniform sampler2D               lastDiffuseGIMap;
+uniform sampler2D               lastNormalGIMap;
+uniform sampler2D               lastMinpGIMap;
+uniform sampler2D               lastMaxpGIMap;
+
+uniform float gi_blend;
+
+uniform mat4 gi_mat;  //gPipeline.mGIMatrix - eye space to sun space
+uniform mat4 gi_mat_proj; //gPipeline.mGIMatrixProj - eye space to projected sun space
+uniform mat4 gi_norm_mat; //gPipeline.mGINormalMatrix - eye space normal to sun space normal matrix
+uniform mat4 gi_inv_proj; //gPipeline.mGIInvProj - projected sun space to sun space
+uniform float gi_radius;
+uniform float gi_intensity;
+uniform vec2 gi_kern[16];
+uniform vec2 gi_scale;
+
+
+vec4 getGIPosition(vec2 gi_tc)
+{
+        float depth = texture2D(depthGIMap, gi_tc).a;
+        vec2 sc = gi_tc*2.0;
+        sc -= vec2(1.0, 1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = gi_inv_proj*ndc;
+        pos.xyz /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+
+void main() 
+{
+        vec2 c_tc = gl_TexCoord[0].xy;
+        
+        vec3 diff = vec3(0,0,0);
+        vec3 minp = vec3(1024,1024,1024);
+        vec3 maxp = vec3(-1024,-1024,-1024);
+        vec3 norm = vec3(0,0,0);
+        
+        float dweight = 0.0;
+        
+        vec3 cnorm = normalize(texture2D(normalGIMap, c_tc).rgb*2.0-1.0);
+        
+        vec3 cpos = vec3(0,0,0);
+        float tweight = 0.0;
+        
+        for (int i = 0; i < 8; ++i)
+        {
+                for (int j = 0; j < 8; ++j)
+                {
+                        vec2 tc = vec2(i-4+0.5, j-4+0.5);
+                        float weight = 1.0-length(tc)/6.0;
+                        tc *= 1.0/(256.0);
+                        tc += c_tc;
+                                        
+                        vec3 n = texture2D(normalGIMap, tc).rgb*2.0-1.0;
+                        tweight += weight;
+                        
+                        diff += weight*texture2D(diffuseGIMap, tc).rgb;
+                
+                        norm += n*weight;
+                        
+                        dweight += dot(n, cnorm);
+                        
+                        vec3 pos = getGIPosition(tc).xyz;
+                        cpos += pos*weight;
+                        
+                        minp = min(pos, minp);
+                        maxp = max(pos, maxp); 
+                }
+        }
+                
+        dweight = abs(1.0-dweight/64.0);
+        float mind = min(sqrt(dweight+0.5), 1.0);
+        
+        dweight *= dweight;
+        
+        cpos /= tweight;
+        
+        diff = clamp(diff/tweight, vec3(1.0/2.2), vec3(1,1,1));
+        norm = normalize(norm);
+        maxp = cpos;
+        minp = vec3(dweight, mind, cpos.z-minp.z);
+        
+        //float blend = 1.0;
+        //diff = mix(texture2D(lastDiffuseGIMap, c_tc).rgb, diff, blend);
+        //norm = mix(texture2D(lastNormalGIMap, c_tc).rgb, norm, blend);
+        //maxp = mix(texture2D(lastMaxpGIMap, c_tc).rgb, maxp, blend);
+        //minp = mix(texture2D(lastMinpGIMap, c_tc).rgb, minp, blend);
+        
+        gl_FragData[0].rgb = diff;
+        gl_FragData[2].xyz = normalize(norm);
+        gl_FragData[1].xyz = maxp;
+        gl_FragData[3].xyz = minp;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/postgiV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/postgiV.glsl
new file mode 100644
index 0000000..5a8eb65
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/postgiV.glsl
@@ -0,0 +1,16 @@
+/** 
+ * @file postgiV.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+varying vec3 vary_normal;
+
+void main()
+{
+        //transform vertex
+        vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex; 
+        gl_Position = pos;
+        gl_TexCoord[0].xy = pos.xy*0.5+0.5;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl
index b3758c3..b0b31fd 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl
@@ -7,8 +7,11 @@
 
 uniform sampler2D diffuseMap;
 
+varying vec4 post_pos;
 
 void main() 
 {
         gl_FragColor = vec4(1,1,1,texture2D(diffuseMap, gl_TexCoord[0].xy).a * gl_Color.a);
+        
+        gl_FragDepth = max(post_pos.z/post_pos.w*0.5+0.5, 0.0);
 }
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/shadowV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/shadowV.glsl
index aae1bee..7214d24 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/shadowV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/shadowV.glsl
@@ -5,13 +5,17 @@
  * $License$
  */
 
+varying vec4 post_pos;
+
 void main()
 {
         //transform vertex
         vec4 pos = gl_ModelViewProjectionMatrix*gl_Vertex;
-        //smash geometry against the near clip plane (great for ortho projections)
-        pos.z = max(pos.z, -1.0);
-        gl_Position = pos;
+        
+        post_pos = pos;
+        
+        gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
+        
         gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
         gl_FrontColor = gl_Color;
 }
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index d5671a6..64e263a 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -272,8 +272,4 @@ void main()
         
         gl_FragColor.rgb = col;
         gl_FragColor.a = 0.0;
-        //gl_FragColor.rg = scol_ambocc.rg;
-        //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/class1/deferred/spotLightF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
new file mode 100644
index 0000000..d653408
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/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/class1/deferred/sunLightF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/sunLightF.glsl
index d43fe6c..22bdd2c 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/sunLightF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/sunLightF.glsl
@@ -7,17 +7,21 @@
 
 #extension GL_ARB_texture_rectangle : enable
 
-uniform sampler2DRect positionMap;
-uniform sampler2DRect normalMap;
 uniform sampler2DRect depthMap;
-uniform sampler2DShadow shadowMap0;
-uniform sampler2DShadow shadowMap1;
-uniform sampler2DShadow shadowMap2;
-uniform sampler2DShadow shadowMap3;
+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[4];
+uniform mat4 shadow_matrix[6];
 uniform vec4 shadow_clip;
 uniform float ssao_radius;
 uniform float ssao_max_radius;
@@ -27,6 +31,25 @@ 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)
 {
@@ -54,7 +77,7 @@ float calcAmbientOcclusion(vec4 pos, vec3 norm)
         for (int i = 0; i < 8; i++)
         {
                 vec2 samppos_screen = pos_screen + scale * reflect(kern[i], noise_reflect);
-                vec3 samppos_world = texture2DRect(positionMap, samppos_screen).xyz;
+                vec3 samppos_world = getPosition(samppos_screen).xyz; 
                 
                 vec3 diff = pos_world - samppos_world;
                 float dist2 = dot(diff, diff);
@@ -74,14 +97,18 @@ float calcAmbientOcclusion(vec4 pos, vec3 norm)
         
         angle_hidden = min(ssao_factor*angle_hidden/float(points), 1.0);
         
-        return 1.0 - (float(points != 0) * angle_hidden);
+        return (1.0 - (float(points != 0) * angle_hidden));
 }
 
 void main() 
 {
         vec2 pos_screen = vary_fragcoord.xy;
-        vec4 pos = vec4(texture2DRect(positionMap, pos_screen).xyz, 1.0);
-        vec3 norm = texture2DRect(normalMap, pos_screen).xyz;
+        
+        //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
         {
@@ -90,35 +117,45 @@ void main()
         }*/
         
         float shadow = 1.0;
-        float dp_directional_light = max(0.0, dot(norm, vary_light.xyz));
+    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 (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 if (pos.z > -shadow_clip.w)
+        else if (spos.z > -shadow_clip.w)
         {       
-                if (pos.z < -shadow_clip.z)
+                vec4 lpos;
+                
+                if (spos.z < -shadow_clip.z)
                 {
-                        vec4 lpos = shadow_matrix[3]*pos;
-                        shadow = shadow2DProj(shadowMap3, lpos).x;
+                        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 (pos.z < -shadow_clip.y)
+                else if (spos.z < -shadow_clip.y)
                 {
-                        vec4 lpos = shadow_matrix[2]*pos;
-                        shadow = shadow2DProj(shadowMap2, lpos).x;
+                        lpos = shadow_matrix[2]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap2, lpos).x;
                 }
-                else if (pos.z < -shadow_clip.x)
+                else if (spos.z < -shadow_clip.x)
                 {
-                        vec4 lpos = shadow_matrix[1]*pos;
-                        shadow = shadow2DProj(shadowMap1, lpos).x;
+                        lpos = shadow_matrix[1]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap1, lpos).x;
                 }
                 else
                 {
-                        vec4 lpos = shadow_matrix[0]*pos;
-                        shadow = shadow2DProj(shadowMap0, lpos).x;
+                        lpos = shadow_matrix[0]*spos;
+                        lpos.xy *= screen_res;
+                        shadow = shadow2DRectProj(shadowMap0, lpos).x;
                 }
 
                 // take the most-shadowed value out of these two:
@@ -126,6 +163,17 @@ void main()
                 //  * 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
         {
@@ -135,5 +183,18 @@ void main()
         
         gl_FragColor[0] = shadow;
         gl_FragColor[1] = calcAmbientOcclusion(pos, norm);
-        //gl_FragColor[2] is unused as of August 2008, may be used for debugging
+        
+        //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/class1/deferred/terrainF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl
index 211b2e0..308b9b1 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl
@@ -12,7 +12,6 @@ uniform sampler2D detail_3;
 uniform sampler2D alpha_ramp;
 
 varying vec3 vary_normal;
-varying vec4 vary_position;
 
 void main()
 {
@@ -28,9 +27,8 @@ void main()
         float alphaFinal = texture2D(alpha_ramp, gl_TexCoord[1].zw).a;
         vec4 outColor = mix( mix(color3, color2, alpha2), mix(color1, color0, alpha1), alphaFinal );
         
-        gl_FragData[0] = vec4(outColor.rgb, 1.0);
+        gl_FragData[0] = vec4(outColor.rgb, 0.0); // Kl 0.0 looks fine atm however check grass above waterline when GI enabled in future releases!
         gl_FragData[1] = vec4(outColor.rgb*0.2, 0.2);
-        gl_FragData[2] = vec4(normalize(vary_normal), 0.0);
-        gl_FragData[3] = vary_position;
+        gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
 }
 
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
index e9d6dca..3038b14 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
@@ -6,7 +6,6 @@
  */
 
 varying vec3 vary_normal;
-varying vec4 vary_position;
 
 vec4 texgen_object(vec4  vpos, vec4 tc, mat4 mat, vec4 tp0, vec4 tp1)
 {
@@ -27,7 +26,6 @@ void main()
         //transform vertex
         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
                         
-        vary_position = gl_ModelViewMatrix * gl_Vertex;
         vary_normal = normalize(gl_NormalMatrix * gl_Normal);
         
         // Transform and pass tex coords
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl
index bc2c981..49c65f1 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl
@@ -8,13 +8,11 @@
 uniform sampler2D diffuseMap;
 
 varying vec3 vary_normal;
-varying vec4 vary_position;
 
 void main() 
 {
         vec4 col = texture2D(diffuseMap, gl_TexCoord[0].xy);
         gl_FragData[0] = gl_Color*col;
         gl_FragData[1] = vec4(0,0,0,0);
-        gl_FragData[2] = vec4(normalize(vary_normal), 0.0);
-        gl_FragData[3] = vary_position;
+        gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
 }
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/treeV.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/treeV.glsl
index 9131d7c..6b9dc2d 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/treeV.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/treeV.glsl
@@ -6,7 +6,6 @@
  */
 
 varying vec3 vary_normal;
-varying vec4 vary_position;
 
 void main()
 {
@@ -14,8 +13,6 @@ void main()
         gl_Position = ftransform(); 
         gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
         
-        vary_position = gl_ModelViewMatrix * gl_Vertex;
-        
         vary_normal = normalize(gl_NormalMatrix * gl_Normal);
 
         gl_FrontColor = gl_Color;
diff --git a/linden/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl b/linden/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
index 0a1f019..6eea656 100644
--- a/linden/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
+++ b/linden/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
@@ -17,7 +17,7 @@ uniform sampler2DShadow shadowMap2;
 uniform sampler2DShadow shadowMap3;
 uniform sampler2D noiseMap;
 
-uniform mat4 shadow_matrix[4];
+uniform mat4 shadow_matrix[6];
 uniform vec4 shadow_clip;
 
 uniform float sunAngle;
diff --git a/linden/indra/newview/app_settings/shaders/class1/effects/colorFilterF.glsl b/linden/indra/newview/app_settings/shaders/class1/effects/colorFilterF.glsl
new file mode 100644
index 0000000..623ef7a
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/effects/colorFilterF.glsl
@@ -0,0 +1,31 @@
+/**
+ * @file colorFilterF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect RenderTexture;
+uniform float brightness;
+uniform float contrast;
+uniform vec3  contrastBase;
+uniform float saturation;
+uniform vec3  lumWeights;
+
+const float gamma = 2.0;
+
+void main(void) 
+{
+        vec3 color = vec3(texture2DRect(RenderTexture, gl_TexCoord[0].st));
+
+        /// Modulate brightness
+        color *= brightness;
+
+        /// Modulate contrast
+        color = mix(contrastBase, color, contrast);
+
+        /// Modulate saturation
+        color = mix(vec3(dot(color, lumWeights)), color, saturation);
+
+        gl_FragColor = vec4(color, 1.0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/effects/drawQuadV.glsl b/linden/indra/newview/app_settings/shaders/class1/effects/drawQuadV.glsl
new file mode 100644
index 0000000..29c2a09
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/effects/drawQuadV.glsl
@@ -0,0 +1,14 @@
+/**
+ * @file drawQuadV.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+void main(void)
+{
+        //transform vertex
+        gl_Position = ftransform();
+        gl_TexCoord[0] = gl_MultiTexCoord0;
+        gl_TexCoord[1] = gl_MultiTexCoord1;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class1/effects/nightVisionF.glsl b/linden/indra/newview/app_settings/shaders/class1/effects/nightVisionF.glsl
new file mode 100644
index 0000000..271d5cf
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class1/effects/nightVisionF.glsl
@@ -0,0 +1,42 @@
+/**
+ * @file nightVisionF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect RenderTexture;
+uniform sampler2D NoiseTexture;
+uniform float brightMult;
+uniform float noiseStrength;
+
+float luminance(vec3 color)
+{
+        /// CALCULATING LUMINANCE (Using NTSC lum weights)
+        /// http://en.wikipedia.org/wiki/Luma_%28video%29
+        return dot(color, vec3(0.299, 0.587, 0.114));
+}
+
+void main(void) 
+{
+        /// Get scene color
+        vec3 color = vec3(texture2DRect(RenderTexture, gl_TexCoord[0].st));
+        
+        /// Extract luminance and scale up by night vision brightness
+        float lum = luminance(color) * brightMult;
+
+        /// Convert into night vision color space
+        /// Newer NVG colors (crisper and more saturated)
+        vec3 outColor = (lum * vec3(0.91, 1.21, 0.9)) + vec3(-0.07, 0.1, -0.12); 
+
+        /// Add noise
+        float noiseValue = texture2D(NoiseTexture, gl_TexCoord[1].st).r;
+        noiseValue = (noiseValue - 0.5) * noiseStrength;
+
+        /// Older NVG colors (more muted)
+        // vec3 outColor = (lum * vec3(0.82, 0.75, 0.83)) + vec3(0.05, 0.32, -0.11); 
+        
+        outColor += noiseValue;
+
+        gl_FragColor = vec4(outColor, 1.0);
+}
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;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/avatarF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/avatarF.glsl
new file mode 100644
index 0000000..9cc71a7
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/avatarF.glsl
@@ -0,0 +1,18 @@
+/** 
+ * @file avatarF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2D diffuseMap;
+
+varying vec3 vary_normal;
+
+void main() 
+{
+        gl_FragData[0] = vec4(gl_Color.rgb * texture2D(diffuseMap, gl_TexCoord[0].xy).rgb, 0.0);
+        gl_FragData[1] = vec4(0,0,0,0);
+        gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
+}
+
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/bumpF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/bumpF.glsl
new file mode 100644
index 0000000..6eb4a51
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/bumpF.glsl
@@ -0,0 +1,27 @@
+/** 
+ * @file bumpF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2D diffuseMap;
+uniform sampler2D bumpMap;
+
+varying vec3 vary_mat0;
+varying vec3 vary_mat1;
+varying vec3 vary_mat2;
+
+void main() 
+{
+        vec3 col = texture2D(diffuseMap, gl_TexCoord[0].xy).rgb;
+        vec3 norm = texture2D(bumpMap, gl_TexCoord[0].xy).rgb * 2.0 - 1.0;
+
+        vec3 tnorm = vec3(dot(norm,vary_mat0),
+                                          dot(norm,vary_mat1),
+                                          dot(norm,vary_mat2));
+                                                
+        gl_FragData[0] = vec4(gl_Color.rgb*col, 0.0);
+        gl_FragData[1] = vec4(vec3(gl_Color.a), gl_Color.a+(1.0-gl_Color.a)*gl_Color.a);
+        gl_FragData[2] = vec4(normalize(tnorm)*0.5+0.5, 0.0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/diffuseF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/diffuseF.glsl
new file mode 100644
index 0000000..c9f75f7
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/diffuseF.glsl
@@ -0,0 +1,18 @@
+/** 
+ * @file diffuseF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2D diffuseMap;
+
+varying vec3 vary_normal;
+
+void main() 
+{
+        vec3 col = texture2D(diffuseMap, gl_TexCoord[0].xy).rgb;
+        gl_FragData[0] = vec4(gl_Color.rgb*col, 0.0);
+        gl_FragData[1] = vec4(vec3(gl_Color.a), gl_Color.a+(1.0-gl_Color.a)*gl_Color.a);
+        gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/giDownsampleF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/giDownsampleF.glsl
new file mode 100644
index 0000000..7325825
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/giDownsampleF.glsl
@@ -0,0 +1,84 @@
+/** 
+ * @file giDownsampleF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect giLightMap;
+
+uniform vec2 kern[32];
+uniform float dist_factor;
+uniform float blur_size;
+uniform vec2 delta;
+uniform int kern_length;
+uniform float kern_scale;
+uniform vec3 blur_quad;
+
+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;
+}
+
+float getDepth(vec2 pos_screen)
+{
+        float z = texture2DRect(depthMap, pos_screen.xy).a;
+        z = z*2.0-1.0;
+        vec4 ndc = vec4(0.0, 0.0, z, 1.0);
+        vec4 p = inv_proj*ndc;
+        return p.z/p.w;
+}
+
+void main() 
+{
+        vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
+        float depth = getDepth(vary_fragcoord.xy);
+                
+        vec3 ccol = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+        vec2 dlt = kern_scale * delta/(vec2(1.0,1.0)+norm.xy*norm.xy);
+        dlt /= clamp(-depth*blur_quad.x, 1.0, 3.0);
+        float defined_weight = kern[0].x;
+        vec3 col = ccol*kern[0].x;
+        
+        for (int i = 0; i < kern_length; i++)
+        {
+                vec2 tc = vary_fragcoord.xy + kern[i].y*dlt;
+            vec3 sampNorm = texture2DRect(normalMap, tc.xy).xyz*2.0-1.0;
+            
+           float d = dot(norm.xyz, sampNorm);
+                
+                if (d > 0.5)
+                {
+                        float sampdepth = getDepth(tc.xy);
+                        sampdepth -= depth;
+                        if (sampdepth*sampdepth < blur_quad.z)
+                        {
+                        col += texture2DRect(giLightMap, tc).rgb*kern[i].x;
+                                defined_weight += kern[i].x;
+                        }
+                }
+        }
+
+        col /= defined_weight;
+        
+        //col = ccol;
+        
+        col = col*blur_quad.y;
+        
+        gl_FragData[0].xyz = col;
+        
+        //gl_FragColor = ccol;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/giDownsampleV.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/giDownsampleV.glsl
new file mode 100644
index 0000000..6adcda8
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/giDownsampleV.glsl
@@ -0,0 +1,17 @@
+/** 
+ * @file postgiV.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/class3/deferred/giF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/giF.glsl
new file mode 100644
index 0000000..43da836
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/giF.glsl
@@ -0,0 +1,219 @@
+/** 
+ * @file giF.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 sampler2DRect specularRect;
+
+uniform sampler2D noiseMap;
+
+uniform sampler2D               diffuseGIMap;
+uniform sampler2D               specularGIMap;
+uniform sampler2D               normalGIMap;
+uniform sampler2D               depthGIMap;
+
+uniform sampler2D               lightFunc;
+
+// Inputs
+varying vec2 vary_fragcoord;
+
+uniform vec2 screen_res;
+
+uniform vec4 sunlight_color;
+
+uniform mat4 inv_proj;
+uniform mat4 gi_mat;  //gPipeline.mGIMatrix - eye space to sun space
+uniform mat4 gi_mat_proj; //gPipeline.mGIMatrixProj - eye space to projected sun space
+uniform mat4 gi_norm_mat; //gPipeline.mGINormalMatrix - eye space normal to sun space normal matrix
+uniform mat4 gi_inv_proj; //gPipeline.mGIInvProj - projected sun space to sun space
+uniform float gi_radius;
+uniform float gi_intensity;
+uniform int gi_samples;
+uniform vec2 gi_kern[25];
+uniform vec2 gi_scale;
+uniform vec3 gi_quad;
+uniform vec3 gi_spec;
+uniform float gi_direction_weight;
+uniform float gi_light_offset;
+uniform float gi_range;
+
+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;
+}
+
+vec4 getGIPosition(vec2 gi_tc)
+{
+        float depth = texture2D(depthGIMap, gi_tc).a;
+        vec2 sc = gi_tc*2.0;
+        sc -= vec2(1.0, 1.0);
+        vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+        vec4 pos = gi_inv_proj*ndc;
+        pos.xyz /= pos.w;
+        pos.w = 1.0;
+        return pos;
+}
+
+vec3 giAmbient(vec3 pos, vec3 norm)
+{
+        vec4 gi_c = gi_mat_proj * vec4(pos, 1.0);
+        gi_c.xyz /= gi_c.w;
+
+        vec4 gi_pos = gi_mat*vec4(pos,1.0);
+        vec3 gi_norm = (gi_norm_mat*vec4(norm,1.0)).xyz;
+        gi_norm = normalize(gi_norm);
+        
+        vec4 c_spec = texture2DRect(specularRect, vary_fragcoord.xy);
+        gi_pos.xyz += (texture2D(noiseMap, vary_fragcoord.xy/128.0).x)*gi_spec.z*gi_norm.xyz;
+        vec2 tcx = gi_norm.xy;
+        vec2 tcy = gi_norm.yx;
+        
+        vec4 eye_pos = gi_mat*vec4(0,0,0,1.0);
+        
+        vec3 eye_dir = normalize(gi_pos.xyz-eye_pos.xyz);
+        vec3 eye_ref = reflect(eye_dir, gi_norm);
+        
+        //vec3 eye_dir = vec3(0,0,-1);
+        //eye_dir = (gi_norm_mat*vec4(eye_dir, 1.0)).xyz;
+        //eye_dir = normalize(eye_dir);
+        
+        //float round_x = gi_scale.x;
+        //float round_y = gi_scale.y;
+        
+        vec3 debug = texture2D(normalGIMap, gi_c.xy).rgb;
+        //debug.xz = vec2(0.0,0.0);
+        //debug = fract(debug);
+        
+        float round_x = 1.0/64.0;
+        float round_y = 1.0/64.0;
+        
+        //gi_c.x = floor(gi_c.x/round_x+0.5)*round_x;
+        //gi_c.y = floor(gi_c.y/round_y+0.5)*round_y;
+
+        float da = texture2DRect(lightMap, vary_fragcoord.xy).r;
+
+        vec3 fdiff = vec3(da);
+        
+        if (da > 0.0)
+        {
+                vec3 ha = -eye_dir;
+                ha.z += 1.0;
+                ha = normalize(ha);
+                
+                float sa = dot(ha,gi_norm);
+                da = min(da, texture2D(lightFunc, vec2(sa, c_spec.a)).a);
+                fdiff += da*(c_spec.rgb*c_spec.a*2.0);
+        }
+        
+        float fda = da;
+        
+        vec3 rcol = vec3(0,0,0);
+        
+        float fsa = 0.0;
+        
+
+        for (int i = -1; i <= 1; i += 1 )
+        {
+                for (int j = -1; j <= 1; j+= 1)
+                {
+                        vec2 tc = vec2(i, j)*0.75+gi_norm.xy;
+                        vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0+tc*0.5).xyz;
+                        tc += gi_norm.xy*nz.z;
+                        tc += nz.xy*2.0;
+                        tc /= gi_samples;
+                        tc += gi_c.xy;
+                        
+                        vec3 lnorm = -normalize(texture2D(normalGIMap, tc.xy).xyz*2.0-1.0);
+                        vec3 lpos = getGIPosition(tc.xy).xyz;
+                                                        
+                        vec3 at = lpos-gi_pos.xyz;
+                        float dist = dot(at,at);
+                        float da = clamp(1.0/(gi_spec.x*dist), 0.0, 1.0);
+                        
+                                                
+                        if (da > 0.01)
+                        { //possible contribution of indirect light to this surface
+                                vec3 ldir = at;
+                                
+                                float ld = -dot(ldir, lnorm);
+                                
+                                if (ld < 0.0)
+                                {                                       
+                                        float ang_atten = dot(ldir, gi_norm);
+                                
+                                        if (ang_atten > 0.0)
+                                        {  
+                                                vec4 spec = texture2D(specularGIMap, tc.xy);
+                                                at = normalize(at);
+                                                vec3 diff;              
+                                                                                                
+                                                { //contribution from indirect source to visible pixel
+                                                        vec3 ha = at;
+                                                        ha.z -= 1.0;
+                                                        ha = normalize(ha);
+                                                        float sa = dot(ha,lnorm);
+                                                        da = min(da, texture2D(lightFunc, vec2(sa, spec.a)).a);
+                                                
+                                                        diff = texture2D(diffuseGIMap, tc.xy).rgb+spec.rgb*spec.a*2.0;
+                                                }
+                                                
+                                                if (da > 0.0)
+                                                { //contribution from visible pixel to eye
+                                                        vec3 ha = normalize(at-eye_dir);
+                                                        float sa = dot(ha, gi_norm);
+                                                        da = min(da, texture2D(lightFunc, vec2(sa, c_spec.a)).a);
+                                                        fda += da;
+                                                        fdiff += da*(c_spec.rgb*c_spec.a*2.0+vec3(1,1,1))*diff.rgb;
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+
+        //fdiff /= max(gi_spec.y*fda, gi_quad.z);
+        //fdiff = clamp(fdiff, vec3(0), vec3(1));
+        fdiff *= 64.0;
+        fdiff *= sunlight_color.rgb;
+        
+        vec3 ret = fda*fdiff;
+        //ret = ret*ret*gi_quad.x+ret*gi_quad.y+gi_quad.z;                      
+
+        //fda *= nz.z;
+        
+        //rcol.rgb *= gi_intensity;
+        //return rcol.rgb+vary_AmblitColor.rgb*0.25;
+        //return vec4(debug, 0.0);
+        //return vec4(fda*fdiff, 0.0);
+        return clamp(ret,vec3(0.0), vec3(1.0));
+        //return debug.xyz;
+}
+
+void main() 
+{
+        vec2 pos_screen = vary_fragcoord.xy;
+        vec4 pos = getPosition(pos_screen);
+        
+        float rad = gi_range*0.5;
+        
+        vec3 norm = texture2DRect(normalMap, pos_screen).xyz*2.0-1.0;
+        float dist = max(length(pos.xyz)-rad, 0.0);
+        
+        float da = clamp(1.0-dist/rad, 0.0, 1.0);
+        gl_FragData[0].xyz = da > 0.0 ? giAmbient(pos, norm)*da : vec3(0,0,0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/giV.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/giV.glsl
new file mode 100644
index 0000000..71dcea9
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/giV.glsl
@@ -0,0 +1,22 @@
+/** 
+ * @file giV.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;       
+        vec4 tex = gl_MultiTexCoord0;
+        tex.w = 1.0;
+
+        gl_FrontColor = gl_Color;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/luminanceF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/luminanceF.glsl
new file mode 100644
index 0000000..0de0d11
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/luminanceF.glsl
@@ -0,0 +1,16 @@
+/** 
+ * @file luminanceF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect diffuseMap;
+
+varying vec2 vary_fragcoord;
+uniform float fade;
+void main() 
+{
+        gl_FragColor.rgb = texture2DRect(diffuseMap, vary_fragcoord.xy).rgb;
+        gl_FragColor.a = fade;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/luminanceV.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/luminanceV.glsl
new file mode 100644
index 0000000..db8775f
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/luminanceV.glsl
@@ -0,0 +1,20 @@
+/** 
+ * @file giV.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;       
+
+        gl_FrontColor = gl_Color;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/postDeferredF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/postDeferredF.glsl
new file mode 100644
index 0000000..609fb1d
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/postDeferredF.glsl
@@ -0,0 +1,76 @@
+/** 
+ * @file postDeferredF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+uniform sampler2DRect localLightMap;
+uniform sampler2DRect sunLightMap;
+uniform sampler2DRect giLightMap;
+uniform sampler2D         luminanceMap;
+uniform sampler2DRect lightMap;
+uniform sampler2D         lightFunc;
+
+
+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);
+        vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+        
+        float ambocc = texture2DRect(lightMap, vary_fragcoord.xy).g;
+                        
+        vec3 ccol = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+        vec3 gi_col = ccol;
+        /*for (int i = -1; i <= 1; i+=1)
+        {
+                for (int j = -1; j <= 1; j+=1)
+                {
+                        vec2 tc = vec2(i,j);
+                        float wght = 1.0/(length(tc)+1.0);
+                        gi_col += texture2DRect(giLightMap, vary_fragcoord.xy+vec2(i,j)).rgb * wght;
+                }
+        }*/
+        
+        //gi_col *= 1.0+spec.a*4.0;
+        gi_col = (sqrt(gi_col)*gi_quad.x + gi_col*gi_quad.y)*(diff.rgb+spec.rgb*spec.a)+gi_quad.z*ambocc*ambient.rgb*diff.rgb;
+        
+        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;
+        //gl_FragColor.rgb = vec3(texture2D(lightFunc, vary_fragcoord.xy/512.0-vec2(0.5, 0.5)).a);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/postDeferredV.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/postDeferredV.glsl
new file mode 100644
index 0000000..9819232
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/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/class3/deferred/postgiF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/postgiF.glsl
new file mode 100644
index 0000000..12a5f39
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/postgiF.glsl
@@ -0,0 +1,87 @@
+/** 
+ * @file postgiF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2DRect giLightMap;
+uniform sampler2D       noiseMap;
+
+uniform vec2 kern[32];
+uniform float dist_factor;
+uniform float blur_size;
+uniform vec2 delta;
+uniform int kern_length;
+uniform float kern_scale;
+uniform vec3 blur_quad;
+
+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;
+}
+
+float getDepth(vec2 pos_screen)
+{
+        float z = texture2DRect(depthMap, pos_screen.xy).a;
+        z = z*2.0-1.0;
+        vec4 ndc = vec4(0.0, 0.0, z, 1.0);
+        vec4 p = inv_proj*ndc;
+        return p.z/p.w;
+}
+
+void main() 
+{
+        vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
+        float depth = getDepth(vary_fragcoord.xy);
+                
+        vec3 ccol = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+        vec2 dlt = kern_scale * delta/(vec2(1.0,1.0)+norm.xy*norm.xy);
+        dlt /= clamp(-depth*blur_quad.x, 1.0, 3.0);
+        float defined_weight = kern[0].x;
+        vec3 col = ccol*kern[0].x;
+        
+        for (int i = 0; i < kern_length; i++)
+        {
+                vec2 tc = vary_fragcoord.xy + kern[i].y*dlt;
+            vec3 sampNorm = texture2DRect(normalMap, tc.xy).xyz*2.0-1.0;
+            
+           float d = dot(norm.xyz, sampNorm);
+                
+                if (d > 0.5)
+                {
+                        float sampdepth = getDepth(tc.xy);
+                        sampdepth -= depth;
+                        if (sampdepth*sampdepth < blur_quad.z)
+                        {
+                        col += texture2DRect(giLightMap, tc).rgb*kern[i].x;
+                                defined_weight += kern[i].x;
+                        }
+                }
+        }
+
+        col /= defined_weight;
+        
+        //col = ccol;
+        
+        col = col*blur_quad.y;
+        
+        gl_FragData[0].xyz = col;
+        
+        //gl_FragColor = ccol;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/postgiV.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/postgiV.glsl
new file mode 100644
index 0000000..6adcda8
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/postgiV.glsl
@@ -0,0 +1,17 @@
+/** 
+ * @file postgiV.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/class3/deferred/softenLightF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
new file mode 100644
index 0000000..654b182
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -0,0 +1,312 @@
+/** 
+ * @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 sampler2DRect giLightMap;
+uniform sampler2D         noiseMap;
+uniform samplerCube environmentMap;
+uniform sampler2D         lightFunc;
+uniform sampler2D         luminanceMap;
+
+uniform vec3 gi_quad;
+uniform vec3 lum_quad;
+uniform float lum_lod;
+
+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;
+        
+        vec3 at = normalize(pos);
+        
+        vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+        
+        vec3 lum = texture2DLod(luminanceMap, tc/screen_res, lum_lod).rgb;
+        
+        vec3 ha = normalize(vary_light.xyz-at);
+        
+        float da = dot(ha, norm.xyz);
+        da = texture2D(lightFunc, vec2(da, spec.a)).a;
+        
+        vec4 diffuse = texture2DRect(diffuseRect, tc);
+                
+        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 = vec3(0,0,0);
+        
+        col += atmosAffectDirectionalLight(max(min(da, scol), diffuse.a)*(1.0+spec.a));
+                
+        col *= diffuse.rgb;
+        
+        col += da*spec.rgb*spec.a*vary_SunlitColor*scol_ambocc.r;
+        
+        /*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);
+
+        col = col*vec3(1.0+1.0/2.2);
+                                        
+        gl_FragColor.rgb = col;
+        //gl_FragColor.rgb = lum;
+        
+        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/class3/deferred/softenLightV.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
new file mode 100644
index 0000000..ad8af47
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/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/class3/deferred/treeF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/treeF.glsl
new file mode 100644
index 0000000..258acee
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/deferred/treeF.glsl
@@ -0,0 +1,18 @@
+/** 
+ * @file treeF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2D diffuseMap;
+
+varying vec3 vary_normal;
+
+void main() 
+{
+        vec4 col = texture2D(diffuseMap, gl_TexCoord[0].xy);
+        gl_FragData[0] = vec4(gl_Color.rgb*col.rgb, col.a <= 0.5 ? 0.0 : 0.005);
+        gl_FragData[1] = vec4(0,0,0,0);
+        gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl b/linden/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl
new file mode 100644
index 0000000..bea1515
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/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.5);
+        gl_FragData[1] = vec4(0.5,0.5,0.5, 0.95);
+        gl_FragData[2] = vec4(wavef*0.5+0.5, 0.f);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/effects/blurF.glsl b/linden/indra/newview/app_settings/shaders/class3/effects/blurF.glsl
new file mode 100644
index 0000000..9443320
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/effects/blurF.glsl
@@ -0,0 +1,31 @@
+/**
+ * @file blurf.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect RenderTexture;
+uniform float bloomStrength;
+
+varying vec4 gl_TexCoord[gl_MaxTextureCoords];
+void main(void) 
+{
+        float blurWeights[7];
+        blurWeights[0] = 0.05;
+        blurWeights[1] = 0.1;
+        blurWeights[2] = 0.2;
+        blurWeights[3] = 0.3;
+        blurWeights[4] = 0.2;
+        blurWeights[5] = 0.1;
+        blurWeights[6] = 0.05;
+        
+        vec3 color = vec3(0,0,0);
+        for (int i = 0; i < 7; i++){
+                color += vec3(texture2DRect(RenderTexture, gl_TexCoord[i].st)) * blurWeights[i];
+        }
+
+        color *= bloomStrength;
+
+        gl_FragColor = vec4(color, 1.0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/effects/blurV.glsl b/linden/indra/newview/app_settings/shaders/class3/effects/blurV.glsl
new file mode 100644
index 0000000..ba65b16
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/effects/blurV.glsl
@@ -0,0 +1,35 @@
+/**
+ * @file blurV.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform vec2 texelSize;
+uniform vec2 blurDirection;
+uniform float blurWidth;
+
+void main(void)
+{
+        // Transform vertex
+        gl_Position = ftransform();
+        
+        vec2 blurDelta = texelSize * blurDirection * vec2(blurWidth, blurWidth);
+        vec2 s = gl_MultiTexCoord0.st - (blurDelta * 3.0);
+        
+        // for (int i = 0; i < 7; i++) {
+                // gl_TexCoord[i].st = s + (i * blurDelta);
+        // }
+
+        // MANUALLY UNROLL
+        gl_TexCoord[0].st = s;
+        gl_TexCoord[1].st = s + blurDelta;
+        gl_TexCoord[2].st = s + (2. * blurDelta);
+        gl_TexCoord[3].st = s + (3. * blurDelta);
+        gl_TexCoord[4].st = s + (4. * blurDelta);
+        gl_TexCoord[5].st = s + (5. * blurDelta);
+        gl_TexCoord[6].st = s + (6. * blurDelta);
+
+        // gl_TexCoord[0].st = s;
+        // gl_TexCoord[1].st = blurDelta;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/effects/colorFilterF.glsl b/linden/indra/newview/app_settings/shaders/class3/effects/colorFilterF.glsl
new file mode 100644
index 0000000..623ef7a
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/effects/colorFilterF.glsl
@@ -0,0 +1,31 @@
+/**
+ * @file colorFilterF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect RenderTexture;
+uniform float brightness;
+uniform float contrast;
+uniform vec3  contrastBase;
+uniform float saturation;
+uniform vec3  lumWeights;
+
+const float gamma = 2.0;
+
+void main(void) 
+{
+        vec3 color = vec3(texture2DRect(RenderTexture, gl_TexCoord[0].st));
+
+        /// Modulate brightness
+        color *= brightness;
+
+        /// Modulate contrast
+        color = mix(contrastBase, color, contrast);
+
+        /// Modulate saturation
+        color = mix(vec3(dot(color, lumWeights)), color, saturation);
+
+        gl_FragColor = vec4(color, 1.0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/effects/drawQuadV.glsl b/linden/indra/newview/app_settings/shaders/class3/effects/drawQuadV.glsl
new file mode 100644
index 0000000..29c2a09
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/effects/drawQuadV.glsl
@@ -0,0 +1,14 @@
+/**
+ * @file drawQuadV.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+void main(void)
+{
+        //transform vertex
+        gl_Position = ftransform();
+        gl_TexCoord[0] = gl_MultiTexCoord0;
+        gl_TexCoord[1] = gl_MultiTexCoord1;
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/effects/extractF.glsl b/linden/indra/newview/app_settings/shaders/class3/effects/extractF.glsl
new file mode 100644
index 0000000..a1583b1
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/effects/extractF.glsl
@@ -0,0 +1,22 @@
+/**
+ * @file extractF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect RenderTexture;
+uniform float extractLow;
+uniform float extractHigh;
+uniform vec3 lumWeights;
+
+void main(void) 
+{
+        /// Get scene color
+        vec3 color = vec3(texture2DRect(RenderTexture, gl_TexCoord[0].st));
+        
+        /// Extract luminance and scale up by night vision brightness
+        float lum = smoothstep(extractLow, extractHigh, dot(color, lumWeights));
+
+        gl_FragColor = vec4(vec3(lum), 1.0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/effects/nightVisionF.glsl b/linden/indra/newview/app_settings/shaders/class3/effects/nightVisionF.glsl
new file mode 100644
index 0000000..271d5cf
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/effects/nightVisionF.glsl
@@ -0,0 +1,42 @@
+/**
+ * @file nightVisionF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect RenderTexture;
+uniform sampler2D NoiseTexture;
+uniform float brightMult;
+uniform float noiseStrength;
+
+float luminance(vec3 color)
+{
+        /// CALCULATING LUMINANCE (Using NTSC lum weights)
+        /// http://en.wikipedia.org/wiki/Luma_%28video%29
+        return dot(color, vec3(0.299, 0.587, 0.114));
+}
+
+void main(void) 
+{
+        /// Get scene color
+        vec3 color = vec3(texture2DRect(RenderTexture, gl_TexCoord[0].st));
+        
+        /// Extract luminance and scale up by night vision brightness
+        float lum = luminance(color) * brightMult;
+
+        /// Convert into night vision color space
+        /// Newer NVG colors (crisper and more saturated)
+        vec3 outColor = (lum * vec3(0.91, 1.21, 0.9)) + vec3(-0.07, 0.1, -0.12); 
+
+        /// Add noise
+        float noiseValue = texture2D(NoiseTexture, gl_TexCoord[1].st).r;
+        noiseValue = (noiseValue - 0.5) * noiseStrength;
+
+        /// Older NVG colors (more muted)
+        // vec3 outColor = (lum * vec3(0.82, 0.75, 0.83)) + vec3(0.05, 0.32, -0.11); 
+        
+        outColor += noiseValue;
+
+        gl_FragColor = vec4(outColor, 1.0);
+}
diff --git a/linden/indra/newview/app_settings/shaders/class3/effects/simpleF.glsl b/linden/indra/newview/app_settings/shaders/class3/effects/simpleF.glsl
new file mode 100644
index 0000000..e55d278
--- /dev/null
+++ b/linden/indra/newview/app_settings/shaders/class3/effects/simpleF.glsl
@@ -0,0 +1,14 @@
+/**
+ * @file simpleF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+uniform sampler2DRect RenderTexture;
+
+void main(void) 
+{
+        vec3 color = vec3(texture2DRect(RenderTexture, gl_TexCoord[0].st));
+        gl_FragColor = vec4(1.0 - color, 1.0);
+}