SL-18190 WIP -- Take 2 on linear space windlight (more methodical approach -- make desired interface but brute force color conversions). Placeholder PBR water and move to deprecate forward rendering shaders.

17 files changed, 832 insertions, 866 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index b72c9651c1..f4ec1ec532 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -25,281 +25,11 @@
 
 //class1/deferred/alphaF.glsl
 
-#extension GL_ARB_texture_rectangle : enable
 
-/*[EXTRA_CODE_HERE]*/
-
-#define INDEXED 1
-#define NON_INDEXED 2
-#define NON_INDEXED_NO_COLOR 3
-
-#ifdef DEFINE_GL_FRAGCOLOR
 out vec4 frag_color;
-#else
-#define frag_color gl_FragColor
-#endif
-
-uniform mat3 env_mat;
-uniform vec3 sun_dir;
-uniform vec3 moon_dir;
-
-#ifdef USE_DIFFUSE_TEX
-uniform sampler2D diffuseMap;
-#endif
-
-VARYING vec3 vary_fragcoord;
-VARYING vec3 vary_position;
-VARYING vec2 vary_texcoord0;
-VARYING vec3 vary_norm;
-
-#ifdef USE_VERTEX_COLOR
-VARYING vec4 vertex_color; //vertex color should be treated as sRGB
-#endif
-
-#ifdef HAS_ALPHA_MASK
-uniform float minimum_alpha;
-#endif
-
-uniform mat4 proj_mat;
-uniform mat4 inv_proj;
-uniform vec2 screen_res;
-uniform int sun_up_factor;
-uniform vec4 light_position[8];
-uniform vec3 light_direction[8];
-uniform vec4 light_attenuation[8]; 
-uniform vec3 light_diffuse[8];
-
-#ifdef WATER_FOG
-vec4 applyWaterFogView(vec3 pos, vec4 color);
-#endif
 
-vec3 srgb_to_linear(vec3 c);
-vec3 linear_to_srgb(vec3 c);
-
-vec2 encode_normal (vec3 n);
-vec3 scaleSoftClipFrag(vec3 l);
-vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten);
-
-void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 atten, out vec3 additive, bool use_ao);
-
-#ifdef HAS_SHADOW
-float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen);
-#endif
-
-float getAmbientClamp();
-
-void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
-        vec3 pos, vec3 norm, float glossiness, float envIntensity);
-
-vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 diffuse, vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float fa, float is_pointlight, float ambiance)
+void main()
 {
-    // SL-14895 inverted attenuation work-around
-    // This routine is tweaked to match deferred lighting, but previously used an inverted la value. To reconstruct
-    // that previous value now that the inversion is corrected, we reverse the calculations in LLPipeline::setupHWLights()
-    // to recover the `adjusted_radius` value previously being sent as la.
-    float falloff_factor = (12.0 * fa) - 9.0;
-    float inverted_la = falloff_factor / la;
-    // Yes, it makes me want to cry as well. DJH
-    
-    vec3 col = vec3(0);
-
-	//get light vector
-	vec3 lv = lp.xyz-v;
-
-	//get distance
-	float dist = length(lv);
-	float da = 1.0;
-
-    /*if (dist > inverted_la)
-    {
-        return col;
-    }
-
-    clip to projector bounds
-     vec4 proj_tc = proj_mat * lp;
-
-    if (proj_tc.z < 0
-     || proj_tc.z > 1
-     || proj_tc.x < 0
-     || proj_tc.x > 1 
-     || proj_tc.y < 0
-     || proj_tc.y > 1)
-    {
-        return col;
-    }*/
-
-	if (dist > 0.0 && inverted_la > 0.0)
-	{
-        dist /= inverted_la;
-
-		//normalize light vector
-		lv = normalize(lv);
-	
-		//distance attenuation
-		float dist_atten = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
-		dist_atten *= dist_atten;
-        dist_atten *= 2.0f;
-
-        if (dist_atten <= 0.0)
-        {
-           return col;
-        }
-
-		// spotlight coefficient.
-		float spot = max(dot(-ln, lv), is_pointlight);
-		da *= spot*spot; // GL_SPOT_EXPONENT=2
-
-		//angular attenuation
-		da *= dot(n, lv);
-        da = max(0.0, da);
-
-		float lit = 0.0f;
-
-        float amb_da = 0.0;//ambiance;
-        if (da > 0)
-        {
-		    lit = max(da * dist_atten,0.0);
-            col = lit * light_col * diffuse;
-            amb_da += (da*0.5+0.5) * ambiance;
-        }
-        amb_da += (da*da*0.5 + 0.5) * ambiance;
-        amb_da *= dist_atten;
-        amb_da = min(amb_da, 1.0f - lit);
-
-        // SL-10969 ... need to work out why this blows out in many setups...
-        //col.rgb += amb_da * light_col * diffuse;
-
-        // no spec for alpha shader...
-    }
-    col = max(col, vec3(0));
-    return col;
-}
-
-void main() 
-{
-    vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
-    frag *= screen_res;
-    
-    vec4 pos = vec4(vary_position, 1.0);
-    vec3 norm = vary_norm;
-
-    float shadow = 1.0f;
-
-#ifdef HAS_SHADOW
-    shadow = sampleDirectionalShadow(pos.xyz, norm.xyz, frag);
-#endif
-
-#ifdef USE_DIFFUSE_TEX
-    vec4 diffuse_tap = texture2D(diffuseMap,vary_texcoord0.xy);
-#endif
-
-#ifdef USE_INDEXED_TEX
-    vec4 diffuse_tap = diffuseLookup(vary_texcoord0.xy);
-#endif
-
-    vec4 diffuse_srgb = diffuse_tap;
-
-#ifdef FOR_IMPOSTOR
-    vec4 color;
-    color.rgb = diffuse_srgb.rgb;
-    color.a = 1.0;
-
-    float final_alpha = diffuse_srgb.a * vertex_color.a;
-    diffuse_srgb.rgb *= vertex_color.rgb;
-    
-    // Insure we don't pollute depth with invis pixels in impostor rendering
-    //
-    if (final_alpha < minimum_alpha)
-    {
-        discard;
-    }
-
-    color.rgb = diffuse_srgb.rgb;
-    color.a = final_alpha;
-
-#else // FOR_IMPOSTOR
-
-    vec4 diffuse_linear = vec4(srgb_to_linear(diffuse_srgb.rgb), diffuse_srgb.a);
-
-    vec3 light_dir = (sun_up_factor == 1) ? sun_dir: moon_dir;
-
-    float final_alpha = diffuse_linear.a;
-
-#ifdef USE_VERTEX_COLOR
-    final_alpha *= vertex_color.a;
-
-    if (final_alpha < minimum_alpha)
-    { // TODO: figure out how to get invisible faces out of 
-        // render batches without breaking glow
-        discard;
-    }
-
-    diffuse_srgb.rgb *= vertex_color.rgb;
-    diffuse_linear.rgb = srgb_to_linear(diffuse_srgb.rgb);
-#endif // USE_VERTEX_COLOR
-
-    vec3 sunlit;
-    vec3 amblit;
-    vec3 additive;
-    vec3 atten;
-
-    calcAtmosphericVars(pos.xyz, light_dir, 1.0, sunlit, amblit, additive, atten, false);
-
-    vec3 ambenv;
-    vec3 glossenv;
-    vec3 legacyenv;
-    sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, 0.0, 0.0);
-    
-
-    float da = dot(norm.xyz, light_dir.xyz);
-          da = clamp(da, -1.0, 1.0);
- 
-    float final_da = da;
-          final_da = clamp(final_da, 0.0f, 1.0f);
-
-    vec4 color = vec4(0.0);
-
-    color.a   = final_alpha;
-
-    float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
-    ambient *= 0.5;
-    ambient *= ambient;
-    ambient = (1.0 - ambient);
-
-    vec3 sun_contrib = min(final_da, shadow) * sunlit;
-
-    color.rgb = max(amblit, ambenv);
-    color.rgb *= ambient;
-
-    color.rgb += sun_contrib;
-
-    color.rgb *= diffuse_linear.rgb;
-
-    color.rgb = atmosFragLighting(color.rgb, additive, atten);
-
-    vec4 light = vec4(0,0,0,0);
-    
-   #define LIGHT_LOOP(i) light.rgb += calcPointLightOrSpotLight(light_diffuse[i].rgb, diffuse_linear.rgb, pos.xyz, norm, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z, light_attenuation[i].w);
-
-    LIGHT_LOOP(1)
-    LIGHT_LOOP(2)
-    LIGHT_LOOP(3)
-    LIGHT_LOOP(4)
-    LIGHT_LOOP(5)
-    LIGHT_LOOP(6)
-    LIGHT_LOOP(7)
-
-    // sum local light contrib in linear colorspace
-#if !defined(LOCAL_LIGHT_KILL)
-    color.rgb += light.rgb;
-#endif // !defined(LOCAL_LIGHT_KILL)
-
-#ifdef WATER_FOG
-    color = applyWaterFogView(pos.xyz, color);
-#endif // WATER_FOG
-
-#endif // #else // FOR_IMPOSTOR
-
-    frag_color = color;
+    frag_color = vec4(1,0,1,0.5);
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/cloudShadowF.glsl b/indra/newview/app_settings/shaders/class1/deferred/cloudShadowF.glsl
index 0157d166e0..afcb309e33 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/cloudShadowF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/cloudShadowF.glsl
@@ -45,7 +45,6 @@ uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
 uniform vec4 sunlight_color;
