Merged in SL-18332 (pull request #1194)

First pass of Screen Space Reflections

Approved-by: Dave Parks

27 files changed, 336 insertions, 124 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/aoUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/aoUtil.glsl
index 23adbded5e..f93ed6bc6d 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/aoUtil.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/aoUtil.glsl
@@ -24,8 +24,8 @@
  */
 
 uniform sampler2D       noiseMap;
-uniform sampler2DRect   normalMap;
-uniform sampler2DRect   depthMap;
+uniform sampler2D   normalMap;
+uniform sampler2D   depthMap;
 
 uniform float ssao_radius;
 uniform float ssao_max_radius;
@@ -38,23 +38,19 @@ uniform vec2 screen_res;
 vec2 getScreenCoordinateAo(vec2 screenpos)
 {
     vec2 sc = screenpos.xy * 2.0;
-    if (screen_res.x > 0 && screen_res.y > 0)
-    {
-       sc /= screen_res;
-    }
     return sc - vec2(1.0, 1.0);
 }
 
 float getDepthAo(vec2 pos_screen)
 {
-    float depth = texture2DRect(depthMap, pos_screen).r;
+    float depth = texture2D(depthMap, pos_screen).r;
     return depth;
 }
 
 vec4 getPositionAo(vec2 pos_screen)
 {
     float depth = getDepthAo(pos_screen);
-    vec2 sc = getScreenCoordinateAo(pos_screen);
+    vec2 sc = (pos_screen);
     vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
     vec4 pos = inv_proj * ndc;
     pos /= pos.w;
@@ -83,7 +79,7 @@ float calcAmbientOcclusion(vec4 pos, vec3 norm, vec2 pos_screen)
 {
     float ret = 1.0;
     vec3 pos_world = pos.xyz;
-    vec2 noise_reflect = texture2D(noiseMap, pos_screen.xy/128.0).xy;
+    vec2 noise_reflect = texture2D(noiseMap, pos_screen.xy).xy;
         
     float angle_hidden = 0.0;
     float points = 0;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
index fa3634f3b6..9bead273ff 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
@@ -33,8 +33,8 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect normalMap;
-uniform sampler2DRect lightMap;
+uniform sampler2D normalMap;
+uniform sampler2D lightMap;
 
 uniform float dist_factor;
 uniform float blur_size;
@@ -52,7 +52,7 @@ void main()
     vec2 tc = vary_fragcoord.xy;
     vec3 norm = getNorm(tc);
     vec3 pos = getPosition(tc).xyz;
-    vec4 ccol = texture2DRect(lightMap, tc).rgba;
+    vec4 ccol = texture2D(lightMap, tc).rgba;
     
     vec2 dlt = kern_scale * delta / (1.0+norm.xy*norm.xy);
     dlt /= max(-pos.z*dist_factor, 1.0);
@@ -89,7 +89,7 @@ void main()
         
         if (d*d <= pointplanedist_tolerance_pow2)
         {
-            col += texture2DRect(lightMap, samptc)*k[i].xyxx;
+            col += texture2D(lightMap, samptc)*k[i].xyxx;
             defined_weight += k[i].xy;
         }
     }
@@ -103,7 +103,7 @@ void main()
         
         if (d*d <= pointplanedist_tolerance_pow2)
         {
-            col += texture2DRect(lightMap, samptc)*k[i].xyxx;
+            col += texture2D(lightMap, samptc)*k[i].xyxx;
             defined_weight += k[i].xy;
         }
     }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/blurLightV.glsl b/indra/newview/app_settings/shaders/class1/deferred/blurLightV.glsl
index 212f7e56ad..5e0f01981b 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/blurLightV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/blurLightV.glsl
@@ -23,8 +23,6 @@
  * $/LicenseInfo$
  */
 
-uniform mat4 modelview_projection_matrix;
-
 ATTRIBUTE vec3 position;
 
 VARYING vec2 vary_fragcoord;
@@ -33,7 +31,7 @@ uniform vec2 screen_res;
 void main()
 {
 	//transform vertex
-	vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
+	vec4 pos = vec4(position.xyz, 1.0);
 	gl_Position = pos; 
-	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+	vary_fragcoord = (pos.xy*0.5+0.5);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/cofF.glsl b/indra/newview/app_settings/shaders/class1/deferred/cofF.glsl
index 079d8458c9..1e640d95ae 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/cofF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/cofF.glsl
@@ -33,8 +33,8 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect depthMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D depthMap;
 uniform sampler2D bloomMap;
 
 uniform float depth_cutoff;
@@ -69,19 +69,19 @@ void main()
 {
 	vec2 tc = vary_fragcoord.xy;
 
-    float z = texture2DRect(depthMap, tc).r;
+    float z = texture2D(depthMap, tc).r;
 	z = z*2.0-1.0;
 	vec4 ndc = vec4(0.0, 0.0, z, 1.0);
 	vec4 p = inv_proj*ndc;
 	float depth = p.z/p.w;
 	
-	vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
+	vec4 diff = texture2D(diffuseRect, vary_fragcoord.xy);
 	
 	float sc = calc_cof(depth);
 	sc = min(sc, max_cof);
 	sc = max(sc, -max_cof);
 	
-	vec4 bloom = texture2D(bloomMap, vary_fragcoord.xy/screen_res);
+	vec4 bloom = texture2D(bloomMap, vary_fragcoord.xy);
 	frag_color.rgb = diff.rgb + bloom.rgb;
 	frag_color.a = sc/max_cof*0.5+0.5;
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl
index 1a96ee0736..c87e754eca 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl
@@ -48,8 +48,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-uniform sampler2DRect   normalMap;
-uniform sampler2DRect   depthMap;
+uniform sampler2D   normalMap;
+uniform sampler2D   depthMap;
 uniform sampler2D projectionMap; // rgba
 uniform sampler2D brdfLut;
 
@@ -138,10 +138,6 @@ bool clipProjectedLightVars(vec3 light_center, vec3 pos, out float dist, out flo
 vec2 getScreenCoordinate(vec2 screenpos)
 {
     vec2 sc = screenpos.xy * 2.0;
-    if (screen_res.x > 0 && screen_res.y > 0)
-    {
-       sc /= screen_res;
-    }
     return sc - vec2(1.0, 1.0);
 }
 
@@ -149,7 +145,7 @@ vec2 getScreenCoordinate(vec2 screenpos)
 //      Method #4: Spheremap Transform, Lambert Azimuthal Equal-Area projection
 vec3 getNorm(vec2 screenpos)
 {
-   vec2 enc = texture2DRect(normalMap, screenpos.xy).xy;
+   vec2 enc = texture2D(normalMap, screenpos.xy).xy;
    vec2 fenc = enc*4-2;
    float f = dot(fenc,fenc);
    float g = sqrt(1-f/4);
@@ -175,7 +171,7 @@ vec3 getNormalFromPacked(vec4 packedNormalEnvIntensityFlags)
 // See: C++: addDeferredAttachments(), GLSL: softenLightF
 vec4 getNormalEnvIntensityFlags(vec2 screenpos, out vec3 n, out float envIntensity)
 {
-    vec4 packedNormalEnvIntensityFlags = texture2DRect(normalMap, screenpos.xy);
+    vec4 packedNormalEnvIntensityFlags = texture2D(normalMap, screenpos.xy);
     n = getNormalFromPacked( packedNormalEnvIntensityFlags );
     envIntensity = packedNormalEnvIntensityFlags.z;
     return packedNormalEnvIntensityFlags;
@@ -188,9 +184,14 @@ float linearDepth(float d, float znear, float zfar)
     return znear * 2.0 * zfar / (zfar + znear - d * (zfar - znear));
 }
 
+float linearDepth01(float d, float znear, float zfar)
+{
+    return linearDepth(d, znear, zfar) / zfar;
+}
+
 float getDepth(vec2 pos_screen)
 {
-    float depth = texture2DRect(depthMap, pos_screen).r;
+    float depth = texture2D(depthMap, pos_screen).r;
     return depth;
 }
 
@@ -333,6 +334,14 @@ vec4 getPositionWithDepth(vec2 pos_screen, float depth)
     return vec4(getPositionWithNDC(ndc), 1.0);
 }
 
+vec2 getScreenCoord(vec4 clip)
+{
+    vec4 ndc = clip;
+         ndc.xyz /= clip.w;
+    vec2 screen = vec2( ndc.xy * 0.5 );
+         screen += 0.5;
+    return screen;
+}
 
 vec2 getScreenXY(vec4 clip)
 {
diff --git a/indra/newview/app_settings/shaders/class1/deferred/dofCombineF.glsl b/indra/newview/app_settings/shaders/class1/deferred/dofCombineF.glsl
index 8d48bb016b..d9c0e590c8 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/dofCombineF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/dofCombineF.glsl
@@ -33,8 +33,8 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect lightMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D lightMap;
 
 uniform mat4 inv_proj;
 uniform vec2 screen_res;
@@ -46,12 +46,12 @@ uniform float dof_height;
 
 VARYING vec2 vary_fragcoord;
 
-vec4 dofSample(sampler2DRect tex, vec2 tc)
+vec4 dofSample(sampler2D tex, vec2 tc)
 {
 	tc.x = min(tc.x, dof_width);
 	tc.y = min(tc.y, dof_height);
 
-	return texture2DRect(tex, tc);
+	return texture2D(tex, tc);
 }
 
 void main() 
@@ -60,7 +60,7 @@ void main()
 	
 	vec4 dof = dofSample(diffuseRect, vary_fragcoord.xy*res_scale);
 	
-	vec4 diff = texture2DRect(lightMap, vary_fragcoord.xy);
+	vec4 diff = texture2D(lightMap, vary_fragcoord.xy);
 
 	float a = min(abs(diff.a*2.0-1.0) * max_cof*res_scale*res_scale, 1.0);
 
@@ -69,10 +69,10 @@ void main()
 		float sc = a/res_scale;
 		
 		vec4 col;
-		col = texture2DRect(lightMap, vary_fragcoord.xy+vec2(sc,sc));
-		col += texture2DRect(lightMap, vary_fragcoord.xy+vec2(-sc,sc));
-		col += texture2DRect(lightMap, vary_fragcoord.xy+vec2(sc,-sc));
-		col += texture2DRect(lightMap, vary_fragcoord.xy+vec2(-sc,-sc));
+		col = texture2D(lightMap, vary_fragcoord.xy+vec2(sc,sc)/screen_res);
+		col += texture2D(lightMap, vary_fragcoord.xy+vec2(-sc,sc)/screen_res);
+		col += texture2D(lightMap, vary_fragcoord.xy+vec2(sc,-sc)/screen_res);
+		col += texture2D(lightMap, vary_fragcoord.xy+vec2(-sc,-sc)/screen_res);
 		
 		diff = mix(diff, col*0.25, a);
 	}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl b/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl
index be1003a7e0..185c1150ef 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl
@@ -31,10 +31,10 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseMap;
+uniform sampler2D diffuseMap;
 VARYING vec2 vary_fragcoord;
 
 void main() 
 {
-	frag_color = texture2DRect(diffuseMap, vary_fragcoord.xy);
+	frag_color = texture2D(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
index f2dc60aa5d..5488a63c6a 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/luminanceV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/luminanceV.glsl
@@ -39,7 +39,7 @@ void main()
 	vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
 	gl_Position = pos;
 	
-	vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;	
+	vary_fragcoord = (pos.xy * 0.5 + 0.5);	
 
 	vertex_color = diffuse_color;
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
index 0ae4bbfc5d..8feeff848b 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
@@ -33,9 +33,9 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect depthMap;
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
+uniform sampler2D depthMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
 uniform sampler2D     noiseMap;
 uniform sampler2D     lightFunc;
 
@@ -54,6 +54,8 @@ VARYING vec4 vary_fragcoord;
 vec4 getPosition(vec2 pos_screen);
 vec3 getNorm(vec2 pos_screen);
 vec3 srgb_to_linear(vec3 c);
+float getDepth(vec2 tc);
+vec2 getScreenCoord(vec4 clip);
 
 void main()
 {
@@ -62,7 +64,7 @@ void main()
 #endif
 
     vec3 out_col = vec3(0, 0, 0);
-    vec2 frag    = (vary_fragcoord.xy * 0.5 + 0.5) * screen_res;
+    vec2 frag    = getScreenCoord(vary_fragcoord);
     vec3 pos     = getPosition(frag.xy).xyz;
     if (pos.z < far_z)
     {
@@ -71,8 +73,8 @@ void main()
 
     vec3 norm = getNorm(frag.xy);
 
-    vec4 spec = texture2DRect(specularRect, frag.xy);
-    vec3 diff = texture2DRect(diffuseRect, frag.xy).rgb;
+    vec4 spec = texture2D(specularRect, frag.xy);
+    vec3 diff = texture2D(diffuseRect, frag.xy).rgb;
 
     float noise = texture2D(noiseMap, frag.xy / 128.0).b;
     vec3  npos  = normalize(-pos);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/multiPointLightV.glsl b/indra/newview/app_settings/shaders/class1/deferred/multiPointLightV.glsl
index eefefa640d..d71dc76423 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/multiPointLightV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/multiPointLightV.glsl
@@ -23,8 +23,6 @@
  * $/LicenseInfo$
  */
 
-uniform mat4 modelview_projection_matrix;
-
 ATTRIBUTE vec3 position;
 
 VARYING vec4 vary_fragcoord;
@@ -32,7 +30,7 @@ VARYING vec4 vary_fragcoord;
 void main()
 {
 	//transform vertex
-	vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
+	vec4 pos = vec4(position.xyz, 1.0);
 	vary_fragcoord = pos;
 
 	gl_Position = pos;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
index 8dcc18080d..42a52d7908 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
@@ -38,10 +38,10 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect depthMap;
-uniform sampler2DRect normalMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D depthMap;
+uniform sampler2D normalMap;
 uniform sampler2D noiseMap;
 uniform sampler2D projectionMap;
 uniform sampler2D lightFunc;
@@ -72,6 +72,7 @@ uniform vec2 screen_res;
 uniform mat4 inv_proj;
 vec3 getNorm(vec2 pos_screen);
 vec3 srgb_to_linear(vec3 c);
+float getDepth(vec2 tc);
 
 vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
 {
@@ -137,7 +138,6 @@ 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 = center.xyz-pos.xyz;
@@ -148,7 +148,7 @@ void main()
 		discard;
 	}
 		
-	float envIntensity = texture2DRect(normalMap, frag.xy).z;
+	float envIntensity = texture2D(normalMap, frag.xy).z;
 	vec3 norm = getNorm(frag.xy);
 
 	float l_dist = -dot(lv, proj_n);
@@ -180,7 +180,7 @@ void main()
 	float da = dot(norm, lv);
 		
 		
-	vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
+	vec3 diff_tex = texture2D(diffuseRect, frag.xy).rgb;
 
 	vec3 dlit = vec3(0, 0, 0);
 	
@@ -220,7 +220,7 @@ void main()
 	}
 	
 	
-	vec4 spec = texture2DRect(specularRect, frag.xy);
+	vec4 spec = texture2D(specularRect, frag.xy);
 	
 	if (spec.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 5bb034d5c1..40a4f86c37 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
@@ -33,12 +33,12 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect normalMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D normalMap;
 uniform sampler2D noiseMap;
 uniform sampler2D lightFunc;
-uniform sampler2DRect depthMap;
+uniform sampler2D depthMap;
 
 uniform vec3 env_mat[3];
 uniform float sun_wash;
@@ -57,6 +57,7 @@ uniform vec4 viewport;
 
 vec3 getNorm(vec2 pos_screen);
 vec4 getPosition(vec2 pos_screen);
+float getDepth(vec2 pos);
 vec3 srgb_to_linear(vec3 c);
 
 void main() 
@@ -64,7 +65,6 @@ 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 = trans_center.xyz-pos;
@@ -88,7 +88,7 @@ void main()
     
     float noise = texture2D(noiseMap, frag.xy/128.0).b;
     
-    vec3 col = texture2DRect(diffuseRect, frag.xy).rgb;
+    vec3 col = texture2D(diffuseRect, frag.xy).rgb;
 
     float fa = falloff+1.0;
     float dist_atten = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
@@ -99,7 +99,7 @@ void main()
 
     col = color.rgb*lit*col;
 
-    vec4 spec = texture2DRect(specularRect, frag.xy);
+    vec4 spec = texture2D(specularRect, frag.xy);
     if (spec.a > 0.0)
     {
         lit = min(da*6.0, 1.0) * dist_atten;
@@ -125,6 +125,7 @@ void main()
     {
         discard;
     }
+    final_color.rgb = vec3(getDepth(frag.xy));
 
     frag_color.rgb = col;   
     frag_color.a = 0.0;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl
index f06f8c870b..5ca39d6966 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
+uniform sampler2D diffuseRect;
 
 uniform mat4 inv_proj;
 uniform vec2 screen_res;
@@ -44,7 +44,7 @@ VARYING vec2 vary_fragcoord;
 
 void dofSample(inout vec4 diff, inout float w, float min_sc, vec2 tc)
 {
-	vec4 s = texture2DRect(diffuseRect, tc);
+	vec4 s = texture2D(diffuseRect, tc);
 
 	float sc = abs(s.a*2.0-1.0)*max_cof;
 
@@ -63,7 +63,7 @@ void dofSample(inout vec4 diff, inout float w, float min_sc, vec2 tc)
 
 void dofSampleNear(inout vec4 diff, inout float w, float min_sc, vec2 tc)
 {
-	vec4 s = texture2DRect(diffuseRect, tc);
+	vec4 s = texture2D(diffuseRect, tc);
 
 	float wg = 0.25;
 
@@ -79,7 +79,7 @@ void main()
 {
 	vec2 tc = vary_fragcoord.xy;
 	
-	vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
+	vec4 diff = texture2D(diffuseRect, vary_fragcoord.xy);
 	
 	{ 
 		float w = 1.0;
@@ -93,14 +93,14 @@ void main()
 		{
 			while (sc > 0.5)
 			{
-				int its = int(max(1.0,(sc*3.7)));
+				int its = int(max(1.0,(sc*3.7)));	
 				for (int i=0; i<its; ++i)
 				{
 					float ang = sc+i*2*PI/its; // sc is added for rotary perturbance
 					float samp_x = sc*sin(ang);
 					float samp_y = sc*cos(ang);
 					// you could test sample coords against an interesting non-circular aperture shape here, if desired.
-					dofSampleNear(diff, w, sc, vary_fragcoord.xy + vec2(samp_x,samp_y));
+					dofSampleNear(diff, w, sc, vary_fragcoord.xy + (vec2(samp_x,samp_y) / screen_res));
 				}
 				sc -= 1.0;
 			}
@@ -117,7 +117,7 @@ void main()
 					float samp_x = sc*sin(ang);
 					float samp_y = sc*cos(ang);
 					// you could test sample coords against an interesting non-circular aperture shape here, if desired.
-					dofSample(diff, w, sc, vary_fragcoord.xy + vec2(samp_x,samp_y));
+					dofSample(diff, w, sc, vary_fragcoord.xy + (vec2(samp_x,samp_y) / screen_res));
 				}
 				sc -= 1.0;
 			}
@@ -125,6 +125,6 @@ void main()
 
 		diff /= w;
 	}
-		
+	
 	frag_color = diff;
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
index b61f37fe47..a73a59bc6f 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
+uniform sampler2D diffuseRect;
 
 uniform vec2 screen_res;
 VARYING vec2 vary_fragcoord;
@@ -82,7 +82,7 @@ float noise(vec2 x) {
 void main() 
 {
     //this is the one of the rare spots where diffuseRect contains linear color values (not sRGB)
-    vec4 diff = texture2DRect(diffuseRect, vary_fragcoord);
+    vec4 diff = texture2D(diffuseRect, vary_fragcoord);
     diff.rgb = linear_to_srgb(diff.rgb);
     vec3 seed = (diff.rgb+vec3(1.0))*vec3(vary_fragcoord.xy, vary_fragcoord.x+vary_fragcoord.y);
     vec3 nz = vec3(noise(seed.rg), noise(seed.gb), noise(seed.rb));
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl
index 058941bfb2..a79f644aef 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
+uniform sampler2D diffuseRect;
 uniform sampler2D bloomMap;
 
 uniform vec2 screen_res;
@@ -41,9 +41,9 @@ VARYING vec2 vary_fragcoord;
 
 void main() 
 {
-	vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
+	vec4 diff = texture2D(diffuseRect, vary_fragcoord.xy);
 	
-	vec4 bloom = texture2D(bloomMap, vary_fragcoord.xy/screen_res);
+	vec4 bloom = texture2D(bloomMap, vary_fragcoord.xy);
 	frag_color = diff + bloom;
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoTCV.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoTCV.glsl
index bd0cb50464..4d24b4de9a 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoTCV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoTCV.glsl
@@ -23,8 +23,6 @@
  * $/LicenseInfo$
  */
 
-uniform mat4 modelview_projection_matrix;
-
 ATTRIBUTE vec3 position;
 
 VARYING vec2 vary_fragcoord;
@@ -34,7 +32,7 @@ uniform vec2 screen_res;
 void main()
 {
 	//transform vertex
-	vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
+	vec4 pos = vec4(position.xyz, 1.0);
 	gl_Position = pos;	
-	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+	vary_fragcoord = (pos.xy*0.5+0.5);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl
index 8edf5b2723..86f0077edb 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl
@@ -23,8 +23,6 @@
  * $/LicenseInfo$
  */
 
-uniform mat4 modelview_projection_matrix;
-
 ATTRIBUTE vec3 position;
 
 VARYING vec2 vary_fragcoord;
@@ -37,8 +35,8 @@ uniform vec2 screen_res;
 void main()
 {
 	//transform vertex
-	vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
+	vec4 pos = vec4(position.xyz, 1.0);
 	gl_Position = pos;	
 	vary_tc = (pos.xy*0.5+0.5)*tc_scale;
-	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+	vary_fragcoord = (pos.xy*0.5+0.5);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl b/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl
index cf994d3547..8111f43c28 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl
@@ -31,9 +31,9 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
  
-uniform sampler2DRect depthMap;
-uniform sampler2DRect normalMap;
-uniform sampler2DRect giLightMap;
+uniform sampler2D depthMap;
+uniform sampler2D normalMap;
+uniform sampler2D giLightMap;
 uniform sampler2D	noiseMap;
 
 uniform vec2 kern[32];
@@ -53,11 +53,11 @@ vec4 getPosition(vec2 pos_screen);
 
 void main() 
 {
-	vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz;
+	vec3 norm = texture2D(normalMap, vary_fragcoord.xy).xyz;
 	norm = vec3((norm.xy-0.5)*2.0,norm.z); // unpack norm
 	vec3 pos = getPosition(vary_fragcoord.xy).xyz;
 	
-	vec3 ccol = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+	vec3 ccol = texture2D(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;
@@ -66,7 +66,7 @@ void main()
 	for (int i = 0; i < kern_length; i++)
 	{
 		vec2 tc = vary_fragcoord.xy + kern[i].y*dlt;
-		vec3 sampNorm = texture2DRect(normalMap, tc.xy).xyz;
+		vec3 sampNorm = texture2D(normalMap, tc.xy).xyz;
 		sampNorm = vec3((sampNorm.xy-0.5)*2.0,sampNorm.z); // unpack norm
 	    
 		float d = dot(norm.xyz, sampNorm);
@@ -77,7 +77,7 @@ void main()
 			samppos -= pos;
 			if (dot(samppos,samppos) < -0.05*pos.z)
 			{
-	    		col += texture2DRect(giLightMap, tc).rgb*kern[i].x;
+	    		col += texture2D(giLightMap, tc).rgb*kern[i].x;
 				defined_weight += kern[i].x;
 			}
 		}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflPostF.glsl b/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflPostF.glsl
new file mode 100644
index 0000000000..8373567bb0
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflPostF.glsl
@@ -0,0 +1,57 @@
+/**
+ * @file class3/deferred/screenSpaceReflPostF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2007, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform vec2 screen_res;
+uniform mat4 projection_matrix;
+uniform mat4 inv_proj;
+uniform float zNear;
+uniform float zFar;
+
+VARYING vec2 vary_fragcoord;
+
+uniform sampler2D depthMap;
+uniform sampler2D normalMap;
+uniform sampler2D sceneMap;
+uniform sampler2D diffuseRect;
+
+vec3 getNorm(vec2 screenpos);
+float getDepth(vec2 pos_screen);
+float linearDepth(float d, float znear, float zfar);
+
+void main() {
+    vec2  tc = vary_fragcoord.xy;
+    vec4 pos = getPositionWithDepth(tc, getDepth(tc));
+    frag_color = pos;
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflPostV.glsl b/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflPostV.glsl
new file mode 100644
index 0000000000..966e7e1cbb
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflPostV.glsl
@@ -0,0 +1,39 @@
+/**
+ * @file class3/deferred/screenSpaceReflPostV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2007, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+ATTRIBUTE vec3 position;
+
+uniform vec2 screen_res;
+
+VARYING vec2 vary_fragcoord;
+
+void main()
+{
+	//transform vertex
+	vec4 pos = vec4(position.xyz, 1.0);
+	gl_Position = pos; 
+    
+	vary_fragcoord = pos.xy * 0.5 + 0.5;
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflUtil.glsl
new file mode 100644
index 0000000000..6dfc89a6c6
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/screenSpaceReflUtil.glsl
@@ -0,0 +1,120 @@
+/**
+ * @file class3/deferred/screenSpaceReflUtil.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2007, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+uniform sampler2D depthMap;
+uniform sampler2D normalMap;
+uniform sampler2D sceneMap;
+uniform vec2 screen_res;
+uniform mat4 projection_matrix;
+
+// Shamelessly taken from http://casual-effects.blogspot.com/2014/08/screen-space-ray-tracing.html
+// Original paper: https://jcgt.org/published/0003/04/04/
+// By Morgan McGuire and Michael Mara at Williams College 2014
+// Released as open source under the BSD 2-Clause License
+// http://opensource.org/licenses/BSD-2-Clause
+
+float distanceSquared(vec2 a, vec2 b) { a -= b; return dot(a, a); }
+
+bool traceScreenSpaceRay1(vec3 csOrig, vec3 csDir, mat4 proj, float zThickness, 
+                            float nearPlaneZ, float stride, float jitter, const float maxSteps, float maxDistance,
+                            out vec2 hitPixel, out vec3 hitPoint)
+{
+
+    // Clip to the near plane    
+    float rayLength = ((csOrig.z + csDir.z * maxDistance) > nearPlaneZ) ?
+        (nearPlaneZ - csOrig.z) / csDir.z : maxDistance;
+    vec3 csEndPoint = csOrig + csDir * rayLength;
+
+    // Project into homogeneous clip space
+    vec4 H0 = proj * vec4(csOrig, 1.0);
+    vec4 H1 = proj * vec4(csEndPoint, 1.0);
+    float k0 = 1.0 / H0.w, k1 = 1.0 / H1.w;
+
+    // The interpolated homogeneous version of the camera-space points  
+    vec3 Q0 = csOrig * k0, Q1 = csEndPoint * k1;
+
+    // Screen-space endpoints
+    vec2 P0 = H0.xy * k0, P1 = H1.xy * k1;
+
+    // If the line is degenerate, make it cover at least one pixel
+    // to avoid handling zero-pixel extent as a special case later
+    P1 += vec2((distanceSquared(P0, P1) < 0.0001) ? 0.01 : 0.0);
+    vec2 delta = P1 - P0;
+
+    // Permute so that the primary iteration is in x to collapse
+    // all quadrant-specific DDA cases later
+    bool permute = false;
+    if (abs(delta.x) < abs(delta.y)) { 
+        // This is a more-vertical line
+        permute = true; delta = delta.yx; P0 = P0.yx; P1 = P1.yx; 
+    }
+
+    float stepDir = sign(delta.x);
+    float invdx = stepDir / delta.x;
+
+    // Track the derivatives of Q and k
+    vec3  dQ = (Q1 - Q0) * invdx;
+    float dk = (k1 - k0) * invdx;
+    vec2  dP = vec2(stepDir, delta.y * invdx);
+
+    // Scale derivatives by the desired pixel stride and then
+    // offset the starting values by the jitter fraction
+    dP *= stride; dQ *= stride; dk *= stride;
+    P0 += dP * jitter; Q0 += dQ * jitter; k0 += dk * jitter;
+
+    // Slide P from P0 to P1, (now-homogeneous) Q from Q0 to Q1, k from k0 to k1
+    vec3 Q = Q0; 
+
+    // Adjust end condition for iteration direction
+    float  end = P1.x * stepDir;
+
+    float k = k0, stepCount = 0.0, prevZMaxEstimate = csOrig.z;
+    float rayZMin = prevZMaxEstimate, rayZMax = prevZMaxEstimate;
+    float sceneZMax = rayZMax + 100;
+    for (vec2 P = P0; 
+         ((P.x * stepDir) <= end) && (stepCount < maxSteps) &&
+         ((rayZMax < sceneZMax - zThickness) || (rayZMin > sceneZMax)) &&
+          (sceneZMax != 0); 
+         P += dP, Q.z += dQ.z, k += dk, ++stepCount) {
+        
+        rayZMin = prevZMaxEstimate;
+        rayZMax = (dQ.z * 0.5 + Q.z) / (dk * 0.5 + k);
+        prevZMaxEstimate = rayZMax;
+        if (rayZMin > rayZMax) { 
+           float t = rayZMin; rayZMin = rayZMax; rayZMax = t;
+        }
+
+        hitPixel = permute ? P.yx : P;
+        hitPixel.y = screen_res.y - hitPixel.y;
+        // You may need hitPixel.y = screen_res.y - hitPixel.y; here if your vertical axis
+        // is different than ours in screen space
+        sceneZMax = texelFetch(depthMap, ivec2(hitPixel)).r;
+    }
+    
+    // Advance Q based on the number of steps
+    Q.xy += dQ.xy * stepCount;
+    hitPoint = Q * (1.0 / k);
+    return (rayZMax >= sceneZMax - zThickness) && (rayZMin < sceneZMax);
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl
index 4134220306..5dc219702d 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl
@@ -23,8 +23,8 @@
  * $/LicenseInfo$
  */
 
-uniform sampler2DRect   normalMap;
-uniform sampler2DRect   depthMap;
+uniform sampler2D   normalMap;
+uniform sampler2D   depthMap;
 uniform sampler2DShadow shadowMap0;
 uniform sampler2DShadow shadowMap1;
 uniform sampler2DShadow shadowMap2;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index 4b34e55efd..152402907b 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -34,11 +34,11 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect normalMap;
-uniform sampler2DRect lightMap;
-uniform sampler2DRect depthMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D normalMap;
+uniform sampler2D lightMap;
+uniform sampler2D depthMap;
 uniform samplerCube environmentMap;
 uniform sampler2D     lightFunc;
 
@@ -58,6 +58,7 @@ uniform vec2 screen_res;
 
 vec3 getNorm(vec2 pos_screen);
 vec4 getPositionWithDepth(vec2 pos_screen, float depth);
+float getDepth(vec2 pos_screen);
 
 void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
 float getAmbientClamp();
@@ -76,9 +77,9 @@ vec4 applyWaterFogView(vec3 pos, vec4 color);
 void main() 
 {
     vec2 tc = vary_fragcoord.xy;
-    float depth = texture2DRect(depthMap, tc.xy).r;
+    float depth = getDepth(tc);
     vec4 pos = getPositionWithDepth(tc, depth);
-    vec4 norm = texture2DRect(normalMap, tc);
+    vec4 norm = texture2D(normalMap, tc);
     float envIntensity = norm.z;
     norm.xyz = getNorm(tc);
     
@@ -87,12 +88,12 @@ void main()
     float light_gamma = 1.0/1.3;
     da = pow(da, light_gamma);
     
-    vec4 diffuse = texture2DRect(diffuseRect, tc);
+    vec4 diffuse = texture2D(diffuseRect, tc);
 
     //convert to gamma space
     diffuse.rgb = linear_to_srgb(diffuse.rgb); // SL-14035
 
-    vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+    vec4 spec = texture2D(specularRect, vary_fragcoord.xy);
     vec3 color = vec3(0);
     float bloom = 0.0;
     {
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightV.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightV.glsl
index 8891315e15..23ad332db4 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightV.glsl
@@ -22,8 +22,6 @@
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
- 
-uniform mat4 modelview_projection_matrix;
 
 ATTRIBUTE vec3 position;
 
@@ -36,10 +34,10 @@ VARYING vec2 vary_fragcoord;
 void main()
 {
     //transform vertex
-    vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
+    vec4 pos = vec4(position.xyz, 1.0);
     gl_Position = pos; 
     // appease OSX GLSL compiler/linker by touching all the varyings we said we would
     setAtmosAttenuation(vec3(1));
     setAdditiveColor(vec3(0));
-    vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+    vary_fragcoord = (pos.xy*0.5+0.5);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
index 694b19cdfb..7f21a074bd 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
@@ -36,10 +36,10 @@ out vec4 frag_color;
 
 //class 1 -- no shadows
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect depthMap;
-uniform sampler2DRect normalMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D depthMap;
+uniform sampler2D normalMap;
 uniform samplerCube environmentMap;
 uniform sampler2D noiseMap;
 uniform sampler2D projectionMap;
@@ -137,7 +137,6 @@ 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 = trans_center.xyz-pos.xyz;
@@ -148,7 +147,7 @@ void main()
 		discard;
 	}
 		
-	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
+	vec3 norm = texture2D(normalMap, frag.xy).xyz;
 	float envIntensity = norm.z;
 	norm = getNorm(frag.xy);
 	norm = normalize(norm);
@@ -176,11 +175,11 @@ void main()
 	lv = normalize(lv);
 	float da = dot(norm, lv);
 		
-	vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
+	vec3 diff_tex = texture2D(diffuseRect, frag.xy).rgb;
 	//light shaders output linear and are gamma corrected later in postDeferredGammaCorrectF.glsl
     diff_tex.rgb = srgb_to_linear(diff_tex.rgb);
 
-	vec4 spec = texture2DRect(specularRect, frag.xy);
+	vec4 spec = texture2D(specularRect, frag.xy);
 
 	float noise = texture2D(noiseMap, frag.xy/128.0).b;
 	vec3 dlit = vec3(0, 0, 0);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/sunLightSSAOF.glsl b/indra/newview/app_settings/shaders/class1/deferred/sunLightSSAOF.glsl
index 15f141cbe5..d9a0b6c702 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/sunLightSSAOF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/sunLightSSAOF.glsl
@@ -35,7 +35,7 @@ out vec4 frag_color;
 
 //class 1 -- no shadow, SSAO only
 
-uniform sampler2DRect normalMap;
+uniform sampler2D normalMap;
 
 // Inputs
 VARYING vec2 vary_fragcoord;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/sunLightV.glsl b/indra/newview/app_settings/shaders/class1/deferred/sunLightV.glsl
index 473d6df8fa..9d70b9d98d 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/sunLightV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/sunLightV.glsl
@@ -22,8 +22,6 @@
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
-
-uniform mat4 modelview_projection_matrix;
  
 ATTRIBUTE vec3 position;
 
@@ -34,8 +32,8 @@ uniform vec2 screen_res;
 void main()
 {
 	//transform vertex
-	vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
+	vec4 pos = vec4(position.xyz, 1.0);
 	gl_Position = pos; 
 	
-	vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;	
+	vary_fragcoord = (pos.xy * 0.5 + 0.5);	
 }