Merge remote-tracking branch 'origin/release/materials_featurette' into DRTVWR-583

22 files changed, 840 insertions, 414 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/emissiveF.glsl b/indra/newview/app_settings/shaders/class1/deferred/emissiveF.glsl
index 9e61b6b894..c95f791dbf 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/emissiveF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/emissiveF.glsl
@@ -34,6 +34,6 @@ void main()
 {
     // NOTE: when this shader is used, only alpha is being written to
 	float a = diffuseLookup(vary_texcoord0.xy).a*vertex_color.a;
-	frag_color = vec4(0, 0, 0, a);
+	frag_color = max(vec4(0, 0, 0, a), vec4(0));
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
index 5d58cc91cd..a6fab10791 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
@@ -35,21 +35,19 @@ in vec3 vary_position;
 in vec4 vertex_color;
 in vec2 vary_texcoord0;
 
-#ifdef WATER_FOG
-vec4 applyWaterFogView(vec3 pos, vec4 color);
-#endif
-
 vec3 srgb_to_linear(vec3 cs);
 vec3 linear_to_srgb(vec3 cl);
-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 additive, out vec3 atten);
 
 #ifdef HAS_ALPHA_MASK
 uniform float minimum_alpha;
 #endif
 
 #ifdef IS_ALPHA
+uniform vec4 waterPlane;
 void waterClip(vec3 pos);
+void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive,
+                         out vec3 atten);
+vec4 applySkyAndWaterFog(vec3 pos, vec3 additive, vec3 atten, vec4 color);
 #endif
 
 void main() 
@@ -78,26 +76,21 @@ void main()
 
     vec3 pos = vary_position;
 
+    color.a = final_alpha;
 #ifndef IS_HUD
+    color.rgb = srgb_to_linear(color.rgb);
+#ifdef IS_ALPHA
+
     vec3 sunlit;
     vec3 amblit;
     vec3 additive;
     vec3 atten;
     calcAtmosphericVars(pos.xyz, vec3(0), 1.0, sunlit, amblit, additive, atten);
-#endif
 
-#ifdef WATER_FOG
+    color.rgb = applySkyAndWaterFog(pos, additive, atten, color).rgb;
     
-    vec4 fogged = applyWaterFogView(pos, vec4(color.rgb, final_alpha));
-    color.rgb = fogged.rgb;
-    color.a   = fogged.a;
-#else
-    color.a   = final_alpha;
 #endif
 
-#ifndef IS_HUD
-    color.rgb = srgb_to_linear(color.rgb);
-    color.rgb = atmosFragLighting(color.rgb, additive, atten);
 #endif
 
     frag_color = max(color, vec4(0));