-uniform vec4 cloud_color;
 uniform float cloud_shadow;
 uniform float cloud_scale;
 uniform float cloud_variance;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbralphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbralphaF.glsl
index 3afa9fb435..cb91dfdcce 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/pbralphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbralphaF.glsl
@@ -25,229 +25,9 @@
 
 /*[EXTRA_CODE_HERE]*/
 
-#define DIFFUSE_ALPHA_MODE_NONE     0
-#define DIFFUSE_ALPHA_MODE_BLEND    1
-#define DIFFUSE_ALPHA_MODE_MASK     2
-#define DIFFUSE_ALPHA_MODE_EMISSIVE 3
-
-uniform sampler2D diffuseMap;  //always in sRGB space
-uniform sampler2D bumpMap;
-uniform sampler2D emissiveMap;
-uniform sampler2D specularMap; // PBR: Packed: Occlusion, Metal, Roughness
-
-uniform float metallicFactor;
-uniform float roughnessFactor;
-uniform vec3 emissiveColor;
-
-#if defined(HAS_SUN_SHADOW) || defined(HAS_SSAO)
-uniform sampler2DRect lightMap;
-#endif
-
-uniform int sun_up_factor;
-uniform vec3 sun_dir;
-uniform vec3 moon_dir;
-
-#if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_BLEND)
-  #ifdef DEFINE_GL_FRAGCOLOR
-    out vec4 frag_color;
-  #else
-    #define frag_color gl_FragColor
-  #endif
-#else
-  #ifdef DEFINE_GL_FRAGCOLOR
-    out vec4 frag_data[4];
-  #else
-    #define frag_data gl_FragData
-  #endif
-#endif
-
-#ifdef HAS_SHADOW
-  VARYING vec3 vary_fragcoord;
-  uniform vec2 screen_res;
-#endif
-
-VARYING vec3 vary_position;
-VARYING vec4 vertex_color;
-VARYING vec2 vary_texcoord0;
-VARYING vec2 vary_texcoord1;
-VARYING vec2 vary_texcoord2;
-VARYING vec3 vary_normal;
-VARYING vec3 vary_tangent;
-flat in float vary_sign;
-
-
-#ifdef HAS_ALPHA_MASK
-uniform float minimum_alpha; // PBR alphaMode: MASK, See: mAlphaCutoff, setAlphaCutoff()
-#endif
-
-// Lights
-// See: LLRender::syncLightState()
-uniform vec4 light_position[8];
-uniform vec3 light_direction[8]; // spot direction
-uniform vec4 light_attenuation[8]; // linear, quadratic, is omni, unused, See: LLPipeline::setupHWLights() and syncLightState()
-uniform vec3 light_diffuse[8];
-uniform vec2 light_deferred_attenuation[8]; // light size and falloff
-
-vec3 srgb_to_linear(vec3 c);
-vec3 linear_to_srgb(vec3 c);
-
-// These are in deferredUtil.glsl but we can't set: mFeatures.isDeferred to include it
-void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
-vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
-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, 
-        vec3 pos, vec3 norm, float glossiness);
-
-// PBR interface
-vec3 pbrIbl(vec3 diffuseColor,
-            vec3 specularColor,
-            vec3 radiance, // radiance map sample
-            vec3 irradiance, // irradiance map sample
-            float ao,       // ambient occlusion factor
-            float nv,       // normal dot view vector
-            float perceptualRoughness);
-
-vec3 pbrPunctual(vec3 diffuseColor, vec3 specularColor, 
-                    float perceptualRoughness, 
-                    float metallic,
-                    vec3 n, // normal
-                    vec3 v, // surface point to camera
-                    vec3 l); //surface point to light
-
-vec3 calcPointLightOrSpotLight(vec3 diffuseColor, vec3 specularColor, 
-                    float perceptualRoughness, 
-                    float metallic,
-                    vec3 n, // normal
-                    vec3 p, // pixel position
-                    vec3 v, // view vector (negative normalized pixel position)
-                    vec3 lp, // light position
-                    vec3 ld, // light direction (for spotlights)
-                    vec3 lightColor,
-                    float lightSize, float falloff, float is_pointlight, float ambiance)
-{
-    vec3 color = vec3(0,0,0);
-
-    vec3 lv = lp.xyz - p;
-
-    float lightDist = length(lv);
-
-    float dist = lightDist / lightSize;
-    if (dist <= 1.0)
-    {
-        lv /= lightDist;
-
-        float dist_atten = calcLegacyDistanceAttenuation(dist, falloff);
-
-        vec3 intensity = dist_atten * lightColor * 3.0;
-
-        color = intensity*pbrPunctual(diffuseColor, specularColor, perceptualRoughness, metallic, n.xyz, v, lv);
-    }
-
-    return color;
-}
+out vec4 frag_color;
 
 void main()
 {
-    vec3 color = vec3(0,0,0);
-
-    vec3  light_dir   = (sun_up_factor == 1) ? sun_dir : moon_dir;
-    vec3  pos         = vary_position;
-
-    float scol = 1.0;
-    float ambocc = 1.0;
-
-    vec3 sunlit;
-    vec3 amblit;
-    vec3 additive;
-    vec3 atten;
-    calcAtmosphericVars(pos.xyz, light_dir, ambocc, sunlit, amblit, additive, atten, true);
-
-
-// IF .mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-//    vec3 col = vertex_color.rgb * diffuseLookup(vary_texcoord0.xy).rgb;
-// else
-    vec4 albedo = texture(diffuseMap, vary_texcoord0.xy).rgba;
-    albedo.rgb = srgb_to_linear(albedo.rgb);
-#ifdef HAS_ALPHA_MASK
-    if (albedo.a < minimum_alpha)
-    {
-        discard;
-    }
-#endif
-
-    vec3 baseColor = vertex_color.rgb * albedo.rgb;
-
-    vec3 vNt = texture(bumpMap, vary_texcoord1.xy).xyz*2.0-1.0;
-    float sign = vary_sign;
-    vec3 vN = vary_normal;
-    vec3 vT = vary_tangent.xyz;
-    
-    vec3 vB = sign * cross(vN, vT);
-    vec3 norm = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
-
-    norm *= gl_FrontFacing ? 1.0 : -1.0;
-
-#ifdef HAS_SHADOW
-    vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
-    frag *= screen_res;
-    scol = sampleDirectionalShadow(pos.xyz, norm.xyz, frag);
-#endif
-
-    vec3 orm = texture(specularMap, vary_texcoord2.xy).rgb; //orm is packed into "emissiveRect" to keep the data in linear color space
-
-    float perceptualRoughness = orm.g * roughnessFactor;
-    float metallic = orm.b * metallicFactor;
-    float ao = orm.r;
-
-    // emissiveColor is the emissive color factor from GLTF and is already in linear space
-    vec3 colorEmissive = emissiveColor;
-    // emissiveMap here is a vanilla RGB texture encoded as sRGB, manually convert to linear
-    colorEmissive *= srgb_to_linear(texture2D(emissiveMap, vary_texcoord0.xy).rgb);
-
-    // PBR IBL
-    float gloss      = 1.0 - perceptualRoughness;
-    vec3  irradiance = vec3(0);
-    vec3  radiance  = vec3(0);
-    sampleReflectionProbes(irradiance, radiance, pos.xyz, norm.xyz, gloss);
-    irradiance       = max(srgb_to_linear(amblit),irradiance) * ambocc*4.0;
-
-    vec3 f0 = vec3(0.04);
-    
-    vec3 diffuseColor = baseColor.rgb*(vec3(1.0)-f0);
-    diffuseColor *= 1.0 - metallic;
-
-    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
-
-    vec3 v = -normalize(pos.xyz);
-    float NdotV = clamp(abs(dot(norm.xyz, v)), 0.001, 1.0);
-
-    color += pbrIbl(diffuseColor, specularColor, radiance, irradiance, ao, NdotV, perceptualRoughness);
-    color += pbrPunctual(diffuseColor, specularColor, perceptualRoughness, metallic, norm.xyz, v, light_dir) * sunlit*8.0 * scol;
-    color += colorEmissive;
-    
-    vec3 light = vec3(0);
-
-    // Punctual lights
-#define LIGHT_LOOP(i) light += calcPointLightOrSpotLight(diffuseColor, specularColor, perceptualRoughness, metallic, norm.xyz, pos.xyz, v, light_position[i].xyz, light_direction[i].xyz, light_diffuse[i].rgb, light_deferred_attenuation[i].x, light_deferred_attenuation[i].y, light_attenuation[i].z, light_attenuation[i].w);
-
-    LIGHT_LOOP(1)
-    LIGHT_LOOP(2)
-    LIGHT_LOOP(3)
-    LIGHT_LOOP(4)
-    LIGHT_LOOP(5)
-    LIGHT_LOOP(6)
-    LIGHT_LOOP(7)
-
-    color.rgb += light.rgb;
-
-    color.rgb = linear_to_srgb(color.rgb);
-    color *= atten.r;
-    color += 2.0*additive;
-    color  = scaleSoftClipFrag(color);
-
-    frag_color = vec4(srgb_to_linear(color.rgb),albedo.a * vertex_color.a);
-}
+    frag_color = vec4(0,1,0,0.5);
+}
\ No newline at end of file
diff --git a/indra/newview/app_settings/shaders/class1/deferred/skyV.glsl b/indra/newview/app_settings/shaders/class1/deferred/skyV.glsl
index 28a1faf24f..223143bc1b 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/skyV.glsl
@@ -55,8 +55,6 @@ uniform float max_y;
 uniform vec4  glow;
 uniform float sun_moon_glow_factor;
 
