SL-17705 Backwards compatibility pass. Support OpenGL pre-4.0 by disabling reflection probes and anti-aliasing. Get render parity with current release viewer when reflection probes are disabled.

10 files changed, 81 insertions, 534 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyV.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyV.glsl
index 5264b3b716..0e461b4004 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyV.glsl
@@ -73,12 +73,7 @@ void main()
     vary_position = pos.xyz;
 	vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
 
-#ifndef HAS_REFLECTION_PROBES	
-    vec3 ref = reflect(pos.xyz, -norm);
-	vary_texcoord1 = transpose(normal_matrix) * ref.xyz;
-#else
     vary_texcoord1 = norm;
-#endif
 
 	calcAtmospherics(pos.xyz);
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/genbrdflutF.glsl b/indra/newview/app_settings/shaders/class1/deferred/genbrdflutF.glsl
index 73a70d8dc5..9e6c853015 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/genbrdflutF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/genbrdflutF.glsl
@@ -53,7 +53,7 @@ VARYING vec2 vary_uv;
 
 out vec4 outColor;
 
-#define NUM_SAMPLES 1024
+#define NUM_SAMPLES 1024u
 
 const float PI = 3.1415926536;
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbralphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbralphaF.glsl
index 04be496292..3afa9fb435 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/pbralphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbralphaF.glsl
@@ -99,8 +99,8 @@ vec3 scaleSoftClipFrag(vec3 l);
 void calcHalfVectors(vec3 lv, vec3 n, vec3 v, out vec3 h, out vec3 l, out float nh, out float nl, out float nv, out float vh, out float lightDist);
 float calcLegacyDistanceAttenuation(float distance, float falloff);
 float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen);
