Merging render-pipeline-6-qa-2 into viewer-2

Self reviewed.

69 files changed, 3639 insertions, 252 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index a91e9fa15b..4fb109d687 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -8,14 +8,10 @@
 #extension GL_ARB_texture_rectangle : enable
 
 uniform sampler2D diffuseMap;
-uniform sampler2DShadow shadowMap0;
-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,52 +22,42 @@ 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);
 	
-	if (pos.z > -shadow_clip.w)
-	{	
-		if (pos.z < -shadow_clip.z)
-		{
-			vec4 lpos = shadow_matrix[3]*pos;
-			shadow = shadow2DProj(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)
-		{
-			vec4 lpos = shadow_matrix[2]*pos;
-			shadow = shadow2DProj(shadowMap2, lpos).x;
-		}
-		else if (pos.z < -shadow_clip.x)
-		{
-			vec4 lpos = shadow_matrix[1]*pos;
-			shadow = shadow2DProj(shadowMap1, lpos).x;
-		}
-		else
-		{
-			vec4 lpos = shadow_matrix[0]*pos;
-			shadow = shadow2DProj(shadowMap0, lpos).x;
-		}
-	}
-	
-	vec4 col = vec4(vary_ambient + vary_directional.rgb*shadow, gl_Color.a);
+	vec4 col = vec4(vary_ambient + vary_directional.rgb, 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)
+	if (samp_pos.z != 0.0 && gl_Color.a < 1.0)
 	{
 		float dist_factor = alpha_soften;
 		float a = gl_Color.a;
@@ -83,6 +69,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/indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl
index b496bd674f..1a7d58b07b 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl
+++ b/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;
 	
+	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/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaF.glsl
index 6c94f5c5a7..ff64a6b0c3 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaF.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl
index 58aa5a9cb5..75df388941 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl
+++ b/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);
+	
+	if (diff.a < 0.2)
+	{
+		discard;
+	}
+	
+	gl_FragData[0] = vec4(diff.rgb, 0.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/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl
index 27c09db922..00083eb6b3 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/avatarShadowV.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarShadowV.glsl
index 14da6b1ad4..8c8489d087 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/avatarShadowV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/avatarV.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarV.glsl
index 12a7ff7f29..471a1f0407 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/avatarV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
index 3c6700a871..bd5e9dd758 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
@@ -7,10 +7,12 @@
 
 #extension GL_ARB_texture_rectangle : enable
 
-uniform sampler2DRect positionMap;
+uniform sampler2DRect depthMap;
 uniform sampler2DRect normalMap;
 uniform sampler2DRect lightMap;
+uniform sampler2DRect giLightMap;
 
+uniform float dist_factor;
 uniform float blur_size;
 uniform vec2 delta;
 uniform vec3 kern[32];
@@ -19,30 +21,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/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl b/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl
index a8712bc8cc..1c29dae5f7 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/bumpV.glsl b/indra/newview/app_settings/shaders/class1/deferred/bumpV.glsl
index ba180922cc..9589912c6c 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/bumpV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl b/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl
index f2ba2df69a..5895ebda84 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl
+++ b/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, 0.0);
 	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/indra/newview/app_settings/shaders/class1/deferred/diffuseV.glsl b/indra/newview/app_settings/shaders/class1/deferred/diffuseV.glsl
index 3413a7f9d6..44468cdfa2 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/diffuseV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
index 2a811c5897..e518bddb98 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
index 6381a1ced8..aff51178b0 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/giF.glsl b/indra/newview/app_settings/shaders/class1/deferred/giF.glsl
new file mode 100644
index 0000000000..b351eec6e5
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/giV.glsl b/indra/newview/app_settings/shaders/class1/deferred/giV.glsl
new file mode 100644
index 0000000000..71dcea9628
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
index 20a3f3df5b..8c140a7b4f 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
@@ -9,12 +9,9 @@ uniform sampler2D diffuseMap;
 uniform sampler2D normalMap;
 uniform sampler2D specularMap;
 
-varying vec4 vary_position;
-
 void main() 
 {
 	gl_FragData[0] = texture2D(diffuseMap, gl_TexCoord[0].xy);
 	gl_FragData[1] = texture2D(specularMap, gl_TexCoord[0].xy);
-	gl_FragData[2] = vec4(texture2D(normalMap, gl_TexCoord[0].xy).xyz, vary_position.z);
-	gl_FragData[3] = vary_position;
+	gl_FragData[2] = vec4(texture2D(normalMap, gl_TexCoord[0].xy).xyz, 0.0);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/impostorV.glsl b/indra/newview/app_settings/shaders/class1/deferred/impostorV.glsl
index 9c5ae31541..57532a30b3 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/impostorV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/impostorV.glsl
@@ -5,15 +5,11 @@
  * $License$
  */
 
-varying vec4 vary_position;
-
 void main()
 {
 	//transform vertex
 	gl_Position = ftransform(); 
 	gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
 	
-	vary_position = gl_ModelViewMatrix * gl_Vertex;
-
 	gl_FrontColor = gl_Color;
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl b/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl
new file mode 100644
index 0000000000..e8b53b0293
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/luminanceV.glsl b/indra/newview/app_settings/shaders/class1/deferred/luminanceV.glsl
new file mode 100644
index 0000000000..db8775f024
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
index 3689d12840..797b9e9f3b 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
@@ -7,13 +7,14 @@
 
 #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 +24,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 +80,38 @@ 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.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;	
 	}
 	
-	//attenuate point light contribution by SSAO component
-	out_col *= texture2DRect(lightMap, frag.xy).g;
+	if (dot(out_col, out_col) <= 0.0)
+	{
+		discard;
+	}
 	
 	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/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
new file mode 100644
index 0000000000..28bcd720c0
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
@@ -0,0 +1,178 @@
+/** 
+ * @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 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;
+
+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;
+	}
+	
+	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;
+		}
+		
+		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;
+		
+		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;
+				}
+			}
+		}
+	}
+	
+	/*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;
+	}*/
+	
+	gl_FragColor.rgb = col;	
+	gl_FragColor.a = 0.0;
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
index 52bad1f34c..78256e20cc 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
@@ -9,33 +9,53 @@
 
 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,30 +66,32 @@ 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;
+		}
 	}
 	
