Merged in SL-18332 (pull request #1194)

First pass of Screen Space Reflections

Approved-by: Dave Parks

68 files changed, 897 insertions, 353 deletions

diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 27de7070ff..0a834b28e3 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -84,6 +84,7 @@ LLShaderFeatures::LLShaderFeatures()
     , hasSrgb(false)
     , encodesNormal(false)
     , isDeferred(false)
+    , hasScreenSpaceReflections(false)
     , hasIndirect(false)
     , hasShadows(false)
     , hasAmbientOcclusion(false)
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 3401da832e..0df0531dce 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -54,6 +54,7 @@ public:
 	bool hasSrgb;
     bool encodesNormal; // include: shaders\class1\environment\encodeNormF.glsl
     bool isDeferred;
+    bool hasScreenSpaceReflections;
     bool hasIndirect;
 	S32 mIndexedTextureChannels;
 	bool disableTextureIndex;
diff --git a/indra/llrender/llpostprocess.cpp b/indra/llrender/llpostprocess.cpp
index 74154e5676..0d87800690 100644
--- a/indra/llrender/llpostprocess.cpp
+++ b/indra/llrender/llpostprocess.cpp
@@ -390,7 +390,7 @@ void LLPostProcess::doEffects(void)
 
 void LLPostProcess::copyFrameBuffer(U32 & texture, unsigned int width, unsigned int height)
 {
-	gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_RECT_TEXTURE, texture);
+	gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture);
 	glCopyTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_RGBA, 0, 0, width, height, 0);
 }
 
@@ -502,7 +502,7 @@ void LLPostProcess::createTexture(LLPointer<LLImageGL>& texture, unsigned int wi
 	texture = new LLImageGL(FALSE) ;	
 	if(texture->createGLTexture())
 	{
-		gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_RECT_TEXTURE, texture->getTexName());
+		gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture->getTexName());
 		glTexImage2D(GL_TEXTURE_RECTANGLE, 0, 4, width, height, 0,
 			GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
 		gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index 39e3a0243c..c58fbe6c8e 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -1087,13 +1087,20 @@ void LLRender::syncMatrices()
 		{ //update projection matrix, normal, and MVP
 			glh::matrix4f& mat = mMatrix[MM_PROJECTION][mMatIdx[MM_PROJECTION]];
 
-            // it would be nice to have this automatically track the state of the proj matrix
-            // but certain render paths (deferred lighting) require it to be mismatched *sigh*
-            //if (shader->getUniformLocation(LLShaderMgr::INVERSE_PROJECTION_MATRIX))
-            //{
-	        //    glh::matrix4f inv_proj = mat.inverse();
-	        //    shader->uniformMatrix4fv(LLShaderMgr::INVERSE_PROJECTION_MATRIX, 1, FALSE, inv_proj.m);
-            //}
+            // GZ: This was previously disabled seemingly due to a bug involving the deferred renderer's regular pushing and popping of mats.
+			// We're reenabling this and cleaning up the code around that - that would've been the appropriate course initially.
+			// Anything beyond the standard proj and inv proj mats are special cases.  Please setup special uniforms accordingly in the future.
+            if (shader->getUniformLocation(LLShaderMgr::INVERSE_PROJECTION_MATRIX))
+            {
+	            glh::matrix4f inv_proj = mat.inverse();
+	            shader->uniformMatrix4fv(LLShaderMgr::INVERSE_PROJECTION_MATRIX, 1, FALSE, inv_proj.m);
+            }
+
+			// Used by some full screen effects - such as full screen lights, glow, etc.
+            if (shader->getUniformLocation(LLShaderMgr::IDENTITY_MATRIX))
+            {
+                shader->uniformMatrix4fv(LLShaderMgr::IDENTITY_MATRIX, 1, GL_FALSE, glh::matrix4f::identity().m);
+            }
 
 			shader->uniformMatrix4fv(name[MM_PROJECTION], 1, GL_FALSE, mat.m);
 			shader->mMatHash[MM_PROJECTION] = mMatHash[MM_PROJECTION];
diff --git a/indra/llrender/llrender.h b/indra/llrender/llrender.h
index 6dd5f9601e..9fabeb1d7a 100644
--- a/indra/llrender/llrender.h
+++ b/indra/llrender/llrender.h
@@ -339,7 +339,7 @@ public:
 		BF_ONE_MINUS_SOURCE_COLOR,
 		BF_DEST_ALPHA,
 		BF_SOURCE_ALPHA,
-		BF_ONE_MINUS_DEST_ALPHA,
+		BF_ONE_MINUS_DEST_ALPHA, 
 		BF_ONE_MINUS_SOURCE_ALPHA,
 
 		BF_UNDEF
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index ac4c610d72..b189e5452c 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -222,6 +222,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 		}
 	}
 
+	if (features->hasScreenSpaceReflections)
+	{
+        if (!shader->attachFragmentObject("deferred/screenSpaceReflUtil.glsl"))
+        {
+            return FALSE;
+        }
+	}
+
     if (features->hasShadows)
 	{
         if (!shader->attachFragmentObject("deferred/shadowUtil.glsl"))
@@ -1170,6 +1178,7 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("inv_proj");
 	mReservedUniforms.push_back("modelview_projection_matrix");
     mReservedUniforms.push_back("inv_modelview");
+    mReservedUniforms.push_back("identity_matrix");
 	mReservedUniforms.push_back("normal_matrix");
 	mReservedUniforms.push_back("texture_matrix0");
 	mReservedUniforms.push_back("texture_matrix1");
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index e1fb60eccf..90a8c2853c 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -44,6 +44,7 @@ public:
         INVERSE_PROJECTION_MATRIX,          //  "inv_proj"
         MODELVIEW_PROJECTION_MATRIX,        //  "modelview_projection_matrix"
         INVERSE_MODELVIEW_MATRIX,           //  "inv_modelview"
+        IDENTITY_MATRIX,                    //  "identity_matrix"
         NORMAL_MATRIX,                      //  "normal_matrix"
         TEXTURE_MATRIX0,                    //  "texture_matrix0"
         TEXTURE_MATRIX1,                    //  "texture_matrix1"
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 3f9a91e38f..71611a58bc 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -9133,6 +9133,17 @@
       <real>0.00</real>
     </array>
   </map>
+  <key>RenderScreenSpaceReflections</key>
+  <map>
+    <key>Comment</key>
+    <string>Renders screen space reflections to better account for dynamic objects with reflection probes.</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>0</integer>
+  </map>
   <key>RenderBumpmapMinDistanceSquared</key>
     <map>
       <key>Comment</key>
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);	
 }
diff --git a/indra/newview/app_settings/shaders/class1/effects/glowExtractF.glsl b/indra/newview/app_settings/shaders/class1/effects/glowExtractF.glsl
index 36563982ba..4e535f7e18 100644
--- a/indra/newview/app_settings/shaders/class1/effects/glowExtractF.glsl
+++ b/indra/newview/app_settings/shaders/class1/effects/glowExtractF.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseMap;
+uniform sampler2D diffuseMap;
 uniform float minLuminance;
 uniform float maxExtractAlpha;
 uniform vec3 lumWeights;