-uniform vec4 cloud_color;
-
 // NOTE: Keep these in sync!
 //       indra\newview\app_settings\shaders\class1\deferred\skyV.glsl
 //       indra\newview\app_settings\shaders\class1\deferred\cloudsV.glsl
diff --git a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
index 03896f4c51..c9e7552312 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
@@ -28,7 +28,7 @@
 /*[EXTRA_CODE_HERE]*/
 
 #ifdef DEFINE_GL_FRAGCOLOR
-out vec4 frag_data[3];
+out vec4 frag_data[4];
 #else
 #define frag_data gl_FragData
 #endif
@@ -162,11 +162,13 @@ void main()
 	
 	vec4 pos = vary_position;
 	
-	color.rgb += spec * specular;
+	//color.rgb += spec * specular;
 
-	color.rgb = atmosTransport(color.rgb);
-	color.rgb = scaleSoftClip(color.rgb);
+	//color.rgb = atmosTransport(color.rgb);
+	//color.rgb = scaleSoftClip(color.rgb);
     
+    //color.rgb = refcol.rgb;
+    color.rgb = vec3(0.0);
 	color.a   = spec * sunAngle2;
     
 	vec3 screenspacewavef = normalize((norm_mat*vec4(wavef, 1.0)).xyz);
@@ -176,9 +178,14 @@ void main()
     // TODO: The non-obvious assignment below is copied from the pre-EEP WL shader code
     //       Unfortunately, fixing it causes a mismatch for EEP, and so it remains...  for now
     //       SL-12975 (unfix pre-EEP broken alpha)
-    frag_data[0] = vec4(color.rgb, color);  // Effectively, color.rgbr
-
+    frag_data[0] = vec4(srgb_to_linear(color.rgb), 0.0);  // Effectively, color.rgbr
+    
+    frag_data[1] = vec4(1.0, 0.2, 0.0, 0.0);		// speccolor, spec
+	frag_data[2] = vec4(encode_normal(screenspacewavef.xyz), 0.0, GBUFFER_FLAG_HAS_PBR);// normalxy, env intens, flags (atmo kill)
+    frag_data[3] = vec4(srgb_to_linear(refcol.rgb),0);
 
-    frag_data[1] = vec4(0);		// speccolor, spec
-	frag_data[2] = vec4(encode_normal(screenspacewavef.xyz), 0.05, GBUFFER_FLAG_HAS_ATMOS);// normalxy, env intens, flags (atmo kill)
+    
+    //frag_data[0] = vec4(0.0,0,0,0);
+    //frag_data[1] = vec4(0, 1.0, 0.0, 0.0);
+    //frag_data[3] = vec4(0);
 }
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsFuncs.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsFuncs.glsl
index 3831eeaa01..28d1ae2027 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsFuncs.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsFuncs.glsl
@@ -22,24 +22,8 @@
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
-uniform vec4  lightnorm;
-uniform vec4  sunlight_color;
-uniform vec4  moonlight_color;
-uniform int   sun_up_factor;
-uniform vec4  ambient_color;
-uniform vec4  blue_horizon;
-uniform vec4  blue_density;
-uniform float haze_horizon;
-uniform float haze_density;
-uniform float cloud_shadow;
-uniform float density_multiplier;
-uniform float distance_multiplier;
-uniform float max_y;
-uniform vec4  glow;
-uniform float scene_light_strength;
-uniform mat3  ssao_effect_mat;
-uniform int   no_atmo;
-uniform float sun_moon_glow_factor;
+
+// debug stub
 
 float getAmbientClamp() { return 1.0f; }
 
@@ -47,89 +31,17 @@ float getAmbientClamp() { return 1.0f; }
 void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive,
                          out vec3 atten, bool use_ao)
 {
-    vec3 rel_pos = inPositionEye;
-
-    //(TERRAIN) limit altitude
-    if (abs(rel_pos.y) > max_y) rel_pos *= (max_y / rel_pos.y);
-
-    vec3  rel_pos_norm = normalize(rel_pos);
-    float rel_pos_len  = length(rel_pos);
-    vec4  sunlight     = (sun_up_factor == 1) ? sunlight_color : moonlight_color;
-
-    // sunlight attenuation effect (hue and brightness) due to atmosphere
-    // this is used later for sunlight modulation at various altitudes
-    vec4 light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
-    // I had thought blue_density and haze_density should have equal weighting,
-    // but attenuation due to haze_density tends to seem too strong
-
-    vec4 combined_haze = blue_density + vec4(haze_density);
-    vec4 blue_weight   = blue_density / combined_haze;
-    vec4 haze_weight   = vec4(haze_density) / combined_haze;
-
-    //(TERRAIN) compute sunlight from lightnorm y component. Factor is roughly cosecant(sun elevation) (for short rays like terrain)
-    float above_horizon_factor = 1.0 / max(1e-6, lightnorm.y);
-    sunlight *= exp(-light_atten * above_horizon_factor);  // for sun [horizon..overhead] this maps to an exp curve [0..1]
-
-    // main atmospheric scattering line integral
-    float density_dist = rel_pos_len * density_multiplier;
-
-    // Transparency (-> combined_haze)
-    // ATI Bugfix -- can't store combined_haze*density_dist*distance_multiplier in a variable because the ati
-    // compiler gets confused.
-    combined_haze = exp(-combined_haze * density_dist * distance_multiplier);
-
-    // final atmosphere attenuation factor
-    atten = combined_haze.rgb;
-
-    // compute haze glow
-    float haze_glow = dot(rel_pos_norm, lightnorm.xyz);
-
-    // dampen sun additive contrib when not facing it...
-    // SL-13539: This "if" clause causes an "additive" white artifact at roughly 77 degreees.
-    //    if (length(light_dir) > 0.01)
-    haze_glow *= max(0.0f, dot(light_dir, rel_pos_norm));
-
-    haze_glow = 1. - haze_glow;
-    // haze_glow is 0 at the sun and increases away from sun
-    haze_glow = max(haze_glow, .001);  // set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
-    haze_glow *= glow.x;
-    // higher glow.x gives dimmer glow (because next step is 1 / "angle")
-    haze_glow = pow(haze_glow, glow.z);
-    // glow.z should be negative, so we're doing a sort of (1 / "angle") function
-
-    // add "minimum anti-solar illumination"
-    haze_glow += .25;
-
-    haze_glow *= sun_moon_glow_factor;
-
-    vec4 amb_color = ambient_color;
-
-    // increase ambient when there are more clouds
-    vec4 tmpAmbient = amb_color + (vec4(1.) - amb_color) * cloud_shadow * 0.5;
-
-    /*  decrease value and saturation (that in HSV, not HSL) for occluded areas
-     * // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html
-     * // The following line of code performs the equivalent of:
-     * float ambAlpha = tmpAmbient.a;
-     * float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis
-     * vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);
-     * tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat,
-     * ambAlpha);
-     */
-    if (use_ao)
-    {
-        tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);
-    }
-
-    // Similar/Shared Algorithms:
-    //     indra\llinventory\llsettingssky.cpp                                        -- LLSettingsSky::calculateLightSettings()
-    //     indra\newview\app_settings\shaders\class1\windlight\atmosphericsFuncs.glsl -- calcAtmosphericVars()
-    // haze color
-    vec3 cs = sunlight.rgb * (1. - cloud_shadow);
-    additive = (blue_horizon.rgb * blue_weight.rgb) * (cs + tmpAmbient.rgb) + (haze_horizon * haze_weight.rgb) * (cs * haze_glow + tmpAmbient.rgb);
+    amblit = vec3(0.2, 0, 0.2);
+    sunlit = vec3(1,0,1);
+    additive = vec3(0.5,0.5,0.5);
+    atten = vec3(1,0,1);
+}
 
-    // brightness of surface both sunlight and ambient
-    sunlit = sunlight.rgb * 0.5;
-    amblit = tmpAmbient.rgb * .25;
-    additive *= vec3(1.0 - combined_haze);
+void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive,
+                         out vec3 atten, bool use_ao)
+{
+    amblit = vec3(0.2, 0, 0.2);
+    sunlit = vec3(1,0,1);
+    additive = vec3(0.5,0.5,0.5);
+    atten = vec3(1,0,1);
 }
diff --git a/indra/newview/app_settings/shaders/class1/windlight/cloudShadowF.glsl b/indra/newview/app_settings/shaders/class1/windlight/cloudShadowF.glsl
index 82fad4db5a..332fb9d809 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/cloudShadowF.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/cloudShadowF.glsl
@@ -45,7 +45,6 @@ uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
 uniform vec4 sunlight_color;
-uniform vec4 cloud_color;
 uniform float cloud_shadow;
 uniform float cloud_scale;
 uniform float cloud_variance;