-void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyEnv, 
-        vec3 pos, vec3 norm, float glossiness, float envIntensity);
+void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, 
+        vec3 pos, vec3 norm, float glossiness);
 
 // PBR interface
 vec3 pbrIbl(vec3 diffuseColor,
@@ -212,8 +212,7 @@ void main()
     float gloss      = 1.0 - perceptualRoughness;
     vec3  irradiance = vec3(0);
     vec3  radiance  = vec3(0);
-    vec3 legacyenv = vec3(0);
-    sampleReflectionProbes(irradiance, radiance, legacyenv, pos.xyz, norm.xyz, gloss, 0.0);
+    sampleReflectionProbes(irradiance, radiance, pos.xyz, norm.xyz, gloss);
     irradiance       = max(srgb_to_linear(amblit),irradiance) * ambocc*4.0;
 
     vec3 f0 = vec3(0.04);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/reflectionProbeF.glsl b/indra/newview/app_settings/shaders/class1/deferred/reflectionProbeF.glsl
index 8f3e38b08b..4b79297aef 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/reflectionProbeF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/reflectionProbeF.glsl
@@ -24,7 +24,14 @@
  */
 
 // fallback stub -- will be used if actual reflection probe shader failed to load (output pink so it's obvious)
-void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
+void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv,
+        vec3 pos, vec3 norm, float glossiness)
+{
+    ambenv = vec3(1,0,1);
+    glossenv = vec3(1,0,1);
+}
+
+void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
         vec3 pos, vec3 norm, float glossiness, float envIntensity)
 {
     ambenv = vec3(1,0,1);
@@ -34,11 +41,11 @@ void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 l
 
 void applyGlossEnv(inout vec3 color, vec3 glossenv, vec4 spec, vec3 pos, vec3 norm)
 {
-    color = vec3(1,0,1);
+    
 }
 
 void applyLegacyEnv(inout vec3 color, vec3 legacyenv, vec4 spec, vec3 pos, vec3 norm, float envIntensity)
 {
-    color = vec3(1,0,1);
+
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index 918e119c31..4b34e55efd 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -156,12 +156,6 @@ void main()
 
     }
 
-// linear debuggables
-//color.rgb = vec3(final_da);
-//color.rgb = vec3(ambient);
-//color.rgb = vec3(scol);
-//color.rgb = diffuse_srgb.rgb;
-
     // convert to linear as fullscreen lights need to sum in linear colorspace
     // and will be gamma (re)corrected downstream...
     
diff --git a/indra/newview/app_settings/shaders/class2/deferred/reflectionProbeF.glsl b/indra/newview/app_settings/shaders/class2/deferred/reflectionProbeF.glsl
index 3d96fe25be..15d6b5a05d 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/reflectionProbeF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/reflectionProbeF.glsl
@@ -23,455 +23,46 @@
  * $/LicenseInfo$
  */
 
-#extension GL_ARB_shader_texture_lod : enable
+// Implementation for when reflection probes are disabled
 
-#define FLT_MAX 3.402823466e+38
+uniform float minimumReflectionAmbiance;
 
-#define REFMAP_COUNT 256
-#define REF_SAMPLE_COUNT 64 //maximum number of samples to consider
+uniform samplerCube environmentMap;
 
-uniform samplerCubeArray   reflectionProbes;
-
-layout (std140) uniform ReflectionProbes
-{
-    // list of OBBs for user override probes
-    // box is a set of 3 planes outward facing planes and the depth of the box along that plane
-    // for each box refBox[i]...
-    /// box[0..2] - plane 0 .. 2 in [A,B,C,D] notation
-    //  box[3][0..2] - plane thickness
-    mat4 refBox[REFMAP_COUNT];
-    // list of bounding spheres for reflection probes sorted by distance to camera (closest first)
-    vec4 refSphere[REFMAP_COUNT];
-    // index  of cube map in reflectionProbes for a corresponding reflection probe
-    // e.g. cube map channel of refSphere[2] is stored in refIndex[2]
-    // refIndex.x - cubemap channel in reflectionProbes
-    // refIndex.y - index in refNeighbor of neighbor list (index is ivec4 index, not int index)
-    // refIndex.z - number of neighbors
-    // refIndex.w - priority, if negative, this probe has a box influence
-    ivec4 refIndex[REFMAP_COUNT];
-
-    // neighbor list data (refSphere indices, not cubemap array layer)
-    ivec4 refNeighbor[1024];
-
-    // number of reflection probes present in refSphere
-    int refmapCount;
-
-    // intensity of ambient light from reflection probes
-    float reflectionAmbiance;
-};
-
-// Inputs
 uniform mat3 env_mat;
 
-// list of probeIndexes shader will actually use after "getRefIndex" is called
-// (stores refIndex/refSphere indices, NOT rerflectionProbes layer)
-int probeIndex[REF_SAMPLE_COUNT];
-
-// number of probes stored in probeIndex
-int probeInfluences = 0;
-
-bool isAbove(vec3 pos, vec4 plane)
-{
-    return (dot(plane.xyz, pos) + plane.w) > 0;
-}
-
-// return true if probe at index i influences position pos
-bool shouldSampleProbe(int i, vec3 pos)
-{
-    if (refIndex[i].w < 0)
-    {
-        vec4 v = refBox[i] * vec4(pos, 1.0);
-        if (abs(v.x) > 1 || 
-            abs(v.y) > 1 ||
-            abs(v.z) > 1)
-        {
-            return false;
-        }
-    }
-    else
-    {
-        vec3 delta = pos.xyz - refSphere[i].xyz;
-        float d = dot(delta, delta);
-        float r2 = refSphere[i].w;
-        r2 *= r2;
-
-        if (d > r2)
-        { //outside bounding sphere
-            return false;
-        }
-    }
-
-    return true;
-}
-
-// call before sampleRef
-// populate "probeIndex" with N probe indices that influence pos where N is REF_SAMPLE_COUNT
-// overall algorithm -- 
-void preProbeSample(vec3 pos)
-{
-    // TODO: make some sort of structure that reduces the number of distance checks
-
-    for (int i = 0; i < refmapCount; ++i)
-    {
-        // found an influencing probe
-        if (shouldSampleProbe(i, pos))
-        {
-            probeIndex[probeInfluences] = i;
-            ++probeInfluences;
-
-            int neighborIdx = refIndex[i].y;
-            if (neighborIdx != -1)
-            {
-                int neighborCount = min(refIndex[i].z, REF_SAMPLE_COUNT-1);
-
-                int count = 0;
-                while (count < neighborCount)
-                {
-                    // check up to REF_SAMPLE_COUNT-1 neighbors (neighborIdx is ivec4 index)
-
-                    int idx = refNeighbor[neighborIdx].x;
-                    if (shouldSampleProbe(idx, pos))
-                    {
-                        probeIndex[probeInfluences++] = idx;
-                        if (probeInfluences == REF_SAMPLE_COUNT)
-                        {
-                            return;
-                        }
-                    }
-                    count++;
-                    if (count == neighborCount)
-                    {
-                        return;
-                    }
-
-                    idx = refNeighbor[neighborIdx].y;
-                    if (shouldSampleProbe(idx, pos))
-                    {
-                        probeIndex[probeInfluences++] = idx;
-                        if (probeInfluences == REF_SAMPLE_COUNT)
-                        {
-                            return;
-                        }
-                    }
-                    count++;
-                    if (count == neighborCount)
-                    {
-                        return;
-                    }
-
-                    idx = refNeighbor[neighborIdx].z;
-                    if (shouldSampleProbe(idx, pos))
-                    {
-                        probeIndex[probeInfluences++] = idx;
-                        if (probeInfluences == REF_SAMPLE_COUNT)
-                        {
-                            return;
-                        }
-                    }
-                    count++;
-                    if (count == neighborCount)
-                    {
-                        return;
-                    }
-
-                    idx = refNeighbor[neighborIdx].w;
-                    if (shouldSampleProbe(idx, pos))
-                    {
-                        probeIndex[probeInfluences++] = idx;
-                        if (probeInfluences == REF_SAMPLE_COUNT)
-                        {
-                            return;
-                        }
-                    }
-                    count++;
-                    if (count == neighborCount)
-                    {
-                        return;
-                    }
-
-                    ++neighborIdx;
-                }
-
-                return;
-            }
-        }
-    }
-}
-
-// from https://www.scratchapixel.com/lessons/3d-basic-rendering/minimal-ray-tracer-rendering-simple-shapes/ray-sphere-intersection
-
-// original reference implementation:
-/*
-bool intersect(const Ray &ray) const 
-{ 
-        float t0, t1; // solutions for t if the ray intersects 
-#if 0 
-        // geometric solution
-        Vec3f L = center - orig; 
-        float tca = L.dotProduct(dir); 
-        // if (tca < 0) return false;
-        float d2 = L.dotProduct(L) - tca * tca; 
-        if (d2 > radius2) return false; 
-        float thc = sqrt(radius2 - d2); 
-        t0 = tca - thc; 
-        t1 = tca + thc; 
-#else 
-        // analytic solution
-        Vec3f L = orig - center; 
-        float a = dir.dotProduct(dir); 
-        float b = 2 * dir.dotProduct(L); 
-        float c = L.dotProduct(L) - radius2; 
-        if (!solveQuadratic(a, b, c, t0, t1)) return false; 
-#endif 
-        if (t0 > t1) std::swap(t0, t1); 
- 
-        if (t0 < 0) { 
-            t0 = t1; // if t0 is negative, let's use t1 instead 
-            if (t0 < 0) return false; // both t0 and t1 are negative 
-        } 
- 
-        t = t0; 
- 
-        return true; 
-} */
-
-// adapted -- assume that origin is inside sphere, return distance from origin to edge of sphere
-vec3 sphereIntersect(vec3 origin, vec3 dir, vec3 center, float radius2)
-{ 
-        float t0, t1; // solutions for t if the ray intersects 
-
-        vec3 L = center - origin; 
-        float tca = dot(L,dir);
-
-        float d2 = dot(L,L) - tca * tca; 
-
-        float thc = sqrt(radius2 - d2); 
-        t0 = tca - thc; 
-        t1 = tca + thc; 
- 
-        vec3 v = origin + dir * t1;
-        return v; 
-} 
-
-// from https://seblagarde.wordpress.com/2012/09/29/image-based-lighting-approaches-and-parallax-corrected-cubemap/
-/*
-vec3 DirectionWS = normalize(PositionWS - CameraWS);
-vec3 ReflDirectionWS = reflect(DirectionWS, NormalWS);
-
-// Intersection with OBB convertto unit box space
-// Transform in local unit parallax cube space (scaled and rotated)
-vec3 RayLS = MulMatrix( float(3x3)WorldToLocal, ReflDirectionWS);
-vec3 PositionLS = MulMatrix( WorldToLocal, PositionWS);
-
-vec3 Unitary = vec3(1.0f, 1.0f, 1.0f);
-vec3 FirstPlaneIntersect  = (Unitary - PositionLS) / RayLS;
-vec3 SecondPlaneIntersect = (-Unitary - PositionLS) / RayLS;
-vec3 FurthestPlane = max(FirstPlaneIntersect, SecondPlaneIntersect);
-float Distance = min(FurthestPlane.x, min(FurthestPlane.y, FurthestPlane.z));
-
-// Use Distance in WS directly to recover intersection
-vec3 IntersectPositionWS = PositionWS + ReflDirectionWS * Distance;
-vec3 ReflDirectionWS = IntersectPositionWS - CubemapPositionWS;
+vec3 srgb_to_linear(vec3 c);
 
-return texCUBE(envMap, ReflDirectionWS);
-*/
-
-// get point of intersection with given probe's box influence volume
-// origin - ray origin in clip space
-// dir - ray direction in clip space
-// i - probe index in refBox/refSphere
-vec3 boxIntersect(vec3 origin, vec3 dir, int i)
-{
-    // Intersection with OBB convertto unit box space
-    // Transform in local unit parallax cube space (scaled and rotated)
-    mat4 clipToLocal = refBox[i];
-
-    vec3 RayLS = mat3(clipToLocal) * dir;
-    vec3 PositionLS = (clipToLocal * vec4(origin, 1.0)).xyz;
-
-    vec3 Unitary = vec3(1.0f, 1.0f, 1.0f);
-    vec3 FirstPlaneIntersect  = (Unitary - PositionLS) / RayLS;
-    vec3 SecondPlaneIntersect = (-Unitary - PositionLS) / RayLS;
-    vec3 FurthestPlane = max(FirstPlaneIntersect, SecondPlaneIntersect);
-    float Distance = min(FurthestPlane.x, min(FurthestPlane.y, FurthestPlane.z));
-
-    // Use Distance in CS directly to recover intersection
-    vec3 IntersectPositionCS = origin + dir * Distance;
-
-    return IntersectPositionCS;
-}
-
-
-
-// Tap a sphere based reflection probe
-// pos - position of pixel
-// dir - pixel normal
-// lod - which mip to bias towards (lower is higher res, sharper reflections)
-// c - center of probe
-// r2 - radius of probe squared
-// i - index of probe 
-// vi - point at which reflection vector struck the influence volume, in clip space
-vec3 tapRefMap(vec3 pos, vec3 dir, float lod, vec3 c, float r2, int i)
+void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv,
+        vec3 pos, vec3 norm, float glossiness)
 {
-    //lod = max(lod, 1);
-    // parallax adjustment
-
-    vec3 v;
-    if (refIndex[i].w < 0)
-    {
-        v = boxIntersect(pos, dir, i);
-    }
-    else
-    {
-        v = sphereIntersect(pos, dir, c, r2);
-    }
-
-    v -= c;
-    v = env_mat * v;
-    {
-        float min_lod = textureQueryLod(reflectionProbes,v).y; // lower is higher res
-        return textureLod(reflectionProbes, vec4(v.xyz, refIndex[i].x), max(min_lod, lod)).rgb;
-        //return texture(reflectionProbes, vec4(v.xyz, refIndex[i].x)).rgb;
-    }
-}
-
-vec3 sampleProbes(vec3 pos, vec3 dir, float lod)
-{
-    float wsum = 0.0;
-    vec3 col = vec3(0,0,0);
-    float vd2 = dot(pos,pos); // view distance squared
-
-    for (int idx = 0; idx < probeInfluences; ++idx)
-    {
-        int i = probeIndex[idx];
-        float r = refSphere[i].w; // radius of sphere volume
-        float p = float(abs(refIndex[i].w)); // priority
-        float rr = r*r; // radius squred
-        float r1 = r * 0.1; // 75% of radius (outer sphere to start interpolating down)
-        vec3 delta = pos.xyz-refSphere[i].xyz;
-        float d2 = dot(delta,delta);
-        float r2 = r1*r1; 
-        
-        {
-            vec3 refcol = tapRefMap(pos, dir, lod, refSphere[i].xyz, rr, i);
-            
-            float w = 1.0/d2;
-
-            float atten = 1.0-max(d2-r2, 0.0)/(rr-r2);
-            w *= atten;
-            w *= p; // boost weight based on priority
-            col += refcol*w;
-            
-            wsum += w;
-        }
-    }
-
-    if (probeInfluences <= 1)
-    { //edge-of-scene probe or no probe influence, mix in with embiggened version of probes closest to camera 
-        for (int idx = 0; idx < 8; ++idx)
-        {
-            if (refIndex[idx].w < 0)
-            { // don't fallback to box probes, they are *very* specific
-                continue;
-            }
-            int i = idx;
-            vec3 delta = pos.xyz-refSphere[i].xyz;
-            float d2 = dot(delta,delta);
-            
-            {
-                vec3 refcol = tapRefMap(pos, dir, lod, refSphere[i].xyz, d2, i);
-                
-                float w = 1.0/d2;
-                w *= w;
-                col += refcol*w;
-                wsum += w;
-            }
-        }
-    }
-
-    if (wsum > 0.0)
-    {
-        col *= 1.0/wsum;
-    }
+    ambenv = vec3(0,0,0);
     
-    return col;
+    vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
+    vec3 env_vec = env_mat * refnormpersp;
+    glossenv = srgb_to_linear(textureCube(environmentMap, env_vec).rgb);
 }
 