diff --git a/indra/newview/app_settings/shaders/class1/deferred/moonF.glsl b/indra/newview/app_settings/shaders/class1/deferred/moonF.glsl
index f3e7b2ee72..183354b9bd 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/moonF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/moonF.glsl
@@ -57,5 +57,8 @@ void main()
     frag_data[1] = vec4(0.0);
     frag_data[2] = vec4(0.0, 0.0, 0.0, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(c.rgb, c.a);
+
+    // Added and commented out for a ground truth.  Do not uncomment - Geenz
+    //gl_FragDepth = 0.999985f;
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/moonV.glsl b/indra/newview/app_settings/shaders/class1/deferred/moonV.glsl
index 032245a01c..c2a1dccb33 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/moonV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/moonV.glsl
@@ -39,7 +39,8 @@ void main()
     vec4 pos = (modelview_projection_matrix * vert);
 
     // smash to *almost* far clip plane -- stars are still behind
-    pos.z = pos.w*0.999999;
+    // SL-19283 - finagle the moon position to be between clouds and stars.
+    pos.z = pos.w*0.999991;
     gl_Position = pos;
 
     vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbrterrainF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainF.glsl
new file mode 100644
index 0000000000..db03e0885c
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainF.glsl
@@ -0,0 +1,272 @@
+/** 
+ * @file class1\deferred\terrainF.glsl
+ *
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2023, 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]*/
+
+#define TERRAIN_PBR_DETAIL_EMISSIVE 0
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+#define TerrainCoord vec4[2]
+#elif TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 1
+#define TerrainCoord vec2
+#endif
+
+#define MIX_X    1 << 3
+#define MIX_Y    1 << 4
+#define MIX_Z    1 << 5
+#define MIX_W    1 << 6
+
+// TODO: Decide if this struct needs to be declared
+struct TerrainMix
+{
+    vec4 weight;
+    int type;
+};
+
+TerrainMix get_terrain_mix_weights(float alpha1, float alpha2, float alphaFinal);
+
+// TODO: Decide if this struct needs to be declared
+struct PBRMix
+{
+    vec4 col;       // RGB color with alpha, linear space
+    vec3 orm;       // Occlusion, roughness, metallic
+    vec3 vNt;       // Unpacked normal texture sample, vector
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    vec3 emissive;  // RGB emissive color, linear space
+#endif
+};
+
+PBRMix init_pbr_mix();
+
+PBRMix terrain_sample_and_multiply_pbr(
+    TerrainCoord terrain_coord
+    , sampler2D tex_col
+    , sampler2D tex_orm
+    , sampler2D tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , sampler2D tex_emissive
+#endif
+    , vec4 factor_col
+    , vec3 factor_orm
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , vec3 factor_emissive
+#endif
+    );
+
+PBRMix mix_pbr(PBRMix mix1, PBRMix mix2, float mix2_weight);
+
+out vec4 frag_data[4];
+
+uniform sampler2D alpha_ramp;
+
+// *TODO: More configurable quality level which disables PBR features on machines
+// with limited texture availability
+// https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#additional-textures
+uniform sampler2D detail_0_base_color;
+uniform sampler2D detail_1_base_color;
+uniform sampler2D detail_2_base_color;
+uniform sampler2D detail_3_base_color;
+uniform sampler2D detail_0_normal;
+uniform sampler2D detail_1_normal;
+uniform sampler2D detail_2_normal;
+uniform sampler2D detail_3_normal;
+uniform sampler2D detail_0_metallic_roughness;
+uniform sampler2D detail_1_metallic_roughness;
+uniform sampler2D detail_2_metallic_roughness;
+uniform sampler2D detail_3_metallic_roughness;
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+uniform sampler2D detail_0_emissive;
+uniform sampler2D detail_1_emissive;
+uniform sampler2D detail_2_emissive;
+uniform sampler2D detail_3_emissive;
+#endif
+
+uniform vec4[4] baseColorFactors; // See also vertex_color in pbropaqueV.glsl
+uniform vec4 metallicFactors;
+uniform vec4 roughnessFactors;
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+uniform vec3[4] emissiveColors;
+#endif
+uniform vec4 minimum_alphas; // PBR alphaMode: MASK, See: mAlphaCutoff, setAlphaCutoff()
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+in vec4[2] vary_coords;
+#endif
+in vec3 vary_normal;
+in vec3 vary_tangent;
+flat in float vary_sign;
+in vec4 vary_texcoord0;
+in vec4 vary_texcoord1;
+
+vec2 encode_normal(vec3 n);
+
+float terrain_mix(TerrainMix tm, vec4 tms4);
+
+void main()
+{
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+    TerrainCoord terrain_texcoord = vary_coords;
+#elif TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 1
+    TerrainCoord terrain_texcoord = vary_texcoord0.xy;
+#endif
+
+    float alpha1 = texture(alpha_ramp, vary_texcoord0.zw).a;
+    float alpha2 = texture(alpha_ramp,vary_texcoord1.xy).a;
+    float alphaFinal = texture(alpha_ramp, vary_texcoord1.zw).a;
+
+    TerrainMix tm = get_terrain_mix_weights(alpha1, alpha2, alphaFinal);
+
+    // RGB = Occlusion, Roughness, Metal
+    // default values, see LLViewerTexture::sDefaultPBRORMImagep
+    //   occlusion 1.0
+    //   roughness 0.0
+    //   metal     0.0
+    vec3[4] orm_factors;
+    orm_factors[0] = vec3(1.0, roughnessFactors.x, metallicFactors.x);
+    orm_factors[1] = vec3(1.0, roughnessFactors.y, metallicFactors.y);
+    orm_factors[2] = vec3(1.0, roughnessFactors.z, metallicFactors.z);
+    orm_factors[3] = vec3(1.0, roughnessFactors.w, metallicFactors.w);
+
+    PBRMix mix = init_pbr_mix();
+    PBRMix mix2;
+    switch (tm.type & MIX_X)
+    {
+    case MIX_X:
+        mix2 = terrain_sample_and_multiply_pbr(
+            terrain_texcoord
+            , detail_0_base_color
+            , detail_0_metallic_roughness
+            , detail_0_normal
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , detail_0_emissive
+#endif
+            , baseColorFactors[0]
+            , orm_factors[0]
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , emissiveColors[0]
+#endif
+        );
+        mix = mix_pbr(mix, mix2, tm.weight.x);
+        break;
+    default:
+        break;
+    }
+    switch (tm.type & MIX_Y)
+    {
+    case MIX_Y:
+        mix2 = terrain_sample_and_multiply_pbr(
+            terrain_texcoord
+            , detail_1_base_color
+            , detail_1_metallic_roughness
+            , detail_1_normal
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , detail_1_emissive
+#endif
+            , baseColorFactors[1]
+            , orm_factors[1]
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , emissiveColors[1]
+#endif
+        );
+        mix = mix_pbr(mix, mix2, tm.weight.y);
+        break;
+    default:
+        break;
+    }
+    switch (tm.type & MIX_Z)
+    {
+    case MIX_Z:
+        mix2 = terrain_sample_and_multiply_pbr(
+            terrain_texcoord
+            , detail_2_base_color
+            , detail_2_metallic_roughness
+            , detail_2_normal
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , detail_2_emissive
+#endif
+            , baseColorFactors[2]
+            , orm_factors[2]
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , emissiveColors[2]
+#endif
+        );
+        mix = mix_pbr(mix, mix2, tm.weight.z);
+        break;
+    default:
+        break;
+    }
+    switch (tm.type & MIX_W)
+    {
+    case MIX_W:
+        mix2 = terrain_sample_and_multiply_pbr(
+            terrain_texcoord
+            , detail_3_base_color
+            , detail_3_metallic_roughness
+            , detail_3_normal
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , detail_3_emissive
+#endif
+            , baseColorFactors[3]
+            , orm_factors[3]
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , emissiveColors[3]
+#endif
+        );
+        mix = mix_pbr(mix, mix2, tm.weight.w);
+        break;
+    default:
+        break;
+    }
+
+    float minimum_alpha = terrain_mix(tm, minimum_alphas);
+    if (mix.col.a < minimum_alpha)
+    {
+        discard;
+    }
+    float base_color_factor_alpha = terrain_mix(tm, vec4(baseColorFactors[0].z, baseColorFactors[1].z, baseColorFactors[2].z, baseColorFactors[3].z));
+
+    // from mikktspace.com
+    vec3 vNt = mix.vNt;
+    vec3 vN = vary_normal;
+    vec3 vT = vary_tangent.xyz;
+    
+    vec3 vB = vary_sign * cross(vN, vT);
+    vec3 tnorm = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
+
+    tnorm *= gl_FrontFacing ? 1.0 : -1.0;
+   
+
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+#define emissive mix.emissive
+#else
+#define emissive vec3(0)
+#endif
+    frag_data[0] = max(vec4(mix.col.xyz, 0.0), vec4(0));                                                   // Diffuse
+    frag_data[1] = max(vec4(mix.orm.rgb, base_color_factor_alpha), vec4(0));                                    // PBR linear packed Occlusion, Roughness, Metal.
+    frag_data[2] = max(vec4(encode_normal(tnorm), base_color_factor_alpha, GBUFFER_FLAG_HAS_PBR), vec4(0)); // normal, environment intensity, flags
+    frag_data[3] = max(vec4(emissive,0), vec4(0));                                                // PBR sRGB Emissive
+}
+
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbrterrainUtilF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainUtilF.glsl
new file mode 100644
index 0000000000..316b751590
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainUtilF.glsl
@@ -0,0 +1,396 @@
+/** 
+ * @file class1\deferred\pbrterrainUtilF.glsl
+ *
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2023, 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]*/
+
+/**
+ * Triplanar mapping implementation adapted from Inigo Quilez' example shader,
+ * MIT license.
+ * https://www.shadertoy.com/view/MtsGWH
+ * Copyright © 2015 Inigo Quilez
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions: The above copyright
+ * notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS",
+ * WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+ * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TERRAIN_PBR_DETAIL_EMISSIVE 0
+
+in vec3 vary_vertex_normal;
+
+vec3 srgb_to_linear(vec3 c);
+
+// A relatively agressive threshold for terrain material mixing sampling
+// cutoff. This ensures that only one or two materials are used in most places,
+// making PBR terrain blending more performant. Should be greater than 0 to work.
+#define TERRAIN_RAMP_MIX_THRESHOLD 0.1
+// A small threshold for triplanar mapping sampling cutoff. This and
+// TERRAIN_TRIPLANAR_BLEND_FACTOR together ensures that only one or two samples
+// per texture are used in most places, making triplanar mapping more
+// performant. Should be greater than 0 to work.
+// There's also an artistic design choice in the use of these factors, and the
+// use of triplanar generally. Don't take these triplanar constants for granted.
+#define TERRAIN_TRIPLANAR_MIX_THRESHOLD 0.01
+
+#define SAMPLE_X 1 << 0
+#define SAMPLE_Y 1 << 1
+#define SAMPLE_Z 1 << 2
+#define MIX_X    1 << 3
+#define MIX_Y    1 << 4
+#define MIX_Z    1 << 5
+#define MIX_W    1 << 6
+
+struct PBRMix
+{
+    vec4 col;       // RGB color with alpha, linear space
+    vec3 orm;       // Occlusion, roughness, metallic
+    vec3 vNt;       // Unpacked normal texture sample, vector
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    vec3 emissive;  // RGB emissive color, linear space
+#endif
+};
+
+PBRMix init_pbr_mix()
+{
+    PBRMix mix;
+    mix.col = vec4(0);
+    mix.orm = vec3(0);
+    mix.vNt = vec3(0);
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    mix.emissive = vec3(0);
+#endif
+    return mix;
+}
+
+// Usage example, for two weights:
+// vec2 weights = ... // Weights must add up to 1
+// PBRMix mix = init_pbr_mix();
+// PBRMix mix1 = ...
+// mix = mix_pbr(mix, mix1, weights.x);
+// PBRMix mix2 = ...
+// mix = mix_pbr(mix, mix2, weights.y);
+PBRMix mix_pbr(PBRMix mix1, PBRMix mix2, float mix2_weight)
+{
+    PBRMix mix;
+    mix.col      = mix1.col      + (mix2.col      * mix2_weight);
+    mix.orm      = mix1.orm      + (mix2.orm      * mix2_weight);
+    mix.vNt      = mix1.vNt      + (mix2.vNt      * mix2_weight);
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    mix.emissive = mix1.emissive + (mix2.emissive * mix2_weight);
+#endif
+    return mix;
+}
+
+PBRMix sample_pbr(
+    vec2 uv
+    , sampler2D tex_col
+    , sampler2D tex_orm
+    , sampler2D tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , sampler2D tex_emissive
+#endif
+    )
+{
+    PBRMix mix;
+    mix.col = texture(tex_col, uv);
+    mix.col.rgb = srgb_to_linear(mix.col.rgb);
+    mix.orm = texture(tex_orm, uv).xyz;
+    mix.vNt = texture(tex_vNt, uv).xyz*2.0-1.0;
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    mix.emissive = srgb_to_linear(texture(tex_emissive, uv).xyz);
+#endif
+    return mix;
+}
+
+struct TerrainTriplanar
+{
+    vec3 weight;
+    int type;
+};
+
+struct TerrainMix
+{
+    vec4 weight;
+    int type;
+};
+
+#define TerrainMixSample vec4[4]
+#define TerrainMixSample3 vec3[4]
+
+TerrainMix get_terrain_mix_weights(float alpha1, float alpha2, float alphaFinal)
+{
+    TerrainMix tm;
+    vec4 sample_x = vec4(1,0,0,0);
+    vec4 sample_y = vec4(0,1,0,0);
+    vec4 sample_z = vec4(0,0,1,0);
+    vec4 sample_w = vec4(0,0,0,1);
+
+    tm.weight = mix( mix(sample_w, sample_z, alpha2), mix(sample_y, sample_x, alpha1), alphaFinal );
+    tm.weight -= TERRAIN_RAMP_MIX_THRESHOLD;
+    ivec4 usage = max(ivec4(0), ivec4(ceil(tm.weight)));
+    // Prevent negative weights and keep weights balanced
+    tm.weight = tm.weight*vec4(usage);
+    tm.weight /= (tm.weight.x + tm.weight.y + tm.weight.z + tm.weight.w);
+
+    tm.type = (usage.x * MIX_X) |
+              (usage.y * MIX_Y) |
+              (usage.z * MIX_Z) |
+              (usage.w * MIX_W);
+    return tm;
+}
+
+TerrainTriplanar _t_triplanar()
+{
+    float sharpness = TERRAIN_TRIPLANAR_BLEND_FACTOR;
+    float threshold = TERRAIN_TRIPLANAR_MIX_THRESHOLD;
+    vec3 weight_signed = pow(abs(vary_vertex_normal), vec3(sharpness));
+    weight_signed /= (weight_signed.x + weight_signed.y + weight_signed.z);
+    weight_signed -= vec3(threshold);
+    TerrainTriplanar tw;
+    // *NOTE: Make sure the threshold doesn't affect the materials
+    tw.weight = max(vec3(0), weight_signed);
+    tw.weight /= (tw.weight.x + tw.weight.y + tw.weight.z);
+    ivec3 usage = ivec3(round(max(vec3(0), sign(weight_signed))));
+    tw.type = ((usage.x) * SAMPLE_X) |
+              ((usage.y) * SAMPLE_Y) |
+              ((usage.z) * SAMPLE_Z);
+    return tw;
+}
+
+// Assume weights add to 1
+float terrain_mix(TerrainMix tm, vec4 tms4)
+{
+    return (tm.weight.x * tms4[0]) +
+           (tm.weight.y * tms4[1]) +
+           (tm.weight.z * tms4[2]) +
+           (tm.weight.w * tms4[3]);
+}
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+// Triplanar mapping
+
+// Pre-transformed texture coordinates for each axial uv slice (Packing: xy, yz, (-x)z, unused)
+#define TerrainCoord vec4[2]
+
+vec2 _t_uv(vec2 uv_unflipped, float sign_or_zero)
+{
+    // Handle case where sign is 0
+    float sign = (2.0*sign_or_zero) + 1.0;
+    sign /= abs(sign);
+    // If the vertex normal is negative, flip the texture back
+    // right-side up.
+    vec2 uv = uv_unflipped * vec2(sign, 1);
+    return uv;
+}
+
+vec3 _t_normal_post_1(vec3 vNt0, float sign_or_zero)
+{
+    // Assume normal is unpacked
+    vec3 vNt1 = vNt0;
+    // Get sign
+    float sign = sign_or_zero;
+    // Handle case where sign is 0
+    sign = (2.0*sign) + 1.0;
+    sign /= abs(sign);
+    // If the sign is negative, rotate normal by 180 degrees
+    vNt1.xy = (min(0, sign) * vNt1.xy) + (min(0, -sign) * -vNt1.xy);
+    return vNt1;
+}
+
+// Triplanar-specific normal texture fixes
+vec3 _t_normal_post_x(vec3 vNt0)
+{
+    vec3 vNt_x = _t_normal_post_1(vNt0, sign(vary_vertex_normal.x));
+    // *HACK: Transform normals according to orientation of the UVs
+    vNt_x.xy = vec2(-vNt_x.y, vNt_x.x);
+    return vNt_x;
+}
+vec3 _t_normal_post_y(vec3 vNt0)
+{
+    vec3 vNt_y = _t_normal_post_1(vNt0, sign(vary_vertex_normal.y));
+    // *HACK: Transform normals according to orientation of the UVs
+    vNt_y.xy = -vNt_y.xy;
+    return vNt_y;
+}
+vec3 _t_normal_post_z(vec3 vNt0)
+{
+    vec3 vNt_z = _t_normal_post_1(vNt0, sign(vary_vertex_normal.z));
+    return vNt_z;
+}
+
+PBRMix terrain_sample_pbr(
+    TerrainCoord terrain_coord
+    , TerrainTriplanar tw
+    , sampler2D tex_col
+    , sampler2D tex_orm
+    , sampler2D tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , sampler2D tex_emissive
+#endif
+    )
+{
+    PBRMix mix = init_pbr_mix();
+
+#define get_uv_x() _t_uv(terrain_coord[0].zw, sign(vary_vertex_normal.x))
+#define get_uv_y() _t_uv(terrain_coord[1].xy, sign(vary_vertex_normal.y))
+#define get_uv_z() _t_uv(terrain_coord[0].xy, sign(vary_vertex_normal.z))
+    switch (tw.type & SAMPLE_X)
+    {
+    case SAMPLE_X:
+        PBRMix mix_x = sample_pbr(
+            get_uv_x()
+            , tex_col
+            , tex_orm
+            , tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , tex_emissive
+#endif
+            );
+        // Triplanar-specific normal texture fix
+        mix_x.vNt = _t_normal_post_x(mix_x.vNt);
+        mix = mix_pbr(mix, mix_x, tw.weight.x);
+        break;
+    default:
+        break;
+    }
+
+    switch (tw.type & SAMPLE_Y)
+    {
+    case SAMPLE_Y:
+        PBRMix mix_y = sample_pbr(
+            get_uv_y()
+            , tex_col
+            , tex_orm
+            , tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , tex_emissive
+#endif
+            );
+        // Triplanar-specific normal texture fix
+        mix_y.vNt = _t_normal_post_y(mix_y.vNt);
+        mix = mix_pbr(mix, mix_y, tw.weight.y);
+        break;
+    default:
+        break;
+    }
+
+    switch (tw.type & SAMPLE_Z)
+    {
+    case SAMPLE_Z:
+        PBRMix mix_z = sample_pbr(
+            get_uv_z()
+            , tex_col
+            , tex_orm
+            , tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , tex_emissive
+#endif
+            );
+        // Triplanar-specific normal texture fix
+        // *NOTE: Bottom face has not been tested
+        mix_z.vNt = _t_normal_post_z(mix_z.vNt);
+        mix = mix_pbr(mix, mix_z, tw.weight.z);
+        break;
+    default:
+        break;
+    }
+    
+    return mix;
+}
+
+#elif TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 1
+
+#define TerrainCoord vec2
+
+#define terrain_sample_pbr sample_pbr
+
+#endif
+
+PBRMix multiply_factors_pbr(
+    PBRMix mix_in
+    , vec4 factor_col
+    , vec3 factor_orm
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , vec3 factor_emissive
+#endif
+    )
+{
+    PBRMix mix = mix_in;
+    mix.col *= factor_col;
+    mix.orm *= factor_orm;
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    mix.emissive *= factor_emissive;
+#endif
+    return mix;
+}
+
+PBRMix terrain_sample_and_multiply_pbr(
+    TerrainCoord terrain_coord
+    , sampler2D tex_col
+    , sampler2D tex_orm
+    , sampler2D tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , sampler2D tex_emissive
+#endif
+    , vec4 factor_col
+    , vec3 factor_orm
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , vec3 factor_emissive
+#endif
+    )
+{
+    PBRMix mix = terrain_sample_pbr(
+        terrain_coord
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+        , _t_triplanar()
+#endif
+        , tex_col
+        , tex_orm
+        , tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+        , tex_emissive
+#endif
+        );
+
+    mix = multiply_factors_pbr(mix
+        , factor_col
+        , factor_orm
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+        , factor_emissive
+#endif
+    );
+
+    return mix;
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbrterrainV.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainV.glsl
new file mode 100644
index 0000000000..dbb9404219
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainV.glsl
@@ -0,0 +1,93 @@
+/** 
+ * @file class1\environment\pbrterrainV.glsl
+ *
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2023, 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 mat3 normal_matrix;
+uniform mat4 texture_matrix0;
+uniform mat4 modelview_projection_matrix;
+
+in vec3 position;
+in vec3 normal;
+in vec4 tangent;
+in vec4 diffuse_color;
+in vec2 texcoord1;
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+out vec4[2] vary_coords;
+#endif
+out vec3 vary_vertex_normal; // Used by pbrterrainUtilF.glsl
+out vec3 vary_normal;
+out vec3 vary_tangent;
+flat out float vary_sign;
+out vec4 vary_texcoord0;
+out vec4 vary_texcoord1;
+
+// *HACK: tangent_space_transform should use texture_normal_transform, or maybe
+// we shouldn't use tangent_space_transform at all. See the call to
+// tangent_space_transform below.
+uniform vec4[2] texture_base_color_transform;
+
+vec2 texture_transform(vec2 vertex_texcoord, vec4[2] khr_gltf_transform, mat4 sl_animation_transform);
+vec3 tangent_space_transform(vec4 vertex_tangent, vec3 vertex_normal, vec4[2] khr_gltf_transform, mat4 sl_animation_transform);
+
+void main()
+{
+    //transform vertex
+	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0); 
+
+	vec3 n = normal_matrix * normal;
+    vary_vertex_normal = normal;
+	vec3 t = normal_matrix * tangent.xyz;
+
+    vary_tangent = normalize(t);
+    // *TODO: Decide if we want this. It may be better to just calculate the
+    // tangents on-the-fly in the fragment shader, due to the subtleties of the
+    // effect of triplanar mapping on UVs.
+    // *HACK: Should be using texture_normal_transform here. The KHR texture
+    // transform spec requires handling texture transforms separately for each
+    // individual texture.
+    vary_tangent = normalize(tangent_space_transform(vec4(t, tangent.w), n, texture_base_color_transform, texture_matrix0));
+    vary_sign = tangent.w;
+    vary_normal = normalize(n);
+
+    // Transform and pass tex coords
+    // *HACK: texture_base_color_transform is used for all of these here, but
+    // the KHR texture transform spec requires handling texture transforms
+    // separately for each individual texture.
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+    // xy
+    vary_coords[0].xy = texture_transform(position.xy, texture_base_color_transform, texture_matrix0);
+    // yz
+    vary_coords[0].zw = texture_transform(position.yz, texture_base_color_transform, texture_matrix0);
+    // (-x)z
+    vary_coords[1].xy = texture_transform(position.xz * vec2(-1, 1), texture_base_color_transform, texture_matrix0);
+#elif TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 1
+    vary_texcoord0.xy = texture_transform(position.xy, texture_base_color_transform, texture_matrix0);
+#endif
+    
+    vec4 tc = vec4(texcoord1,0,1);
+    vary_texcoord0.zw = tc.xy;
+    vary_texcoord1.xy = tc.xy-vec2(2.0, 0.0);
+    vary_texcoord1.zw = tc.xy-vec2(1.0, 0.0);
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
index 64e6bc9da2..3443785e1a 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
@@ -106,7 +106,7 @@ vec3 toneMap(vec3 color)
     color *= exposure * exp_scale;
 
     // mix ACES and Linear here as a compromise to avoid over-darkening legacy content
-    color = mix(toneMapACES_Hill(color), color, 0.333);
+    color = mix(toneMapACES_Hill(color), color, 0.3);
 #endif
 
     return color;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl b/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
index f6d3b59e85..33a78fd26d 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
@@ -30,7 +30,6 @@ uniform mat4 modelview_projection_matrix;
 in vec3 position;
 in vec3 normal;
 in vec4 diffuse_color;
-in vec2 texcoord0;
 in vec2 texcoord1;
 
 out vec3 pos;
@@ -41,18 +40,16 @@ out vec4 vary_texcoord1;
 uniform vec4 object_plane_s;
 uniform vec4 object_plane_t;
 
-vec4 texgen_object(vec4  vpos, vec4 tc, mat4 mat, vec4 tp0, vec4 tp1)
+vec2 texgen_object(vec4 vpos, mat4 mat, vec4 tp0, vec4 tp1)
 {
     vec4 tcoord;
     
     tcoord.x = dot(vpos, tp0);
     tcoord.y = dot(vpos, tp1);
-    tcoord.z = tc.z;
-    tcoord.w = tc.w;
     
     tcoord = mat * tcoord; 
     
-    return tcoord; 
+    return tcoord.xy; 
 }
 
 void main()
@@ -67,7 +64,7 @@ void main()
     vary_normal = normalize(normal_matrix * normal);
     
     // Transform and pass tex coords
-    vary_texcoord0.xy = texgen_object(vec4(position, 1.0), vec4(texcoord0,0,1), texture_matrix0, object_plane_s, object_plane_t).xy;
+    vary_texcoord0.xy = texgen_object(vec4(position, 1.0), texture_matrix0, object_plane_s, object_plane_t);
     
     vec4 t = vec4(texcoord1,0,1);
     
diff --git a/indra/newview/app_settings/shaders/class1/deferred/textureUtilV.glsl b/indra/newview/app_settings/shaders/class1/deferred/textureUtilV.glsl
index 636dfed4ba..732333311c 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/textureUtilV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/textureUtilV.glsl
@@ -65,7 +65,7 @@ vec2 texture_transform(vec2 vertex_texcoord, vec4[2] khr_gltf_transform, mat4 sl
     // Apply texture animation first to avoid shearing and other artifacts
     texcoord = (sl_animation_transform * vec4(texcoord, 0, 1)).xy;
     // Convert to left-handed coordinate system. The offset of 1 is necessary
-    // for rotations to be applied correctly.
+    // for rotation and scale to be applied correctly.
     texcoord.y = 1.0 - texcoord.y;
     texcoord = khr_texture_transform(texcoord, khr_gltf_transform[0].xy, khr_gltf_transform[0].z, khr_gltf_transform[1].xy);
     // Convert back to right-handed coordinate system
diff --git a/indra/newview/app_settings/shaders/class1/environment/waterFogF.glsl b/indra/newview/app_settings/shaders/class1/environment/waterFogF.glsl
index cfdb393b34..f796bb5f3f 100644
--- a/indra/newview/app_settings/shaders/class1/environment/waterFogF.glsl
+++ b/indra/newview/app_settings/shaders/class1/environment/waterFogF.glsl
@@ -30,12 +30,14 @@ uniform vec4 waterFogColor;
 uniform float waterFogDensity;
 uniform float waterFogKS;
 
-vec3 getPositionEye();
-
 vec3 srgb_to_linear(vec3 col);
 vec3 linear_to_srgb(vec3 col);
 
-vec4 applyWaterFogView(vec3 pos, vec4 color)
+vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten);
+
+// get a water fog color that will apply the appropriate haze to a color given
+// a blend function of (ONE, SOURCE_ALPHA)
+vec4 getWaterFogViewNoClip(vec3 pos)
 {
     vec3 view = normalize(pos);
     //normalize view vector
@@ -67,38 +69,76 @@ vec4 applyWaterFogView(vec3 pos, vec4 color)
     float L = min(t1/t2*t3, 1.0);
     
     float D = pow(0.98, l*kd);
+
+    return vec4(srgb_to_linear(kc.rgb*L), D);
+}
+
+vec4 getWaterFogView(vec3 pos)
+{
+    if (dot(pos, waterPlane.xyz) + waterPlane.w > 0.0)
+    {
+        return vec4(0,0,0,1);
+    }
+
+    return getWaterFogViewNoClip(pos);
+}
+
+vec4 applyWaterFogView(vec3 pos, vec4 color)
+{
+    vec4 fogged = getWaterFogView(pos);
     
-    color.rgb = color.rgb * D + kc.rgb * L;
+    color.rgb = color.rgb * fogged.a + fogged.rgb;
 
     return color;
 }
 
-vec4 applyWaterFogViewLinearNoClip(vec3 pos, vec4 color, vec3 sunlit)
+vec4 applyWaterFogViewLinearNoClip(vec3 pos, vec4 color)
 {
-    color.rgb = linear_to_srgb(color.rgb);
-    color = applyWaterFogView(pos, color);
-    color.rgb = srgb_to_linear(color.rgb);
+    vec4 fogged = getWaterFogViewNoClip(pos);
+    color.rgb *= fogged.a;
+    color.rgb += fogged.rgb;
     return color;
 }
 
-vec4 applyWaterFogViewLinear(vec3 pos, vec4 color, vec3 sunlit)
+vec4 applyWaterFogViewLinear(vec3 pos, vec4 color)
 {
     if (dot(pos, waterPlane.xyz) + waterPlane.w > 0.0)
     {
         return color;
     }
 
-    return applyWaterFogViewLinearNoClip(pos, color, sunlit);
+    return applyWaterFogViewLinearNoClip(pos, color);
 }
 
-vec4 applyWaterFogViewLinear(vec3 pos, vec4 color)
+// for post deferred shaders, apply sky and water fog in a way that is consistent with
+// the deferred rendering haze post effects
+vec4 applySkyAndWaterFog(vec3 pos, vec3 additive, vec3 atten, vec4 color)
 {
-    return applyWaterFogViewLinear(pos, color, vec3(1));
-}
+    bool eye_above_water = dot(vec3(0), waterPlane.xyz) + waterPlane.w > 0.0;
+    bool obj_above_water = dot(pos.xyz, waterPlane.xyz) + waterPlane.w > 0.0;
 
-vec4 applyWaterFog(vec4 color)
-{
-    //normalize view vector
-    return applyWaterFogViewLinear(getPositionEye(), color);
-}
+    if (eye_above_water)
+    {
+        if (!obj_above_water)
+        { 
+            color.rgb = applyWaterFogViewLinearNoClip(pos, color).rgb;
+        }
+        else
+        {
+            color.rgb = atmosFragLighting(color.rgb, additive, atten);
+        }
+    }
+    else
+    {
+        if (obj_above_water)
+        {
+            color.rgb = atmosFragLighting(color.rgb, additive, atten);
+        }
+        else
+        {
+            color.rgb = applyWaterFogViewLinearNoClip(pos, color).rgb;
+        }
+    }
 
+    return color;
+}
diff --git a/indra/newview/app_settings/shaders/class1/lighting/lightWaterAlphaMaskF.glsl b/indra/newview/app_settings/shaders/class1/lighting/lightWaterAlphaMaskF.glsl
deleted file mode 100644
index 670b3ddaf1..0000000000
--- a/indra/newview/app_settings/shaders/class1/lighting/lightWaterAlphaMaskF.glsl
+++ /dev/null
@@ -1,51 +0,0 @@
-/** 
- * @file class1\lighting\lightWaterAlphaMaskF.glsl
- *
- * $LicenseInfo:firstyear=2011&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2011, 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$
- */
-
-out vec4 frag_color;
-
-uniform float minimum_alpha;
-
-vec3 atmosLighting(vec3 light);
-vec4 applyWaterFog(vec4 color);
-
-in vec4 vertex_color;
-in vec2 vary_texcoord0;
-
-void default_lighting_water()
-{
-	vec4 color = diffuseLookup(vary_texcoord0.xy);
-
-	if (color.a < minimum_alpha)
-	{
-		discard;
-	}
-
-	color.rgb *= vertex_color.rgb;
-
-	color.rgb = atmosLighting(color.rgb);
-
-	frag_color = max(applyWaterFog(color), vec4(0));
-}
-
diff --git a/indra/newview/app_settings/shaders/class1/lighting/lightWaterAlphaMaskNonIndexedF.glsl b/indra/newview/app_settings/shaders/class1/lighting/lightWaterAlphaMaskNonIndexedF.glsl
deleted file mode 100644
index 2e5ed57014..0000000000
--- a/indra/newview/app_settings/shaders/class1/lighting/lightWaterAlphaMaskNonIndexedF.glsl
+++ /dev/null
@@ -1,55 +0,0 @@
-/** 
- * @file class1\lighting\lightWaterAlphaMaskNonIndexedF.glsl
- *
- * $LicenseInfo:firstyear=2011&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2011, 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$
- */
-
-out vec4 frag_color;
-
-uniform float minimum_alpha;
-
-uniform sampler2D diffuseMap;
-
-vec3 atmosLighting(vec3 light);
-vec4 applyWaterFog(vec4 color);
-
-in vec4 vertex_color;
-in vec2 vary_texcoord0;
-
-void default_lighting_water()
-{
-	vec4 color = texture(diffuseMap,vary_texcoord0.xy);
-
-	if (color.a < minimum_alpha)
-	{
-		discard;
-	}
-
-	color.rgb *= vertex_color.rgb;
-
-	color.rgb = atmosLighting(color.rgb);
-
-	color = applyWaterFog(color);
-	
-	frag_color = max(color, vec4(0));
-}
-
diff --git a/indra/newview/app_settings/shaders/class1/lighting/lightWaterF.glsl b/indra/newview/app_settings/shaders/class1/lighting/lightWaterF.glsl
deleted file mode 100644
index 09b4a6e317..0000000000
--- a/indra/newview/app_settings/shaders/class1/lighting/lightWaterF.glsl
+++ /dev/null
@@ -1,42 +0,0 @@
-/** 
- * @file class1\lighting\lightWaterF.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$
- */
-
-out vec4 frag_color;
-
-in vec4 vertex_color;
-in vec2 vary_texcoord0;
-
-vec3 atmosLighting(vec3 light);
-vec4 applyWaterFog(vec4 color);
-
-void default_lighting_water()
-{
-	vec4 color = diffuseLookup(vary_texcoord0.xy) * vertex_color;
-
-	color.rgb = atmosLighting(color.rgb);
-
-	frag_color = max(applyWaterFog(color), vec4(0));
-}
-
diff --git a/indra/newview/app_settings/shaders/class1/lighting/lightWaterNonIndexedF.glsl b/indra/newview/app_settings/shaders/class1/lighting/lightWaterNonIndexedF.glsl
deleted file mode 100644
index 4888fa547c..0000000000
--- a/indra/newview/app_settings/shaders/class1/lighting/lightWaterNonIndexedF.glsl
+++ /dev/null
@@ -1,44 +0,0 @@
-/** 
- * @file class1\lighting\lightWaterNonIndexedF.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$
- */
-
-out vec4 frag_color;
-
-in vec4 vertex_color;
-in vec2 vary_texcoord0;
-
-uniform sampler2D diffuseMap;
-
-vec3 atmosLighting(vec3 light);
-vec4 applyWaterFog(vec4 color);
-
-void default_lighting_water()
-{
-	vec4 color = texture(diffuseMap,vary_texcoord0.xy) * vertex_color;
-
-	color.rgb = atmosLighting(color.rgb);
-
-	frag_color = max(applyWaterFog(color), vec4(0));
-}
-
diff --git a/indra/newview/app_settings/shaders/class1/objects/simpleWaterF.glsl b/indra/newview/app_settings/shaders/class1/objects/simpleWaterF.glsl
deleted file mode 100644
index 2e87ac5bbc..0000000000
--- a/indra/newview/app_settings/shaders/class1/objects/simpleWaterF.glsl
+++ /dev/null
@@ -1,33 +0,0 @@
-/** 
- * @file simpleWaterF.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$
- */
- 
-
-
-void default_lighting_water();
-
-void main() 
-{
-	default_lighting_water();
-}
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl
index 6ecbfaecb1..4f88aed765 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl
@@ -30,7 +30,6 @@ vec3 getSunlitColor();
 vec3 getAmblitColor();
 vec3 getAdditiveColor();
 vec3 getAtmosAttenuation();
-vec3 getPositionEye();
 
 uniform float scene_light_strength;
 
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsV.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsV.glsl
index cc3617ba61..7b59e07243 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsV.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsV.glsl
@@ -42,7 +42,6 @@ void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, ou
 
 void calcAtmospherics(vec3 inPositionEye) {
     vec3 P = inPositionEye;
-    setPositionEye(P);
     vec3 tmpsunlit = vec3(1);
     vec3 tmpamblit = vec3(1);
     vec3 tmpaddlit = vec3(1);
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsF.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsF.glsl
index 34669a6796..9d5f60b313 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsF.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsF.glsl
@@ -44,5 +44,5 @@ vec3 getAdditiveColor()
 
 vec3 getAtmosAttenuation()
 {
-	return vec3(vary_AtmosAttenuation);
+	return vary_AtmosAttenuation;
 }
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsV.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsV.glsl
index 1b854d80b3..0617bc9908 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsV.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsV.glsl
@@ -31,7 +31,6 @@ vec3 additive_color;
 vec3 atmos_attenuation;
 vec3 sunlit_color;
 vec3 amblit_color;
-vec3 position_eye;
 
 vec3 getSunlitColor()
 {
@@ -51,16 +50,6 @@ vec3 getAtmosAttenuation()
 	return atmos_attenuation;
 }
 
-vec3 getPositionEye()
-{
-	return position_eye;
-}
-
-void setPositionEye(vec3 v)
-{
-	position_eye = v;
-}
-
 void setSunlitColor(vec3 v)
 {
 	sunlit_color  = v;
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsWaterF.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsWaterF.glsl
deleted file mode 100644
index 7a6741fe0e..0000000000
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsWaterF.glsl
+++ /dev/null
@@ -1,50 +0,0 @@
-/** 
- * @file class2\wl\atmosphericVarsWaterF.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$
- */
- 
-in vec3 vary_PositionEye;
-in vec3 vary_AdditiveColor;
-in vec3 vary_AtmosAttenuation;
-
-vec3 getSunlitColor()
-{
-	return vec3(0,0,0);
-}
-vec3 getAmblitColor()
-{
-	return vec3(0,0,0);
-}
-vec3 getAdditiveColor()
-{
-	return vary_AdditiveColor;
-}
-vec3 getAtmosAttenuation()
-{
-	return vary_AtmosAttenuation;
-}
-vec3 getPositionEye()
-{
-	return vary_PositionEye;
-}
-
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsWaterV.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsWaterV.glsl
deleted file mode 100644
index 23c3aed4d8..0000000000
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsVarsWaterV.glsl
+++ /dev/null
@@ -1,81 +0,0 @@
-/** 
- * @file class2\wl\atmosphericVarsWaterV.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$
- */
- 
-out vec3 vary_PositionEye;
-out vec3 vary_AdditiveColor;
-out vec3 vary_AtmosAttenuation;
-
-vec3 atmos_attenuation;
-vec3 sunlit_color;
-vec3 amblit_color;
-
-vec3 getSunlitColor()
-{
-	return sunlit_color;
-}
-vec3 getAmblitColor()
-{
-	return amblit_color;
-}
-
-vec3 getAdditiveColor()
-{
-	return vary_AdditiveColor;
-}
-vec3 getAtmosAttenuation()
-{
-	return atmos_attenuation;
-}
-
-vec3 getPositionEye()
-{
-	return vary_PositionEye;
-}
-
-void setPositionEye(vec3 v)
-{
-	vary_PositionEye = v;
-}
-
-void setSunlitColor(vec3 v)
-{
-	sunlit_color  = v;
-}
-
-void setAmblitColor(vec3 v)
-{
-	amblit_color = v;
-}
-
-void setAdditiveColor(vec3 v)
-{
-	vary_AdditiveColor = v;
-}
-
-void setAtmosAttenuation(vec3 v)
-{
-	atmos_attenuation = v;
-	vary_AtmosAttenuation = v;
-}