diff --git a/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
new file mode 100644
index 0000000000..39aec699fe
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
@@ -0,0 +1,306 @@
+/** 
+ * @file alphaF.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$
+ */
+
+//class2/deferred/alphaF.glsl
+
+#extension GL_ARB_texture_rectangle : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+#define INDEXED 1
+#define NON_INDEXED 2
+#define NON_INDEXED_NO_COLOR 3
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform mat3 env_mat;
+uniform vec3 sun_dir;
+uniform vec3 moon_dir;
+
+#ifdef USE_DIFFUSE_TEX
+uniform sampler2D diffuseMap;
+#endif
+
+VARYING vec3 vary_fragcoord;
+VARYING vec3 vary_position;
+VARYING vec2 vary_texcoord0;
+VARYING vec3 vary_norm;
+
+#ifdef USE_VERTEX_COLOR
+VARYING vec4 vertex_color; //vertex color should be treated as sRGB
+#endif
+
+#ifdef HAS_ALPHA_MASK
+uniform float minimum_alpha;
+#endif
+
+uniform mat4 proj_mat;
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+uniform int sun_up_factor;
+uniform vec4 light_position[8];
+uniform vec3 light_direction[8];
+uniform vec4 light_attenuation[8]; 
+uniform vec3 light_diffuse[8];
+
+#ifdef WATER_FOG
+vec4 applyWaterFogView(vec3 pos, vec4 color);
+#endif
+
+vec3 srgb_to_linear(vec3 c);
+vec3 linear_to_srgb(vec3 c);
+
+vec2 encode_normal (vec3 n);
+vec3 scaleSoftClipFragLinear(vec3 l);
+vec3 atmosFragLightingLinear(vec3 light, vec3 additive, vec3 atten);
+
+void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 atten, out vec3 additive, bool use_ao);
+
+#ifdef HAS_SHADOW
+float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen);
+#endif
+
+float getAmbientClamp();
+
+void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv, 
+        vec3 pos, vec3 norm, float glossiness, float envIntensity);
+
+vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 diffuse, vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float fa, float is_pointlight, float ambiance)
+{
+    // SL-14895 inverted attenuation work-around
+    // This routine is tweaked to match deferred lighting, but previously used an inverted la value. To reconstruct
+    // that previous value now that the inversion is corrected, we reverse the calculations in LLPipeline::setupHWLights()
+    // to recover the `adjusted_radius` value previously being sent as la.
+    float falloff_factor = (12.0 * fa) - 9.0;
+    float inverted_la = falloff_factor / la;
+    // Yes, it makes me want to cry as well. DJH
+    
+    vec3 col = vec3(0);
+
+	//get light vector
+	vec3 lv = lp.xyz-v;
+
+	//get distance
+	float dist = length(lv);
+	float da = 1.0;
+
+    /*if (dist > inverted_la)
+    {
+        return col;
+    }
+
+    clip to projector bounds
+     vec4 proj_tc = proj_mat * lp;
+
+    if (proj_tc.z < 0
+     || proj_tc.z > 1
+     || proj_tc.x < 0
+     || proj_tc.x > 1 
+     || proj_tc.y < 0
+     || proj_tc.y > 1)
+    {
+        return col;
+    }*/
+
+	if (dist > 0.0 && inverted_la > 0.0)
+	{
+        dist /= inverted_la;
+
+		//normalize light vector
+		lv = normalize(lv);
+	
+		//distance attenuation
+		float dist_atten = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
+		dist_atten *= dist_atten;
+        dist_atten *= 2.0f;
+
+        if (dist_atten <= 0.0)
+        {
+           return col;
+        }
+
+		// spotlight coefficient.
+		float spot = max(dot(-ln, lv), is_pointlight);
+		da *= spot*spot; // GL_SPOT_EXPONENT=2
+
+		//angular attenuation
+		da *= dot(n, lv);
+        da = max(0.0, da);
+
+		float lit = 0.0f;
+
+        float amb_da = 0.0;//ambiance;
+        if (da > 0)
+        {
+		    lit = max(da * dist_atten,0.0);
+            col = lit * light_col * diffuse;
+            amb_da += (da*0.5+0.5) * ambiance;
+        }
+        amb_da += (da*da*0.5 + 0.5) * ambiance;
+        amb_da *= dist_atten;
+        amb_da = min(amb_da, 1.0f - lit);
+
+        // SL-10969 ... need to work out why this blows out in many setups...
+        //col.rgb += amb_da * light_col * diffuse;
+
+        // no spec for alpha shader...
+    }
+    col = max(col, vec3(0));
+    return col;
+}
+
+void main() 
+{
+    vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
+    frag *= screen_res;
+    
+    vec4 pos = vec4(vary_position, 1.0);
+    vec3 norm = vary_norm;
+
+    float shadow = 1.0f;
+
+#ifdef HAS_SHADOW
+    shadow = sampleDirectionalShadow(pos.xyz, norm.xyz, frag);
+#endif
+
+#ifdef USE_DIFFUSE_TEX
+    vec4 diffuse_tap = texture2D(diffuseMap,vary_texcoord0.xy);
+#endif
+
+#ifdef USE_INDEXED_TEX
+    vec4 diffuse_tap = diffuseLookup(vary_texcoord0.xy);
+#endif
+
+    vec4 diffuse_srgb = diffuse_tap;
+
+#ifdef FOR_IMPOSTOR
+    vec4 color;
+    color.rgb = diffuse_srgb.rgb;
+    color.a = 1.0;
+
+    float final_alpha = diffuse_srgb.a * vertex_color.a;
+    diffuse_srgb.rgb *= vertex_color.rgb;
+    
+    // Insure we don't pollute depth with invis pixels in impostor rendering
+    //
+    if (final_alpha < minimum_alpha)
+    {
+        discard;
+    }
+
+    color.rgb = diffuse_srgb.rgb;
+    color.a = final_alpha;
+
+#else // FOR_IMPOSTOR
+
+    vec4 diffuse_linear = vec4(srgb_to_linear(diffuse_srgb.rgb), diffuse_srgb.a);
+
+    vec3 light_dir = (sun_up_factor == 1) ? sun_dir: moon_dir;
+
+    float final_alpha = diffuse_linear.a;
+
+#ifdef USE_VERTEX_COLOR
+    final_alpha *= vertex_color.a;
+
+    if (final_alpha < minimum_alpha)
+    { // TODO: figure out how to get invisible faces out of 
+        // render batches without breaking glow
+        discard;
+    }
+
+    diffuse_srgb.rgb *= vertex_color.rgb;
+    diffuse_linear.rgb = srgb_to_linear(diffuse_srgb.rgb);
+#endif // USE_VERTEX_COLOR
+
+    vec3 sunlit;
+    vec3 amblit;
+    vec3 additive;
+    vec3 atten;
+
+    calcAtmosphericVarsLinear(pos.xyz, light_dir, 1.0, sunlit, amblit, additive, atten, false);
+
+    vec3 ambenv;
+    vec3 glossenv;
+    vec3 legacyenv;
+    sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, 0.0, 0.0);
+    
+
+    float da = dot(norm.xyz, light_dir.xyz);
+          da = clamp(da, -1.0, 1.0);
+ 
+    float final_da = da;
+          final_da = clamp(final_da, 0.0f, 1.0f);
+
+    vec4 color = vec4(0.0);
+
+    color.a   = final_alpha;
+
+    float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
+    ambient *= 0.5;
+    ambient *= ambient;
+    ambient = (1.0 - ambient);
+
+    vec3 sun_contrib = min(final_da, shadow) * sunlit;
+
+    color.rgb = max(amblit, ambenv);
+    color.rgb *= ambient;
+
+    color.rgb += sun_contrib;
+
+    color.rgb *= diffuse_linear.rgb;
+
+    color.rgb = atmosFragLightingLinear(color.rgb, additive, atten);
+    color.rgb = scaleSoftClipFragLinear(color.rgb);
+
+    vec4 light = vec4(0,0,0,0);
+    
+   #define LIGHT_LOOP(i) light.rgb += calcPointLightOrSpotLight(light_diffuse[i].rgb, diffuse_linear.rgb, pos.xyz, norm, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z, light_attenuation[i].w);
+
+    LIGHT_LOOP(1)
+    LIGHT_LOOP(2)
+    LIGHT_LOOP(3)
+    LIGHT_LOOP(4)
+    LIGHT_LOOP(5)
+    LIGHT_LOOP(6)
+    LIGHT_LOOP(7)
+
+    // sum local light contrib in linear colorspace
+#if !defined(LOCAL_LIGHT_KILL)
+    color.rgb += light.rgb;
+#endif // !defined(LOCAL_LIGHT_KILL)
+
+#ifdef WATER_FOG
+    color = applyWaterFogView(pos.xyz, color);
+#endif // WATER_FOG
+
+#endif // #else // FOR_IMPOSTOR
+
+    frag_color = color;
+}
+
diff --git a/indra/newview/app_settings/shaders/class2/deferred/pbralphaF.glsl b/indra/newview/app_settings/shaders/class2/deferred/pbralphaF.glsl
new file mode 100644
index 0000000000..f49a7bd169
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/deferred/pbralphaF.glsl
@@ -0,0 +1,234 @@
+/** 
+ * @file class1\deferred\pbralphaF.glsl
+ *
+ * $LicenseInfo:firstyear=2022&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2022, 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$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+uniform sampler2D diffuseMap;  //always in sRGB space
+uniform sampler2D bumpMap;
+uniform sampler2D emissiveMap;
+uniform sampler2D specularMap; // PBR: Packed: Occlusion, Metal, Roughness
+
+uniform float metallicFactor;
+uniform float roughnessFactor;
+uniform vec3 emissiveColor;
+
+#if defined(HAS_SUN_SHADOW) || defined(HAS_SSAO)
+uniform sampler2DRect lightMap;
+#endif
+
+uniform int sun_up_factor;
+uniform vec3 sun_dir;
+uniform vec3 moon_dir;
+
+out vec4 frag_color;
+
+#ifdef HAS_SHADOW
+  VARYING vec3 vary_fragcoord;
+  uniform vec2 screen_res;
+#endif
+
+VARYING vec3 vary_position;
+VARYING vec4 vertex_color;
+VARYING vec2 vary_texcoord0;
+VARYING vec2 vary_texcoord1;
+VARYING vec2 vary_texcoord2;
+VARYING vec3 vary_normal;
+VARYING vec3 vary_tangent;
+flat in float vary_sign;
+
+
+#ifdef HAS_ALPHA_MASK
+uniform float minimum_alpha; // PBR alphaMode: MASK, See: mAlphaCutoff, setAlphaCutoff()
+#endif
+
+// Lights
+// See: LLRender::syncLightState()
+uniform vec4 light_position[8];
+uniform vec3 light_direction[8]; // spot direction
+uniform vec4 light_attenuation[8]; // linear, quadratic, is omni, unused, See: LLPipeline::setupHWLights() and syncLightState()
+uniform vec3 light_diffuse[8];
+uniform vec2 light_deferred_attenuation[8]; // light size and falloff
+
+vec3 srgb_to_linear(vec3 c);
+vec3 linear_to_srgb(vec3 c);
+
+// These are in deferredUtil.glsl but we can't set: mFeatures.isDeferred to include it
+void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
+vec3 atmosFragLightingLinear(vec3 light, vec3 additive, vec3 atten);
+vec3 scaleSoftClipFragLinear(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, 
+        vec3 pos, vec3 norm, float glossiness);
+
+// PBR interface
+vec3 pbrIbl(vec3 diffuseColor,
+            vec3 specularColor,
+            vec3 radiance, // radiance map sample
+            vec3 irradiance, // irradiance map sample
+            float ao,       // ambient occlusion factor
+            float nv,       // normal dot view vector
+            float perceptualRoughness);
+
+vec3 pbrPunctual(vec3 diffuseColor, vec3 specularColor, 
+                    float perceptualRoughness, 
+                    float metallic,
+                    vec3 n, // normal
+                    vec3 v, // surface point to camera
+                    vec3 l); //surface point to light
+
+vec3 calcPointLightOrSpotLight(vec3 diffuseColor, vec3 specularColor, 
+                    float perceptualRoughness, 
+                    float metallic,
+                    vec3 n, // normal
+                    vec3 p, // pixel position
+                    vec3 v, // view vector (negative normalized pixel position)
+                    vec3 lp, // light position
+                    vec3 ld, // light direction (for spotlights)
+                    vec3 lightColor,
+                    float lightSize, float falloff, float is_pointlight, float ambiance)
+{
+    vec3 color = vec3(0,0,0);
+
+    vec3 lv = lp.xyz - p;
+
+    float lightDist = length(lv);
+
+    float dist = lightDist / lightSize;
+    if (dist <= 1.0)
+    {
+        lv /= lightDist;
+
+        float dist_atten = calcLegacyDistanceAttenuation(dist, falloff);
+
+        vec3 intensity = dist_atten * lightColor * 3.0;
+
+        color = intensity*pbrPunctual(diffuseColor, specularColor, perceptualRoughness, metallic, n.xyz, v, lv);
+    }
+
+    return color;
+}
+
+void main()
+{
+    vec3 color = vec3(0,0,0);
+
+    vec3  light_dir   = (sun_up_factor == 1) ? sun_dir : moon_dir;
+    vec3  pos         = vary_position;
+
+    float scol = 1.0;
+    float ambocc = 1.0;
+
+    vec3 sunlit;
+    vec3 amblit;
+    vec3 additive;
+    vec3 atten;
+    calcAtmosphericVarsLinear(pos.xyz, light_dir, ambocc, sunlit, amblit, additive, atten, true);
+
+
+// IF .mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+//    vec3 col = vertex_color.rgb * diffuseLookup(vary_texcoord0.xy).rgb;
+// else
+    vec4 albedo = texture(diffuseMap, vary_texcoord0.xy).rgba;
+    albedo.rgb = srgb_to_linear(albedo.rgb);
+#ifdef HAS_ALPHA_MASK
+    if (albedo.a < minimum_alpha)
+    {
+        discard;
+    }
+#endif
+
+    vec3 baseColor = vertex_color.rgb * albedo.rgb;
+
+    vec3 vNt = texture(bumpMap, vary_texcoord1.xy).xyz*2.0-1.0;
+    float sign = vary_sign;
+    vec3 vN = vary_normal;
+    vec3 vT = vary_tangent.xyz;
+    
+    vec3 vB = sign * cross(vN, vT);
+    vec3 norm = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
+
+    norm *= gl_FrontFacing ? 1.0 : -1.0;
+
+#ifdef HAS_SHADOW
+    vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
+    frag *= screen_res;
+    scol = sampleDirectionalShadow(pos.xyz, norm.xyz, frag);
+#endif
+
+    vec3 orm = texture(specularMap, vary_texcoord2.xy).rgb; //orm is packed into "emissiveRect" to keep the data in linear color space
+
+    float perceptualRoughness = orm.g * roughnessFactor;
+    float metallic = orm.b * metallicFactor;
+    float ao = orm.r;
+
+    // emissiveColor is the emissive color factor from GLTF and is already in linear space
+    vec3 colorEmissive = emissiveColor;
+    // emissiveMap here is a vanilla RGB texture encoded as sRGB, manually convert to linear
+    colorEmissive *= srgb_to_linear(texture2D(emissiveMap, vary_texcoord0.xy).rgb);
+
+    // PBR IBL
+    float gloss      = 1.0 - perceptualRoughness;
+    vec3  irradiance = vec3(0);
+    vec3  radiance  = vec3(0);
+    sampleReflectionProbes(irradiance, radiance, pos.xyz, norm.xyz, gloss);
+    irradiance       = max(amblit*1.5,irradiance);
+
+    vec3 f0 = vec3(0.04);
+    
+    vec3 diffuseColor = baseColor.rgb*(vec3(1.0)-f0);
+    diffuseColor *= 1.0 - metallic;
+
+    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+
+    vec3 v = -normalize(pos.xyz);
+    float NdotV = clamp(abs(dot(norm.xyz, v)), 0.001, 1.0);
+
+    color += pbrIbl(diffuseColor, specularColor, radiance, irradiance, ao, NdotV, perceptualRoughness);
+    color += pbrPunctual(diffuseColor, specularColor, perceptualRoughness, metallic, norm.xyz, v, light_dir) * sunlit*2.75 * scol;
+    color += colorEmissive;
+    
+    vec3 light = vec3(0);
+
+    // Punctual lights
+#define LIGHT_LOOP(i) light += calcPointLightOrSpotLight(diffuseColor, specularColor, perceptualRoughness, metallic, norm.xyz, pos.xyz, v, light_position[i].xyz, light_direction[i].xyz, light_diffuse[i].rgb, light_deferred_attenuation[i].x, light_deferred_attenuation[i].y, light_attenuation[i].z, light_attenuation[i].w);
+
+    LIGHT_LOOP(1)
+    LIGHT_LOOP(2)
+    LIGHT_LOOP(3)
+    LIGHT_LOOP(4)
+    LIGHT_LOOP(5)
+    LIGHT_LOOP(6)
+    LIGHT_LOOP(7)
+
+    color.rgb += light.rgb;
+
+    color = atmosFragLightingLinear(color, additive, atten);
+    color  = scaleSoftClipFragLinear(color);
+
+    frag_color = vec4(color.rgb,albedo.a * vertex_color.a);
+}
diff --git a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl
index ee9c990b12..ecf1545d2d 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl
@@ -29,6 +29,26 @@ vec3 scaleSoftClipFrag(vec3 light);
 
 uniform int no_atmo;
 
+vec3 srgb_to_linear(vec3 col);
+vec3 linear_to_srgb(vec3 col);
+
+vec3 atmosFragLightingLinear(vec3 light, vec3 additive, vec3 atten)
+{
+    if (no_atmo == 1)
+    {
+        return light;
+    }
+    
+    light = linear_to_srgb(light);
+    additive = linear_to_srgb(additive);
+    atten = linear_to_srgb(atten);
+    
+    light *= atten.r;
+    light += additive;
+    return srgb_to_linear(light);
+}
+
+
 vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten)
 {
     if (no_atmo == 1)
diff --git a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsFuncs.glsl b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsFuncs.glsl
new file mode 100644
index 0000000000..e7e1938a11
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsFuncs.glsl
@@ -0,0 +1,148 @@
+/**
+ * @file class2\windlight\atmosphericsFuncs.glsl
+ *
+ * $LicenseInfo:firstyear=2022&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2022, 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 vec4  lightnorm;
+uniform vec4  sunlight_color;
+uniform vec4  moonlight_color;
+uniform int   sun_up_factor;
+uniform vec4  ambient_color;
+uniform vec4  blue_horizon;
+uniform vec4  blue_density;
+uniform float haze_horizon;
+uniform float haze_density;
+uniform float cloud_shadow;
+uniform float density_multiplier;
+uniform float distance_multiplier;
+uniform float max_y;
+uniform vec4  glow;
+uniform float scene_light_strength;
+uniform mat3  ssao_effect_mat;
+uniform int   no_atmo;
+uniform float sun_moon_glow_factor;
+
+vec3 srgb_to_linear(vec3 col);
+
+float getAmbientClamp() { return 1.0f; }
+
+// return colors in sRGB space
+void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive,
+                         out vec3 atten, bool use_ao)
+{
+    vec3 rel_pos = inPositionEye;
+
+    //(TERRAIN) limit altitude
+    if (abs(rel_pos.y) > max_y) rel_pos *= (max_y / rel_pos.y);
+
+    vec3  rel_pos_norm = normalize(rel_pos);
+    float rel_pos_len  = length(rel_pos);
+    vec4  sunlight     = (sun_up_factor == 1) ? sunlight_color : moonlight_color;
+
+    // sunlight attenuation effect (hue and brightness) due to atmosphere
+    // this is used later for sunlight modulation at various altitudes
+    vec4 light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
+    // I had thought blue_density and haze_density should have equal weighting,
+    // but attenuation due to haze_density tends to seem too strong
+
+    vec4 combined_haze = blue_density + vec4(haze_density);
+    vec4 blue_weight   = blue_density / combined_haze;
+    vec4 haze_weight   = vec4(haze_density) / combined_haze;
+
+    //(TERRAIN) compute sunlight from lightnorm y component. Factor is roughly cosecant(sun elevation) (for short rays like terrain)
+    float above_horizon_factor = 1.0 / max(1e-6, lightnorm.y);
+    sunlight *= exp(-light_atten * above_horizon_factor);  // for sun [horizon..overhead] this maps to an exp curve [0..1]
+
+    // main atmospheric scattering line integral
+    float density_dist = rel_pos_len * density_multiplier;
+
+    // Transparency (-> combined_haze)
+    // ATI Bugfix -- can't store combined_haze*density_dist*distance_multiplier in a variable because the ati
+    // compiler gets confused.
+    combined_haze = exp(-combined_haze * density_dist * distance_multiplier);
+
+    // final atmosphere attenuation factor
+    atten = combined_haze.rgb;
+
+    // compute haze glow
+    float haze_glow = dot(rel_pos_norm, lightnorm.xyz);
+
+    // dampen sun additive contrib when not facing it...
+    // SL-13539: This "if" clause causes an "additive" white artifact at roughly 77 degreees.
+    //    if (length(light_dir) > 0.01)
+    haze_glow *= max(0.0f, dot(light_dir, rel_pos_norm));
+
+    haze_glow = 1. - haze_glow;
+    // haze_glow is 0 at the sun and increases away from sun
+    haze_glow = max(haze_glow, .001);  // set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
+    haze_glow *= glow.x;
+    // higher glow.x gives dimmer glow (because next step is 1 / "angle")
+    haze_glow = pow(haze_glow, glow.z);
+    // glow.z should be negative, so we're doing a sort of (1 / "angle") function
+
+    // add "minimum anti-solar illumination"
+    haze_glow += .25;
+
+    haze_glow *= sun_moon_glow_factor;
+
+    vec4 amb_color = ambient_color;
+
+    // increase ambient when there are more clouds
+    vec4 tmpAmbient = amb_color + (vec4(1.) - amb_color) * cloud_shadow * 0.5;
+
+    /*  decrease value and saturation (that in HSV, not HSL) for occluded areas
+     * // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html
+     * // The following line of code performs the equivalent of:
+     * float ambAlpha = tmpAmbient.a;
+     * float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis
+     * vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);
+     * tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat,
+     * ambAlpha);
+     */
+    if (use_ao)
+    {
+        tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);
+    }
+
+    // Similar/Shared Algorithms:
+    //     indra\llinventory\llsettingssky.cpp                                        -- LLSettingsSky::calculateLightSettings()
+    //     indra\newview\app_settings\shaders\class1\windlight\atmosphericsFuncs.glsl -- calcAtmosphericVars()
+    // haze color
+    vec3 cs = sunlight.rgb * (1. - cloud_shadow);
+    additive = (blue_horizon.rgb * blue_weight.rgb) * (cs + tmpAmbient.rgb) + (haze_horizon * haze_weight.rgb) * (cs * haze_glow + tmpAmbient.rgb);
+
+    // brightness of surface both sunlight and ambient
+    sunlit = sunlight.rgb;
+    amblit = tmpAmbient.rgb;
+    additive *= vec3(1.0 - combined_haze);
+}
+
+// return colors in linear space
+void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive,
+                         out vec3 atten, bool use_ao)
+{
+    calcAtmosphericVars(inPositionEye, light_dir, ambFactor, sunlit, amblit, additive, atten, use_ao);
+    sunlit = srgb_to_linear(sunlit)*2.25;
+    amblit = srgb_to_linear(amblit)*0.15;
+    additive = srgb_to_linear(additive);
+    atten = srgb_to_linear(atten);
+}
diff --git a/indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl b/indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl
index 68db7fcbb1..6dfb2e7cf6 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl
@@ -28,6 +28,22 @@ uniform int no_atmo;
 vec3 getAtmosAttenuation();
 vec3 getAdditiveColor();
 