-vec3 sampleProbeAmbient(vec3 pos, vec3 dir, float lod)
+void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
+        vec3 pos, vec3 norm, float glossiness, float envIntensity)
 {
-    vec3 col = sampleProbes(pos, dir, lod);
-
-    //desaturate
-    vec3 hcol = col *0.5;
-    
-    col *= 2.0;
-    col = vec3(
-        col.r + hcol.g + hcol.b,
-        col.g + hcol.r + hcol.b,
-        col.b + hcol.r + hcol.g
-    );
+    ambenv = vec3(0,0,0);
     
-    col *= 0.333333;
+    vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
+    vec3 env_vec = env_mat * refnormpersp;
 
-    return col*reflectionAmbiance;
+    legacyenv = textureCube(environmentMap, env_vec).rgb;
 
+    glossenv = legacyenv;
 }
 
-// brighten a color so that at least one component is 1
-vec3 brighten(vec3 c)
-{
-    float m = max(max(c.r, c.g), c.b);
-
-    if (m == 0)
-    {
-        return vec3(1,1,1);
-    }
-
-    return c * 1.0/m;
-}
-
-
-void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
-        vec3 pos, vec3 norm, float glossiness, float envIntensity)
+void applyGlossEnv(inout vec3 color, vec3 glossenv, vec4 spec, vec3 pos, vec3 norm)
 {
-    // TODO - don't hard code lods
-    float reflection_lods = 8;
-    preProbeSample(pos);
-
-    vec3 refnormpersp = reflect(pos.xyz, norm.xyz);
-
-    ambenv = sampleProbeAmbient(pos, norm, reflection_lods-1);
-
-    if (glossiness > 0.0)
-    {
-        float lod = (1.0-glossiness)*reflection_lods;
-        glossenv = sampleProbes(pos, normalize(refnormpersp), lod);
-    }
-
-    if (envIntensity > 0.0)
-    {
-        legacyenv = sampleProbes(pos, normalize(refnormpersp), 0.0);
-    }
+    
 }
 