-	//attenuate point light contribution by SSAO component
-	col *= texture2DRect(lightMap, frag.xy).g;
-	
-
+	if (dot(col, col) <= 0.0)
+	{
+		discard;
+	}
+		
 	gl_FragColor.rgb = col;	
 	gl_FragColor.a = 0.0;
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pointLightV.glsl b/indra/newview/app_settings/shaders/class1/deferred/pointLightV.glsl
index a4edb88259..e815ca260f 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/pointLightV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl
new file mode 100644
index 0000000000..71de03663c
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl
new file mode 100644
index 0000000000..9819232fd5
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl b/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl
new file mode 100644
index 0000000000..9612aee405
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl
@@ -0,0 +1,79 @@
+/** 
+ * @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;
+}
+
+void main() 
+{
+	vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
+	vec3 pos = getPosition(vary_fragcoord.xy).xyz;
+	
+	
+	vec3 ccol = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+	vec2 dlt = kern_scale * delta/(1.0+norm.xy*norm.xy);
+	dlt /= max(-pos.z*dist_factor, 1.0);
+	float defined_weight = kern[0].x;
+	vec3 col = vec3(0.0);
+	
+	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.8)
+		{
+			vec3 samppos = getPosition(tc.xy).xyz;
+			samppos -= pos;
+			if (dot(samppos,samppos) < -0.05*pos.z)
+			{
+	    		col += texture2DRect(giLightMap, tc).rgb*kern[i].x;
+				defined_weight += kern[i].x;
+			}
+		}
+	}
+
+	col /= defined_weight;
+	
+	//col = ccol;
+	
+	col = col*col*blur_quad.x + col*blur_quad.y + blur_quad.z;
+	
+	gl_FragData[0].xyz = col;
+	
+	//gl_FragColor = ccol;
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postgiV.glsl b/indra/newview/app_settings/shaders/class1/deferred/postgiV.glsl
new file mode 100644
index 0000000000..6adcda82a3
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/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/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl b/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl
index b3758c3638..b0b31fd4ba 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/shadowV.glsl b/indra/newview/app_settings/shaders/class1/deferred/shadowV.glsl
index aae1beeae3..7214d246a4 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/shadowV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index d5671a6ce4..b4b0d0ce9d 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -12,9 +12,9 @@ uniform sampler2DRect specularRect;
 uniform sampler2DRect positionMap;
 uniform sampler2DRect normalMap;
 uniform sampler2DRect depthMap;
-uniform sampler2DRect lightMap;
 uniform sampler2D	  noiseMap;
 uniform samplerCube environmentMap;
+uniform sampler2D	  lightFunc;
 
 uniform float blur_size;
 uniform float blur_fidelity;
@@ -38,9 +38,9 @@ uniform vec4 max_y;
 uniform vec4 glow;
 uniform float scene_light_strength;
 uniform vec3 env_mat[3];
-uniform mat4 shadow_matrix[3];
-uniform vec4 shadow_clip;
-uniform mat3 ssao_effect_mat;
+//uniform mat4 shadow_matrix[3];
+//uniform vec4 shadow_clip;
+//uniform mat3 ssao_effect_mat;
 
 varying vec4 vary_light;
 varying vec2 vary_fragcoord;
@@ -52,6 +52,22 @@ vec3 vary_AmblitColor;
 vec3 vary_AdditiveColor;
 vec3 vary_AtmosAttenuation;
 
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+
+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;
@@ -162,17 +178,7 @@ void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
 	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);
+	vec4 tmpAmbient = ambient + (vec4(1.) - ambient) * cloud_shadow.x * 0.5;	
 
 	//haze color
 	setAdditiveColor(
@@ -235,36 +241,27 @@ vec3 scaleSoftClip(vec3 light)
 void main() 
 {
 	vec2 tc = vary_fragcoord.xy;
-	vec3 pos = texture2DRect(positionMap, tc).xyz;
-	vec3 norm = texture2DRect(normalMap, tc).xyz;
-	vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).xyz;
+	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 = vec4(texture2DRect(diffuseRect, tc).rgb, 1.0);
+	vec4 diffuse = texture2DRect(diffuseRect, tc);
 	vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
 	
-	vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
-	float scol = scol_ambocc.r; 
-	float ambocc = scol_ambocc.g;
-	
-	calcAtmospherics(pos.xyz, ambocc);
+	calcAtmospherics(pos.xyz, 0.0);
 	
 	vec3 col = atmosAmbient(vec3(0));
-	col += atmosAffectDirectionalLight(min(da, scol));
+	col += atmosAffectDirectionalLight(clamp(da, diffuse.a, 1.0));
 	
 	col *= diffuse.rgb;
 	
-	if (spec.a > 0.2)
+	if (spec.a > 0.0)
 	{
-		vec3 ref = reflect(pos.xyz, norm.xyz);
-		vec3 rc;
-		rc.x = dot(ref, env_mat[0]);
-		rc.y = dot(ref, env_mat[1]);
-		rc.z = dot(ref, env_mat[2]);
-		
-		vec3 refcol = textureCube(environmentMap, rc).rgb;
-		col.rgb += refcol * spec.rgb; 
+		vec3 ref = normalize(reflect(pos.xyz, norm.xyz));
+		float sa = dot(ref, vary_light.xyz);
+		col.rgb += vary_SunlitColor*spec.rgb*texture2D(lightFunc, vec2(sa, spec.a)).a;
 	}
 	
 	col = atmosLighting(col);
@@ -272,8 +269,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/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
new file mode 100644
index 0000000000..2a7234fd83
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
@@ -0,0 +1,177 @@
+/** 
+ * @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 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;
+
+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;
+	}
+	
+	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;
+		}
+		
+		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;
+		
+		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;
+				}
+			}
+		}
+	}
+	
+	/*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;
+	}*/
+	
+	gl_FragColor.rgb = col;	
+	gl_FragColor.a = 0.0;
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/sunLightF.glsl
index d43fe6ca95..22bdd2c7f3 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/sunLightF.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl b/indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl
index 211b2e0397..3cccfb7202 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl
+++ b/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);
 	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/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl b/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