+vec3 srgb_to_linear(vec3 col);
+vec3 linear_to_srgb(vec3 col);
+
+vec3 scaleSoftClipFragLinear(vec3 light)
+{
+    if (no_atmo == 1)
+    {
+        return light;
+    }
+    light = linear_to_srgb(light);
+    //soft clip effect:
+    light = 1. - clamp(light, vec3(0.), vec3(1.));
+    light = 1. - pow(light, vec3(gamma)); // s/b inverted already CPU-side
+    return srgb_to_linear(light);
+}
+
 vec3 scaleSoftClipFrag(vec3 light)
 {
     if (no_atmo == 1)
diff --git a/indra/newview/app_settings/shaders/class2/windlight/skyV.glsl b/indra/newview/app_settings/shaders/class2/windlight/skyV.glsl
index a0a33b8642..3edc94f4ca 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/skyV.glsl
@@ -55,8 +55,6 @@ uniform float max_y;
 uniform vec4  glow;
 uniform float sun_moon_glow_factor;
 
-uniform vec4 cloud_color;
-
 void main()
 {
     // World / view / projection
diff --git a/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl b/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
index b53a2e237f..4bf2275e6a 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
@@ -32,6 +32,9 @@ vec3 getAtmosAttenuation();
 
 uniform int no_atmo;
 
+vec3 srgb_to_linear(vec3 col);
+vec3 linear_to_srgb(vec3 col);
+
 vec3 atmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
 {
     light *= atten.r;
@@ -44,6 +47,16 @@ vec3 atmosTransport(vec3 light)
      return atmosTransportFrag(light, getAdditiveColor(), getAtmosAttenuation());
 }
 
+vec3 fullbrightAtmosTransportFragLinear(vec3 light, vec3 additive, vec3 atten)
+{
+    light = linear_to_srgb(light);
+    additive = linear_to_srgb(additive);
+    atten = linear_to_srgb(atten);
+
+    float brightness = dot(light.rgb * 0.5, vec3(0.3333)) + 0.1;    
+    return srgb_to_linear(mix(atmosTransportFrag(light.rgb, additive, atten), light.rgb + additive, brightness * brightness));
+}
+
 vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
 {
     float brightness = dot(light.rgb * 0.5, vec3(0.3333)) + 0.1;    
diff --git a/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl
index 7c0a11d442..c1f60da7ee 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl
@@ -41,13 +41,10 @@ uniform int sun_up_factor;
 vec4 applyWaterFogView(vec3 pos, vec4 color);
 #endif
 
-vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
-vec3 scaleSoftClipFrag(vec3 l);
-
-vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
-vec3 fullbrightScaleSoftClip(vec3 light);
-
-void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
+vec3 atmosFragLightingLinear(vec3 l, vec3 additive, vec3 atten);
+vec3 scaleSoftClipFragLinear(vec3 l);
+void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
+vec3 fullbrightAtmosTransportFragLinear(vec3 light, vec3 additive, vec3 atten);
 
 vec3 srgb_to_linear(vec3 cs);
 vec3 linear_to_srgb(vec3 cs);
@@ -94,7 +91,7 @@ uniform vec3 light_diffuse[8];
 
 float getAmbientClamp();
 
-vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 npos, vec3 diffuse, vec4 spec, vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float fa, float is_pointlight, inout float glare, float ambiance)
+vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 npos, vec3 diffuse, vec4 spec, vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float fa, float is_pointlight, float ambiance)
 {
     // SL-14895 inverted attenuation work-around
     // This routine is tweaked to match deferred lighting, but previously used an inverted la value. To reconstruct
@@ -172,11 +169,6 @@ vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 npos, vec3 diffuse, vec4 spe
                 vec3 speccol = lit*scol*light_col.rgb*spec.rgb;
                 speccol = clamp(speccol, vec3(0), vec3(1));
                 col += speccol;
-
-                float cur_glare = max(speccol.r, speccol.g);
-                cur_glare = max(cur_glare, speccol.b);
-                glare = max(glare, speccol.r);
-                glare += max(cur_glare, 0.0);
             }
         }
     }