-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)
 {
-    glossenv *= 0.35; // fudge darker
-    float fresnel = 1.0+dot(normalize(pos.xyz), norm.xyz);
-    float minf = spec.a * 0.1;
-    fresnel = fresnel * (1.0-minf) + minf;
-    glossenv *= spec.rgb*min(fresnel, 1.0);
-    color.rgb += glossenv;
+    color = mix(color.rgb, legacyenv, envIntensity);
 }
 
- void applyLegacyEnv(inout vec3 color, vec3 legacyenv, vec4 spec, vec3 pos, vec3 norm, float envIntensity)
- {
-    vec3 reflected_color = legacyenv; //*0.5; //fudge darker
-    vec3 lookAt = normalize(pos);
-    float fresnel = 1.0+dot(lookAt, norm.xyz);
-    fresnel *= fresnel;
-    fresnel = min(fresnel+envIntensity, 1.0);
-    reflected_color *= (envIntensity*fresnel)*brighten(spec.rgb);
-    color = mix(color.rgb, reflected_color, envIntensity);
- }
-
diff --git a/indra/newview/app_settings/shaders/class3/deferred/fullbrightShinyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/fullbrightShinyF.glsl
index 67f1fc4c18..c0a1491446 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/fullbrightShinyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/fullbrightShinyF.glsl
@@ -55,13 +55,11 @@ void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, ou
 vec3 linear_to_srgb(vec3 c);
 vec3 srgb_to_linear(vec3 c);
 