index e9d6dcabff..3038b14772 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl b/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl
index bc2c9816dc..258acee08c 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl
+++ b/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[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.0);
-	gl_FragData[3] = vary_position;
+	gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/treeV.glsl b/indra/newview/app_settings/shaders/class1/deferred/treeV.glsl
index 9131d7c2b3..6b9dc2defb 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/treeV.glsl
+++ b/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/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
index 0a1f019e3d..d21575119d 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
@@ -5,19 +5,21 @@
  * $License$
  */
 
+#extension GL_ARB_texture_rectangle : enable
+
 vec3 scaleSoftClip(vec3 inColor);
 vec3 atmosTransport(vec3 inColor);
 
 uniform sampler2D bumpMap;   
 uniform sampler2D screenTex;
 uniform sampler2D refTex;
-uniform sampler2DShadow shadowMap0;
-uniform sampler2DShadow shadowMap1;
-uniform sampler2DShadow shadowMap2;
-uniform sampler2DShadow shadowMap3;
+uniform sampler2DRectShadow shadowMap0;
+uniform sampler2DRectShadow shadowMap1;
+uniform sampler2DRectShadow shadowMap2;
+uniform sampler2DRectShadow shadowMap3;
 uniform sampler2D noiseMap;
 
-uniform mat4 shadow_matrix[4];
+uniform mat4 shadow_matrix[6];
 uniform vec4 shadow_clip;
 
 uniform float sunAngle;
@@ -32,7 +34,8 @@ 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;
@@ -88,7 +91,7 @@ void main()
 	refcol *= df1 * 0.333;
 	
 	vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5;
-	wavef.z *= max(-viewVec.z, 0.1);
+	//wavef.z *= max(-viewVec.z, 0.1);
 	wavef = normalize(wavef);
 	
 	float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset;
@@ -101,10 +104,10 @@ void main()
 	refcol = mix(baseCol*df2, refcol, dweight);
 
 	//get specular component
-	float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
+	//float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
 		
 	//harden specular
-	spec = pow(spec, 128.0);
+	//spec = pow(spec, 128.0);
 
 	//figure out distortion vector (ripply)   
 	vec2 distort2 = distort+wavef.xy*refScale/max(dmod*df1, 1.0);
@@ -118,40 +121,21 @@ void main()
 	float shadow = 1.0;
 	vec4 pos = vary_position;
 	