@@ -288,7 +280,7 @@ void main()
 
     //forward rendering, output lit linear color
     diffcol.rgb = srgb_to_linear(diffcol.rgb);
-    spec.rgb = srgb_to_linear(spec.rgb);
+    final_specular.rgb = srgb_to_linear(final_specular.rgb);
 
     vec3 pos = vary_position;
 
@@ -298,9 +290,7 @@ void main()
     shadow = sampleDirectionalShadow(pos.xyz, norm.xyz, pos_screen);
 #endif
 
-    spec = final_specular;
     vec4 diffuse = final_color;
-    float envIntensity = final_normal.z;
 
     vec3 color = vec3(0,0,0);
 
@@ -311,70 +301,62 @@ void main()
     vec3 amblit;
     vec3 additive;
     vec3 atten;
-
-    calcAtmosphericVars(pos.xyz, light_dir, 1.0, sunlit, amblit, additive, atten, false);
+    calcAtmosphericVarsLinear(pos.xyz, light_dir, 1.0, sunlit, amblit, additive, atten, false);
     
-        // This call breaks the Mac GLSL compiler/linker for unknown reasons (17Mar2020)
-        // The call is either a no-op or a pure (pow) gamma adjustment, depending on GPU level
-        // TODO: determine if we want to re-apply the gamma adjustment, and if so understand & fix Mac breakage
-        //color = fullbrightScaleSoftClip(color);
-
-    vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
-
     vec3 ambenv;
     vec3 glossenv;
     vec3 legacyenv;