-#ifdef HAS_REFLECTION_PROBES
 // reflection probe interface
-void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyEnv, 
+void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyEnv, 
         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);
-#endif
 
 // See:
 //   class1\deferred\fullbrightShinyF.glsl
@@ -87,35 +85,21 @@ void main()
         calcAtmosphericVars(pos.xyz, vec3(0), 1.0, sunlit, amblit, additive, atten, false);
 
         float env_intensity = vertex_color.a;
-#ifndef HAS_REFLECTION_PROBES
-        vec3 envColor = textureCube(environmentMap, vary_texcoord1.xyz).rgb;	
-        color.rgb = mix(color.rgb, envColor.rgb, env_intensity);
-#else
+
         vec3 ambenv;
         vec3 glossenv;
         vec3 legacyenv;
         vec3 norm = normalize(vary_texcoord1.xyz);
         vec4 spec = vec4(0,0,0,0);
-        sampleReflectionProbes(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, spec.a, env_intensity);
-        legacyenv *= 1.5; // fudge brighter
+        sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, spec.a, env_intensity);
         applyLegacyEnv(color.rgb, legacyenv, spec, pos, norm, env_intensity);
-#endif
+
         color.rgb = fullbrightAtmosTransportFrag(color.rgb, additive, atten);
         color.rgb = fullbrightScaleSoftClip(color.rgb);
 	}
 