-	vec3 nz = texture2D(noiseMap, gl_FragCoord.xy/128.0).xyz;
-
-	if (pos.z > -shadow_clip.w)
-	{	
-		vec4 spos = pos;
-			
-		if (pos.z < -shadow_clip.z)
-		{
-			vec4 lpos = (shadow_matrix[3]*spos);
-			shadow = shadow2DProj(shadowMap3, lpos).x;
-		}
-		else if (pos.z < -shadow_clip.y)
-		{
-			vec4 lpos = (shadow_matrix[2]*spos);
-			shadow = shadow2DProj(shadowMap2, lpos).x;
-		}
-		else if (pos.z < -shadow_clip.x)
-		{
-			vec4 lpos = (shadow_matrix[1]*spos);
-			shadow = shadow2DProj(shadowMap1, lpos).x;
-		}
-		else
-		{
-			vec4 lpos = (shadow_matrix[0]*spos);
-			shadow = shadow2DProj(shadowMap0, lpos).x;
-		}
-	}
-	
-	spec *= shadow;
-	color.rgb += spec * specular;
-	
-	color.rgb = atmosTransport(color.rgb);
-	color.rgb = scaleSoftClip(color.rgb);
-	color.a = spec * sunAngle2;
+	//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;
 
-	gl_FragColor = color;
+	//wavef.z = -0.25f;
+	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.0);
 }