-    sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, spec.a, envIntensity);
+    sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, pos.xyz, norm.xyz, final_specular.a, env_intensity);
+    
     // use sky settings ambient or irradiance map sample, whichever is brighter
     color = max(amblit, ambenv);
 
-    float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
+    float ambient = min(abs(dot(norm.xyz, light_dir.xyz)), 1.0);
     ambient *= 0.5;
     ambient *= ambient;
     ambient = (1.0 - ambient);
     color.rgb *= ambient;
 
-    float da          = clamp(dot(norm.xyz, sun_dir.xyz), 0.0, 1.0);
+    float da          = clamp(dot(norm.xyz, light_dir.xyz), 0.0, 1.0);
     vec3 sun_contrib = min(da, shadow) * sunlit;
     color.rgb += sun_contrib;
-    color.rgb *= diffuse.rgb;
-
     color *= diffcol.rgb;
 
-    float glare = 0.0;
+    vec3 refnormpersp = reflect(pos.xyz, norm.xyz);
 
-    if (spec.a > 0.0)  // specular reflection
+    if (final_specular.a > 0.0)  // specular reflection
     {
-        float sa        = dot(refnormpersp, sun_dir.xyz);
-        vec3  dumbshiny = sunlit * shadow * (texture2D(lightFunc, vec2(sa, spec.a)).r);
+        float sa        = dot(normalize(refnormpersp), light_dir.xyz);
+        vec3  dumbshiny = sunlit * shadow * (texture2D(lightFunc, vec2(sa, final_specular.a)).r);
 
         // add the two types of shiny together
-        vec3 spec_contrib = dumbshiny * spec.rgb;
+        vec3 spec_contrib = dumbshiny * final_specular.rgb;
         bloom             = dot(spec_contrib, spec_contrib) / 6;
 
-        glare = max(spec_contrib.r, spec_contrib.g);
-        glare = max(glare, spec_contrib.b);
-
         color += spec_contrib;
 
-        applyGlossEnv(color, glossenv, spec, pos.xyz, norm.xyz);
+        applyGlossEnv(color, glossenv, final_specular, pos.xyz, norm.xyz);
     }
 
-    color = atmosFragLighting(color, additive, atten);
-    if (envIntensity > 0.0)
+    color = mix(color.rgb, diffcol.rgb, diffuse.a);
+
+    if (env_intensity > 0.0)
     {  // add environmentmap
-        applyLegacyEnv(color, legacyenv, spec, pos.xyz, norm.xyz, envIntensity);
+        applyLegacyEnv(color, legacyenv, final_specular, pos.xyz, norm.xyz, env_intensity);
     }
 
-    vec3 npos = normalize(-pos.xyz);
+    color.rgb = mix(atmosFragLightingLinear(color.rgb, additive, atten), fullbrightAtmosTransportFragLinear(color, additive, atten), diffuse.a); 
+    color.rgb = scaleSoftClipFragLinear(color.rgb);
 
-    vec3 light = vec3(0, 0, 0);
-    
-    final_specular.rgb = final_specular.rgb; // SL-14035
+#ifdef WATER_FOG
+    vec4 temp = applyWaterFogView(pos, vec4(color, 0.0));
+    color = temp.rgb;
+#endif
 
-    color = mix(color.rgb, diffcol.rgb, diffuse.a);
+    vec3 npos = normalize(-pos.xyz);
+    vec3 light = vec3(0, 0, 0);
 
-#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 );
+#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, light_attenuation[i].w );
 
     LIGHT_LOOP(1)
         LIGHT_LOOP(2)
@@ -386,17 +368,9 @@ void main()
 
     color += light;
 
-    glare = min(glare, 1.0);
-    float al = max(diffcol.a, glare)*vertex_color.a;
-
-#ifdef WATER_FOG
-    vec4 temp = applyWaterFogView(pos, vec4(color, al));
-    color = temp.rgb;
-    al = temp.a;
-#endif
+    float al = diffcol.a*vertex_color.a;
 
     frag_color = vec4(color, al);
-
 #else // mode is not DIFFUSE_ALPHA_MODE_BLEND, encode to gbuffer 
 
     // deferred path               // See: C++: addDeferredAttachment(), shader: softenLightF.glsl
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index d525b673bf..c7ec1ddde9 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -69,11 +69,10 @@ uniform vec2 screen_res;
 vec3 getNorm(vec2 pos_screen);
 vec4 getPositionWithDepth(vec2 pos_screen, float depth);
 
-void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
-vec3  atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
-vec3  scaleSoftClipFrag(vec3 l);
-vec3  fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
-vec3  fullbrightScaleSoftClip(vec3 light);
+void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
+vec3  atmosFragLightingLinear(vec3 l, vec3 additive, vec3 atten);
+vec3  scaleSoftClipFragLinear(vec3 l);
+vec3  fullbrightAtmosTransportFragLinear(vec3 light, vec3 additive, vec3 atten);
 
 // reflection probe interface
 void sampleReflectionProbes(inout vec3 ambenv, inout vec3 glossenv,
@@ -135,7 +134,7 @@ void main()
     vec3 additive;
     vec3 atten;
 
-    calcAtmosphericVars(pos.xyz, light_dir, ambocc, sunlit, amblit, additive, atten, true);
+    calcAtmosphericVarsLinear(pos.xyz, light_dir, 1.0, sunlit, amblit, additive, atten, false);
 
     vec3 ambenv;
     vec3 glossenv;
@@ -158,7 +157,7 @@ void main()
         vec3  radiance  = vec3(0);
         sampleReflectionProbes(irradiance, radiance, pos.xyz, norm.xyz, gloss);
         
-        irradiance       = max(amblit*1.725,irradiance);
+        irradiance       = max(amblit*ao,irradiance);
 
         vec3 f0 = vec3(0.04);
         vec3 baseColor = diffuse.rgb;
@@ -172,17 +171,14 @@ void main()
         float NdotV = clamp(abs(dot(norm.xyz, v)), 0.001, 1.0);
         
         color.rgb += pbrIbl(diffuseColor, specularColor, radiance, irradiance, ao, NdotV, perceptualRoughness);
-        color.rgb += pbrPunctual(diffuseColor, specularColor, perceptualRoughness, metallic, norm.xyz, v, normalize(light_dir)) * sunlit*8.0 * scol;
+        color.rgb += pbrPunctual(diffuseColor, specularColor, perceptualRoughness, metallic, norm.xyz, v, normalize(light_dir)) * sunlit*2.75 * scol;
         color.rgb += colorEmissive;
 
-        //color = atmosFragLighting(color, additive, atten);
-        color *= atten.r;
-        color += additive*2.0;
-        
+        color = atmosFragLightingLinear(color, additive, atten);
+        color  = scaleSoftClipFragLinear(color);
     }
     else
     {
-
         // legacy shaders are still writng sRGB to gbuffer
         diffuse.rgb = srgb_to_linear(diffuse.rgb);
         spec.rgb = srgb_to_linear(spec.rgb);
@@ -197,7 +193,7 @@ void main()
         // use sky settings ambient or irradiance map sample, whichever is brighter
         color = max(amblit, ambenv*ambocc);
 
-        float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
+        float ambient = min(abs(dot(norm.xyz, light_dir.xyz)), 1.0);
         ambient *= 0.5;
         ambient *= ambient;
         ambient = (1.0 - ambient);
@@ -216,32 +212,30 @@ void main()
 
             // add the two types of shiny together
             vec3 spec_contrib = dumbshiny * spec.rgb;
-            bloom             = dot(spec_contrib, spec_contrib) / 6;
             color.rgb += spec_contrib;
 
-            // add reflection map - EXPERIMENTAL WORK IN PROGRESS
+            // add radiance map
             applyGlossEnv(color, glossenv, spec, pos.xyz, norm.xyz);
         }
 
         color.rgb = mix(color.rgb, diffuse.rgb, diffuse.a);
-
+        
+        if (envIntensity > 0.0)
+        {  // add environment map
+            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(color, fullbrightScaleSoftClip(color), diffuse.a);
+            color = mix(atmosFragLightingLinear(color, additive, atten), fullbrightAtmosTransportFragLinear(color, additive, atten), diffuse.a);    
+            color = scaleSoftClipFragLinear(color);
         }
     }
 
     #ifdef WATER_FOG
         vec4 fogged = applyWaterFogView(pos.xyz, vec4(color, bloom));
         color       = fogged.rgb;
-        bloom       = fogged.a;
     #endif
 
     frag_color.rgb = color.rgb; //output linear since local lights will be added to this shader's results
-    frag_color.a = bloom;
+    frag_color.a = 0.0;
 }
diff --git a/indra/newview/app_settings/shaders/shader_hierarchy.txt b/indra/newview/app_settings/shaders/shader_hierarchy.txt
index 8ef04d8e1f..81e1327178 100644
--- a/indra/newview/app_settings/shaders/shader_hierarchy.txt
+++ b/indra/newview/app_settings/shaders/shader_hierarchy.txt
@@ -1,177 +1,15 @@
-Class 3 is highest quality / lowest  performance
-Class 2 is medium  quality / medium  performance
-Class 1 is lowest  quality / highest performance
+Second Life shader variants are referred to as "classes."  
 