-/*
-	// NOTE: HUD objects will be full bright. Uncomment if you want "some" environment lighting effecting these HUD objects.
-	else
-	{
-		vec3  envColor = textureCube(environmentMap, vary_texcoord1.xyz).rgb;
-		float env_intensity = vertex_color.a;
-		color.rgb = mix(color.rgb, envColor.rgb, env_intensity);
-	}
-*/
-
 	color.a = 1.0;
-
+    
     color.rgb = srgb_to_linear(color.rgb);
 	frag_color = color;
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl
index 07f50af7e3..27eb0b9888 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl
@@ -64,12 +64,10 @@ out vec4 frag_color;
 float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen);
 #endif
 
-#ifdef HAS_REFLECTION_PROBES
-void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
+void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
         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);
-#endif
 
 uniform samplerCube environmentMap;
 uniform sampler2D     lightFunc;
@@ -326,27 +324,12 @@ void main()
     da = pow(da, 1.0 / 1.3);
     vec3 sun_contrib = min(da, shadow) * sunlit;
 
-#ifdef HAS_REFLECTION_PROBES
     vec3 ambenv;
     vec3 glossenv;
     vec3 legacyenv;
-    sampleReflectionProbes(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, spec.a, envIntensity);
+    sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, spec.a, envIntensity);
     amblit = max(ambenv, amblit);
     color.rgb = amblit;