@@ -44,7 +44,7 @@ VARYING vec2 vary_texcoord0;
 
 void main()
 {
-	vec4 col = texture2DRect(diffuseMap, vary_texcoord0.xy);	
+	vec4 col = texture2D(diffuseMap, vary_texcoord0.xy);	
 	/// CALCULATING LUMINANCE (Using NTSC lum weights)
 	/// http://en.wikipedia.org/wiki/Luma_%28video%29
 	float lum = smoothstep(minLuminance, minLuminance+1.0, dot(col.rgb, lumWeights ) );
diff --git a/indra/newview/app_settings/shaders/class1/effects/glowExtractV.glsl b/indra/newview/app_settings/shaders/class1/effects/glowExtractV.glsl
index 1396dc6973..db0662ad89 100644
--- a/indra/newview/app_settings/shaders/class1/effects/glowExtractV.glsl
+++ b/indra/newview/app_settings/shaders/class1/effects/glowExtractV.glsl
@@ -32,7 +32,7 @@ VARYING vec2 vary_texcoord0;
 
 void main() 
 {
-	gl_Position = modelview_projection_matrix * vec4(position, 1.0);
+	gl_Position = vec4(position, 1.0);
 	
-	vary_texcoord0.xy = texcoord0;
+	vary_texcoord0.xy = position.xy * 0.5 + 0.5;
 }
diff --git a/indra/newview/app_settings/shaders/class1/effects/glowV.glsl b/indra/newview/app_settings/shaders/class1/effects/glowV.glsl
index cdb2281578..ea66e8271b 100644
--- a/indra/newview/app_settings/shaders/class1/effects/glowV.glsl
+++ b/indra/newview/app_settings/shaders/class1/effects/glowV.glsl
@@ -37,7 +37,7 @@ VARYING vec4 vary_texcoord3;
 
 void main() 
 {
-	gl_Position = modelview_projection_matrix * vec4(position, 1.0);
+	gl_Position = vec4(position, 1.0);
 	
 	vary_texcoord0.xy = texcoord0 + glowDelta*(-3.5);
 	vary_texcoord1.xy = texcoord0 + glowDelta*(-2.5);
diff --git a/indra/newview/app_settings/shaders/class1/interface/downsampleDepthRectF.glsl b/indra/newview/app_settings/shaders/class1/interface/downsampleDepthRectF.glsl
index cff8d9d50f..99662097bb 100644
--- a/indra/newview/app_settings/shaders/class1/interface/downsampleDepthRectF.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/downsampleDepthRectF.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect depthMap;
+uniform sampler2D depthMap;
 
 VARYING vec2 tc0;
 VARYING vec2 tc1;
@@ -48,22 +48,22 @@ VARYING vec2 tc8;
 void main() 
 {
 	vec4 depth1 = 
-		vec4(texture2DRect(depthMap, tc0).r,
-			texture2DRect(depthMap, tc1).r,
-			texture2DRect(depthMap, tc2).r,
-			texture2DRect(depthMap, tc3).r);
+		vec4(texture2D(depthMap, tc0).r,
+			texture2D(depthMap, tc1).r,
+			texture2D(depthMap, tc2).r,
+			texture2D(depthMap, tc3).r);
 
 	vec4 depth2 = 
-		vec4(texture2DRect(depthMap, tc4).r,
-			texture2DRect(depthMap, tc5).r,
-			texture2DRect(depthMap, tc6).r,
-			texture2DRect(depthMap, tc7).r);
+		vec4(texture2D(depthMap, tc4).r,
+			texture2D(depthMap, tc5).r,
+			texture2D(depthMap, tc6).r,
+			texture2D(depthMap, tc7).r);
 
 	depth1 = min(depth1, depth2);
 	float depth = min(depth1.x, depth1.y);
 	depth = min(depth, depth1.z);
 	depth = min(depth, depth1.w);
-	depth = min(depth, texture2DRect(depthMap, tc8).r);
+	depth = min(depth, texture2D(depthMap, tc8).r);
 
 	gl_FragDepth = depth;
 }
diff --git a/indra/newview/app_settings/shaders/class1/interface/downsampleDepthV.glsl b/indra/newview/app_settings/shaders/class1/interface/downsampleDepthV.glsl
index 71d80911d6..e104377037 100644
--- a/indra/newview/app_settings/shaders/class1/interface/downsampleDepthV.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/downsampleDepthV.glsl
@@ -45,7 +45,7 @@ void main()
 {
 	gl_Position = vec4(position, 1.0); 
 	
-	vec2 tc = (position.xy*0.5+0.5)*screen_res;
+	vec2 tc = (position.xy*0.5+0.5);
 	tc0 = tc+vec2(-delta.x,-delta.y);
 	tc1 = tc+vec2(0,-delta.y);
 	tc2 = tc+vec2(delta.x,-delta.y);
diff --git a/indra/newview/app_settings/shaders/class1/interface/glowcombineF.glsl b/indra/newview/app_settings/shaders/class1/interface/glowcombineF.glsl
index b5bbbb5c73..0b4680767a 100644
--- a/indra/newview/app_settings/shaders/class1/interface/glowcombineF.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/glowcombineF.glsl
@@ -34,7 +34,7 @@ out vec4 frag_color;
 #endif
 
 uniform sampler2D glowMap;
-uniform sampler2DRect screenMap;
+uniform sampler2D screenMap;
 
 VARYING vec2 vary_texcoord0;
 VARYING vec2 vary_texcoord1;
@@ -42,5 +42,5 @@ VARYING vec2 vary_texcoord1;
 void main() 
 {
 	frag_color = texture2D(glowMap, vary_texcoord0.xy) +
-					texture2DRect(screenMap, vary_texcoord1.xy);
+					texture2D(screenMap, vary_texcoord1.xy);
 }
diff --git a/indra/newview/app_settings/shaders/class1/interface/glowcombineFXAAF.glsl b/indra/newview/app_settings/shaders/class1/interface/glowcombineFXAAF.glsl
index a9e7ea1de8..6a4c2ca623 100644
--- a/indra/newview/app_settings/shaders/class1/interface/glowcombineFXAAF.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/glowcombineFXAAF.glsl
@@ -33,14 +33,14 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
+uniform sampler2D diffuseRect;
 
 uniform vec2 screen_res;
 VARYING vec2 vary_tc;
 
 void main() 
 {
-	vec3 col = texture2DRect(diffuseRect, vary_tc*screen_res).rgb;
+	vec3 col = texture2D(diffuseRect, vary_tc).rgb;
 	
 	frag_color = vec4(col.rgb, dot(col.rgb, vec3(0.299, 0.587, 0.144)));
 }
diff --git a/indra/newview/app_settings/shaders/class1/interface/glowcombineFXAAV.glsl b/indra/newview/app_settings/shaders/class1/interface/glowcombineFXAAV.glsl
index 058f3b1b82..48aab1ce21 100644
--- a/indra/newview/app_settings/shaders/class1/interface/glowcombineFXAAV.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/glowcombineFXAAV.glsl
@@ -23,7 +23,6 @@
  * $/LicenseInfo$
  */
 
-uniform mat4 modelview_projection_matrix;
 
 ATTRIBUTE vec3 position;
 
@@ -31,7 +30,7 @@ VARYING vec2 vary_tc;
 
 void main()
 {
-	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;
diff --git a/indra/newview/app_settings/shaders/class1/interface/glowcombineV.glsl b/indra/newview/app_settings/shaders/class1/interface/glowcombineV.glsl
index f7970b7f78..e08284f762 100644
--- a/indra/newview/app_settings/shaders/class1/interface/glowcombineV.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/glowcombineV.glsl
@@ -34,7 +34,7 @@ VARYING vec2 vary_texcoord1;
 
 void main()
 {
-	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
+	gl_Position = vec4(position.xyz, 1.0);
 	vary_texcoord0 = texcoord0;
 	vary_texcoord1 = texcoord1;
 }
diff --git a/indra/newview/app_settings/shaders/class1/interface/radianceGenF.glsl b/indra/newview/app_settings/shaders/class1/interface/radianceGenF.glsl
index 839e10ce5e..858052281b 100644
--- a/indra/newview/app_settings/shaders/class1/interface/radianceGenF.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/radianceGenF.glsl
@@ -36,6 +36,7 @@ VARYING vec3 vary_dir;
 //uniform float roughness;
 
 uniform float mipLevel;
+uniform int u_width; 
 
 // =============================================================================================================
 // Parts of this file are (c) 2018 Sascha Willems
@@ -124,7 +125,7 @@ vec4 prefilterEnvMap(vec3 R)
 	vec3 V = R;
 	vec4 color = vec4(0.0);
 	float totalWeight = 0.0;
-	float envMapDim = 128.0;
+	float envMapDim = u_width;
     int numSamples = 4;
     
     float numMips = 6.0;
diff --git a/indra/newview/app_settings/shaders/class1/interface/reflectionmipF.glsl b/indra/newview/app_settings/shaders/class1/interface/reflectionmipF.glsl
index f0d579f85e..a9c28b2974 100644
--- a/indra/newview/app_settings/shaders/class1/interface/reflectionmipF.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/reflectionmipF.glsl
@@ -35,8 +35,8 @@ out vec4 frag_color;
 
 // NOTE screenMap should always be texture channel 0 and 
 // depthmap should always be channel 1
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect depthMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D depthMap;
 
 uniform float resScale;
 uniform float znear;
@@ -76,26 +76,25 @@ void main()
 
     for (int i = 0; i < 9; ++i)
     {
-        color += texture2DRect(screenMap, vary_texcoord0.xy+tc[i]).rgb * w[i];
-        //color += texture2DRect(screenMap, vary_texcoord0.xy+tc[i]*2.0).rgb * w[i]*0.5;
+        color += texture2D(screenMap, vary_texcoord0.xy+tc[i]).rgb * w[i];
+        //color += texture2D(screenMap, vary_texcoord0.xy+tc[i]*2.0).rgb * w[i]*0.5;
     }
 
     //color /= wsum;
 
     frag_color = vec4(color, 1.0);
 #else
-    vec2 depth_tc = vary_texcoord0.xy * resScale;
-    float depth = texture(depthMap, depth_tc).r;
+    float depth = texture(depthMap, vary_texcoord0.xy).r;
     float dist = linearDepth(depth, znear, zfar);
 
     // convert linear depth to distance
     vec3 v;
-    v.xy = depth_tc / 256.0 * 2.0 - 1.0;
+    v.xy = vary_texcoord0.xy / 512.0 * 2.0 - 1.0;
     v.z = 1.0;
     v = normalize(v);
     dist /= v.z;
 
-    vec3 col = texture2DRect(diffuseRect, vary_texcoord0.xy).rgb;
+    vec3 col = texture2D(diffuseRect, vary_texcoord0.xy).rgb;
     frag_color = vec4(col, dist/256.0); 
 #endif
 }
diff --git a/indra/newview/app_settings/shaders/class1/interface/splattexturerectF.glsl b/indra/newview/app_settings/shaders/class1/interface/splattexturerectF.glsl
index 7614075cfd..bf6c1b355c 100644
--- a/indra/newview/app_settings/shaders/class1/interface/splattexturerectF.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/splattexturerectF.glsl
@@ -33,12 +33,12 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect screenMap;
+uniform sampler2D screenMap;
 
 VARYING vec4 vertex_color;
 VARYING vec2 vary_texcoord0;
 
 void main() 
 {
-	frag_color = 	texture2DRect(screenMap, vary_texcoord0.xy) * vertex_color;
+	frag_color = 	texture2D(screenMap, vary_texcoord0.xy) * vertex_color;
 }
diff --git a/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
index e255c78b86..25b0a0b970 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
@@ -180,7 +180,6 @@ vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 diffuse, vec3 v, vec3 n, vec
 void main() 
 {
     vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
-    frag *= screen_res;
     
     vec4 pos = vec4(vary_position, 1.0);
 #ifndef IS_AVATAR_SKIN
diff --git a/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
index 1b7a1cc6ec..24068c04b5 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
@@ -34,12 +34,12 @@ 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 samplerCube environmentMap;
-uniform sampler2DRect lightMap;
+uniform sampler2D lightMap;
 uniform sampler2D noiseMap;
 uniform sampler2D projectionMap;
 uniform sampler2D lightFunc;
@@ -138,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;
@@ -154,13 +153,13 @@ void main()
     
     if (proj_shadow_idx >= 0)
     {
-        vec4 shd = texture2DRect(lightMap, frag.xy);
+        vec4 shd = texture2D(lightMap, frag.xy);
         shadow = (proj_shadow_idx==0)?shd.b:shd.a;
         shadow += shadow_fade;
         shadow = clamp(shadow, 0.0, 1.0);        
     }
     
-    vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
+    vec3 norm = texture2D(normalMap, frag.xy).xyz;
     
     float envIntensity = norm.z;
 
@@ -190,9 +189,9 @@ 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;
  
-    vec4 spec = texture2DRect(specularRect, frag.xy);
+    vec4 spec = texture2D(specularRect, frag.xy);
 
     vec3 dlit = vec3(0, 0, 0);
 
diff --git a/indra/newview/app_settings/shaders/class2/deferred/pbralphaF.glsl b/indra/newview/app_settings/shaders/class2/deferred/pbralphaF.glsl
index 6500c4bb1f..d81102991e 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/pbralphaF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/pbralphaF.glsl
@@ -35,7 +35,7 @@ uniform float roughnessFactor;
 uniform vec3 emissiveColor;
 
 #if defined(HAS_SUN_SHADOW) || defined(HAS_SSAO)
-uniform sampler2DRect lightMap;
+uniform sampler2D lightMap;
 #endif
 
 uniform int sun_up_factor;
@@ -189,7 +189,6 @@ void main()
 
 #ifdef HAS_SUN_SHADOW
     vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
-    frag *= screen_res;
     scol = sampleDirectionalShadow(pos.xyz, norm.xyz, frag);
 #endif
 
diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
index 677c9c244c..fab227f5a4 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/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.xy);
     vec4  pos          = getPositionWithDepth(tc, depth);
-    vec4  norm         = texture2DRect(normalMap, tc);
+    vec4  norm         = texture2D(normalMap, tc);
     float envIntensity = norm.z;
     norm.xyz           = getNorm(tc);
 
@@ -87,11 +88,11 @@ void main()
     float light_gamma = 1.0 / 1.3;
     da                = pow(da, light_gamma);
 
-    vec4 diffuse     = texture2DRect(diffuseRect, tc);
+    vec4 diffuse     = texture2D(diffuseRect, tc);
          diffuse.rgb = linear_to_srgb(diffuse.rgb); // SL-14035
-    vec4 spec        = texture2DRect(specularRect, vary_fragcoord.xy);
+    vec4 spec        = texture2D(specularRect, vary_fragcoord.xy);
 
-    vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
+    vec2 scol_ambocc = texture2D(lightMap, vary_fragcoord.xy).rg;
     scol_ambocc      = pow(scol_ambocc, vec2(light_gamma));
     float scol       = max(scol_ambocc.r, diffuse.a);
     float ambocc     = scol_ambocc.g;
@@ -153,6 +154,6 @@ void main()
 
     // convert to linear as fullscreen lights need to sum in linear colorspace
     // and will be gamma (re)corrected downstream...
-    frag_color.rgb = srgb_to_linear(color.rgb);
+    frag_color.rgb = pos.xyz;// srgb_to_linear(color.rgb);
     frag_color.a   = bloom;
 }
diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl
index bd11aa3f05..1e7ccb747a 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl
@@ -23,8 +23,6 @@
  * $/LicenseInfo$
  */
 
-uniform mat4 modelview_projection_matrix;
-
 ATTRIBUTE vec3 position;
 
 uniform vec2 screen_res;
@@ -38,12 +36,12 @@ void setAdditiveColor(vec3 c);
 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/class2/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl
index 774f537821..c41b7b210c 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl
@@ -34,12 +34,12 @@ 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 samplerCube environmentMap;
-uniform sampler2DRect lightMap;
+uniform sampler2D lightMap;
 uniform sampler2D noiseMap;
 uniform sampler2D projectionMap;
 uniform sampler2D lightFunc;
@@ -138,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 = trans_center.xyz-pos.xyz;
@@ -154,13 +153,13 @@ void main()
 	
 	if (proj_shadow_idx >= 0)
 	{
-		vec4 shd = texture2DRect(lightMap, frag.xy);
+		vec4 shd = texture2D(lightMap, frag.xy);
         shadow = (proj_shadow_idx == 0) ? shd.b : shd.a;
         shadow += shadow_fade;
 		shadow = clamp(shadow, 0.0, 1.0);        
 	}
 	
-	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
+	vec3 norm = texture2D(normalMap, frag.xy).xyz;
 	float envIntensity = norm.z;
 	norm = getNorm(frag.xy);
 	
@@ -189,8 +188,8 @@ void main()
 	lv = normalize(lv);
 	float da = dot(norm, lv);
 		
-	vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
-	vec4 spec = texture2DRect(specularRect, frag.xy);
+	vec3 diff_tex = texture2D(diffuseRect, frag.xy).rgb;
+	vec4 spec = texture2D(specularRect, frag.xy);
 	vec3 dlit = vec3(0, 0, 0);
 
 	float noise = texture2D(noiseMap, frag.xy/128.0).b;
diff --git a/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl b/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl
index bc5eb5181d..3dfca0f655 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl
@@ -23,8 +23,6 @@
  * $/LicenseInfo$
  */
 
-uniform mat4 modelview_projection_matrix;
-
 ATTRIBUTE vec3 position;
 
 VARYING vec2 vary_fragcoord;
@@ -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);	
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiPointLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiPointLightF.glsl
index 6dd446d9f7..43327be49f 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiPointLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiPointLightF.glsl
@@ -33,10 +33,10 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect depthMap;
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
+uniform sampler2D depthMap;
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
 uniform sampler2D     noiseMap;
 uniform sampler2D     lightFunc;
 
@@ -57,6 +57,7 @@ float calcLegacyDistanceAttenuation(float distance, float falloff);
 vec4 getPosition(vec2 pos_screen);
 vec4 getNormalEnvIntensityFlags(vec2 screenpos, out vec3 n, out float envIntensity);
 vec2 getScreenXY(vec4 clip);
+vec2 getScreenCoord(vec4 clip);
 vec3 srgb_to_linear(vec3 c);
 
 // Util
@@ -76,7 +77,7 @@ void main()
     discard;  // Bail immediately
 #else
     vec3 final_color = vec3(0, 0, 0);
-    vec2 tc          = getScreenXY(vary_fragcoord);
+    vec2 tc          = getScreenCoord(vary_fragcoord);
     vec3 pos         = getPosition(tc).xyz;
     if (pos.z < far_z)
     {
@@ -87,15 +88,15 @@ void main()
     vec3 n;
     vec4 norm = getNormalEnvIntensityFlags(tc, n, envIntensity); // need `norm.w` for GET_GBUFFER_FLAG()
 
-    vec4 spec    = texture2DRect(specularRect, tc);
-    vec3 diffuse = texture2DRect(diffuseRect, tc).rgb;
+    vec4 spec    = texture2D(specularRect, tc);
+    vec3 diffuse = texture2D(diffuseRect, tc).rgb;
 
     vec3  h, l, v = -normalize(pos);
     float nh, nv, vh, lightDist;
 
     if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR))
     {
-        vec3 colorEmissive = texture2DRect(emissiveRect, tc).rgb;
+        vec3 colorEmissive = texture2D(emissiveRect, tc).rgb;
         vec3 orm = spec.rgb;
         float perceptualRoughness = orm.g;
         float metallic = orm.b;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiPointLightV.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiPointLightV.glsl
index ad6a0fa752..831b3b2684 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiPointLightV.glsl
+++ b/indra/newview/app_settings/shaders/class3/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/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index cb8877ebe5..4a172f7a10 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -34,13 +34,13 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect depthMap;
-uniform sampler2DRect normalMap;
-uniform sampler2DRect emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D depthMap;
+uniform sampler2D normalMap;
+uniform sampler2D emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
 uniform samplerCube environmentMap;
-uniform sampler2DRect lightMap;
+uniform sampler2D lightMap;
 uniform sampler2D noiseMap;
 uniform sampler2D projectionMap; // rgba
 uniform sampler2D lightFunc;
@@ -82,6 +82,7 @@ vec3 getProjectedLightAmbiance(float amb_da, float attenuation, float lit, float
 vec3 getProjectedLightDiffuseColor(float light_distance, vec2 projected_uv );
 vec3 getProjectedLightSpecularColor(vec3 pos, vec3 n);
 vec2 getScreenXY(vec4 clip);
+vec2 getScreenCoord(vec4 clip);
 vec3 srgb_to_linear(vec3 cs);
 vec4 texture2DLodSpecular(vec2 tc, float lod);
 
@@ -102,7 +103,7 @@ void main()
     discard;
 #else
     vec3 final_color = vec3(0,0,0);
-    vec2 tc          = getScreenXY(vary_fragcoord);
+    vec2 tc          = getScreenCoord(vary_fragcoord);
     vec3 pos         = getPosition(tc).xyz;
 
     vec3 lv;
@@ -117,7 +118,7 @@ void main()
     
     if (proj_shadow_idx >= 0)
     {
-        vec4 shd = texture2DRect(lightMap, tc);
+        vec4 shd = texture2D(lightMap, tc);
         shadow = (proj_shadow_idx==0)?shd.b:shd.a;
         shadow += shadow_fade;
         shadow = clamp(shadow, 0.0, 1.0);        
@@ -138,8 +139,8 @@ void main()
     float nh, nl, nv, vh, lightDist;
     calcHalfVectors(lv, n, v, h, l, nh, nl, nv, vh, lightDist);
 
-    vec3 diffuse = texture2DRect(diffuseRect, tc).rgb;
-    vec4 spec    = texture2DRect(specularRect, tc);
+    vec3 diffuse = texture2D(diffuseRect, tc).rgb;
+    vec4 spec    = texture2D(specularRect, tc);
     vec3 dlit    = vec3(0, 0, 0);
     vec3 slit    = vec3(0, 0, 0);
 
@@ -147,7 +148,7 @@ void main()
 
     if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR))
     {
-        vec3 colorEmissive = texture2DRect(emissiveRect, tc).rgb; 
+        vec3 colorEmissive = texture2D(emissiveRect, tc).rgb; 
         vec3 orm = spec.rgb;
         float perceptualRoughness = orm.g;
         float metallic = orm.b;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/pointLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/pointLightF.glsl
index cdffcf103d..0c8baab14f 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/pointLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/pointLightF.glsl
@@ -33,13 +33,13 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect normalMap;
-uniform sampler2DRect emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D normalMap;
+uniform sampler2D emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
 uniform sampler2D noiseMap;
 uniform sampler2D lightFunc;
-uniform sampler2DRect depthMap;
+uniform sampler2D depthMap;
 
 uniform vec3 env_mat[3];
 uniform float sun_wash;
@@ -62,7 +62,9 @@ float calcLegacyDistanceAttenuation(float distance, float falloff);
 vec4 getNormalEnvIntensityFlags(vec2 screenpos, out vec3 n, out float envIntensity);
 vec4 getPosition(vec2 pos_screen);
 vec2 getScreenXY(vec4 clip);
+vec2 getScreenCoord(vec4 clip);
 vec3 srgb_to_linear(vec3 c);
+float getDepth(vec2 tc);
 
 vec3 pbrPunctual(vec3 diffuseColor, vec3 specularColor, 
                     float perceptualRoughness, 
@@ -74,15 +76,15 @@ vec3 pbrPunctual(vec3 diffuseColor, vec3 specularColor,
 void main()
 {
     vec3 final_color = vec3(0);
-    vec2 tc          = getScreenXY(vary_fragcoord);
+    vec2 tc          = getScreenCoord(vary_fragcoord);
     vec3 pos         = getPosition(tc).xyz;
 
     float envIntensity;
     vec3 n;
     vec4 norm = getNormalEnvIntensityFlags(tc, n, envIntensity); // need `norm.w` for GET_GBUFFER_FLAG()
 
-    vec3 diffuse = texture2DRect(diffuseRect, tc).rgb;
-    vec4 spec    = texture2DRect(specularRect, tc);
+    vec3 diffuse = texture2D(diffuseRect, tc).rgb;
+    vec4 spec    = texture2D(specularRect, tc);
 
     // Common half vectors calcs
     vec3  lv = trans_center.xyz-pos;
@@ -99,7 +101,7 @@ void main()
 
     if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR))
     {
-        vec3 colorEmissive = texture2DRect(emissiveRect, tc).rgb; 
+        vec3 colorEmissive = texture2D(emissiveRect, tc).rgb; 
         vec3 orm = spec.rgb;
         float perceptualRoughness = orm.g;
         float metallic = orm.b;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostF.glsl b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostF.glsl
new file mode 100644
index 0000000000..9172789b38
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostF.glsl
@@ -0,0 +1,98 @@
+/**
+ * @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;
+VARYING vec3 camera_ray;
+
+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);
+float linearDepth01(float d, float znear, float zfar);
+
+vec4 getPositionWithDepth(vec2 pos_screen, float depth);
+vec4 getPosition(vec2 pos_screen);
+
+bool traceScreenRay(vec3 position, vec3 reflection, out vec3 hitColor, out float hitDepth, float depth, sampler2D textureFrame);
+float random (vec2 uv);
+void main() {
+    vec2  tc = vary_fragcoord.xy;
+    float depth = linearDepth01(getDepth(tc), zNear, zFar);
+    vec3 pos = getPositionWithDepth(tc, getDepth(tc)).xyz;
+    vec3 viewPos = camera_ray * depth;
+    vec3 rayDirection = normalize(reflect(normalize(viewPos), getNorm(tc))) * -viewPos.z;
+    vec2 hitpixel;
+    vec3 hitpoint;
+
+	vec2 uv2 = tc * screen_res;
+	float c = (uv2.x + uv2.y) * 0.125;
+	float jitter = mod( c, 1.0);
+
+    vec3 firstBasis = normalize(cross(vec3(0.f, 0.f, 1.f), rayDirection));
+	vec3 secondBasis = normalize(cross(rayDirection, firstBasis));
+    
+    frag_color.rgb = texture(diffuseRect, tc).rgb;
+    vec4 collectedColor;
+    for (int i = 0; i < 1; i++) {
+		vec2 coeffs = vec2(random(tc + vec2(0, i)) + random(tc + vec2(i, 0))) * 0.25;
+		vec3 reflectionDirectionRandomized = rayDirection + firstBasis * coeffs.x + secondBasis * coeffs.y;
+
+        bool hit = traceScreenRay(pos, reflectionDirectionRandomized, hitpoint, depth, depth, diffuseRect);
+        if (hit) {
+            vec2 screenpos = tc * 2 - 1;
+            float vignette = 1;// clamp((1 - dot(screenpos, screenpos)) * 4,0, 1);
+            vignette *= dot(normalize(viewPos), getNorm(tc)) * 0.5 + 0.5;
+            vignette *= min(linearDepth(getDepth(tc), zNear, zFar) / (zFar * 0.0125), 1);
+            collectedColor.rgb = hitpoint * vignette * 0.25;
+            frag_color.rgb = hitpoint;
+        }
+	}
+
+    //frag_color.rgb = collectedColor.rgb;
+
+
+
+    frag_color.a = 1.0;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostV.glsl b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostV.glsl
new file mode 100644
index 0000000000..b084094d4d
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflPostV.glsl
@@ -0,0 +1,48 @@
+/**
+ * @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$
+ */
+
+uniform mat4 projection_matrix;
+uniform mat4 inv_proj;
+
+ATTRIBUTE vec3 position;
+
+uniform vec2 screen_res;
+
+VARYING vec2 vary_fragcoord;
+VARYING vec3 camera_ray;
+
+
+void main()
+{
+	//transform vertex
+	vec4 pos = vec4(position.xyz, 1.0);
+	gl_Position = pos; 
+	
+	vary_fragcoord = pos.xy * 0.5 + 0.5;
+
+	vec4 rayOrig = inv_proj * vec4(pos.xy, 1, 1);
+    camera_ray = rayOrig.xyz / rayOrig.w;
+
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflUtil.glsl b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflUtil.glsl
new file mode 100644
index 0000000000..5eefd99d00
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/screenSpaceReflUtil.glsl
@@ -0,0 +1,138 @@
+/**
+ * @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;
+uniform float zNear;
+uniform float zFar;
+uniform mat4 inv_proj;
+
+vec4 getPositionWithDepth(vec2 pos_screen, float depth);
+float linearDepth(float depth, float near, float far);
+float getDepth(vec2 pos_screen);
+float linearDepth01(float d, float znear, float zfar);
+
+float random (vec2 uv) {
+	return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453123); //simple random function
+}
+
+// Based off of https://github.com/RoundedGlint585/ScreenSpaceReflection/
+// A few tweaks here and there to suit our needs.
+
+vec2 generateProjectedPosition(vec3 pos){
+	vec4 samplePosition = projection_matrix * vec4(pos, 1.f);
+	samplePosition.xy = (samplePosition.xy / samplePosition.w) * 0.5 + 0.5;
+	return samplePosition.xy;
+}
+
+bool isBinarySearchEnabled = true;
+bool isAdaptiveStepEnabled = true;
+bool isExponentialStepEnabled = false;
+bool debugDraw = false;
+int iterationCount = 100;
+float rayStep = 0.2;
+float distanceBias = 0.05;
+float depthRejectBias = 0.001;
+float epsilon = 0.1;
+
+bool traceScreenRay(vec3 position, vec3 reflection, out vec3 hitColor, out float hitDepth, float depth, sampler2D textureFrame) {
+	vec3 step = rayStep * reflection;
+	vec3 marchingPosition = position + step;
+	float delta;
+	float depthFromScreen;
+	vec2 screenPosition;
+    bool hit = false;
+    hitColor = vec3(0);
+	
+	int i = 0;
+	if (depth > depthRejectBias) {
+		for (; i < iterationCount && !hit; i++) {
+			screenPosition = generateProjectedPosition(marchingPosition);
+			depthFromScreen = abs(getPositionWithDepth(screenPosition, linearDepth(getDepth(screenPosition), zNear, zFar)).z);
+			delta = abs(marchingPosition.z) - depthFromScreen;
+			
+			if (depth < depthFromScreen + epsilon && depth > depthFromScreen - epsilon) {
+				break;
+			}
+
+			if (abs(delta) < distanceBias) {
+				vec3 color = vec3(1);
+				if(debugDraw)
+					color = vec3( 0.5+ sign(delta)/2,0.3,0.5- sign(delta)/2);
+				hitColor = texture(textureFrame, screenPosition).xyz * color;
+				hitDepth = depthFromScreen;
+				hit = true;
+				break;
+			}
+			if (isBinarySearchEnabled && delta > 0) {
+				break;
+			}
+			if (isAdaptiveStepEnabled){
+				float directionSign = sign(abs(marchingPosition.z) - depthFromScreen);
+				//this is sort of adapting step, should prevent lining reflection by doing sort of iterative converging
+				//some implementation doing it by binary search, but I found this idea more cheaty and way easier to implement
+				step = step * (1.0 - rayStep * max(directionSign, 0.0));
+				marchingPosition += step * (-directionSign);
+			}
+			else {
+				marchingPosition += step;
+			}
+
+			if (isExponentialStepEnabled){
+				step *= 1.05;
+			}
+		}
+		if(isBinarySearchEnabled){
+			for(; i < iterationCount && !hit; i++){
+			
+				step *= 0.5;
+				marchingPosition = marchingPosition - step * sign(delta);
+				
+				screenPosition = generateProjectedPosition(marchingPosition);
+				depthFromScreen = abs(getPositionWithDepth(screenPosition, getDepth(screenPosition)).z);
+				delta = abs(marchingPosition.z) - depthFromScreen;
+
+				if (depth < depthFromScreen + epsilon && depth > depthFromScreen - epsilon) {
+					break;
+				}
+
+				if (abs(delta) < distanceBias && depthFromScreen != (depth - distanceBias)) {
+					vec3 color = vec3(1);
+					if(debugDraw)
+						color = vec3( 0.5+ sign(delta)/2,0.3,0.5- sign(delta)/2);
+					hitColor = texture(textureFrame, screenPosition).xyz * color;
+					hitDepth = depthFromScreen;
+					hit = true;
+					break;
+				}
+			}
+		}
+	}
+	
+    return hit;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index 879f4ef510..5f6982746b 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -37,19 +37,19 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect normalMap;
-uniform sampler2DRect emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D normalMap;
+uniform sampler2D emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
 uniform sampler2D altDiffuseMap; // PBR: irradiance, skins/default/textures/default_irradiance.png
 
 const float M_PI = 3.14159265;
 
 #if defined(HAS_SUN_SHADOW) || defined(HAS_SSAO)
-uniform sampler2DRect lightMap;
+uniform sampler2D lightMap;
 #endif
 
-uniform sampler2DRect depthMap;
+uniform sampler2D depthMap;
 uniform sampler2D     lightFunc;
 
 uniform float blur_size;
@@ -81,6 +81,7 @@ void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout
         vec3 pos, vec3 norm, float glossiness, float envIntensity);
 void applyGlossEnv(inout vec3 color, vec3 glossenv, vec4 spec, vec3 pos, vec3 norm);
 void applyLegacyEnv(inout vec3 color, vec3 legacyenv, vec4 spec, vec3 pos, vec3 norm, float envIntensity);
+float getDepth(vec2 pos_screen);
 
 vec3 linear_to_srgb(vec3 c);
 vec3 srgb_to_linear(vec3 c);
@@ -118,18 +119,18 @@ vec3 pbrPunctual(vec3 diffuseColor, vec3 specularColor,
 void main()
 {
     vec2  tc           = vary_fragcoord.xy;
-    float depth        = texture2DRect(depthMap, tc.xy).r;
+    float depth        = getDepth(tc.xy);
     vec4  pos          = getPositionWithDepth(tc, depth);
-    vec4  norm         = texture2DRect(normalMap, tc);
+    vec4  norm         = texture2D(normalMap, tc);
     float envIntensity = norm.z;
     norm.xyz           = getNorm(tc);
     vec3  light_dir   = (sun_up_factor == 1) ? sun_dir : moon_dir;
 
-    vec4 baseColor     = texture2DRect(diffuseRect, tc);
-    vec4 spec        = texture2DRect(specularRect, vary_fragcoord.xy); // NOTE: PBR linear Emissive
+    vec4 baseColor     = texture2D(diffuseRect, tc);
+    vec4 spec        = texture2D(specularRect, vary_fragcoord.xy); // NOTE: PBR linear Emissive
 
 #if defined(HAS_SUN_SHADOW) || defined(HAS_SSAO)
-    vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
+    vec2 scol_ambocc = texture2D(lightMap, vary_fragcoord.xy).rg;
 #endif
 
 #if defined(HAS_SUN_SHADOW)
@@ -155,12 +156,12 @@ void main()
 
     if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR))
     {
-        vec3 orm = texture2DRect(specularRect, tc).rgb; 
+        vec3 orm = texture2D(specularRect, tc).rgb; 
         float perceptualRoughness = orm.g;
         float metallic = orm.b;
         float ao = orm.r * ambocc;
 
-        vec3 colorEmissive = texture2DRect(emissiveRect, tc).rgb;
+        vec3 colorEmissive = texture2D(emissiveRect, tc).rgb;
 
         // PBR IBL
         float gloss      = 1.0 - perceptualRoughness;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index 3274153a46..8618159313 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -44,13 +44,13 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
-uniform sampler2DRect diffuseRect;
-uniform sampler2DRect specularRect;
-uniform sampler2DRect depthMap;
-uniform sampler2DRect normalMap;
-uniform sampler2DRect emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
+uniform sampler2D diffuseRect;
+uniform sampler2D specularRect;
+uniform sampler2D depthMap;
+uniform sampler2D normalMap;
+uniform sampler2D emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
 uniform samplerCube environmentMap;
-uniform sampler2DRect lightMap;
+uniform sampler2D lightMap;
 uniform sampler2D noiseMap;
 uniform sampler2D projectionMap; // rgba
 uniform sampler2D lightFunc;
@@ -90,6 +90,7 @@ vec3 getProjectedLightAmbiance(float amb_da, float attenuation, float lit, float
 vec3 getProjectedLightDiffuseColor(float light_distance, vec2 projected_uv );
 vec3 getProjectedLightSpecularColor(vec3 pos, vec3 n);
 vec2 getScreenXY(vec4 clip_point);
+vec2 getScreenCoord(vec4 clip_point);
 vec3 srgb_to_linear(vec3 c);
 vec4 texture2DLodSpecular(vec2 tc, float lod);
 
@@ -110,7 +111,7 @@ void main()
     discard;
 #else
     vec3 final_color = vec3(0,0,0);
-    vec2 tc          = getScreenXY(vary_fragcoord);
+    vec2 tc          = getScreenCoord(vary_fragcoord);
     vec3 pos         = getPosition(tc).xyz;
 
     vec3 lv;
@@ -125,7 +126,7 @@ void main()
 
     if (proj_shadow_idx >= 0)
     {
-        vec4 shd = texture2DRect(lightMap, tc);
+        vec4 shd = texture2D(lightMap, tc);
         shadow = (proj_shadow_idx == 0) ? shd.b : shd.a;
         shadow += shadow_fade;
         shadow = clamp(shadow, 0.0, 1.0);
@@ -146,15 +147,15 @@ void main()
     float nh, nl, nv, vh, lightDist;
     calcHalfVectors(lv, n, v, h, l, nh, nl, nv, vh, lightDist);
 
-    vec3 diffuse = texture2DRect(diffuseRect, tc).rgb;
-    vec4 spec    = texture2DRect(specularRect, tc);
+    vec3 diffuse = texture2D(diffuseRect, tc).rgb;
+    vec4 spec    = texture2D(specularRect, tc);
     vec3 dlit    = vec3(0, 0, 0);
     vec3 slit    = vec3(0, 0, 0);
 
     vec3 amb_rgb = vec3(0);
     if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR))
     {
-        vec3 colorEmissive = texture2DRect(emissiveRect, tc).rgb;
+        vec3 colorEmissive = texture2D(emissiveRect, tc).rgb;
         vec3 orm = spec.rgb; 
         float perceptualRoughness = orm.g;
         float metallic = orm.b;
diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp
index 19f0a8d089..8282aa2507 100644
--- a/indra/newview/llreflectionmapmanager.cpp
+++ b/indra/newview/llreflectionmapmanager.cpp
@@ -88,7 +88,7 @@ void LLReflectionMapManager::update()
         const bool use_depth_buffer = true;
         const bool use_stencil_buffer = false;
         U32 targetRes = LL_REFLECTION_PROBE_RESOLUTION * 2; // super sample
-        mRenderTarget.allocate(targetRes, targetRes, color_fmt, use_depth_buffer, use_stencil_buffer, LLTexUnit::TT_RECT_TEXTURE);
+        mRenderTarget.allocate(targetRes, targetRes, color_fmt, use_depth_buffer, use_stencil_buffer, LLTexUnit::TT_TEXTURE);
     }
 
     if (mMipChain.empty())
@@ -99,7 +99,7 @@ void LLReflectionMapManager::update()
         mMipChain.resize(count);
         for (int i = 0; i < count; ++i)
         {
-            mMipChain[i].allocate(res, res, GL_RGBA16F, false, false, LLTexUnit::TT_RECT_TEXTURE);
+            mMipChain[i].allocate(res, res, GL_RGBA16F, false, false, LLTexUnit::TT_TEXTURE);
             res /= 2;
         }
     }
@@ -437,8 +437,8 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face)
 
         S32 mips = log2((F32)LL_REFLECTION_PROBE_RESOLUTION) + 0.5f;
 
-        S32 diffuseChannel = gReflectionMipProgram.enableTexture(LLShaderMgr::DEFERRED_DIFFUSE, LLTexUnit::TT_RECT_TEXTURE);
-        S32 depthChannel = gReflectionMipProgram.enableTexture(LLShaderMgr::DEFERRED_DEPTH, LLTexUnit::TT_RECT_TEXTURE);
+        S32 diffuseChannel = gReflectionMipProgram.enableTexture(LLShaderMgr::DEFERRED_DIFFUSE, LLTexUnit::TT_TEXTURE);
+        S32 depthChannel   = gReflectionMipProgram.enableTexture(LLShaderMgr::DEFERRED_DEPTH, LLTexUnit::TT_TEXTURE);
 
         LLRenderTarget* screen_rt = &gPipeline.mAuxillaryRT.screen;
         LLRenderTarget* depth_rt = &gPipeline.mAuxillaryRT.deferredScreen;
@@ -472,13 +472,13 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face)
             gGL.texCoord2f(0, 0);
             gGL.vertex2f(-1, -1);
 
-            gGL.texCoord2f(res, 0);
+            gGL.texCoord2f(1.f, 0);
             gGL.vertex2f(1, -1);
 
-            gGL.texCoord2f(res, res);
+            gGL.texCoord2f(1.f, 1.f);
             gGL.vertex2f(1, 1);
 
-            gGL.texCoord2f(0, res);
+            gGL.texCoord2f(0, 1.f);
             gGL.vertex2f(-1, 1);
             gGL.end();
             gGL.flush();
@@ -506,8 +506,8 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face)
         gGL.matrixMode(gGL.MM_MODELVIEW);
         gGL.popMatrix();
 
-        gGL.getTexUnit(diffuseChannel)->unbind(LLTexUnit::TT_RECT_TEXTURE);
-        gGL.getTexUnit(depthChannel)->unbind(LLTexUnit::TT_RECT_TEXTURE);
+        gGL.getTexUnit(diffuseChannel)->unbind(LLTexUnit::TT_TEXTURE);
+        gGL.getTexUnit(depthChannel)->unbind(LLTexUnit::TT_TEXTURE);
         gReflectionMipProgram.unbind();
     }
 
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index e1bf1b6e6d..9e2d28f29e 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -92,6 +92,7 @@ LLGLSLShader	gDownsampleDepthProgram;
 LLGLSLShader	gDownsampleDepthRectProgram;
 LLGLSLShader	gAlphaMaskProgram;
 LLGLSLShader	gBenchmarkProgram;
+LLGLSLShader    gScreenSpaceReflectionProgram;
 
 
 //object shaders
@@ -178,7 +179,8 @@ LLGLSLShader            gWLMoonProgram;
 LLGLSLShader			gGlowProgram;
 LLGLSLShader			gGlowExtractProgram;
 LLGLSLShader			gPostColorFilterProgram;
-LLGLSLShader			gPostNightVisionProgram;
+LLGLSLShader            gPostNightVisionProgram;
+LLGLSLShader			gPostScreenSpaceReflectionProgram;
 
 // Deferred rendering shaders
 LLGLSLShader			gDeferredImpostorProgram;
@@ -698,6 +700,7 @@ void LLViewerShaderMgr::unloadShaders()
 	gOneTextureFilterProgram.unload();
 	gOneTextureNoColorProgram.unload();
 	gSolidColorProgram.unload();
+    gScreenSpaceReflectionProgram.unload();
 
 	gObjectFullbrightNoColorProgram.unload();
 	gObjectFullbrightNoColorWaterProgram.unload();
@@ -770,6 +773,7 @@ void LLViewerShaderMgr::unloadShaders()
 
 	gPostColorFilterProgram.unload();
 	gPostNightVisionProgram.unload();
+    gPostScreenSpaceReflectionProgram.unload();
 
 	gDeferredDiffuseProgram.unload();
 	gDeferredDiffuseAlphaMaskProgram.unload();
@@ -912,6 +916,7 @@ std::string LLViewerShaderMgr::loadBasicShaders()
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/shadowUtil.glsl",                      1) );
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/aoUtil.glsl",                          1) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/reflectionProbeF.glsl",                has_reflection_probes ? 3 : 2) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/screenSpaceReflUtil.glsl",				3) );
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "lighting/lightNonIndexedF.glsl",                    mShaderLevel[SHADER_LIGHTING] ) );
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "lighting/lightAlphaMaskNonIndexedF.glsl",                   mShaderLevel[SHADER_LIGHTING] ) );
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "lighting/lightFullbrightNonIndexedF.glsl",          mShaderLevel[SHADER_LIGHTING] ) );
@@ -2872,6 +2877,16 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         success = gDeferredGenBrdfLutProgram.createShader(NULL, NULL);
     }
 
+	if (success) {
+        gPostScreenSpaceReflectionProgram.mName = "Screen Space Reflection Post";
+        gPostScreenSpaceReflectionProgram.mShaderFiles.clear();
+        gPostScreenSpaceReflectionProgram.mShaderFiles.push_back(make_pair("deferred/screenSpaceReflPostV.glsl", GL_VERTEX_SHADER));
+        gPostScreenSpaceReflectionProgram.mShaderFiles.push_back(make_pair("deferred/screenSpaceReflPostF.glsl", GL_FRAGMENT_SHADER));
+        gPostScreenSpaceReflectionProgram.mFeatures.hasScreenSpaceReflections = true;
+        gPostScreenSpaceReflectionProgram.mFeatures.isDeferred                = true;
+        gPostScreenSpaceReflectionProgram.mShaderLevel = 3;
+        success = gPostScreenSpaceReflectionProgram.createShader(NULL, NULL);
+	}
 
 	return success;
 }
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index a2ae984caa..4ed6b02728 100644
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -247,7 +247,7 @@ extern LLGLSLShader			gWLMoonProgram;
 // Post Process Shaders
 extern LLGLSLShader			gPostColorFilterProgram;
 extern LLGLSLShader			gPostNightVisionProgram;
-
+extern LLGLSLShader         gPostScreenSpaceReflectionProgram;
 
 // Deferred rendering shaders
 extern LLGLSLShader			gDeferredImpostorProgram;
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index aa4cd38b99..dff84bda0e 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -215,6 +215,7 @@ bool LLPipeline::CameraOffset;
 F32 LLPipeline::CameraMaxCoF;
 F32 LLPipeline::CameraDoFResScale;
 F32 LLPipeline::RenderAutoHideSurfaceAreaLimit;
+bool LLPipeline::RenderScreenSpaceReflections;
 LLTrace::EventStatHandle<S64> LLPipeline::sStatBatchSize("renderbatchsize");
 
 const F32 BACKLIGHT_DAY_MAGNITUDE_OBJECT = 0.1f;
@@ -345,7 +346,7 @@ bool addDeferredAttachments(LLRenderTarget& target, bool for_impostor = false)
 {
     bool valid = true
         && target.addColorAttachment(GL_RGBA) // frag-data[1] specular OR PBR ORM
-        && target.addColorAttachment(GL_RGB10_A2)                              // frag_data[2] normal+z+fogmask, See: class1\deferred\materialF.glsl & softenlight
+        && target.addColorAttachment(GL_RGBA16F)                              // frag_data[2] normal+z+fogmask, See: class1\deferred\materialF.glsl & softenlight
         && target.addColorAttachment(GL_RGBA);                  // frag_data[3] PBR emissive
     return valid;
 }
@@ -576,6 +577,7 @@ void LLPipeline::init()
 	connectRefreshCachedSettingsSafe("CameraMaxCoF");
 	connectRefreshCachedSettingsSafe("CameraDoFResScale");
 	connectRefreshCachedSettingsSafe("RenderAutoHideSurfaceAreaLimit");
+    connectRefreshCachedSettingsSafe("RenderScreenSpaceReflections");
 	gSavedSettings.getControl("RenderAutoHideSurfaceAreaLimit")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
 }
 
@@ -731,7 +733,7 @@ void LLPipeline::allocatePhysicsBuffer()
 
 	if (mPhysicsDisplay.getWidth() != resX || mPhysicsDisplay.getHeight() != resY)
 	{
-		mPhysicsDisplay.allocate(resX, resY, GL_RGBA, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE);
+		mPhysicsDisplay.allocate(resX, resY, GL_RGBA, TRUE, FALSE, LLTexUnit::TT_TEXTURE, FALSE);
 	}
 }
 
@@ -825,7 +827,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
 
 	if (RenderUIBuffer)
 	{
-		if (!mRT->uiScreen.allocate(resX,resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE))
+		if (!mRT->uiScreen.allocate(resX,resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_TEXTURE, FALSE))
 		{
 			return false;
 		}
@@ -839,14 +841,14 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
 		const U32 occlusion_divisor = 3;
 
 		//allocate deferred rendering color buffers
-		if (!mRT->deferredScreen.allocate(resX, resY, GL_RGBA, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
-		//if (!mRT->deferredDepth.allocate(resX, resY, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
-		if (!mRT->occlusionDepth.allocate(resX/occlusion_divisor, resY/occlusion_divisor, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
+		if (!mRT->deferredScreen.allocate(resX, resY, GL_RGBA, TRUE, FALSE, LLTexUnit::TT_TEXTURE, FALSE, samples)) return false;
+		//if (!mRT->deferredDepth.allocate(resX, resY, 0, TRUE, FALSE, LLTexUnit::TT_TEXTURE, FALSE, samples)) return false;
+		if (!mRT->occlusionDepth.allocate(resX/occlusion_divisor, resY/occlusion_divisor, 0, TRUE, FALSE, LLTexUnit::TT_TEXTURE, FALSE, samples)) return false;
 		if (!addDeferredAttachments(mRT->deferredScreen)) return false;
 	
 		GLuint screenFormat = GL_RGBA16;
         
-		if (!mRT->screen.allocate(resX, resY, screenFormat, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
+		if (!mRT->screen.allocate(resX, resY, screenFormat, FALSE, FALSE, LLTexUnit::TT_TEXTURE, FALSE, samples)) return false;
 
         mRT->deferredScreen.shareDepthBuffer(mRT->screen);
 
@@ -861,7 +863,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
 		
 		if (shadow_detail > 0 || ssao || RenderDepthOfField || samples > 0)
 		{ //only need mRT->deferredLight for shadows OR ssao OR dof OR fxaa
-			if (!mRT->deferredLight.allocate(resX, resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE)) return false;
+			if (!mRT->deferredLight.allocate(resX, resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_TEXTURE, FALSE)) return false;
 		}
 		else
 		{
@@ -889,7 +891,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
 		//mRT->deferredDepth.release();
 		mRT->occlusionDepth.release();
 						
-		if (!mRT->screen.allocate(resX, resY, GL_RGBA, TRUE, TRUE, LLTexUnit::TT_RECT_TEXTURE, FALSE)) return false;		
+		if (!mRT->screen.allocate(resX, resY, GL_RGBA, TRUE, TRUE, LLTexUnit::TT_TEXTURE, FALSE)) return false;		
 	}
 	
 	gGL.getTexUnit(0)->disable();
@@ -1077,6 +1079,7 @@ void LLPipeline::refreshCachedSettings()
 	CameraMaxCoF = gSavedSettings.getF32("CameraMaxCoF");
 	CameraDoFResScale = gSavedSettings.getF32("CameraDoFResScale");
 	RenderAutoHideSurfaceAreaLimit = gSavedSettings.getF32("RenderAutoHideSurfaceAreaLimit");
+    RenderScreenSpaceReflections = gSavedSettings.getBOOL("RenderScreenSpaceReflections");
 	RenderSpotLight = nullptr;
 	updateRenderDeferred();
 
@@ -2543,7 +2546,7 @@ void LLPipeline::downsampleDepthBuffer(LLRenderTarget& source, LLRenderTarget& d
 	vert[1].set(-1,-3,0);
 	vert[2].set(3,1,0);
 	
-	if (source.getUsage() == LLTexUnit::TT_RECT_TEXTURE)
+	if (source.getUsage() == LLTexUnit::TT_TEXTURE)
 	{
 		shader = &gDownsampleDepthRectProgram;
 		shader->bind();
@@ -7573,13 +7576,6 @@ void LLPipeline::renderFinalize()
 
     enableLightsFullbright();
 
-    gGL.matrixMode(LLRender::MM_PROJECTION);
-    gGL.pushMatrix();
-    gGL.loadIdentity();
-    gGL.matrixMode(LLRender::MM_MODELVIEW);
-    gGL.pushMatrix();
-    gGL.loadIdentity();
-
     LLGLDisable test(GL_ALPHA_TEST);
 
     gGL.setColorMask(true, true);
@@ -7587,13 +7583,64 @@ void LLPipeline::renderFinalize()
 
     if (!gCubeSnapshot)
     {
+        if (RenderScreenSpaceReflections)
+        {
+            LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("renderDeferredLighting - screen space reflections");
+            LL_PROFILE_GPU_ZONE("screen space reflections");
+            LLStrider<LLVector3> vert;
+            mDeferredVB->getVertexStrider(vert);
+
+            vert[0].set(-1, 1, 0);
+            vert[1].set(-1, -3, 0);
+            vert[2].set(3, 1, 0);
+
+            // Make sure the deferred VB is a full screen triangle.
+            mDeferredVB->getVertexStrider(vert);
+
+            bindDeferredShader(gPostScreenSpaceReflectionProgram, NULL);
+            mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
+
+            // Provide our projection matrix.
+            auto          camProj    = LLViewerCamera::getInstance()->getProjection();
+            glh::matrix4f projection = get_current_projection();
+            projection.set_row(0, glh::vec4f(camProj.mMatrix[0][0], camProj.mMatrix[0][1], camProj.mMatrix[0][2], camProj.mMatrix[0][3]));
+            projection.set_row(0, glh::vec4f(camProj.mMatrix[1][0], camProj.mMatrix[1][1], camProj.mMatrix[1][2], camProj.mMatrix[1][3]));
+            projection.set_row(0, glh::vec4f(camProj.mMatrix[2][0], camProj.mMatrix[2][1], camProj.mMatrix[2][2], camProj.mMatrix[2][3]));
+            projection.set_row(0, glh::vec4f(camProj.mMatrix[3][0], camProj.mMatrix[3][1], camProj.mMatrix[3][2], camProj.mMatrix[3][3]));
+            gPostScreenSpaceReflectionProgram.uniformMatrix4fv(LLShaderMgr::PROJECTION_MATRIX, 1, FALSE, projection.m);
+
+            // We need linear depth.
+            static LLStaticHashedString zfar("zFar");
+            static LLStaticHashedString znear("zNear");
+            float                       nearClip = LLViewerCamera::getInstance()->getNear();
+            float                       farClip  = LLViewerCamera::getInstance()->getFar();
+            gPostScreenSpaceReflectionProgram.uniform1f(zfar, farClip);
+            gPostScreenSpaceReflectionProgram.uniform1f(znear, nearClip);
+
+            LLRenderTarget *screen_target = &mRT->screen;
+
+            screen_target->bindTarget();
+            S32 channel = gPostScreenSpaceReflectionProgram.enableTexture(LLShaderMgr::DIFFUSE_MAP, mRT->fxaaBuffer.getUsage());
+            if (channel > -1)
+            {
+                screen_target->bindTexture(0, channel, LLTexUnit::TFO_POINT);
+				
+            }
+
+            {
+                LLGLDisable   blend(GL_BLEND);
+                LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_ALWAYS);
+                stop_glerror();
+                mDeferredVB->drawArrays(LLRender::TRIANGLES, 0, 3);
+                stop_glerror();
+            }
+
+            unbindDeferredShader(gPostScreenSpaceReflectionProgram);
+
+            screen_target->flush();
+        }
+
         // gamma correct lighting
-        gGL.matrixMode(LLRender::MM_PROJECTION);
-        gGL.pushMatrix();
-        gGL.loadIdentity();
-        gGL.matrixMode(LLRender::MM_MODELVIEW);
-        gGL.pushMatrix();
-        gGL.loadIdentity();
 
         {
             LL_PROFILE_GPU_ZONE("gamma correct");
@@ -7639,11 +7686,6 @@ void LLPipeline::renderFinalize()
             screen_target->flush();
         }
 
-        gGL.matrixMode(LLRender::MM_PROJECTION);
-        gGL.popMatrix();
-        gGL.matrixMode(LLRender::MM_MODELVIEW);
-        gGL.popMatrix();
-
         LLVertexBuffer::unbind();
     }
 
@@ -7988,8 +8030,8 @@ void LLPipeline::renderFinalize()
 
                 shader->uniform1f(LLShaderMgr::DOF_MAX_COF, CameraMaxCoF);
                 shader->uniform1f(LLShaderMgr::DOF_RES_SCALE, CameraDoFResScale);
-                shader->uniform1f(LLShaderMgr::DOF_WIDTH, dof_width - 1);
-                shader->uniform1f(LLShaderMgr::DOF_HEIGHT, dof_height - 1);
+                shader->uniform1f(LLShaderMgr::DOF_WIDTH, (dof_width - 1) / (F32)mRT->screen.getWidth());
+                shader->uniform1f(LLShaderMgr::DOF_HEIGHT, (dof_height - 1) / (F32)mRT->screen.getHeight());
 
                 gGL.begin(LLRender::TRIANGLE_STRIP);
                 gGL.texCoord2f(tc1.mV[0], tc1.mV[1]);
@@ -8200,11 +8242,6 @@ void LLPipeline::renderFinalize()
                                                   GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_NEAREST);
     }*/
 
-    gGL.matrixMode(LLRender::MM_PROJECTION);
-    gGL.popMatrix();
-    gGL.matrixMode(LLRender::MM_MODELVIEW);
-    gGL.popMatrix();
-
     LLVertexBuffer::unbind();
 
     LLGLState::checkStates();
@@ -8225,24 +8262,28 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_
 	if (channel > -1)
 	{
         deferred_target->bindTexture(0,channel, LLTexUnit::TFO_POINT); // frag_data[0]
+        gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
 	}
 
     channel = shader.enableTexture(LLShaderMgr::DEFERRED_SPECULAR, deferred_target->getUsage());
 	if (channel > -1)
 	{
         deferred_target->bindTexture(1, channel, LLTexUnit::TFO_POINT); // frag_data[1]
+        gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
 	}
 
     channel = shader.enableTexture(LLShaderMgr::DEFERRED_NORMAL, deferred_target->getUsage());
 	if (channel > -1)
 	{
         deferred_target->bindTexture(2, channel, LLTexUnit::TFO_POINT); // frag_data[2]
+        gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
 	}
 
     channel = shader.enableTexture(LLShaderMgr::DEFERRED_EMISSIVE, deferred_target->getUsage());
     if (channel > -1)
     {
         deferred_target->bindTexture(3, channel, LLTexUnit::TFO_POINT); // frag_data[3]
+        gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
     }
 
     channel = shader.enableTexture(LLShaderMgr::DEFERRED_BRDF_LUT, LLTexUnit::TT_TEXTURE);
@@ -8267,14 +8308,6 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_
         stop_glerror();
     }
 #endif
-		
-    glh::matrix4f projection = get_current_projection();
-		glh::matrix4f inv_proj = projection.inverse();
-		
-    if (shader.getUniformLocation(LLShaderMgr::INVERSE_PROJECTION_MATRIX) != -1)
-    {
-		shader.uniformMatrix4fv(LLShaderMgr::INVERSE_PROJECTION_MATRIX, 1, FALSE, inv_proj.m);
-    }
 
     if (shader.getUniformLocation(LLShaderMgr::VIEWPORT) != -1)
     {
@@ -8507,6 +8540,8 @@ LLVector4 pow4fsrgb(LLVector4 v, F32 f)
 
 void LLPipeline::renderDeferredLighting()
 {
+
+
     LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
     LL_PROFILE_GPU_ZONE("renderDeferredLighting");
     if (!sCull)
@@ -8579,12 +8614,6 @@ void LLPipeline::renderDeferredLighting()
         mat.mult_matrix_vec(tc_moon);
         mTransformedMoonDir.set(tc_moon.v);
 
-        gGL.pushMatrix();
-        gGL.loadIdentity();
-        gGL.matrixMode(LLRender::MM_PROJECTION);
-        gGL.pushMatrix();
-        gGL.loadIdentity();
-
         if (RenderDeferredSSAO || RenderShadowDetail > 0)
         {
             LL_PROFILE_GPU_ZONE("sun program");
@@ -8667,15 +8696,17 @@ void LLPipeline::renderDeferredLighting()
 
                 LLVector3 gauss[32];  // xweight, yweight, offset
 
+				F32 screenPixelSize = 1.f / screen_target->getWidth();
+
                 for (U32 i = 0; i < kern_length; i++)
                 {
                     gauss[i].mV[0] = llgaussian(x, go.mV[0]);
                     gauss[i].mV[1] = llgaussian(x, go.mV[1]);
                     gauss[i].mV[2] = x;
-                    x += 1.f;
+                    x += screenPixelSize;
                 }
 
-                gDeferredBlurLightProgram.uniform2f(sDelta, 1.f, 0.f);
+                gDeferredBlurLightProgram.uniform2f(sDelta, screenPixelSize, 0.f);
                 gDeferredBlurLightProgram.uniform1f(sDistFactor, dist_factor);
                 gDeferredBlurLightProgram.uniform3fv(sKern, kern_length, gauss[0].mV);
                 gDeferredBlurLightProgram.uniform1f(sKernScale, blur_size * (kern_length / 2.f - 0.5f));
@@ -8710,14 +8741,6 @@ void LLPipeline::renderDeferredLighting()
             }
         }
 
-        stop_glerror();
-        gGL.popMatrix();
-        stop_glerror();
-        gGL.matrixMode(LLRender::MM_MODELVIEW);
-        stop_glerror();
-        gGL.popMatrix();
-        stop_glerror();
-
         screen_target->bindTarget();
         // clear color buffer here - zeroing alpha (glow) is important or it will accumulate against sky
         glClearColor(0, 0, 0, 0);
@@ -8752,19 +8775,11 @@ void LLPipeline::renderDeferredLighting()
                 LLGLDisable   test(GL_ALPHA_TEST);
 
                 // full screen blit
-                gGL.pushMatrix();
-                gGL.loadIdentity();
-                gGL.matrixMode(LLRender::MM_PROJECTION);
-                gGL.pushMatrix();
-                gGL.loadIdentity();
 
                 mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
 
                 mDeferredVB->drawArrays(LLRender::TRIANGLES, 0, 3);
 
-                gGL.popMatrix();
-                gGL.matrixMode(LLRender::MM_MODELVIEW);
-                gGL.popMatrix();
             }
 
             unbindDeferredShader(LLPipeline::sUnderWaterRender ? gDeferredSoftenWaterProgram : gDeferredSoftenProgram);
@@ -8966,12 +8981,6 @@ void LLPipeline::renderDeferredLighting()
                 LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("renderDeferredLighting - fullscreen lights");
                 LLGLDepthTest depth(GL_FALSE);
                 LL_PROFILE_GPU_ZONE("fullscreen lights");
-                // full screen blit
-                gGL.pushMatrix();
-                gGL.loadIdentity();
-                gGL.matrixMode(LLRender::MM_PROJECTION);
-                gGL.pushMatrix();
-                gGL.loadIdentity();
 
                 U32 count = 0;
 
@@ -9040,13 +9049,10 @@ void LLPipeline::renderDeferredLighting()
 
                 gDeferredMultiSpotLightProgram.disableTexture(LLShaderMgr::DEFERRED_PROJECTION);
                 unbindDeferredShader(gDeferredMultiSpotLightProgram);
-
-                gGL.popMatrix();
-                gGL.matrixMode(LLRender::MM_MODELVIEW);
-                gGL.popMatrix();
             }
         }
 
+
         gGL.setColorMask(true, true);
     }
 
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index 7bad1cbe87..c61fbd8404 100644
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -1026,6 +1026,7 @@ public:
 	static F32 CameraMaxCoF;
 	static F32 CameraDoFResScale;
 	static F32 RenderAutoHideSurfaceAreaLimit;
+	static bool RenderScreenSpaceReflections;
 };
 
 void render_bbox(const LLVector3 &min, const LLVector3 &max);