-Shaders WILL fall back to "lower" classes for functionality.
+When a shader of a particular class is loaded, a lower class may 
+be loaded if the class requested doesn't exist or fails to load 
+for any reason.  In general, shaders that require more resources
+or later hardware capabilities should be higher class and 
+lower classes can be used for fallback implementations or lower
+detail settings.
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-avatar/avatarV.glsl - gAvatarProgram, gAvatarWaterProgram
-	main() - avatar/avatarV.glsl
-		getSkinnedTransform() - avatarSkinV.glsl
-		calcAtmospherics() - windlight/atmosphericsV.glsl
-		calcLighting() - lighting/lightV.glsl
-			sumLights() - lighting/sumLightsV.glsl
-				calcDirectionalLight() - lighting/lightFuncV.glsl
-				calcPointLight() - lighting/lightFuncV.glsl
-				atmosAmbient() - windlight/atmosphericsHelpersV.glsl
-				atmosAffectDirectionalLight() - windlight/atmosphericsHelpersV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-avatar/avatarF.glsl - gAvatarProgram
-	main() - avatar/avatarF.glsl
-		default_lighting() - lighting/lightF.glsl
-			calc_default_lighting() - lighting/lightF.glsl
-				atmosLighting() - windlight/atmosphericsF.glsl
-				scaleSoftClip() - windlight/gammaF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-avatar/eyeballV.glsl - gAvatarEyeballProgram
-	main() - avatar/eyeballV.glsl
-		calcAtmospherics() - windlight/atmosphericsV.glsl
-		calcLightingSpecular() - lighting/lightSpecularV.glsl
-			sumLightsSpecular() - lighting/sumLightsSpecularV.glsl
-				calcDirectionalLightSpecular() - lighting/lightFuncSpecularV.glsl
-				calcPointLightSpecular() - lighting/lightFuncSpecularV.glsl
-				atmosAmbient() - windlight/atmosphericsHelpersV.glsl
-				atmosAffectDirectionalLight() - windlight/atmosphericsHelpersV.glsl
-				atmosGetDiffuseSunlightColor() - windlight/atmosphericsHelpersV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-avatar/eyeballF.glsl - gAvatarEyeballProgram
-	main() - avatar/eyeballF.glsl
-		default_lighting() - lighting/lightF.glsl
-			calc_default_lighting() - lighting/lightF.glsl
-				atmosLighting() - windlight/atmosphericsF.glsl
-				scaleSoftClip() - windlight/gammaF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-avatar/pickAvatarV.glsl - gAvatarPickProgram
-	main() - avatar/pickAvatarV.glsl
-		getSkinnedTransform() - avatarSkinV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-avatar/pickAvatarF.glsl - gAvatarPickProgram
-	main() - avatar/pickAvatarF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-environment/terrainV.glsl - gTerrainProgram, gTerrainWaterProgram
-	texgen_object() - environment/terrainV.glsl
-	main() - environment/terrainV.glsl
-		texgen_object() - environment/terrainV.glsl
-		calcAtmospherics() - windlight/atmosphericsV.glsl
-		calcLighting() - lighting/lightV.glsl
-			sumLights() - lighting/sumLightsV.glsl
-				calcDirectionalLight() - lighting/lightFuncV.glsl
-				calcPointLight() - lighting/lightFuncV.glsl
-				atmosAmbient() - windlight/atmosphericsHelpersV.glsl
-				atmosAffectDirectionalLight() - windlight/atmosphericsHelpersV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-environment/terrainF.glsl - gTerrainProgram
-	main() - environment/terrainF.glsl
-		atmosLighting() - windlight/atmosphericsF.glsl
-		scaleSoftClip() - windlight/gammaF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-environment/terrainWaterF.glsl - gTerrainWaterProgram
-	main() - environment/terrainWaterF.glsl
-		atmosLighting() - windlight/atmosphericsF.glsl
-		applyWaterFog() - environment/waterFogF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-environment/underWaterF.glsl - gUnderWaterProgram
-	applyWaterFog() - environment/underWaterF.glsl (NOTE: different than one in waterFogF.glsl)
-	main() - environment/underWaterF.glsl
-		applyWaterFog() - environment/underWaterF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-environment/waterV.glsl - gWaterProgram, gUnderWaterProgram
-	main() - environment/waterV.glsl
-		calcAtmospherics() - windlight/atmosphericsV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-environment/waterF.glsl - gWaterProgram
-	main() - environment/waterF.glsl
-		atmosTransport() - windlight/transportF.glsl
-		scaleSoftClip() - windlight/gammaF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/fullbrightV.glsl - gObjectFullbrightProgram, gObjectFullbrightWaterProgram
-	main() - objects/fullbrightV.glsl
-		calcAtmospherics() - windlight/atmosphericsV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/fullbrightF.glsl - gObjectFullbrightProgram
-	main() - objects/fullbrightF.glsl
-		fullbright_lighting() - lighting/lightFullbrightF.glsl
-			fullbrightAtmosTransport() - windlight/transportF.glsl
-				atmosTransport() - windlight/transportF.glsl
-			fullbrightScaleSoftClip() - windlight/gammaF.glsl
-				scaleSoftClip() - windlight/gammaF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/fullbrightShinyV.glsl - gObjectFullbrightShinyProgram
-	main() - objects/fullbrightShinyV.glsl
-		calcAtmospherics() - windlight/atmosphericsV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/fullbrightShinyF.glsl - gObjectFullbrightShinyProgram
-	main() - objects/fullbrightShinyF.glsl
-		fullbright_shiny_lighting() - lighting/lightFullbrightShinyF.glsl
-			fullbrightShinyAtmosTransport() - windlight/transportF.glsl
-				atmosTransport() - windlight/transportF.glsl
-			fullbrightScaleSoftClip() - windlight/gammaF.glsl
-				scaleSoftClip() - windlight/gammaF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/fullbrightWaterF.glsl - gObjectFullbrightWaterProgram
-	main() - objects/fullbrightWaterF.glsl
-		fullbright_lighting_water() - lighting/lightFullbrightWaterF.glsl
-			fullbrightAtmosTransport() - windlight/transportF.glsl
-				atmosTransport() - windlight/transportF.glsl
-			applyWaterFog() - environment/waterFogF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/shinyV.glsl - gObjectShinyProgram, gObjectShinyWaterProgram
-	main() - objects/shinyV.glsl
-		calcAtmospherics() - windlight/atmosphericsV.glsl
-		calcLighting() - lighting/lightV.glsl
-			calcLighting(vec4) - lighting/lightV.glsl
-				sumLights() - lighting/sumLightsV.glsl
-					calcDirectionalLight() - lighting/lightFuncV.glsl
-					calcPointLight() - lighting/lightFuncV.glsl
-					atmosAmbient() - windlight/atmosphericsHelpersV.glsl
-					atmosAffectDirectionalLight() - windlight/atmosphericsHelpersV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/shinyF.glsl - gObjectShinyProgram
-	main() - objects/shinyF.glsl
-		shiny_lighting() - lighting/lightShinyF.glsl
-			atmosLighting() - windlight/atmosphericsF.glsl
-			scaleSoftClip() - windlight/gammaF.glsl	
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/shinyWaterF.glsl - gObjectShinyWaterProgram
-	main() - objects/shinyWaterF.glsl
-		shiny_lighting_water() - lighting/lightShinyWaterF.glsl
-			atmosLighting() - windlight/atmosphericsF.glsl
-			applyWaterFog() - environment/waterFogF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/simpleV.glsl - gObjectSimpleProgram, gObjectSimpleWaterProgram
-	main() - objects/simpleV.glsl
-		calcAtmospherics() - windlight/atmosphericsV.glsl
-		calcLighting() - lighting/lightV.glsl
-			sumLights() - lighting/sumLightsV.glsl
-				calcDirectionalLight() - lighting/lightFuncV.glsl
-				calcPointLight() - lighting/lightFuncV.glsl
-				atmosAmbient() - windlight/atmosphericsHelpersV.glsl
-				atmosAffectDirectionalLight() - windlight/atmosphericsHelpersV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/simpleF.glsl - gObjectSimpleProgram
-	main() - objects/simpleF.glsl
-		default_lighting() - lighting/lightF.glsl
-			atmosLighting() - windlight/atmosphericsF.glsl
-			scaleSoftClip() - windlight/gammaF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-objects/simpleWaterF.glsl - gObjectSimpleWaterProgram, gAvatarWaterProgram
-	main() - objects/simpleWaterF.glsl
-		default_lighting_water() - lighting/lightWaterF.glsl
-			atmosLighting() - windlight/atmosphericsF.glsl
-			applyWaterFog() - environment/waterFogF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-windlight/skyV.glsl - gWLSkyProgram
-	main() - windlight/skyV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-windlight/skyF.glsl - gWLSkyProgram
-	main() - windlight/skyF.glsl
-		scaleSoftClip() - windlight/gammaF.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-windlight/cloudsV.glsl - gWLCloudProgram
-	main() - windlight/cloudsV.glsl
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-windlight/cloudsF.glsl - gWLCloudProgram
-	main() - windlight/cloudsF.glsl
-		scaleSoftClip() - windlight/gammaF.glsl
+Which class is chosen will generally depend on graphics preferences. 
+
+Previously, someone tried to enumerate the shaders here, but don't do 
+that.  It messes with searches and the shader hierarchy changes often.