-#else
-
-    color = amblit;
-
-    //darken ambient for normals perpendicular to light vector so surfaces in shadow 
-    // and facing away from light still have some definition to them.
-    // do NOT gamma correct this dot product so ambient lighting stays soft
-    float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
-    ambient *= 0.5;
-    ambient *= ambient;
-    ambient = (1.0 - ambient);
-
-    color *= ambient;
-#endif
 
     color += sun_contrib;
 
@@ -368,37 +351,14 @@ void main()
 
         color += spec_contrib;
 
-#ifdef HAS_REFLECTION_PROBES
         applyGlossEnv(color, glossenv, spec, pos.xyz, norm.xyz);
-#endif
     }
 
-#ifdef HAS_REFLECTION_PROBES
+    color = atmosFragLighting(color, additive, atten);
     if (envIntensity > 0.0)
     {  // add environmentmap
-        //fudge darker
-        legacyenv *= 0.5*diffuse.a+0.5;
-        
         applyLegacyEnv(color, legacyenv, spec, pos.xyz, norm.xyz, envIntensity);
     }
-#else
-    if (envIntensity > 0.0)
-    {
-        //add environmentmap
-        vec3 env_vec = env_mat * refnormpersp;
-
-        vec3 reflected_color = textureCube(environmentMap, env_vec).rgb;
-
-        color = mix(color, reflected_color, envIntensity);
-
-        float cur_glare = max(reflected_color.r, reflected_color.g);
-        cur_glare = max(cur_glare, reflected_color.b);
-        cur_glare *= envIntensity*4.0;
-        glare += cur_glare;
-    }
-#endif
-
-    color = atmosFragLighting(color, additive, atten);
     color = scaleSoftClipFrag(color);
 
     //convert to linear before adding local lights
@@ -410,6 +370,8 @@ void main()
     
     final_specular.rgb = srgb_to_linear(final_specular.rgb); // SL-14035
 
+    color = mix(color.rgb, srgb_to_linear(diffcol.rgb), diffuse.a);
+
 #define LIGHT_LOOP(i) light.rgb += calcPointLightOrSpotLight(light_diffuse[i].rgb, npos, diffuse.rgb, final_specular, pos.xyz, norm.xyz, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z, glare, light_attenuation[i].w );
 
     LIGHT_LOOP(1)
@@ -431,7 +393,6 @@ void main()
     al = temp.a;
 #endif
 
-    color = mix(color.rgb, srgb_to_linear(diffcol.rgb), diffuse.a);
     frag_color = vec4(color, al);
 
 #else // mode is not DIFFUSE_ALPHA_MODE_BLEND, encode to gbuffer 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl b/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
index 463709de9e..beb0f6f2a6 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
@@ -23,8 +23,6 @@
  * $/LicenseInfo$
  */
 
-#extension GL_ARB_shader_texture_lod : enable
-
 #define FLT_MAX 3.402823466e+38
 
 #define REFMAP_COUNT 256
@@ -33,6 +31,8 @@
 uniform samplerCubeArray   reflectionProbes;
 uniform samplerCubeArray   irradianceProbes;
 
+vec3 linear_to_srgb(vec3 col);
+
 layout (std140) uniform ReflectionProbes
 {
     // list of OBBs for user override probes
@@ -520,7 +520,22 @@ vec3 brighten(vec3 c)
 }
 
 
-void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
+void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv,
+        vec3 pos, vec3 norm, float glossiness)
+{
+    // TODO - don't hard code lods
+    float reflection_lods = 7;
+    preProbeSample(pos);
+
+    vec3 refnormpersp = reflect(pos.xyz, norm.xyz);
+
+    ambenv = sampleProbeAmbient(pos, norm);
+
+    float lod = (1.0-glossiness)*reflection_lods;
+    glossenv = sampleProbes(pos, normalize(refnormpersp), lod, 1.f);
+}
+
+void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv,
         vec3 pos, vec3 norm, float glossiness, float envIntensity)
 {
     // TODO - don't hard code lods
@@ -531,16 +546,22 @@ void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 l
 
     ambenv = sampleProbeAmbient(pos, norm);
 
-    //if (glossiness > 0.0)
+    if (glossiness > 0.0)
     {
         float lod = (1.0-glossiness)*reflection_lods;
         glossenv = sampleProbes(pos, normalize(refnormpersp), lod, 1.f);
+        glossenv = linear_to_srgb(glossenv);
     }
 
     if (envIntensity > 0.0)
     {
         legacyenv = sampleProbes(pos, normalize(refnormpersp), 0.0, 1.f);
+        legacyenv = linear_to_srgb(legacyenv);
     }
+
+    // legacy expects values in sRGB space for now
+    ambenv = linear_to_srgb(ambenv);
+
 }
 
 void applyGlossEnv(inout vec3 color, vec3 glossenv, vec4 spec, vec3 pos, vec3 norm)