diff --git a/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
new file mode 100644
index 0000000000..ad16de6d81
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
@@ -0,0 +1,132 @@
+/** 
+ * @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;
+uniform vec2 shadow_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 float shadow_bias;
+
+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.xyz /= pos.w;
+	pos.w = 1.0;
+	return pos;
+}
+
+float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
+{
+	stc.xyz /= stc.w;
+	stc.z += shadow_bias;
+	
+	float cs = shadow2DRect(shadowMap, stc.xyz).x;
+	float shadow = cs;
+
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(scl, scl, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(scl, -scl, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-scl, scl, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-scl, -scl, 0.0)).x, cs);
+			
+	return shadow/5.0;
+}
+
+
+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 *= shadow_res;
+			shadow = pcfShadow(shadowMap3, lpos, 1.5);
+			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 *= shadow_res;
+			shadow = pcfShadow(shadowMap2, lpos, 1.5);
+		}
+		else if (spos.z < -shadow_clip.x)
+		{
+			lpos = shadow_matrix[1]*spos;
+			lpos.xy *= shadow_res;
+			shadow = pcfShadow(shadowMap1, lpos, 1.5);
+		}
+		else
+		{
+			lpos = shadow_matrix[0]*spos;
+			lpos.xy *= shadow_res;
+			shadow = pcfShadow(shadowMap0, lpos, 1.5);
+		}
+	}
+	
+	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 && gl_Color.a < 1.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/indra/newview/app_settings/shaders/class2/deferred/alphaV.glsl b/indra/newview/app_settings/shaders/class2/deferred/alphaV.glsl
new file mode 100644
index 0000000000..5991e1f3b5
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/alphaV.glsl
@@ -0,0 +1,76 @@
+/** 
+ * @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);
+	
+	float dp_directional_light = max(0.0, dot(norm, gl_LightSource[0].position.xyz));
+	vary_position = pos.xyz + gl_LightSource[0].position.xyz * (1.0-dp_directional_light)*shadow_offset;
+		
+	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/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaF.glsl b/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaF.glsl
new file mode 100644
index 0000000000..a81e4caf4c
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaF.glsl
@@ -0,0 +1,98 @@
+/** 
+ * @file avatarAlphaF.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 mat4 shadow_matrix[6];
+uniform vec4 shadow_clip;
+uniform vec2 screen_res;
+uniform vec2 shadow_res;
+
+vec3 atmosLighting(vec3 light);
+vec3 scaleSoftClip(vec3 light);
+
+varying vec3 vary_ambient;
+varying vec3 vary_directional;
+varying vec3 vary_position;
+varying vec3 vary_normal;
+
+uniform float shadow_bias;
+
+float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
+{
+	stc.xyz /= stc.w;
+	stc.z += shadow_bias;
+	
+	float cs = shadow2DRect(shadowMap, stc.xyz).x;
+	float shadow = cs;
+
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(scl, scl, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(scl, -scl, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-scl, scl, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-scl, -scl, 0.0)).x, cs);
+			
+	return shadow/5.0;
+}
+
+void main() 
+{
+	float shadow = 1.0;
+	vec4 pos = vec4(vary_position, 1.0);
+	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 *= shadow_res;
+			shadow = pcfShadow(shadowMap3, lpos, 1.5);
+			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 *= shadow_res;
+			shadow = pcfShadow(shadowMap2, lpos, 1.5);
+		}
+		else if (spos.z < -shadow_clip.x)
+		{
+			lpos = shadow_matrix[1]*spos;
+			lpos.xy *= shadow_res;
+			shadow = pcfShadow(shadowMap1, lpos, 1.5);
+		}
+		else
+		{
+			lpos = shadow_matrix[0]*spos;
+			lpos.xy *= shadow_res;
+			shadow = pcfShadow(shadowMap0, lpos, 1.5);
+		}
+	}
+	
+	
+	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/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaV.glsl b/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaV.glsl
new file mode 100644
index 0000000000..a939499b17
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/avatarAlphaV.glsl
@@ -0,0 +1,84 @@
+/** 
+ * @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 vec3 vary_position;
+varying vec3 vary_ambient;
+varying vec3 vary_directional;
+varying vec3 vary_normal;
+
+uniform float near_clip;
+uniform float shadow_offset;
+uniform float shadow_bias;
+
+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;
+	
+	float dp_directional_light = max(0.0, dot(norm, gl_LightSource[0].position.xyz));
+	vary_position = pos.xyz + gl_LightSource[0].position.xyz * (1.0-dp_directional_light)*shadow_offset;
+	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/indra/newview/app_settings/shaders/class2/deferred/blurLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/blurLightF.glsl
new file mode 100644
index 0000000000..8bd702a8da
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/blurLightF.glsl
@@ -0,0 +1,96 @@
+/** 
+ * @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 sampler2DRect edgeMap;
+
+uniform float dist_factor;
+uniform float blur_size;
+uniform vec2 delta;
+uniform vec3 kern[4];
+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;
+	
+	float e = 1.0;
+	for (int i = 0; i < 4; i++)
+	{
+		vec2 tc = vary_fragcoord.xy + kern[i].z*dlt;
+		
+		e = max(e, 0.0);
+		
+		vec2 wght = kern[i].xy*e;
+		
+		col += texture2DRect(lightMap, tc)*wght.xyxx;
+		defined_weight += wght;
+		
+		e *= e;
+		e -= texture2DRect(edgeMap, tc.xy).a+
+			texture2DRect(edgeMap, tc.xy+dlt*0.333).a+
+			texture2DRect(edgeMap, tc.xy-dlt*0.333).a;
+	}
+
+
+	e = 1.0;
+	
+	for (int i = 0; i < 4; i++)
+	{
+		vec2 tc = vary_fragcoord.xy - kern[i].z*dlt;
+		
+		e = max(e, 0.0);
+		
+		vec2 wght = kern[i].xy*e;
+		
+		col += texture2DRect(lightMap, tc)*wght.xyxx;
+		defined_weight += wght;
+		
+		e *= e;
+		e -= texture2DRect(edgeMap, tc.xy).a+
+			texture2DRect(edgeMap, tc.xy+dlt*0.333).a+
+			texture2DRect(edgeMap, tc.xy-dlt*0.333).a;
+	}
+
+
+	col /= defined_weight.xyxx;
+	
+	gl_FragColor = col;
+	
+	//gl_FragColor = ccol;
+}
diff --git a/indra/newview/app_settings/shaders/class2/deferred/blurLightV.glsl b/indra/newview/app_settings/shaders/class2/deferred/blurLightV.glsl
new file mode 100644
index 0000000000..b7f07e5702
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class2/deferred/edgeF.glsl b/indra/newview/app_settings/shaders/class2/deferred/edgeF.glsl
new file mode 100644
index 0000000000..02beddd43b
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/edgeF.glsl
@@ -0,0 +1,58 @@
+/** 
+ * @file edgeF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+
+uniform float gi_dist_cutoff;
+
+varying vec2 vary_fragcoord;
+
+uniform float depth_cutoff;
+uniform float norm_cutoff;
+
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+
+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);
+	
+	vec2 tc = vary_fragcoord.xy;
+	
+	float sc = 0.75;
+	
+	vec2 de;
+	de.x = (depth-getDepth(tc+vec2(sc, sc))) + (depth-getDepth(tc+vec2(-sc, -sc)));
+	de.y = (depth-getDepth(tc+vec2(-sc, sc))) + (depth-getDepth(tc+vec2(sc, -sc)));
+	de /= depth;
+	de *= de;
+	de = step(depth_cutoff, de);
+	
+	vec2 ne;
+	ne.x = dot(texture2DRect(normalMap, tc+vec2(-sc,-sc)).rgb*2.0-1.0, norm);
+	ne.y = dot(texture2DRect(normalMap, tc+vec2(sc,sc)).rgb*2.0-1.0, norm);
+	
+	ne = 1.0-ne;
+	
+	ne = step(norm_cutoff, ne);
+	
+	gl_FragColor.a = dot(de,de)+dot(ne,ne);
+	//gl_FragColor.a = dot(de,de);
+}
diff --git a/indra/newview/app_settings/shaders/class2/deferred/edgeV.glsl b/indra/newview/app_settings/shaders/class2/deferred/edgeV.glsl
new file mode 100644
index 0000000000..f1938c92b8
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/edgeV.glsl
@@ -0,0 +1,17 @@
+/** 
+ * @file edgeV.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/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
new file mode 100644
index 0000000000..651959413c
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class2/deferred/postDeferredF.glsl b/indra/newview/app_settings/shaders/class2/deferred/postDeferredF.glsl
new file mode 100644
index 0000000000..ee0e9d6367
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class2/deferred/postDeferredV.glsl b/indra/newview/app_settings/shaders/class2/deferred/postDeferredV.glsl
new file mode 100644
index 0000000000..9819232fd5
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
new file mode 100644
index 0000000000..531f7376a3
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl
new file mode 100644
index 0000000000..ad8af4780d
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl
new file mode 100644
index 0000000000..d6534083cf
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl
new file mode 100644
index 0000000000..a0026edcd2
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl
@@ -0,0 +1,235 @@
+/** 
+ * @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 sampler2DShadow shadowMap4;
+uniform sampler2DShadow 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 vec2 shadow_res;
+uniform vec2 proj_shadow_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));
+}
+
+float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
+{
+	stc.xyz /= stc.w;
+	stc.z += shadow_bias*scl;
+	
+	float cs = shadow2DRect(shadowMap, stc.xyz).x;
+	float shadow = cs;
+
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(1.5, 1.5, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(1.5, -1.5, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-1.5, 1.5, 0.0)).x, cs);
+	shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-1.5, -1.5, 0.0)).x, cs);
+			
+	return shadow/5.0;
+	
+	//return shadow;
+}
+
+float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl)
+{
+	stc.xyz /= stc.w;
+	stc.z += shadow_bias*scl;
+	
+	float cs = shadow2D(shadowMap, stc.xyz).x;
+	float shadow = cs;
+
+	vec2 off = 1.5/proj_shadow_res;
+	
+	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(off.x, off.y, 0.0)).x, cs);
+	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(off.x, -off.y, 0.0)).x, cs);
+	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(-off.x, off.y, 0.0)).x, cs);
+	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(-off.x, -off.y, 0.0)).x, cs);
+	
+			
+	return shadow/5.0;
+	
+	//return shadow;
+}
+
+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 + vary_light.xyz * (1.0-dp_directional_light)*shadow_offset, 1.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 *= shadow_res;
+				shadow = pcfShadow(shadowMap3, lpos, 0.25);
+				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 *= shadow_res;
+				shadow = pcfShadow(shadowMap2, lpos, 0.5);
+			}
+			else if (spos.z < -shadow_clip.x)
+			{
+				lpos = shadow_matrix[1]*spos;
+				lpos.xy *= shadow_res;
+				shadow = pcfShadow(shadowMap1, lpos, 0.75);
+			}
+			else
+			{
+				lpos = shadow_matrix[0]*spos;
+				lpos.xy *= shadow_res;
+				shadow = pcfShadow(shadowMap0, lpos, 1.0);
+			}
+		
+			// 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);
+			
+			//lpos.xy /= lpos.w*32.0;
+			//if (fract(lpos.x) < 0.1 || fract(lpos.y) < 0.1)
+			//{
+			//	shadow = 0.0;
+			//}
+			
+		}
+	}
+	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;
+	gl_FragColor[2] = pcfShadow(shadowMap4, lpos, 0.1).x; 
+	
+	//spotlight shadow 2
+	lpos = shadow_matrix[5]*spos;
+	gl_FragColor[3] = pcfShadow(shadowMap5, lpos, 0.1).x; 
+
+	//gl_FragColor.rgb = pos.xyz;
+	//gl_FragColor.b = shadow;
+}
diff --git a/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl b/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl
new file mode 100644
index 0000000000..5081485c4b
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class3/deferred/giDownsampleF.glsl b/indra/newview/app_settings/shaders/class3/deferred/giDownsampleF.glsl
new file mode 100644
index 0000000000..7325825d6d
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class3/deferred/giDownsampleV.glsl b/indra/newview/app_settings/shaders/class3/deferred/giDownsampleV.glsl
new file mode 100644
index 0000000000..6adcda82a3
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class3/deferred/giF.glsl b/indra/newview/app_settings/shaders/class3/deferred/giF.glsl
new file mode 100644
index 0000000000..939710cb56
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/giF.glsl
@@ -0,0 +1,190 @@
+/** 
+ * @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_sample_width;
+uniform float gi_noise;
+uniform float gi_attenuation;
+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);
+	vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).rgb;
+	gi_pos.xyz += nz.x*gi_noise*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);
+	
+	float da = 0.0; //texture2DRect(lightMap, vary_fragcoord.xy).r*0.5;
+	vec3 fdiff = vec3(da);
+	float fda = da;
+	
+	vec3 rcol = vec3(0,0,0);
+	
+	float fsa = 0.0;
+	
+
+	for (int i = -1; i <= 1; i += 2 )
+	{
+		for (int j = -1; j <= 1; j+= 2)
+		{
+			vec2 tc = vec2(i, j)*0.75+gi_norm.xy*nz.z;
+			tc += nz.xy*2.0;
+			tc *= gi_sample_width*0.25;
+			tc += gi_c.xy;
+			
+			vec3 lnorm = -(texture2D(normalGIMap, tc.xy).xyz*2.0-1.0);
+			vec3 lpos = getGIPosition(tc.xy).xyz;
+							
+			vec3 at = lpos-gi_pos.xyz;
+			float dist = length(at);
+			float dist_atten = clamp(1.0/(gi_attenuation*dist), 0.0, 1.0);
+			
+						
+			if (dist_atten > 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;		
+						
+						float da = 0.0;
+												
+						//contribution from indirect source to visible pixel
+						vec3 ha = at;
+						ha.z -= 1.0;
+						ha = normalize(ha);
+						if (spec.a > 0.0)
+						{
+							float sa = dot(ha,lnorm);
+							da = texture2D(lightFunc, vec2(sa, spec.a)).a;
+						}
+						else
+						{
+							da = -lnorm.z;
+						}
+						
+						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);
+							if (c_spec.a > 0.0)
+							{
+								float sa = dot(ha, gi_norm);
+								da = dist_atten*texture2D(lightFunc, vec2(sa, c_spec.a)).a;
+							}
+							else
+							{
+								da = dist_atten*dot(gi_norm, normalize(ldir));
+							}
+							fda += da;
+							fdiff += da*(c_spec.rgb*c_spec.a*2.0+vec3(1,1,1))*diff.rgb;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	fdiff *= sunlight_color.rgb;
+	
+	vec3 ret = fda*fdiff;
+	
+	return clamp(ret,vec3(0.0), vec3(1.0));
+}
+
+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);
+	
+	vec3 ambient = da > 0.0 ? giAmbient(pos.xyz, norm) : vec3(0);
+	
+		
+	gl_FragData[0].xyz = mix(vec3(0), ambient, da);
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/giFinalF.glsl b/indra/newview/app_settings/shaders/class3/deferred/giFinalF.glsl
new file mode 100644
index 0000000000..e0eeebf8b6
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/giFinalF.glsl
@@ -0,0 +1,25 @@
+/** 
+ * @file giFinalF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2D	  bloomMap;
+uniform sampler2DRect edgeMap;
+
+uniform vec2 screen_res;
+varying vec2 vary_fragcoord;
+
+
+void main() 
+{
+	vec4 bloom = texture2D(bloomMap, vary_fragcoord.xy/screen_res);
+	vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
+	
+	gl_FragColor = bloom + diff;
+	//gl_FragColor.rgb = vec3(texture2DRect(edgeMap, vary_fragcoord.xy).a);
+}
\ No newline at end of file
diff --git a/indra/newview/app_settings/shaders/class3/deferred/giFinalV.glsl b/indra/newview/app_settings/shaders/class3/deferred/giFinalV.glsl
new file mode 100644
index 0000000000..41a29c31bd
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/giFinalV.glsl
@@ -0,0 +1,17 @@
+/** 
+ * @file giFinalV.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/indra/newview/app_settings/shaders/class3/deferred/giV.glsl b/indra/newview/app_settings/shaders/class3/deferred/giV.glsl
new file mode 100644
index 0000000000..71dcea9628
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class3/deferred/luminanceF.glsl b/indra/newview/app_settings/shaders/class3/deferred/luminanceF.glsl
new file mode 100644
index 0000000000..406a7e07cf
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/luminanceF.glsl
@@ -0,0 +1,19 @@
+/** 
+ * @file luminanceF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect lightMap;
+uniform sampler2DRect diffuseRect;
+
+varying vec2 vary_fragcoord;
+void main() 
+{
+	float i = texture2DRect(lightMap, vary_fragcoord.xy).r;
+	gl_FragColor.rgb = vec3(i);
+	gl_FragColor.a = 1.0;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/luminanceV.glsl b/indra/newview/app_settings/shaders/class3/deferred/luminanceV.glsl
new file mode 100644
index 0000000000..db8775f024
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class3/deferred/postDeferredF.glsl b/indra/newview/app_settings/shaders/class3/deferred/postDeferredF.glsl
new file mode 100644
index 0000000000..5e69bf36d9
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/postDeferredF.glsl
@@ -0,0 +1,80 @@
+/** 
+ * @file postDeferredF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+ 
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+
+uniform sampler2DRect localLightMap;
+uniform sampler2DRect sunLightMap;
+uniform sampler2DRect giLightMap;
+uniform sampler2DRect edgeMap;
+
+uniform sampler2D	  luminanceMap;
+
+uniform sampler2DRect lightMap;
+
+uniform sampler2D	  lightFunc;
+uniform sampler2D	  noiseMap;
+
+uniform float sun_lum_scale;
+uniform float sun_lum_offset;
+uniform float lum_scale;
+uniform float lum_lod;
+uniform vec4 ambient;
+uniform float gi_brightness;
+uniform float gi_luminance;
+
+uniform vec4 sunlight_color;
+
+uniform vec2 screen_res;
+varying vec2 vary_fragcoord;
+
+void main() 
+{
+	vec2 tc = vary_fragcoord.xy;
+	vec4 lcol = texture2DLod(luminanceMap, vec2(0.5, 0.5), lum_lod);
+	
+	vec3 gi_col = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+	vec4 sun_col =	texture2DRect(sunLightMap, vary_fragcoord.xy);
+	vec3 local_col = texture2DRect(localLightMap, vary_fragcoord.xy).rgb;
+	
+	float scol = texture2DRect(lightMap, vary_fragcoord.xy).r;
+			
+	vec3 diff = texture2DRect(diffuseRect, vary_fragcoord.xy).rgb;
+	vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+	
+	gi_col = gi_col*(diff.rgb+spec.rgb*spec.a);
+
+	float lum = 1.0-clamp(pow(lcol.r, gi_brightness)+sun_lum_offset, 0.0, 1.0);
+	
+	lum *= sun_lum_scale;
+	
+	sun_col *= 1.0+(lum*lum_scale*scol);
+					  
+	vec4 col;
+	col.rgb = gi_col+sun_col.rgb+local_col;
+	
+	col.a = sun_col.a;
+	
+	vec3 bcol = vec3(0,0,0);
+	float tweight = 0.0;
+	for (int i = 0; i < 16; i++)
+	{
+		float weight = (float(i)+1.0)/2.0;
+		bcol += texture2DLod(luminanceMap, vary_fragcoord.xy/screen_res, weight).rgb*weight*weight*weight;
+		tweight += weight*weight;
+	}
+	
+	bcol /= tweight;
+	bcol *= gi_luminance;
+	col.rgb += bcol*lum;
+	
+	gl_FragColor = col;
+	//gl_FragColor.rgb = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/postDeferredV.glsl b/indra/newview/app_settings/shaders/class3/deferred/postDeferredV.glsl
new file mode 100644
index 0000000000..9819232fd5
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class3/deferred/postgiF.glsl b/indra/newview/app_settings/shaders/class3/deferred/postgiF.glsl
new file mode 100644
index 0000000000..901b60af59
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/postgiF.glsl
@@ -0,0 +1,69 @@
+/** 
+ * @file postgiF.glsl
+ *
+ * Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2DRect giLightMap;
+uniform sampler2D	noiseMap;
+uniform sampler2D	giMip;
+uniform sampler2DRect edgeMap;
+
+
+uniform vec2 delta;
+uniform float kern_scale;
+uniform float gi_edge_weight;
+uniform float gi_blur_brightness;
+
+varying vec2 vary_fragcoord;
+
+void main() 
+{
+	vec2 dlt = kern_scale*delta;
+	float defined_weight = 0.0; 
+	vec3 col = vec3(0.0); 
+	
+	float e = 1.0;
+	
+	for (int i = 1; i < 8; i++)
+	{
+		vec2 tc = vary_fragcoord.xy + float(i) * dlt;
+		
+		e = max(e, 0.0);
+		float wght = e;
+		
+	   	col += texture2DRect(giLightMap, tc).rgb*wght;
+		defined_weight += wght;
+				
+		e *= e;
+		e -=(texture2DRect(edgeMap, tc.xy-dlt*0.25).a+
+			texture2DRect(edgeMap, tc.xy+dlt*0.25).a)*gi_edge_weight;
+	}
+
+	e = 1.0;
+	
+	for (int i = 1; i < 8; i++)
+	{
+		vec2 tc = vary_fragcoord.xy - float(i) * dlt;
+		
+		e = max(e,0.0);
+		float wght = e;
+		
+	   	col += texture2DRect(giLightMap, tc).rgb*wght;
+		defined_weight += wght;
+	
+		e *= e;
+		e -= (texture2DRect(edgeMap, tc.xy-dlt*0.25).a+
+			texture2DRect(edgeMap, tc.xy+dlt*0.25).a)*gi_edge_weight;
+		
+	}
+	
+	col /= max(defined_weight, 0.01);
+
+	gl_FragColor.rgb = col * gi_blur_brightness;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/postgiV.glsl b/indra/newview/app_settings/shaders/class3/deferred/postgiV.glsl
new file mode 100644
index 0000000000..6adcda82a3
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
new file mode 100644
index 0000000000..96a083b522
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -0,0 +1,297 @@
+/** 
+ * @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;
+uniform float gi_ambiance;
+
+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*gi_ambiance + (vec4(1.) - ambient*gi_ambiance) * 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);
+	
+	da = texture2D(lightFunc, vec2(da, 0.0)).a;
+		
+	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/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
new file mode 100644
index 0000000000..ad8af4780d
--- /dev/null
+++ b/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/indra/newview/app_settings/shaders/class3/deferred/treeF.glsl b/indra/newview/app_settings/shaders/class3/deferred/treeF.glsl
new file mode 100644
index 0000000000..258acee08c
--- /dev/null
+++ b/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);
+}