@@ -555,7 +576,7 @@ void applyGlossEnv(inout vec3 color, vec3 glossenv, vec4 spec, vec3 pos, vec3 no
 
  void applyLegacyEnv(inout vec3 color, vec3 legacyenv, vec4 spec, vec3 pos, vec3 norm, float envIntensity)
  {
-    vec3 reflected_color = legacyenv; //*0.5; //fudge darker
+    vec3 reflected_color = legacyenv;
     vec3 lookAt = normalize(pos);
     float fresnel = 1.0+dot(lookAt, norm.xyz);
     fresnel *= fresnel;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index 5c049b6bd6..cfdbbdfe2c 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -76,7 +76,9 @@ vec3  fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
 vec3  fullbrightScaleSoftClip(vec3 light);
 
 // reflection probe interface
-void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyEnv, 
+void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv,
+        vec3 pos, vec3 norm, float glossiness);
+void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyEnv, 
         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);
@@ -156,7 +158,7 @@ void main()
         float gloss      = 1.0 - perceptualRoughness;
         vec3  irradiance = vec3(0);
         vec3  radiance  = vec3(0);
-        sampleReflectionProbes(irradiance, radiance, legacyenv, pos.xyz, norm.xyz, gloss, 0.0);
+        sampleReflectionProbes(irradiance, radiance, pos.xyz, norm.xyz, gloss);
         irradiance       = max(srgb_to_linear(amblit),irradiance) * ambocc*4.0;
 
         vec3 f0 = vec3(0.04);
@@ -196,10 +198,8 @@ void main()
 
         //diffuse.rgb = linear_to_srgb(diffuse.rgb); // SL-14035
 
-        sampleReflectionProbes(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, spec.a, envIntensity);
-        ambenv.rgb = linear_to_srgb(ambenv.rgb); 
-        glossenv.rgb = linear_to_srgb(glossenv.rgb);
-        legacyenv.rgb = linear_to_srgb(legacyenv.rgb);
+        sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, spec.a, envIntensity);
+        vec3 debug = legacyenv;
 
         amblit = max(ambenv, amblit);
         color.rgb = amblit*ambocc;
@@ -227,16 +227,13 @@ void main()
 
         color.rgb = mix(color.rgb, diffuse.rgb, diffuse.a);
 
-        if (envIntensity > 0.0)
-        {  // add environmentmap
-            //fudge darker
-            legacyenv *= 0.5*diffuse.a+0.5;
-            applyLegacyEnv(color, legacyenv, spec, pos.xyz, norm.xyz, envIntensity);
-        }
-
         if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_ATMOS))
         {
             color = mix(atmosFragLighting(color, additive, atten), fullbrightAtmosTransportFrag(color, additive, atten), diffuse.a);
+            if (envIntensity > 0.0)
+            {  // add environmentmap
+                applyLegacyEnv(color, legacyenv, spec, pos.xyz, norm.xyz, envIntensity);
+            }
             color = mix(scaleSoftClipFrag(color), fullbrightScaleSoftClip(color), diffuse.a);
         }
 
@@ -248,8 +245,6 @@ void main()
 
         // convert to linear as fullscreen lights need to sum in linear colorspace
         // and will be gamma (re)corrected downstream...
-        //color = ambenv;
-        //color.b = diffuse.a;
         frag_color.rgb = srgb_to_linear(color.rgb);
     }