From 81a2813bf50c7a75acaa48c7398ce926784300c6 Mon Sep 17 00:00:00 2001
From: Rye <rye@lindenlab.com>
Date: Mon, 3 Feb 2025 14:43:56 -0500
Subject: [PATCH 01/29] Fix media failing to function on PBR materials (#3445)

---
 indra/newview/llviewertexture.cpp | 13 +------------
 indra/newview/llvovolume.cpp      |  7 ++++++-
 2 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index 1084fb91da..609ad38e96 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -3548,18 +3548,7 @@ void LLViewerMediaTexture::setPlaying(bool playing)
         for(std::list< LLFace* >::iterator iter = mMediaFaceList.begin(); iter!= mMediaFaceList.end(); ++iter)
         {
             LLFace* facep = *iter;
-            const LLTextureEntry* te = facep->getTextureEntry();
-            if (te && te->getGLTFMaterial())
-            {
-                // PBR material, switch emissive and basecolor
-                switchTexture(LLRender::EMISSIVE_MAP, *iter);
-                switchTexture(LLRender::BASECOLOR_MAP, *iter);
-            }
-            else
-            {
-                // blinn-phong material, switch diffuse map only
-                switchTexture(LLRender::DIFFUSE_MAP, *iter);
-            }
+            switchTexture(LLRender::DIFFUSE_MAP, facep);
         }
     }
     else //stop playing this media
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index c1079ba12b..4dba930ed5 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -5750,7 +5750,12 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
                 if (is_pbr)
                 {
                     // tell texture streaming system to ignore blinn-phong textures
-                    facep->setTexture(LLRender::DIFFUSE_MAP, nullptr);
+                    // except the special case of the diffuse map containing a
+                    // media texture that will be reused for swapping on to the pbr face
+                    if (!facep->hasMedia())
+                    {
+                        facep->setTexture(LLRender::DIFFUSE_MAP, nullptr);
+                    }
                     facep->setTexture(LLRender::NORMAL_MAP, nullptr);
                     facep->setTexture(LLRender::SPECULAR_MAP, nullptr);
 

From 265ebfb82f09f1c2c24578d4817ba389059e6da0 Mon Sep 17 00:00:00 2001
From: Maxim Nikolenko <maximnproductengine@lindenlab.com>
Date: Tue, 4 Feb 2025 19:19:50 +0200
Subject: [PATCH 02/29] #3346 crash at
 LLConversationItemSession::clearAndDeparentModels

---
 indra/newview/llconversationmodel.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/indra/newview/llconversationmodel.cpp b/indra/newview/llconversationmodel.cpp
index 4cd85ac756..5004055666 100644
--- a/indra/newview/llconversationmodel.cpp
+++ b/indra/newview/llconversationmodel.cpp
@@ -357,8 +357,9 @@ void LLConversationItemSession::clearParticipants()
 
 void LLConversationItemSession::clearAndDeparentModels()
 {
-    for (LLFolderViewModelItem* child : mChildren)
+    for (child_list_t::iterator it = mChildren.begin(); it != mChildren.end();)
     {
+        LLFolderViewModelItem* child = *it;
         if (child->getNumRefs() == 0)
         {
             // LLConversationItemParticipant can be created but not assigned to any view,
@@ -370,8 +371,8 @@ void LLConversationItemSession::clearAndDeparentModels()
             // Model is still assigned to some view/widget
             child->setParent(NULL);
         }
+        it = mChildren.erase(it);
     }
-    mChildren.clear();
 }
 
 LLConversationItemParticipant* LLConversationItemSession::findParticipant(const LLUUID& participant_id)

From 317cd6e66e65256eda6441c06fa32e55eee99fa3 Mon Sep 17 00:00:00 2001
From: "Jonathan \"Geenz\" Goodman" <geenz@lindenlab.com>
Date: Thu, 6 Feb 2025 02:44:16 -0500
Subject: [PATCH 03/29] Add some haze to the distance on water. (#3508)

* #3507 Add distance haze to water to get us closer to 6.6.17's appearance.
---
 .../class3/deferred/reflectionProbeF.glsl     |  3 -
 .../shaders/class3/environment/waterF.glsl    | 63 +++++++++++++------
 2 files changed, 43 insertions(+), 23 deletions(-)

diff --git a/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl b/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
index a975b1f121..136b3dd966 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/reflectionProbeF.glsl
@@ -789,9 +789,6 @@ void sampleReflectionProbesWater(inout vec3 ambenv, inout vec3 glossenv,
     probeIndex[probeInfluences++] = 0;
 
     doProbeSample(ambenv, glossenv, tc, pos, norm, glossiness, false, amblit);
-
-    // fudge factor to get PBR water at a similar luminance ot legacy water
-    glossenv *= 0.4;
 }
 
 void debugTapRefMap(vec3 pos, vec3 dir, float depth, int i, inout vec4 col)
diff --git a/indra/newview/app_settings/shaders/class3/environment/waterF.glsl b/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
index f9e300070d..f8aa684433 100644
--- a/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
@@ -25,6 +25,8 @@
 
 // class3/environment/waterF.glsl
 
+#define WATER_MINIMAL 1
+
 out vec4 frag_color;
 
 #ifdef HAS_SUN_SHADOW
@@ -122,6 +124,9 @@ vec3 BlendNormal(vec3 bump1, vec3 bump2)
 vec3 srgb_to_linear(vec3 col);
 vec3 linear_to_srgb(vec3 col);
 
+vec3 atmosLighting(vec3 light);
+vec3 scaleSoftClip(vec3 light);
+
 vec3 vN, vT, vB;
 
 vec3 transform_normal(vec3 vNt)
@@ -148,7 +153,7 @@ void generateWaveNormals(out vec3 wave1, out vec3 wave2, out vec3 wave3)
 
     vec2 bigwave = vec2(refCoord.w, view.w);
 
-    vec3 wave1_a = texture(bumpMap, bigwave, -2).xyz * 2.0 - 1.0;
+    vec3 wave1_a = texture(bumpMap, bigwave).xyz * 2.0 - 1.0;
     vec3 wave2_a = texture(bumpMap, littleWave.xy).xyz * 2.0 - 1.0;
     vec3 wave3_a = texture(bumpMap, littleWave.zw).xyz * 2.0 - 1.0;
 
@@ -183,6 +188,7 @@ void calculateFresnelFactors(out vec3 df3, out vec2 df2, vec3 viewVec, vec3 wave
 void main()
 {
     mirrorClip(vary_position);
+
     vN = vary_normal;
     vT = vary_tangent;
     vB = cross(vN, vT);
@@ -202,6 +208,7 @@ void main()
 
     generateWaveNormals(wave1, wave2, wave3);
 
+    float dmod = sqrt(dist);
     vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5;
 
     vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5;
@@ -216,7 +223,7 @@ void main()
     vec3 up = transform_normal(vec3(0,0,1));
     float vdu = -dot(viewVec, up)*2;
 
-    vec3 wave_ibl = wavef;
+    vec3 wave_ibl = wavef * normScale;
     wave_ibl.z *= 2.0;
     wave_ibl = transform_normal(normalize(wave_ibl));
 
@@ -233,8 +240,6 @@ void main()
     float dist2 = dist;
     dist = max(dist, 5.0);
 
-    float dmod = sqrt(dist);
-
     //figure out distortion vector (ripply)
     vec2 distort2 = distort + waver.xy * refScale / max(dmod, 1.0) * 2;
 
@@ -254,21 +259,27 @@ void main()
     calcAtmosphericVarsLinear(pos.xyz, wavef, vary_light_dir, sunlit, amblit, additive, atten);
 
     vec3 sunlit_linear = srgb_to_linear(sunlit);
-
+    float fade = 0;
 #ifdef TRANSPARENT_WATER
-    float depth = texture(depthMap, distort2).r;
-    vec4 fb = texture(screenTex, distort2);
-    vec3 refPos = getPositionWithNDC(vec3(distort2*2.0-vec2(1.0), depth*2.0-1.0));
+    float depth = texture(depthMap, distort).r;
+
+    vec3 refPos = getPositionWithNDC(vec3(distort*2.0-vec2(1.0), depth*2.0-1.0));
 
-    if (refPos.z > pos.z-0.05)
+    // Calculate some distance fade in the water to better assist with refraction blending and reducing the refraction texture's "disconnect".
+    fade = max(0,min(1, (pos.z - refPos.z) / 10));
+    distort2 = mix(distort, distort2, min(1, fade * 10));
+
+    depth = texture(depthMap, distort2).r;
+
+    refPos = getPositionWithNDC(vec3(distort2 * 2.0 - vec2(1.0), depth * 2.0 - 1.0));
+
+    if (pos.z < refPos.z - 0.05)
     {
-        //we sampled an above water sample, don't distort
         distort2 = distort;
-        fb = texture(screenTex, distort2);
-        depth = texture(depthMap, distort2).r;
-        refPos = getPositionWithNDC(vec3(distort2 * 2.0 - vec2(1.0), depth * 2.0 - 1.0));
     }
 
+    vec4 fb = texture(screenTex, distort2);
+
 #else
     vec4 fb = applyWaterFogViewLinear(viewVec*2048.0, vec4(1.0));
 #endif
@@ -280,13 +291,18 @@ void main()
     vec3  irradiance = vec3(0);
     vec3  radiance  = vec3(0);
     vec3 legacyenv = vec3(0);
+
+    // TODO: Make this an option.
+#ifdef WATER_MINIMAL
     sampleReflectionProbesWater(irradiance, radiance, distort2, pos.xyz, wave_ibl.xyz, gloss, amblit);
-    //sampleReflectionProbes(irradiance, radiance, distort2, pos.xyz, wave_ibl.xyz, 1, true, amblit);
-    //sampleReflectionProbesLegacy(irradiance, radiance, legacyenv, distort2, pos.xyz, wave_ibl.xyz, gloss, 1, false, amblit);
+#elif WATER_MINIMAL_PLUS
+    sampleReflectionProbes(irradiance, radiance, distort2, pos.xyz, wave_ibl.xyz, 1, false, amblit);
+#endif
 
     vec3 diffuseColor = vec3(0);
     vec3 specularColor = vec3(0);
-    calcDiffuseSpecular(vec3(1), metallic, diffuseColor, specularColor);
+    vec3 specular_linear = srgb_to_linear(specular);
+    calcDiffuseSpecular(specular_linear, metallic, diffuseColor, specularColor);
 
     vec3 v = -normalize(pos.xyz);
 
@@ -302,14 +318,21 @@ void main()
 
     pbrPunctual(diffuseColor, specularColor, perceptualRoughness, metallic, normalize(wavef+up*max(dist, 32.0)/32.0*(1.0-vdu)), v, normalize(light_dir), nl, diffPunc, specPunc);
 
-    vec3 punctual = clamp(nl * (diffPunc + specPunc), vec3(0), vec3(10)) * sunlit_linear * 2.75 * shadow;
+    vec3 punctual = clamp(nl * (diffPunc + specPunc), vec3(0), vec3(10)) * sunlit_linear * shadow;
 
     vec3 color = vec3(0);
+    color = mix(fb.rgb, radiance * df2.y, df2.x * 0.99999) + punctual.rgb;
 
-    color = mix(fb.rgb, radiance * df2.x, df2.x * 0.99999) + punctual.rgb;
+    // This looks super janky, but we do this to restore water haze in the distance.
+    // These values were finagled in to try and bring back some of the distant brightening on legacy water.  Also works reasonably well on PBR skies such as PBR midday.
+    color += color * min(vec3(4),pow(1 - atten, vec3(1.35)) * 16 * fade);
 
-    float spec = min(max(max(punctual.r, punctual.g), punctual.b), 0.05);
+    // We shorten the fade here at the shoreline so it doesn't appear too soft from a distance.
+    fade *= 60;
+    fade = min(1, fade);
+    color = mix(fb.rgb, color, fade);
 
-    frag_color = max(vec4(color.rgb, spec), vec4(0));
+    float spec = min(max(max(punctual.r, punctual.g), punctual.b), 0.05);
+    frag_color = min(vec4(1),max(vec4(color.rgb, spec), vec4(0)));
 }
 

From 93a88e602545828c0298b20ff0375f191d1f6d9a Mon Sep 17 00:00:00 2001
From: "Jonathan \"Geenz\" Goodman" <geenz@lindenlab.com>
Date: Fri, 7 Feb 2025 05:55:47 -0500
Subject: [PATCH 04/29] Water Exclusion Surfaces (#3517)

* #3455 Add support for water exclusion surfaces
---
 indra/llrender/llshadermgr.cpp                |  1 +
 indra/llrender/llshadermgr.h                  |  3 +
 indra/newview/CMakeLists.txt                  |  2 +
 .../shaders/class1/objects/simpleColorF.glsl  | 57 +++++++++++++
 .../class1/objects/simpleNoAtmosV.glsl        | 43 ++++++++++
 .../shaders/class3/deferred/waterHazeF.glsl   | 14 ++++
 .../class3/environment/underWaterF.glsl       |  8 +-
 .../shaders/class3/environment/waterF.glsl    | 13 ++-
 indra/newview/lldrawpool.cpp                  |  4 +
 indra/newview/lldrawpool.h                    |  3 +-
 indra/newview/lldrawpoolwater.cpp             | 48 ++++++-----
 indra/newview/lldrawpoolwater.h               |  2 +
 indra/newview/lldrawpoolwaterexclusion.cpp    | 79 +++++++++++++++++++
 indra/newview/lldrawpoolwaterexclusion.h      | 61 ++++++++++++++
 indra/newview/llviewershadermgr.cpp           | 12 +++
 indra/newview/llviewershadermgr.h             |  1 +
 indra/newview/llviewertexturelist.cpp         |  2 +-
 indra/newview/llvovolume.cpp                  | 12 ++-
 indra/newview/pipeline.cpp                    | 60 ++++++++++++++
 indra/newview/pipeline.h                      |  6 ++
 20 files changed, 400 insertions(+), 31 deletions(-)
 create mode 100644 indra/newview/app_settings/shaders/class1/objects/simpleColorF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class1/objects/simpleNoAtmosV.glsl
 create mode 100644 indra/newview/lldrawpoolwaterexclusion.cpp
 create mode 100644 indra/newview/lldrawpoolwaterexclusion.h

diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 37697f8a15..25d8ccd4b3 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -1392,6 +1392,7 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("screenTex");
     mReservedUniforms.push_back("screenDepth");
     mReservedUniforms.push_back("refTex");
+    mReservedUniforms.push_back("exclusionTex");
     mReservedUniforms.push_back("eyeVec");
     mReservedUniforms.push_back("time");
     mReservedUniforms.push_back("waveDir1");
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index 34bd73a42e..46788841a5 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -36,6 +36,8 @@ class LLShaderMgr
     LLShaderMgr();
     virtual ~LLShaderMgr();
 
+    // Note: although you can use statically hashed strings to just bind a random uniform, it's generally preferably that you use this.
+    // Always document what the actual shader uniform is next to the shader uniform in this struct.
     // clang-format off
     typedef enum
     {                                       // Shader uniform name, set in LLShaderMgr::initAttribsAndUniforms()
@@ -234,6 +236,7 @@ class LLShaderMgr
         WATER_SCREENTEX,                    //  "screenTex"
         WATER_SCREENDEPTH,                  //  "screenDepth"
         WATER_REFTEX,                       //  "refTex"
+        WATER_EXCLUSIONTEX,                 //  "exclusionTex"
         WATER_EYEVEC,                       //  "eyeVec"
         WATER_TIME,                         //  "time"
         WATER_WAVE_DIR1,                    //  "waveDir1"
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 5bcfddfe25..d2736c7c12 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -156,6 +156,7 @@ set(viewer_SOURCE_FILES
     lldrawpooltree.cpp
     lldrawpoolwater.cpp
     lldrawpoolwlsky.cpp
+    lldrawpoolwaterexclusion.cpp
     lldynamictexture.cpp
     llemote.cpp
     llenvironment.cpp
@@ -823,6 +824,7 @@ set(viewer_HEADER_FILES
     lldrawpooltree.h
     lldrawpoolwater.h
     lldrawpoolwlsky.h
+    lldrawpoolwaterexclusion.h
     lldynamictexture.h
     llemote.h
     llenvironment.h
diff --git a/indra/newview/app_settings/shaders/class1/objects/simpleColorF.glsl b/indra/newview/app_settings/shaders/class1/objects/simpleColorF.glsl
new file mode 100644
index 0000000000..dea76da5a5
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/objects/simpleColorF.glsl
@@ -0,0 +1,57 @@
+/**
+ * @file simpleColorF.glsl
+ *
+ * $LicenseInfo:firstyear=2025&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 vec4 vertex_position;
+
+uniform vec4 waterPlane;
+uniform float waterSign;
+
+void waterClip(vec3 pos)
+{
+    // TODO: make this less branchy
+    if (waterSign > 0)
+    {
+        if ((dot(pos.xyz, waterPlane.xyz) + waterPlane.w) < 0.0)
+        {
+            discard;
+        }
+    }
+    else
+    {
+        if ((dot(pos.xyz, waterPlane.xyz) + waterPlane.w) > 0.0)
+        {
+            discard;
+        }
+    }
+}
+
+void main()
+{
+
+    frag_color = vertex_color;
+}
diff --git a/indra/newview/app_settings/shaders/class1/objects/simpleNoAtmosV.glsl b/indra/newview/app_settings/shaders/class1/objects/simpleNoAtmosV.glsl
new file mode 100644
index 0000000000..4564e56313
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/objects/simpleNoAtmosV.glsl
@@ -0,0 +1,43 @@
+/**
+ * @file simpleNoAtmosV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2007, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+uniform mat4 modelview_matrix;
+uniform mat4 modelview_projection_matrix;
+
+uniform vec4 color;
+
+in vec3 position;
+
+out vec4 vertex_color;
+out vec4 vertex_position;
+
+void main()
+{
+    //transform vertex
+    vec4 pos = (modelview_matrix * vec4(position.xyz, 1.0));
+    vertex_position = modelview_projection_matrix * vec4(position.xyz, 1.0);
+    gl_Position = vertex_position;
+    vertex_color = color;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/waterHazeF.glsl b/indra/newview/app_settings/shaders/class3/deferred/waterHazeF.glsl
index ee49b4baae..091c25d15e 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/waterHazeF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/waterHazeF.glsl
@@ -35,13 +35,25 @@ vec4 getWaterFogView(vec3 pos);
 
 uniform int above_water;
 
+uniform sampler2D exclusionTex;
+
 void main()
 {
     vec2  tc           = vary_fragcoord.xy/vary_fragcoord.w*0.5+0.5;
     float depth        = getDepth(tc.xy);
+    float mask = texture(exclusionTex, tc.xy).r;
 
     if (above_water > 0)
     {
+        // Just discard if we're in the exclusion mask.
+        // The previous invisiprim hack we're replacing would also crank up water fog desntiy.
+        // But doing that makes exclusion surfaces very slow as we'd need to render even more into the mask.
+        // - Geenz 2025-02-06
+        if (mask < 1)
+        {
+            discard;
+        }
+
         // we want to depth test when the camera is above water, but some GPUs have a hard time
         // with depth testing against render targets that are bound for sampling in the same shader
         // so we do it manually here
@@ -51,12 +63,14 @@ void main()
         {
             discard;
         }
+
     }
 
     vec4  pos          = getPositionWithDepth(tc, depth);
 
     vec4 fogged = getWaterFogView(pos.xyz);
     fogged.a = max(pow(fogged.a, 1.7), 0);
+
     frag_color = max(fogged, vec4(0)); //output linear since local lights will be added to this shader's results
 
 }
diff --git a/indra/newview/app_settings/shaders/class3/environment/underWaterF.glsl b/indra/newview/app_settings/shaders/class3/environment/underWaterF.glsl
index 1c02dc764d..fa410e9f11 100644
--- a/indra/newview/app_settings/shaders/class3/environment/underWaterF.glsl
+++ b/indra/newview/app_settings/shaders/class3/environment/underWaterF.glsl
@@ -26,6 +26,7 @@
 out vec4 frag_color;
 
 uniform sampler2D bumpMap;
+uniform sampler2D exclusionTex;
 
 #ifdef TRANSPARENT_WATER
 uniform sampler2D screenTex;
@@ -59,6 +60,9 @@ void mirrorClip(vec3 position);
 void main()
 {
     mirrorClip(vary_position);
+    vec2 screen_tc = (refCoord.xy/refCoord.z) * 0.5 + 0.5;
+    float water_mask = texture(exclusionTex, screen_tc).r;
+
     vec4 color;
 
     //get detail normals
@@ -68,8 +72,8 @@ void main()
     vec3 wavef = normalize(wave1+wave2+wave3);
 
     //figure out distortion vector (ripply)
-    vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5;
-    distort = distort+wavef.xy*refScale;
+    vec2 distort = screen_tc;
+    distort = mix(distort, distort+wavef.xy*refScale, water_mask);
 
 #ifdef TRANSPARENT_WATER
     vec4 fb = texture(screenTex, distort);
diff --git a/indra/newview/app_settings/shaders/class3/environment/waterF.glsl b/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
index f8aa684433..7027e3796e 100644
--- a/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
@@ -88,7 +88,7 @@ uniform sampler2D screenTex;
 uniform sampler2D depthMap;
 #endif
 
-uniform sampler2D refTex;
+uniform sampler2D exclusionTex;
 
 uniform float sunAngle;
 uniform float sunAngle2;
@@ -252,6 +252,8 @@ void main()
 
     float shadow = 1.0f;
 
+    float water_mask = texture(exclusionTex, distort).r;
+
 #ifdef HAS_SUN_SHADOW
     shadow = sampleDirectionalShadow(pos.xyz, norm.xyz, distort);
 #endif
@@ -266,9 +268,8 @@ void main()
     vec3 refPos = getPositionWithNDC(vec3(distort*2.0-vec2(1.0), depth*2.0-1.0));
 
     // Calculate some distance fade in the water to better assist with refraction blending and reducing the refraction texture's "disconnect".
-    fade = max(0,min(1, (pos.z - refPos.z) / 10));
+    fade = max(0,min(1, (pos.z - refPos.z) / 10)) * water_mask;
     distort2 = mix(distort, distort2, min(1, fade * 10));
-
     depth = texture(depthMap, distort2).r;
 
     refPos = getPositionWithNDC(vec3(distort2 * 2.0 - vec2(1.0), depth * 2.0 - 1.0));
@@ -282,6 +283,9 @@ void main()
 
 #else
     vec4 fb = applyWaterFogViewLinear(viewVec*2048.0, vec4(1.0));
+
+    if (water_mask < 1)
+        discard;
 #endif
 
     float metallic = 1.0;
@@ -333,6 +337,7 @@ void main()
     color = mix(fb.rgb, color, fade);
 
     float spec = min(max(max(punctual.r, punctual.g), punctual.b), 0.05);
-    frag_color = min(vec4(1),max(vec4(color.rgb, spec), vec4(0)));
+
+    frag_color = min(vec4(1),max(vec4(color.rgb, spec * water_mask), vec4(0)));
 }
 
diff --git a/indra/newview/lldrawpool.cpp b/indra/newview/lldrawpool.cpp
index 7bd5206453..e60b3eb5dc 100644
--- a/indra/newview/lldrawpool.cpp
+++ b/indra/newview/lldrawpool.cpp
@@ -42,6 +42,7 @@
 #include "lldrawpooltree.h"
 #include "lldrawpoolterrain.h"
 #include "lldrawpoolwater.h"
+#include "lldrawpoolwaterexclusion.h"
 #include "llface.h"
 #include "llviewerobjectlist.h" // For debug listing.
 #include "pipeline.h"
@@ -119,6 +120,9 @@ LLDrawPool *LLDrawPool::createPool(const U32 type, LLViewerTexture *tex0)
     case POOL_GLTF_PBR_ALPHA_MASK:
         poolp = new LLDrawPoolGLTFPBR(LLDrawPool::POOL_GLTF_PBR_ALPHA_MASK);
         break;
+    case POOL_WATEREXCLUSION:
+        poolp = new LLDrawPoolWaterExclusion();
+        break;
     default:
         LL_ERRS() << "Unknown draw pool type!" << LL_ENDL;
         return NULL;
diff --git a/indra/newview/lldrawpool.h b/indra/newview/lldrawpool.h
index bc412214c7..1c8864a9df 100644
--- a/indra/newview/lldrawpool.h
+++ b/indra/newview/lldrawpool.h
@@ -55,6 +55,7 @@ class LLDrawPool
         // based on fill rate and likelihood to occlude future passes (faster, large occluders first).
         //
         POOL_SKY = 1,
+        POOL_WATEREXCLUSION,
         POOL_WL_SKY,
         POOL_SIMPLE,
         POOL_FULLBRIGHT,
@@ -140,7 +141,7 @@ class LLRenderPass : public LLDrawPool
         PASS_GRASS,
         PASS_FULLBRIGHT,
         PASS_FULLBRIGHT_RIGGED,
-        PASS_INVISIBLE,
+        PASS_INVISIBLE,                         // Formerly, invisiprims.  Now, water exclusion surfaces.
         PASS_INVISIBLE_RIGGED,
         PASS_INVISI_SHINY,
         PASS_INVISI_SHINY_RIGGED,
diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp
index 53d6e528b6..c27f5ef486 100644
--- a/indra/newview/lldrawpoolwater.cpp
+++ b/indra/newview/lldrawpoolwater.cpp
@@ -236,6 +236,8 @@ void LLDrawPoolWater::renderPostDeferred(S32 pass)
             gGL.getTexUnit(bumpTex2)->bind(tex_b);
         }
 
+        shader->bindTexture(LLShaderMgr::WATER_EXCLUSIONTEX, &gPipeline.mWaterExclusionMask);
+
         // bind reflection texture from RenderTarget
         S32 screentex = shader->enableTexture(LLShaderMgr::WATER_SCREENTEX);
 
@@ -307,30 +309,11 @@ void LLDrawPoolWater::renderPostDeferred(S32 pass)
 
         LLGLDisable cullface(GL_CULL_FACE);
 
-        LLVOWater* water = nullptr;
-        for (LLFace* const& face : mDrawFace)
-        {
-            if (!face) continue;
-            water = static_cast<LLVOWater*>(face->getViewerObject());
-            if (!water) continue;
-
-            if ((bool)edge == (bool)water->getIsEdgePatch())
-            {
-                face->renderIndexed();
-
-                // Note non-void water being drawn, updates required
-                if (!edge)  // SL-16461 remove !LLPipeline::sUseOcclusion check
-                {
-                    sNeedsReflectionUpdate = true;
-                    sNeedsDistortionUpdate = true;
-                }
-            }
-        }
+        pushWaterPlanes(edge);
 
         shader->disableTexture(LLShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
         shader->disableTexture(LLShaderMgr::WATER_SCREENTEX);
         shader->disableTexture(LLShaderMgr::BUMP_MAP);
-        shader->disableTexture(LLShaderMgr::WATER_REFTEX);
 
         // clean up
         gPipeline.unbindDeferredShader(*shader);
@@ -345,6 +328,31 @@ void LLDrawPoolWater::renderPostDeferred(S32 pass)
     gGL.setColorMask(true, false);
 }
 
+void LLDrawPoolWater::pushWaterPlanes(int pass)
+{
+    LLVOWater* water = nullptr;
+    for (LLFace* const& face : mDrawFace)
+    {
+        if (!face)
+            continue;
+        water = static_cast<LLVOWater*>(face->getViewerObject());
+        if (!water)
+            continue;
+
+        if ((bool)pass == (bool)water->getIsEdgePatch())
+        {
+            face->renderIndexed();
+
+            // Note non-void water being drawn, updates required
+            if (!pass) // SL-16461 remove !LLPipeline::sUseOcclusion check
+            {
+                sNeedsReflectionUpdate = true;
+                sNeedsDistortionUpdate = true;
+            }
+        }
+    }
+}
+
 LLViewerTexture *LLDrawPoolWater::getDebugTexture()
 {
     return LLViewerTextureManager::getFetchedTexture(IMG_SMOKE);
diff --git a/indra/newview/lldrawpoolwater.h b/indra/newview/lldrawpoolwater.h
index f64477a059..7fc9b68bcf 100644
--- a/indra/newview/lldrawpoolwater.h
+++ b/indra/newview/lldrawpoolwater.h
@@ -74,6 +74,8 @@ class LLDrawPoolWater final: public LLFacePool
     void setOpaqueTexture(const LLUUID& opaqueTextureId);
     void setNormalMaps(const LLUUID& normalMapId, const LLUUID& nextNormalMapId);
 
+    void pushWaterPlanes(int pass);
+
 protected:
     void renderOpaqueLegacyWater();
 };
diff --git a/indra/newview/lldrawpoolwaterexclusion.cpp b/indra/newview/lldrawpoolwaterexclusion.cpp
new file mode 100644
index 0000000000..d796bf39bf
--- /dev/null
+++ b/indra/newview/lldrawpoolwaterexclusion.cpp
@@ -0,0 +1,79 @@
+/**
+ * @file lldrawpool.cpp
+ * @brief LLDrawPoolMaterials class implementation
+ * @author Jonathan "Geenz" Goodman
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2013, 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$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "lldrawpoolwaterexclusion.h"
+#include "llviewershadermgr.h"
+#include "pipeline.h"
+#include "llglcommonfunc.h"
+#include "llvoavatar.h"
+#include "lldrawpoolwater.h"
+
+LLDrawPoolWaterExclusion::LLDrawPoolWaterExclusion() : LLRenderPass(LLDrawPool::POOL_WATEREXCLUSION)
+{
+    LL_INFOS("DPInvisible") << "Creating water exclusion draw pool" << LL_ENDL;
+}
+
+
+void LLDrawPoolWaterExclusion::render(S32 pass)
+{                                             // render invisiprims
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; // LL_RECORD_BLOCK_TIME(FTM_RENDER_INVISIBLE);
+
+    if (gPipeline.shadersLoaded())
+    {
+        gDrawColorProgram.bind();
+    }
+
+
+    LLGLDepthTest depth(GL_TRUE);
+    gDrawColorProgram.uniform4f(LLShaderMgr::DIFFUSE_COLOR, 1, 1, 1, 1);
+
+    LLDrawPoolWater* pwaterpool = (LLDrawPoolWater*)gPipeline.getPool(LLDrawPool::POOL_WATER);
+    if (pwaterpool)
+    {
+        // Just treat our water planes as double sided for the purposes of generating the exclusion mask.
+        LLGLDisable cullface(GL_CULL_FACE);
+        pwaterpool->pushWaterPlanes(0);
+
+        // Take care of the edge water tiles.
+        pwaterpool->pushWaterPlanes(1);
+    }
+
+    gDrawColorProgram.uniform4f(LLShaderMgr::DIFFUSE_COLOR, 0, 0, 0, 1);
+
+    static LLStaticHashedString waterSign("waterSign");
+    gDrawColorProgram.uniform1f(waterSign, 1.f);
+
+    pushBatches(LLRenderPass::PASS_INVISIBLE, false, false);
+
+
+    if (gPipeline.shadersLoaded())
+    {
+        gDrawColorProgram.unbind();
+    }
+}
diff --git a/indra/newview/lldrawpoolwaterexclusion.h b/indra/newview/lldrawpoolwaterexclusion.h
new file mode 100644
index 0000000000..e95721a443
--- /dev/null
+++ b/indra/newview/lldrawpoolwaterexclusion.h
@@ -0,0 +1,61 @@
+/**
+ * @file lldrawpoolwaterexclusion.h
+ * @brief LLDrawPoolWaterExclusion class definition
+ * @author Jonathan "Geenz" Goodman
+ *
+ * $LicenseInfo:firstyear=2025&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2013, 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$
+ */
+
+#ifndef LL_LLDRAWPOOLWATEREXCLUSION_H
+#define LL_LLDRAWPOOLWATEREXCLUSION_H
+
+#include "v4coloru.h"
+#include "v2math.h"
+#include "v3math.h"
+#include "llvertexbuffer.h"
+#include "lldrawpool.h"
+
+class LLViewerTexture;
+class LLDrawInfo;
+class LLGLSLShader;
+
+class LLDrawPoolWaterExclusion : public LLRenderPass
+{
+public:
+    LLDrawPoolWaterExclusion();
+
+    enum
+    {
+        VERTEX_DATA_MASK = LLVertexBuffer::MAP_VERTEX
+    };
+
+    virtual U32 getVertexDataMask() { return VERTEX_DATA_MASK; }
+
+    virtual void prerender() {}
+
+    virtual void render(S32 pass = 0);
+    virtual void beginRenderPass(S32 pass) {}
+    virtual void endRenderPass(S32 pass) {}
+    virtual S32  getNumPasses() { return 1; }
+};
+
+#endif // LL_LLDRAWPOOLWATEREXCLUSION_H
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 2619bbbfcb..ac4519e593 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -101,6 +101,7 @@ LLGLSLShader    gReflectionProbeDisplayProgram;
 LLGLSLShader    gCopyProgram;
 LLGLSLShader    gCopyDepthProgram;
 LLGLSLShader    gPBRTerrainBakeProgram;
+LLGLSLShader    gDrawColorProgram;
 
 //object shaders
 LLGLSLShader        gObjectPreviewProgram;
@@ -3355,6 +3356,17 @@ bool LLViewerShaderMgr::loadShadersInterface()
         success = gCopyDepthProgram.createShader();
     }
 
+    if (success)
+    {
+        gDrawColorProgram.mName = "Draw Color Shader";
+        gDrawColorProgram.mShaderFiles.clear();
+        gDrawColorProgram.mShaderFiles.push_back(make_pair("objects/simpleNoAtmosV.glsl", GL_VERTEX_SHADER));
+        gDrawColorProgram.mShaderFiles.push_back(make_pair("objects/simpleColorF.glsl", GL_FRAGMENT_SHADER));
+        gDrawColorProgram.clearPermutations();
+        gDrawColorProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
+        success = gDrawColorProgram.createShader();
+    }
+
     if (gSavedSettings.getBOOL("LocalTerrainPaintEnabled"))
     {
         if (success)
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index b08796025a..6326de9a6b 100644
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -175,6 +175,7 @@ extern LLGLSLShader         gReflectionProbeDisplayProgram;
 extern LLGLSLShader         gCopyProgram;
 extern LLGLSLShader         gCopyDepthProgram;
 extern LLGLSLShader         gPBRTerrainBakeProgram;
+extern LLGLSLShader         gDrawColorProgram;
 
 //output tex0[tc0] - tex1[tc1]
 extern LLGLSLShader         gTwoTextureCompareProgram;
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 7f38642623..0c186c0ed2 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -266,7 +266,7 @@ void LLViewerTextureList::doPrefetchImages()
         S32 pixel_area = imagesd["area"];
         S32 texture_type = imagesd["type"];
 
-        if(LLViewerTexture::FETCHED_TEXTURE == texture_type || LLViewerTexture::LOD_TEXTURE == texture_type)
+        if((LLViewerTexture::FETCHED_TEXTURE == texture_type || LLViewerTexture::LOD_TEXTURE == texture_type))
         {
             LLViewerFetchedTexture* image = LLViewerTextureManager::getFetchedTexture(uuid, FTT_DEFAULT, MIPMAP_TRUE, LLGLTexture::BOOST_NONE, texture_type);
             if (image)
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 4dba930ed5..4e8932f912 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -6732,8 +6732,11 @@ U32 LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, LLFace
             { //shiny
                 if (tex->getPrimaryFormat() == GL_ALPHA)
                 { //invisiprim+shiny
-                    registerFace(group, facep, LLRenderPass::PASS_INVISI_SHINY);
-                    registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
+                    if (!facep->getViewerObject()->isAttachment() && !facep->getViewerObject()->isRiggedMesh())
+                    {
+                        registerFace(group, facep, LLRenderPass::PASS_INVISI_SHINY);
+                        registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
+                    }
                 }
                 else if (!hud_group)
                 { //deferred rendering
@@ -6769,7 +6772,10 @@ U32 LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, LLFace
             { //not alpha and not shiny
                 if (!is_alpha && tex->getPrimaryFormat() == GL_ALPHA)
                 { //invisiprim
-                    registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
+                    if (!facep->getViewerObject()->isAttachment() && !facep->getViewerObject()->isRiggedMesh())
+                    {
+                        registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
+                    }
                 }
                 else if (fullbright || bake_sunlight)
                 { //fullbright
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index f91b054dd7..18dd694246 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -431,6 +431,7 @@ void LLPipeline::init()
     stop_glerror();
 
     //create render pass pools
+    getPool(LLDrawPool::POOL_WATEREXCLUSION);
     getPool(LLDrawPool::POOL_ALPHA_PRE_WATER);
     getPool(LLDrawPool::POOL_ALPHA_POST_WATER);
     getPool(LLDrawPool::POOL_SIMPLE);
@@ -673,6 +674,8 @@ void LLPipeline::cleanup()
     // don't delete wl sky pool it was handled above in the for loop
     //delete mWLSkyPool;
     mWLSkyPool = NULL;
+    delete mWaterExclusionPool;
+    mWaterExclusionPool = nullptr;
 
     releaseGLBuffers();
 
@@ -907,6 +910,15 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY)
 
         mPostMap.allocate(resX, resY, screenFormat);
 
+        // The water exclusion mask needs its own depth buffer so we can take care of the problem of multiple water planes.
+        // Should we ever make water not just a plane, it also aids with that as well as the water planes will be rendered into the mask.
+        // Why do we do this? Because it saves us some janky logic in the exclusion shader when we generate the mask.
+        // Regardless, this should always only be an R8 texture unless we choose to start having multiple kinds of exclusion that 8 bits can't handle.
+        // - Geenz 2025-02-06
+        bool success = mWaterExclusionMask.allocate(resX, resY, GL_R8, true);
+
+        assert(success);
+
         // used to scale down textures
         // See LLViwerTextureList::updateImagesCreateTextures and LLImageGL::scaleDown
         mDownResMap.allocate(1024, 1024, GL_RGBA);
@@ -1166,6 +1178,8 @@ void LLPipeline::releaseGLBuffers()
 
     mSceneMap.release();
 
+    mWaterExclusionMask.release();
+
     mPostMap.release();
 
     mFXAAMap.release();
@@ -1676,6 +1690,10 @@ LLDrawPool *LLPipeline::findPool(const U32 type, LLViewerTexture *tex0)
         poolp = mPBRAlphaMaskPool;
         break;
 
+    case LLDrawPool::POOL_WATEREXCLUSION:
+        poolp = mWaterExclusionPool;
+        break;
+
     default:
         llassert(0);
         LL_ERRS() << "Invalid Pool Type in  LLPipeline::findPool() type=" << type << LL_ENDL;
@@ -4068,6 +4086,8 @@ void LLPipeline::renderGeomDeferred(LLCamera& camera, bool do_occlusion)
     }
 }
 
+// Render all of our geometry that's required after our deferred pass.
+// This is gonna be stuff like alpha, water, etc.
 void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
@@ -4084,6 +4104,10 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
 
     bool done_atmospherics = LLPipeline::sRenderingHUDs; //skip atmospherics on huds
     bool done_water_haze = done_atmospherics;
+    bool done_water_exclusion = false;
+
+    // do water exclusion just before water pass.
+    U32 water_exclusion_pass = LLDrawPool::POOL_WATEREXCLUSION;
 
     // do atmospheric haze just before post water alpha
     U32 atmospherics_pass = LLDrawPool::POOL_ALPHA_POST_WATER;
@@ -4122,6 +4146,12 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
 
         cur_type = poolp->getType();
 
+        if (cur_type >= water_exclusion_pass && !done_water_exclusion)
+        { // do water exclusion against depth buffer before rendering alpha
+            doWaterExclusionMask();
+            done_water_exclusion = true;
+        }
+
         if (cur_type >= atmospherics_pass && !done_atmospherics)
         { // do atmospherics against depth buffer before rendering alpha
             doAtmospherics();
@@ -5201,6 +5231,17 @@ void LLPipeline::addToQuickLookup( LLDrawPool* new_poolp )
         }
         break;
 
+    case LLDrawPool::POOL_WATEREXCLUSION:
+        if (mWaterExclusionPool)
+        {
+            llassert(0);
+            LL_WARNS() << "LLPipeline::addPool(): Ignoring duplicate Water Exclusion Pool" << LL_ENDL;
+        }
+        else
+        {
+            mWaterExclusionPool = new_poolp;
+        }
+        break;
 
     default:
         llassert(0);
@@ -5323,6 +5364,11 @@ void LLPipeline::removeFromQuickLookup( LLDrawPool* poolp )
         mPBRAlphaMaskPool = NULL;
         break;
 
+    case LLDrawPool::POOL_WATEREXCLUSION:
+        llassert(poolp == mWaterExclusionPool);
+        mWaterExclusionPool = nullptr;
+        break;
+
     default:
         llassert(0);
         LL_WARNS() << "Invalid Pool Type in  LLPipeline::removeFromQuickLookup() type=" << poolp->getType() << LL_ENDL;
@@ -8824,6 +8870,7 @@ void LLPipeline::renderDeferredLighting()
                           LLPipeline::RENDER_TYPE_FULLBRIGHT_ALPHA_MASK,
                           LLPipeline::RENDER_TYPE_TERRAIN,
                           LLPipeline::RENDER_TYPE_WATER,
+                          LLPipeline::RENDER_TYPE_WATEREXCLUSION,
                           END_RENDER_TYPES);
 
         renderGeomPostDeferred(*LLViewerCamera::getInstance());
@@ -8962,6 +9009,8 @@ void LLPipeline::doWaterHaze()
         static LLStaticHashedString above_water_str("above_water");
         haze_shader.uniform1i(above_water_str, sUnderWaterRender ? -1 : 1);
 
+        haze_shader.bindTexture(LLShaderMgr::WATER_EXCLUSIONTEX, &mWaterExclusionMask);
+
         if (LLPipeline::sUnderWaterRender)
         {
             LLGLDepthTest depth(GL_FALSE);
@@ -8992,6 +9041,17 @@ void LLPipeline::doWaterHaze()
     }
 }
 
+void LLPipeline::doWaterExclusionMask()
+{
+    mWaterExclusionMask.bindTarget();
+    glClearColor(1, 1, 1, 1);
+    mWaterExclusionMask.clear();
+    mWaterExclusionPool->render();
+
+    mWaterExclusionMask.flush();
+    glClearColor(0, 0, 0, 0);
+}
+
 void LLPipeline::setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep)
 {
     //construct frustum
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index 5c9b95ef4a..315e38ed8c 100644
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -337,6 +337,9 @@ class LLPipeline
     // should be called just before rendering pre-water alpha objects
     void doWaterHaze();
 
+    // Generate the water exclusion surface mask.
+    void doWaterExclusionMask();
+
     void postDeferredGammaCorrect(LLRenderTarget* screen_target);
 
     void generateSunShadow(LLCamera& camera);
@@ -500,6 +503,7 @@ class LLPipeline
         RENDER_TYPE_AVATAR                      = LLDrawPool::POOL_AVATAR,
         RENDER_TYPE_CONTROL_AV                  = LLDrawPool::POOL_CONTROL_AV, // Animesh
         RENDER_TYPE_TREE                        = LLDrawPool::POOL_TREE,
+        RENDER_TYPE_WATEREXCLUSION              = LLDrawPool::POOL_WATEREXCLUSION,
         RENDER_TYPE_VOIDWATER                   = LLDrawPool::POOL_VOIDWATER,
         RENDER_TYPE_WATER                       = LLDrawPool::POOL_WATER,
         RENDER_TYPE_GLTF_PBR                    = LLDrawPool::POOL_GLTF_PBR,
@@ -714,6 +718,7 @@ class LLPipeline
     LLRenderTarget          mSpotShadow[2];
 
     LLRenderTarget          mPbrBrdfLut;
+    LLRenderTarget          mWaterExclusionMask;
 
     // copy of the color/depth buffer just before gamma correction
     // for use by SSR
@@ -953,6 +958,7 @@ class LLPipeline
     LLDrawPool*                 mWLSkyPool = nullptr;
     LLDrawPool*                 mPBROpaquePool = nullptr;
     LLDrawPool*                 mPBRAlphaMaskPool = nullptr;
+    LLDrawPool*                 mWaterExclusionPool      = nullptr;
 
     // Note: no need to keep an quick-lookup to avatar pools, since there's only one per avatar
 

From df0634f0c4980fa663f9635c931fd4ba44f864ea Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Thu, 6 Feb 2025 18:02:34 +0200
Subject: [PATCH 05/29] #3505 Make checkFolderForContentsOfType cheaper

---
 indra/newview/llinventorybridge.cpp |  7 +----
 indra/newview/llinventorymodel.cpp  | 41 +++++++++++++++++++++++++++++
 indra/newview/llinventorymodel.h    |  3 +++
 3 files changed, 45 insertions(+), 6 deletions(-)

diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index 2e8b1b94fe..bd3de8db42 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -4231,14 +4231,9 @@ void LLFolderBridge::staticFolderOptionsMenu()
 
 bool LLFolderBridge::checkFolderForContentsOfType(LLInventoryModel* model, LLInventoryCollectFunctor& is_type)
 {
-    LLInventoryModel::cat_array_t cat_array;
-    LLInventoryModel::item_array_t item_array;
-    model->collectDescendentsIf(mUUID,
-                                cat_array,
-                                item_array,
+    return model->hasMatchingDescendents(mUUID,
                                 LLInventoryModel::EXCLUDE_TRASH,
                                 is_type);
-    return !item_array.empty();
 }
 
 void LLFolderBridge::buildContextMenuOptions(U32 flags, menuentry_vec_t&   items, menuentry_vec_t& disabled_items)
diff --git a/indra/newview/llinventorymodel.cpp b/indra/newview/llinventorymodel.cpp
index d57cb13362..9fffe6378e 100644
--- a/indra/newview/llinventorymodel.cpp
+++ b/indra/newview/llinventorymodel.cpp
@@ -1305,6 +1305,47 @@ void LLInventoryModel::collectDescendentsIf(const LLUUID& id,
     }
 }
 
+bool LLInventoryModel::hasMatchingDescendents(const LLUUID& id,
+    bool include_trash,
+    LLInventoryCollectFunctor& matches)
+{
+    if (!include_trash)
+    {
+        const LLUUID trash_id = findCategoryUUIDForType(LLFolderType::FT_TRASH);
+        if (trash_id.notNull() && (trash_id == id))
+            return false;
+    }
+    cat_array_t* cat_array = get_ptr_in_map(mParentChildCategoryTree, id);
+    if (cat_array)
+    {
+        for (auto& cat : *cat_array)
+        {
+            if (matches(cat, NULL))
+            {
+                return true;
+            }
+            if (hasMatchingDescendents(cat->getUUID(), include_trash, matches))
+            {
+                return true;
+            }
+        }
+    }
+
+    item_array_t* item_array = get_ptr_in_map(mParentChildItemTree, id);
+
+    if (item_array)
+    {
+        for (auto& item : *item_array)
+        {
+            if (matches(NULL, item))
+            {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 void LLInventoryModel::addChangedMaskForLinks(const LLUUID& object_id, U32 mask)
 {
     const LLInventoryObject *obj = getObject(object_id);
diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h
index 1472b705e4..d28743357e 100644
--- a/indra/newview/llinventorymodel.h
+++ b/indra/newview/llinventorymodel.h
@@ -287,6 +287,9 @@ class LLInventoryModel
                               item_array_t& items,
                               bool include_trash,
                               LLInventoryCollectFunctor& add);
+    bool hasMatchingDescendents(const LLUUID& id,
+        bool include_trash,
+        LLInventoryCollectFunctor& add);
 
     // Collect all items in inventory that are linked to item_id.
     // Assumes item_id is itself not a linked item.

From 046ec79d2288cbe9e65999ea9e693652036c1813 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Thu, 6 Feb 2025 18:03:21 +0200
Subject: [PATCH 06/29] #3505 Make inventory run less content checks

---
 indra/newview/llinventorybridge.cpp    | 45 +++++++++++++-------------
 indra/newview/llinventoryfunctions.cpp | 16 +++++++++
 indra/newview/llinventoryfunctions.h   | 18 +++++++++++
 indra/newview/llinventorypanel.cpp     |  2 ++
 4 files changed, 58 insertions(+), 23 deletions(-)

diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index bd3de8db42..e7584018a8 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -4410,21 +4410,26 @@ void LLFolderBridge::buildContextMenuOptions(U32 flags, menuentry_vec_t&   items
         //Added by aura to force inventory pull on right-click to display folder options correctly. 07-17-06
         mCallingCards = mWearables = false;
 
-        LLIsType is_callingcard(LLAssetType::AT_CALLINGCARD);
-        if (checkFolderForContentsOfType(model, is_callingcard))
+        if (gInventory.getRootFolderID() != mUUID)
         {
-            mCallingCards=true;
-        }
+            LLIsType is_callingcard(LLAssetType::AT_CALLINGCARD);
+            if (checkFolderForContentsOfType(model, is_callingcard))
+            {
+                mCallingCards = true;
+            }
 
-        LLFindWearables is_wearable;
-        LLIsType is_object( LLAssetType::AT_OBJECT );
-        LLIsType is_gesture( LLAssetType::AT_GESTURE );
+            const std::vector<LLAssetType::EType> types = { LLAssetType::AT_CLOTHING, LLAssetType::AT_BODYPART, LLAssetType::AT_OBJECT, LLAssetType::AT_GESTURE };
+            LLIsOneOfTypes is_wearable(types);
 
-        if (checkFolderForContentsOfType(model, is_wearable) ||
-            checkFolderForContentsOfType(model, is_object)   ||
-            checkFolderForContentsOfType(model, is_gesture)    )
+            if (checkFolderForContentsOfType(model, is_wearable))
+            {
+                mWearables = true;
+            }
+        }
+        else
         {
-            mWearables=true;
+            // Assume that there are wearables in the root folder
+            mWearables = true;
         }
     }
     else
@@ -4437,13 +4442,10 @@ void LLFolderBridge::buildContextMenuOptions(U32 flags, menuentry_vec_t&   items
         LLFolderType::EType type = category->getPreferredType();
         const bool is_system_folder = LLFolderType::lookupIsProtectedType(type);
 
-        LLFindWearables is_wearable;
-        LLIsType is_object(LLAssetType::AT_OBJECT);
-        LLIsType is_gesture(LLAssetType::AT_GESTURE);
+        const std::vector<LLAssetType::EType> types = { LLAssetType::AT_CLOTHING, LLAssetType::AT_BODYPART, LLAssetType::AT_OBJECT, LLAssetType::AT_GESTURE };
+        LLIsOneOfTypes is_wearable(types);
 
-        if (checkFolderForContentsOfType(model, is_wearable) ||
-            checkFolderForContentsOfType(model, is_object) ||
-            checkFolderForContentsOfType(model, is_gesture))
+        if (checkFolderForContentsOfType(model, is_wearable))
         {
             mWearables = true;
         }
@@ -4566,14 +4568,11 @@ void LLFolderBridge::buildContextMenuFolderOptions(U32 flags,   menuentry_vec_t&
 
     // wearables related functionality for folders.
     //is_wearable
-    LLFindWearables is_wearable;
-    LLIsType is_object( LLAssetType::AT_OBJECT );
-    LLIsType is_gesture( LLAssetType::AT_GESTURE );
+    const std::vector<LLAssetType::EType> types = { LLAssetType::AT_CLOTHING, LLAssetType::AT_BODYPART, LLAssetType::AT_OBJECT, LLAssetType::AT_GESTURE };
+    LLIsOneOfTypes is_wearable(types);
 
     if (mWearables ||
-        checkFolderForContentsOfType(model, is_wearable)  ||
-        checkFolderForContentsOfType(model, is_object) ||
-        checkFolderForContentsOfType(model, is_gesture) )
+        checkFolderForContentsOfType(model, is_wearable))
     {
         // Only enable add/replace outfit for non-system folders.
         if (!is_system_folder)
diff --git a/indra/newview/llinventoryfunctions.cpp b/indra/newview/llinventoryfunctions.cpp
index dadd0590a9..1ccefa3212 100644
--- a/indra/newview/llinventoryfunctions.cpp
+++ b/indra/newview/llinventoryfunctions.cpp
@@ -2634,6 +2634,22 @@ bool LLIsType::operator()(LLInventoryCategory* cat, LLInventoryItem* item)
     return false;
 }
 
+bool LLIsOneOfTypes::operator()(LLInventoryCategory* cat, LLInventoryItem* item)
+{
+    for (LLAssetType::EType &type : mTypes)
+    {
+        if (type == LLAssetType::AT_CATEGORY)
+        {
+            if (cat) return true;
+        }
+        if (item)
+        {
+            if (item->getType() == type) return true;
+        }
+    }
+    return false;
+}
+
 bool LLIsNotType::operator()(LLInventoryCategory* cat, LLInventoryItem* item)
 {
     if(mType == LLAssetType::AT_CATEGORY)
diff --git a/indra/newview/llinventoryfunctions.h b/indra/newview/llinventoryfunctions.h
index a25c0d5ad6..13a64f21dc 100644
--- a/indra/newview/llinventoryfunctions.h
+++ b/indra/newview/llinventoryfunctions.h
@@ -245,6 +245,24 @@ class LLIsType : public LLInventoryCollectFunctor
     LLAssetType::EType mType;
 };
 
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLIsOneOfTypes
+//
+// Implementation of a LLInventoryCollectFunctor which returns true if
+// the type is one of the types passed in during construction.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLIsOneOfTypes : public LLInventoryCollectFunctor
+{
+public:
+    LLIsOneOfTypes(const std::vector<LLAssetType::EType> &types) : mTypes(types) {}
+    virtual ~LLIsOneOfTypes() {}
+    virtual bool operator()(LLInventoryCategory* cat,
+        LLInventoryItem* item);
+protected:
+    std::vector <LLAssetType::EType> mTypes;
+};
+
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Class LLIsNotType
 //
diff --git a/indra/newview/llinventorypanel.cpp b/indra/newview/llinventorypanel.cpp
index e4d1010231..5066a7da7f 100644
--- a/indra/newview/llinventorypanel.cpp
+++ b/indra/newview/llinventorypanel.cpp
@@ -1334,6 +1334,8 @@ void LLInventoryPanel::openStartFolderOrMyInventory()
         LLFolderViewFolder *fchild = dynamic_cast<LLFolderViewFolder*>(child);
         if (fchild
             && fchild->getViewModelItem()
+            // Is this right? Name might be localized,
+            // use FT_ROOT_INVENTORY or gInventory.getRootFolderID()?
             && fchild->getViewModelItem()->getName() == "My Inventory")
         {
             fchild->setOpen(true);

From 95106e203cb20b596810c4227acfa45e81358ef9 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Thu, 6 Feb 2025 19:06:09 +0200
Subject: [PATCH 07/29] #3505 Fix updateMenu() being called too frequently on
 fetch callback

The actual problem is fetch dumping thousands of callbacks, but this
should mitigate the problem
---
 indra/llui/llfolderview.cpp | 40 ++++++++++++++++++++++++++++++++-----
 indra/llui/llfolderview.h   |  1 +
 2 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/indra/llui/llfolderview.cpp b/indra/llui/llfolderview.cpp
index 42a9e267d2..a059c4d741 100644
--- a/indra/llui/llfolderview.cpp
+++ b/indra/llui/llfolderview.cpp
@@ -28,6 +28,7 @@
 
 #include "llfolderview.h"
 #include "llfolderviewmodel.h"
+#include "llcallbacklist.h"
 #include "llclipboard.h" // *TODO: remove this once hack below gone.
 #include "llkeyboard.h"
 #include "lllineeditor.h"
@@ -274,7 +275,11 @@ LLFolderView::~LLFolderView( void )
     mRenamer = NULL;
     mStatusTextBox = NULL;
 
-    if (mPopupMenuHandle.get()) mPopupMenuHandle.get()->die();
+    if (mPopupMenuHandle.get())
+    {
+        mPopupMenuHandle.get()->die();
+        gIdleCallbacks.deleteFunction(onIdleUpdateMenu, this);
+    }
     mPopupMenuHandle.markDead();
 
     mAutoOpenItems.removeAllNodes();
@@ -1095,7 +1100,10 @@ bool LLFolderView::handleKeyHere( KEY key, MASK mask )
     LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
     if (menu && menu->isOpen())
     {
-        LLMenuGL::sMenuContainer->hideMenus();
+        if (LLMenuGL::sMenuContainer->hideMenus())
+        {
+            gIdleCallbacks.deleteFunction(onIdleUpdateMenu, this);
+        }
     }
 
     switch( key )
@@ -1340,7 +1348,10 @@ bool LLFolderView::handleUnicodeCharHere(llwchar uni_char)
         LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
         if (menu && menu->isOpen())
         {
-            LLMenuGL::sMenuContainer->hideMenus();
+            if (LLMenuGL::sMenuContainer->hideMenus())
+            {
+                gIdleCallbacks.deleteFunction(onIdleUpdateMenu, this);
+            }
         }
 
         //do text search
@@ -1612,7 +1623,11 @@ void LLFolderView::deleteAllChildren()
     {
         LLUI::getInstance()->removePopup(mRenamer);
     }
-    if (mPopupMenuHandle.get()) mPopupMenuHandle.get()->die();
+    if (mPopupMenuHandle.get())
+    {
+        mPopupMenuHandle.get()->die();
+        gIdleCallbacks.deleteFunction(onIdleUpdateMenu, this);
+    }
     mPopupMenuHandle.markDead();
     mScrollContainer = NULL;
     mRenameItem = NULL;
@@ -1979,9 +1994,24 @@ void LLFolderView::updateMenu()
     LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
     if (menu && menu->getVisible())
     {
-        updateMenuOptions(menu);
+        // When fetching folders in bulk or in parts, each callback
+        // cause updateMenu individually, so make sure it gets called
+        // only once per frame, after callbacks are done.
+        // gIdleCallbacks has built in dupplicate protection.
+        gIdleCallbacks.addFunction(onIdleUpdateMenu, this);
+    }
+}
+
+void LLFolderView::onIdleUpdateMenu(void* user_data)
+{
+    LLFolderView* self = (LLFolderView*)user_data;
+    LLMenuGL* menu = (LLMenuGL*)self->mPopupMenuHandle.get();
+    if (menu)
+    {
+        self->updateMenuOptions(menu);
         menu->needsArrange(); // update menu height if needed
     }
+    gIdleCallbacks.deleteFunction(onIdleUpdateMenu, NULL);
 }
 
 bool LLFolderView::isFolderSelected()
diff --git a/indra/llui/llfolderview.h b/indra/llui/llfolderview.h
index 82637e33ea..7ed10d9223 100644
--- a/indra/llui/llfolderview.h
+++ b/indra/llui/llfolderview.h
@@ -266,6 +266,7 @@ class LLFolderView : public LLFolderViewFolder, public LLEditMenuHandler
 private:
     void updateMenuOptions(LLMenuGL* menu);
     void updateRenamerPosition();
+    static void onIdleUpdateMenu(void* user_data);
 
 protected:
     LLScrollContainer* mScrollContainer;  // NULL if this is not a child of a scroll container.

From 1924241f04699683e697f93388d634022d10aa32 Mon Sep 17 00:00:00 2001
From: Maxim Nikolenko <maximnproductengine@lindenlab.com>
Date: Fri, 7 Feb 2025 19:00:20 +0200
Subject: [PATCH 08/29] viewer-private#375 add more logging in attempt to get
 more info

---
 indra/newview/llvoiceclient.cpp |  1 +
 indra/newview/llvoicewebrtc.cpp | 20 ++++++++++++--------
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/indra/newview/llvoiceclient.cpp b/indra/newview/llvoiceclient.cpp
index 623d8deac9..3edd2b473c 100644
--- a/indra/newview/llvoiceclient.cpp
+++ b/indra/newview/llvoiceclient.cpp
@@ -285,6 +285,7 @@ void LLVoiceClient::setNonSpatialVoiceModule(const std::string &voice_server_typ
 
 void LLVoiceClient::setHidden(bool hidden)
 {
+    LL_INFOS("Voice") << "( " << (hidden ? "true" : "false") << " )" << LL_ENDL;
     LLWebRTCVoiceClient::getInstance()->setHidden(hidden);
     LLVivoxVoiceClient::getInstance()->setHidden(hidden);
 }
diff --git a/indra/newview/llvoicewebrtc.cpp b/indra/newview/llvoicewebrtc.cpp
index b2e5de5371..0bb65f7431 100644
--- a/indra/newview/llvoicewebrtc.cpp
+++ b/indra/newview/llvoicewebrtc.cpp
@@ -345,6 +345,8 @@ void LLWebRTCVoiceClient::updateSettings()
     static LLCachedControl<std::string> sOutputDevice(gSavedSettings, "VoiceOutputAudioDevice");
     setRenderDevice(sOutputDevice);
 
+    LL_INFOS("Voice") << "Input device: " << std::quoted(sInputDevice()) << ", output device: " << std::quoted(sOutputDevice()) << LL_ENDL;
+
     static LLCachedControl<F32> sMicLevel(gSavedSettings, "AudioLevelMic");
     setMicGain(sMicLevel);
 
@@ -896,7 +898,7 @@ void LLWebRTCVoiceClient::OnConnectionShutDown(const std::string &channelID, con
         {
             if (mSession && mSession->mChannelID == channelID)
             {
-                LL_DEBUGS("Voice") << "Main WebRTC Connection Shut Down." << LL_ENDL;
+                LL_INFOS("Voice") << "Main WebRTC Connection Shut Down." << LL_ENDL;
             }
         }
         mSession->removeAllParticipants(regionID);
@@ -1504,6 +1506,11 @@ bool LLWebRTCVoiceClient::compareChannels(const LLSD &channelInfo1, const LLSD &
 // we're muting the mic, so tell each session such
 void LLWebRTCVoiceClient::setMuteMic(bool muted)
 {
+    if (mMuteMic != muted)
+    {
+        LL_INFOS("Voice") << "( " << (muted ? "true" : "false") << " )" << LL_ENDL;
+    }
+
     mMuteMic = muted;
     // when you're hidden, your mic is always muted.
     if (!mHidden)
@@ -1552,14 +1559,10 @@ void LLWebRTCVoiceClient::setVoiceEnabled(bool enabled)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_VOICE;
 
-    LL_DEBUGS("Voice")
-        << "( " << (enabled ? "enabled" : "disabled") << " )"
-        << " was "<< (mVoiceEnabled ? "enabled" : "disabled")
-        << " coro "<< (mIsCoroutineActive ? "active" : "inactive")
-        << LL_ENDL;
-
     if (enabled != mVoiceEnabled)
     {
+        LL_INFOS("Voice") << "( " << (enabled ? "enabled" : "disabled") << " )"
+                           << ", coro: " << (mIsCoroutineActive ? "active" : "inactive") << LL_ENDL;
         // TODO: Refactor this so we don't call into LLVoiceChannel, but simply
         // use the status observer
         mVoiceEnabled = enabled;
@@ -2483,7 +2486,7 @@ void LLVoiceWebRTCConnection::breakVoiceConnectionCoro(connectionPtr_t connectio
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_VOICE;
 
-    LL_DEBUGS("Voice") << "Disconnecting voice." << LL_ENDL;
+    LL_INFOS("Voice") << "Disconnecting voice." << LL_ENDL;
     if (connection->mWebRTCDataInterface)
     {
         connection->mWebRTCDataInterface->unsetDataObserver(connection.get());
@@ -2591,6 +2594,7 @@ void LLVoiceWebRTCSpatialConnection::requestVoiceConnection()
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
 
+    LL_INFOS("Voice") << "Voice connection request: " << (status ? "Success" : status.toString()) << LL_ENDL;
     if (status)
     {
         OnVoiceConnectionRequestSuccess(result);

From 3a251b1b9e753589dd12e25236e77275c9010566 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Fri, 7 Feb 2025 22:07:02 +0200
Subject: [PATCH 09/29] #3332 Switching screens can break text rendering

---
 indra/llrender/llfontgl.cpp           | 1 +
 indra/llrender/llfontgl.h             | 1 +
 indra/llrender/llfontvertexbuffer.cpp | 4 +++-
 indra/llrender/llfontvertexbuffer.h   | 1 +
 indra/newview/llviewerwindow.cpp      | 1 +
 5 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/indra/llrender/llfontgl.cpp b/indra/llrender/llfontgl.cpp
index 4c9a062246..4d4eaf1a9a 100644
--- a/indra/llrender/llfontgl.cpp
+++ b/indra/llrender/llfontgl.cpp
@@ -58,6 +58,7 @@ F32 LLFontGL::sVertDPI = 96.f;
 F32 LLFontGL::sHorizDPI = 96.f;
 F32 LLFontGL::sScaleX = 1.f;
 F32 LLFontGL::sScaleY = 1.f;
+S32 LLFontGL::sResolutionGeneration = 0;
 bool LLFontGL::sDisplayFont = true ;
 std::string LLFontGL::sAppDir;
 
diff --git a/indra/llrender/llfontgl.h b/indra/llrender/llfontgl.h
index 4bb6c55c65..9b63fc7c38 100644
--- a/indra/llrender/llfontgl.h
+++ b/indra/llrender/llfontgl.h
@@ -224,6 +224,7 @@ class LLFontGL
     static F32 sHorizDPI;
     static F32 sScaleX;
     static F32 sScaleY;
+    static S32 sResolutionGeneration;
     static bool sDisplayFont ;
     static std::string sAppDir;         // For loading fonts
 
diff --git a/indra/llrender/llfontvertexbuffer.cpp b/indra/llrender/llfontvertexbuffer.cpp
index 5bd1ca5eed..17b23c420d 100644
--- a/indra/llrender/llfontvertexbuffer.cpp
+++ b/indra/llrender/llfontvertexbuffer.cpp
@@ -146,7 +146,8 @@ S32 LLFontVertexBuffer::render(
              || mLastScaleY != LLFontGL::sScaleY
              || mLastVertDPI != LLFontGL::sVertDPI
              || mLastHorizDPI != LLFontGL::sHorizDPI
-             || mLastOrigin != LLFontGL::sCurOrigin)
+             || mLastOrigin != LLFontGL::sCurOrigin
+             || mLastResGeneration != LLFontGL::sResolutionGeneration)
     {
         genBuffers(fontp, text, begin_offset, x, y, color, halign, valign,
             style, shadow, max_chars, max_pixels, right_x, use_ellipses, use_color);
@@ -201,6 +202,7 @@ void LLFontVertexBuffer::genBuffers(
     mLastVertDPI = LLFontGL::sVertDPI;
     mLastHorizDPI = LLFontGL::sHorizDPI;
     mLastOrigin = LLFontGL::sCurOrigin;
+    mLastResGeneration = LLFontGL::sResolutionGeneration;
 
     if (right_x)
     {
diff --git a/indra/llrender/llfontvertexbuffer.h b/indra/llrender/llfontvertexbuffer.h
index af195dfff9..f244e7fefa 100644
--- a/indra/llrender/llfontvertexbuffer.h
+++ b/indra/llrender/llfontvertexbuffer.h
@@ -117,6 +117,7 @@ class LLFontVertexBuffer
     F32 mLastScaleY = 1.f;
     F32 mLastVertDPI = 0.f;
     F32 mLastHorizDPI = 0.f;
+    S32 mLastResGeneration = 0;
     LLCoordGL mLastOrigin;
 
     static bool sEnableBufferCollection;
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 8a5aac9b8b..8915e68298 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -1750,6 +1750,7 @@ bool LLViewerWindow::handleDPIChanged(LLWindow *window, F32 ui_scale_factor, S32
     {
         LLViewerWindow::reshape(window_width, window_height);
         mResDirty = true;
+        LLFontGL::sResolutionGeneration++;
         return true;
     }
     else

From bc84cb02a2f324792deca766a4179d028473a282 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Sun, 9 Feb 2025 15:58:28 +0200
Subject: [PATCH 10/29] #3332 Issues with text buffer updates

---
 indra/llwindow/llwindowcallbacks.cpp |  5 +++++
 indra/llwindow/llwindowcallbacks.h   |  1 +
 indra/llwindow/llwindowwin32.cpp     |  9 +++++----
 indra/newview/llviewerwindow.cpp     | 10 +++++++++-
 indra/newview/llviewerwindow.h       |  1 +
 5 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/indra/llwindow/llwindowcallbacks.cpp b/indra/llwindow/llwindowcallbacks.cpp
index c160382c17..195f68e08b 100644
--- a/indra/llwindow/llwindowcallbacks.cpp
+++ b/indra/llwindow/llwindowcallbacks.cpp
@@ -194,6 +194,11 @@ bool LLWindowCallbacks::handleDPIChanged(LLWindow *window, F32 ui_scale_factor,
     return false;
 }
 
+bool LLWindowCallbacks::handleDisplayChanged()
+{
+    return false;
+}
+
 bool LLWindowCallbacks::handleWindowDidChangeScreen(LLWindow *window)
 {
     return false;
diff --git a/indra/llwindow/llwindowcallbacks.h b/indra/llwindow/llwindowcallbacks.h
index 63b585231f..d812f93524 100644
--- a/indra/llwindow/llwindowcallbacks.h
+++ b/indra/llwindow/llwindowcallbacks.h
@@ -69,6 +69,7 @@ class LLWindowCallbacks
     virtual bool handleTimerEvent(LLWindow *window);
     virtual bool handleDeviceChange(LLWindow *window);
     virtual bool handleDPIChanged(LLWindow *window, F32 ui_scale_factor, S32 window_width, S32 window_height);
+    virtual bool handleDisplayChanged();
     virtual bool handleWindowDidChangeScreen(LLWindow *window);
 
     enum DragNDropAction {
diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 5defa662fa..832cf254d1 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -81,10 +81,6 @@ const S32   BITS_PER_PIXEL = 32;
 const S32   MAX_NUM_RESOLUTIONS = 32;
 const F32   ICON_FLASH_TIME = 0.5f;
 
-#ifndef WM_DPICHANGED
-#define WM_DPICHANGED 0x02E0
-#endif
-
 #ifndef USER_DEFAULT_SCREEN_DPI
 #define USER_DEFAULT_SCREEN_DPI 96 // Win7
 #endif
@@ -2969,6 +2965,11 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
             return 0;
         }
 
+        case WM_DISPLAYCHANGE:
+        {
+            WINDOW_IMP_POST(window_imp->mCallbacks->handleDisplayChanged());
+        }
+
         case WM_SETFOCUS:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_SETFOCUS");
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 8915e68298..5a7d507b74 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -1746,11 +1746,11 @@ bool LLViewerWindow::handleDeviceChange(LLWindow *window)
 
 bool LLViewerWindow::handleDPIChanged(LLWindow *window, F32 ui_scale_factor, S32 window_width, S32 window_height)
 {
+    LLFontGL::sResolutionGeneration++;
     if (ui_scale_factor >= MIN_UI_SCALE && ui_scale_factor <= MAX_UI_SCALE)
     {
         LLViewerWindow::reshape(window_width, window_height);
         mResDirty = true;
-        LLFontGL::sResolutionGeneration++;
         return true;
     }
     else
@@ -1760,6 +1760,12 @@ bool LLViewerWindow::handleDPIChanged(LLWindow *window, F32 ui_scale_factor, S32
     }
 }
 
+bool LLViewerWindow::handleDisplayChanged()
+{
+    LLFontGL::sResolutionGeneration++;
+    return false;
+}
+
 bool LLViewerWindow::handleWindowDidChangeScreen(LLWindow *window)
 {
     LLCoordScreen window_rect;
@@ -1928,6 +1934,7 @@ LLViewerWindow::LLViewerWindow(const Params& p)
     mDisplayScale.setVec(llmax(1.f / mWindow->getPixelAspectRatio(), 1.f), llmax(mWindow->getPixelAspectRatio(), 1.f));
     mDisplayScale *= ui_scale_factor;
     LLUI::setScaleFactor(mDisplayScale);
+    LLFontGL::sResolutionGeneration++;
 
     {
         LLCoordWindow size;
@@ -2495,6 +2502,7 @@ void LLViewerWindow::reshape(S32 width, S32 height)
 
         bool display_scale_changed = mDisplayScale != LLUI::getScaleFactor();
         LLUI::setScaleFactor(mDisplayScale);
+        LLFontGL::sResolutionGeneration++;
 
         // update our window rectangle
         mWindowRectScaled.mRight = mWindowRectScaled.mLeft + ll_round((F32)width / mDisplayScale.mV[VX]);
diff --git a/indra/newview/llviewerwindow.h b/indra/newview/llviewerwindow.h
index 1b995ea650..fbc2c58fbf 100644
--- a/indra/newview/llviewerwindow.h
+++ b/indra/newview/llviewerwindow.h
@@ -225,6 +225,7 @@ class LLViewerWindow : public LLWindowCallbacks
     /*virtual*/ bool handleTimerEvent(LLWindow *window);
     /*virtual*/ bool handleDeviceChange(LLWindow *window);
     /*virtual*/ bool handleDPIChanged(LLWindow *window, F32 ui_scale_factor, S32 window_width, S32 window_height);
+    /*virtual*/ bool handleDisplayChanged();
     /*virtual*/ bool handleWindowDidChangeScreen(LLWindow *window);
 
     /*virtual*/ void handlePingWatchdog(LLWindow *window, const char * msg);

From 6a78b5b43cf14a30130dded0173ab914e282aa23 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Mon, 10 Feb 2025 19:20:57 +0200
Subject: [PATCH 11/29] #3332 Font issues with multy-byte and multy-glyps
 characters

---
 indra/llrender/llfontgl.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/indra/llrender/llfontgl.cpp b/indra/llrender/llfontgl.cpp
index 4d4eaf1a9a..91242f4947 100644
--- a/indra/llrender/llfontgl.cpp
+++ b/indra/llrender/llfontgl.cpp
@@ -272,9 +272,11 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
     const LLFontGlyphInfo* next_glyph = NULL;
 
     static constexpr S32 GLYPH_BATCH_SIZE = 30;
-    static thread_local LLVector4a vertices[GLYPH_BATCH_SIZE * 6];
-    static thread_local LLVector2 uvs[GLYPH_BATCH_SIZE * 6];
-    static thread_local LLColor4U colors[GLYPH_BATCH_SIZE * 6];
+    // string can have more than one glyph per char, make sure last one can fit
+    static constexpr S32 BUFFER_SIZE = GLYPH_BATCH_SIZE * 2;
+    static thread_local LLVector4a vertices[BUFFER_SIZE * 6];
+    static thread_local LLVector2 uvs[BUFFER_SIZE * 6];
+    static thread_local LLColor4U colors[BUFFER_SIZE * 6];
 
     LLColor4U text_color(color);
     // Preserve the transparency to render fading emojis in fading text (e.g.
@@ -283,6 +285,7 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
 
     std::pair<EFontGlyphType, S32> bitmap_entry = std::make_pair(EFontGlyphType::Grayscale, -1);
     S32 glyph_count = 0;
+    llwchar last_char = wstr[begin_offset];
     for (i = begin_offset; i < begin_offset + length; i++)
     {
         llwchar wch = wstr[i];
@@ -300,7 +303,7 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
         }
         // Per-glyph bitmap texture.
         std::pair<EFontGlyphType, S32> next_bitmap_entry = fgi->mBitmapEntry;
-        if (next_bitmap_entry != bitmap_entry)
+        if (next_bitmap_entry != bitmap_entry || last_char != wch)
         {
             // Actually draw the queued glyphs before switching their texture;
             // otherwise the queued glyphs will be taken from wrong textures.
@@ -317,6 +320,10 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
             bitmap_entry = next_bitmap_entry;
             LLImageGL* font_image = font_bitmap_cache->getImageGL(bitmap_entry.first, bitmap_entry.second);
             gGL.getTexUnit(0)->bind(font_image);
+
+            // For multi-byte characters just draw each time character changes
+            // Might be overkill and might be better to detect multybyte
+            last_char = wch;
         }
 
         if ((start_x + scaled_max_pixels) < (cur_x + fgi->mXBearing + fgi->mWidth))

From d450295cf517784744552acb2e885a1657a60f7e Mon Sep 17 00:00:00 2001
From: "Jonathan \"Geenz\" Goodman" <geenz@lindenlab.com>
Date: Tue, 11 Feb 2025 13:49:24 -0500
Subject: [PATCH 12/29] Additional water fixes and tweaks. (#3524)

* Incorporation of feedback for #3456
---
 indra/llrender/llglslshader.h                 |   1 +
 indra/llrender/llshadermgr.cpp                |   8 +
 .../class1/deferred/postDeferredTonemap.glsl  | 129 +---------
 .../shaders/class1/deferred/tonemapUtilF.glsl | 180 ++++++++++++++
 .../shaders/class3/environment/waterF.glsl    |  55 +++--
 indra/newview/lldrawpoolwater.cpp             | 231 ++++++++----------
 indra/newview/llviewershadermgr.cpp           |  37 +--
 indra/newview/llviewershadermgr.h             |   1 -
 8 files changed, 325 insertions(+), 317 deletions(-)
 create mode 100644 indra/newview/app_settings/shaders/class1/deferred/tonemapUtilF.glsl

diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 58c456f134..873ab0cff5 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -59,6 +59,7 @@ class LLShaderFeatures
     bool attachNothing = false;
     bool hasHeroProbes = false;
     bool isPBRTerrain = false;
+    bool hasTonemap = false;
 };
 
 // ============= Structure for caching shader uniforms ===============
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 25d8ccd4b3..4807c12226 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -291,6 +291,14 @@ bool LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
         }
     }
 
+    if (features->hasTonemap)
+    {
+        if (!shader->attachFragmentObject("deferred/tonemapUtilF.glsl"))
+        {
+            return false;
+        }
+    }
+
     // NOTE order of shader object attaching is VERY IMPORTANT!!!
     if (features->hasAtmospherics)
     {
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredTonemap.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredTonemap.glsl
index fc6d4d7727..c4610bffac 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredTonemap.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredTonemap.glsl
@@ -28,138 +28,11 @@
 out vec4 frag_color;
 
 uniform sampler2D diffuseRect;
-uniform sampler2D exposureMap;
 
-uniform vec2 screen_res;
 in vec2 vary_fragcoord;
 
 vec3 linear_to_srgb(vec3 cl);
-
-//===============================================================
-// tone mapping taken from Khronos sample implementation
-//===============================================================
-
-// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
-const mat3 ACESInputMat = mat3
-(
-    0.59719, 0.07600, 0.02840,
-    0.35458, 0.90834, 0.13383,
-    0.04823, 0.01566, 0.83777
-);
-
-
-// ODT_SAT => XYZ => D60_2_D65 => sRGB
-const mat3 ACESOutputMat = mat3
-(
-    1.60475, -0.10208, -0.00327,
-    -0.53108,  1.10813, -0.07276,
-    -0.07367, -0.00605,  1.07602
-);
-
-// ACES tone map (faster approximation)
-// see: https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/
-vec3 toneMapACES_Narkowicz(vec3 color)
-{
-    const float A = 2.51;
-    const float B = 0.03;
-    const float C = 2.43;
-    const float D = 0.59;
-    const float E = 0.14;
-    return clamp((color * (A * color + B)) / (color * (C * color + D) + E), 0.0, 1.0);
-}
-
-
-// ACES filmic tone map approximation
-// see https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/ACES.hlsl
-vec3 RRTAndODTFit(vec3 color)
-{
-    vec3 a = color * (color + 0.0245786) - 0.000090537;
-    vec3 b = color * (0.983729 * color + 0.4329510) + 0.238081;
-    return a / b;
-}
-
-
-// tone mapping
-vec3 toneMapACES_Hill(vec3 color)
-{
-    color = ACESInputMat * color;
-
-    // Apply RRT and ODT
-    color = RRTAndODTFit(color);
-
-    color = ACESOutputMat * color;
-
-    // Clamp to [0, 1]
-    color = clamp(color, 0.0, 1.0);
-
-    return color;
-}
-
-// Khronos Neutral tonemapping
-// https://github.com/KhronosGroup/ToneMapping/tree/main
-// Input color is non-negative and resides in the Linear Rec. 709 color space.
-// Output color is also Linear Rec. 709, but in the [0, 1] range.
-vec3 PBRNeutralToneMapping( vec3 color )
-{
-  const float startCompression = 0.8 - 0.04;
-  const float desaturation = 0.15;
-
-  float x = min(color.r, min(color.g, color.b));
-  float offset = x < 0.08 ? x - 6.25 * x * x : 0.04;
-  color -= offset;
-
-  float peak = max(color.r, max(color.g, color.b));
-  if (peak < startCompression) return color;
-
-  const float d = 1. - startCompression;
-  float newPeak = 1. - d * d / (peak + d - startCompression);
-  color *= newPeak / peak;
-
-  float g = 1. - 1. / (desaturation * (peak - newPeak) + 1.);
-  return mix(color, newPeak * vec3(1, 1, 1), g);
-}
-
-uniform float exposure;
-uniform float tonemap_mix;
-uniform int tonemap_type;
-
-vec3 toneMap(vec3 color)
-{
-#ifndef NO_POST
-    float exp_scale = texture(exposureMap, vec2(0.5,0.5)).r;
-
-    color *= exposure * exp_scale;
-
-    vec3 clamped_color = clamp(color.rgb, vec3(0.0), vec3(1.0));
-
-    switch(tonemap_type)
-    {
-    case 0:
-        color = PBRNeutralToneMapping(color);
-        break;
-    case 1:
-        color = toneMapACES_Hill(color);
-        break;
-    }
-
-    // mix tonemapped and linear here to provide adjustment
-    color = mix(clamped_color, color, tonemap_mix);
-#endif
-
-    return color;
-}
-
-//===============================================================
-
-void debugExposure(inout vec3 color)
-{
-    float exp_scale = texture(exposureMap, vec2(0.5,0.5)).r;
-    exp_scale *= 0.5;
-    if (abs(vary_fragcoord.y-exp_scale) < 0.01 && vary_fragcoord.x < 0.1)
-    {
-        color = vec3(1,0,0);
-    }
-}
+vec3 toneMap(vec3 color);
 
 void main()
 {
diff --git a/indra/newview/app_settings/shaders/class1/deferred/tonemapUtilF.glsl b/indra/newview/app_settings/shaders/class1/deferred/tonemapUtilF.glsl
new file mode 100644
index 0000000000..a63b8d7c2b
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/tonemapUtilF.glsl
@@ -0,0 +1,180 @@
+/**
+ * @file postDeferredTonemap.glsl
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, 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 exposureMap;
+uniform vec2 screen_res;
+in vec2 vary_fragcoord;
+
+//===============================================================
+// tone mapping taken from Khronos sample implementation
+//===============================================================
+
+// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+const mat3 ACESInputMat = mat3
+(
+    0.59719, 0.07600, 0.02840,
+    0.35458, 0.90834, 0.13383,
+    0.04823, 0.01566, 0.83777
+);
+
+
+// ODT_SAT => XYZ => D60_2_D65 => sRGB
+const mat3 ACESOutputMat = mat3
+(
+    1.60475, -0.10208, -0.00327,
+    -0.53108,  1.10813, -0.07276,
+    -0.07367, -0.00605,  1.07602
+);
+
+// ACES tone map (faster approximation)
+// see: https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/
+vec3 toneMapACES_Narkowicz(vec3 color)
+{
+    const float A = 2.51;
+    const float B = 0.03;
+    const float C = 2.43;
+    const float D = 0.59;
+    const float E = 0.14;
+    return clamp((color * (A * color + B)) / (color * (C * color + D) + E), 0.0, 1.0);
+}
+
+
+// ACES filmic tone map approximation
+// see https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/ACES.hlsl
+vec3 RRTAndODTFit(vec3 color)
+{
+    vec3 a = color * (color + 0.0245786) - 0.000090537;
+    vec3 b = color * (0.983729 * color + 0.4329510) + 0.238081;
+    return a / b;
+}
+
+
+// tone mapping
+vec3 toneMapACES_Hill(vec3 color)
+{
+    color = ACESInputMat * color;
+
+    // Apply RRT and ODT
+    color = RRTAndODTFit(color);
+
+    color = ACESOutputMat * color;
+
+    // Clamp to [0, 1]
+    color = clamp(color, 0.0, 1.0);
+
+    return color;
+}
+
+// Khronos Neutral tonemapping
+// https://github.com/KhronosGroup/ToneMapping/tree/main
+// Input color is non-negative and resides in the Linear Rec. 709 color space.
+// Output color is also Linear Rec. 709, but in the [0, 1] range.
+vec3 PBRNeutralToneMapping( vec3 color )
+{
+  const float startCompression = 0.8 - 0.04;
+  const float desaturation = 0.15;
+
+  float x = min(color.r, min(color.g, color.b));
+  float offset = x < 0.08 ? x - 6.25 * x * x : 0.04;
+  color -= offset;
+
+  float peak = max(color.r, max(color.g, color.b));
+  if (peak < startCompression) return color;
+
+  const float d = 1. - startCompression;
+  float newPeak = 1. - d * d / (peak + d - startCompression);
+  color *= newPeak / peak;
+
+  float g = 1. - 1. / (desaturation * (peak - newPeak) + 1.);
+  return mix(color, newPeak * vec3(1, 1, 1), g);
+}
+
+uniform float exposure;
+uniform float tonemap_mix;
+uniform int tonemap_type;
+
+vec3 toneMap(vec3 color)
+{
+#ifndef NO_POST
+    float exp_scale = texture(exposureMap, vec2(0.5,0.5)).r;
+
+    color *= exposure * exp_scale;
+
+    vec3 clamped_color = clamp(color.rgb, vec3(0.0), vec3(1.0));
+
+    switch(tonemap_type)
+    {
+    case 0:
+        color = PBRNeutralToneMapping(color);
+        break;
+    case 1:
+        color = toneMapACES_Hill(color);
+        break;
+    }
+
+    // mix tonemapped and linear here to provide adjustment
+    color = mix(clamped_color, color, tonemap_mix);
+#endif
+
+    return color;
+}
+
+
+vec3 toneMapNoExposure(vec3 color)
+{
+#ifndef NO_POST
+    vec3 clamped_color = clamp(color.rgb, vec3(0.0), vec3(1.0));
+
+    switch(tonemap_type)
+    {
+    case 0:
+        color = PBRNeutralToneMapping(color);
+        break;
+    case 1:
+        color = toneMapACES_Hill(color);
+        break;
+    }
+
+    // mix tonemapped and linear here to provide adjustment
+    color = mix(clamped_color, color, tonemap_mix);
+#endif
+
+    return color;
+}
+
+
+//===============================================================
+
+void debugExposure(inout vec3 color)
+{
+    float exp_scale = texture(exposureMap, vec2(0.5,0.5)).r;
+    exp_scale *= 0.5;
+    if (abs(vary_fragcoord.y-exp_scale) < 0.01 && vary_fragcoord.x < 0.1)
+    {
+        color = vec3(1,0,0);
+    }
+}
diff --git a/indra/newview/app_settings/shaders/class3/environment/waterF.glsl b/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
index 7027e3796e..c56e38d016 100644
--- a/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
@@ -90,21 +90,15 @@ uniform sampler2D depthMap;
 
 uniform sampler2D exclusionTex;
 
-uniform float sunAngle;
-uniform float sunAngle2;
+uniform int classic_mode;
 uniform vec3 lightDir;
 uniform vec3 specular;
-uniform float lightExp;
+uniform float blurMultiplier;
 uniform float refScale;
 uniform float kd;
-uniform vec2 screenRes;
 uniform vec3 normScale;
 uniform float fresnelScale;
 uniform float fresnelOffset;
-uniform float blurMultiplier;
-uniform vec4 waterFogColor;
-uniform vec3 waterFogColorLinear;
-
 
 //bigWave is (refCoord.w, view.w);
 in vec4 refCoord;
@@ -126,6 +120,7 @@ vec3 linear_to_srgb(vec3 col);
 
 vec3 atmosLighting(vec3 light);
 vec3 scaleSoftClip(vec3 light);
+vec3 toneMapNoExposure(vec3 color);
 
 vec3 vN, vT, vB;
 
@@ -171,18 +166,18 @@ void calculateFresnelFactors(out vec3 df3, out vec2 df2, vec3 viewVec, vec3 wave
     // We calculate the fresnel here.
     // We do this by getting the dot product for each sets of waves, and applying scale and offset.
 
-    df3 = vec3(
+    df3 = max(vec3(0), vec3(
         dot(viewVec, wave1),
         dot(viewVec, (wave2 + wave3) * 0.5),
         dot(viewVec, wave3)
-    ) * fresnelScale + fresnelOffset;
+    ) * fresnelScale + fresnelOffset);
 
     df3 *= df3;
 
-    df2 = vec2(
+    df2 = max(vec2(0), vec2(
         df3.x + df3.y + df3.z,
         dot(viewVec, wavef) * fresnelScale + fresnelOffset
-    );
+    ));
 }
 
 void main()
@@ -194,6 +189,7 @@ void main()
     vB = cross(vN, vT);
 
     vec3 pos = vary_position.xyz;
+    float linear_depth = 1 / -pos.z;
 
     float dist = length(pos.xyz);
 
@@ -216,6 +212,12 @@ void main()
     vec3 df3 = vec3(0);
     vec2 df2 = vec2(0);
 
+    vec3 sunlit;
+    vec3 amblit;
+    vec3 additive;
+    vec3 atten;
+    calcAtmosphericVarsLinear(pos.xyz, wavef, vary_light_dir, sunlit, amblit, additive, atten);
+
     calculateFresnelFactors(df3, df2, normalize(view.xyz), wave1, wave2, wave3, wavef);
 
     vec3 waver = wavef*3;
@@ -230,7 +232,7 @@ void main()
     vec3 norm = transform_normal(normalize(wavef));
 
     vdu = clamp(vdu, 0, 1);
-    wavef.z *= max(vdu*vdu*vdu, 0.1);
+    //wavef.z *= max(vdu*vdu*vdu, 0.1);
 
     wavef = normalize(wavef);
 
@@ -245,11 +247,6 @@ void main()
 
     distort2 = clamp(distort2, vec2(0), vec2(0.999));
 
-    vec3 sunlit;
-    vec3 amblit;
-    vec3 additive;
-    vec3 atten;
-
     float shadow = 1.0f;
 
     float water_mask = texture(exclusionTex, distort).r;
@@ -258,8 +255,6 @@ void main()
     shadow = sampleDirectionalShadow(pos.xyz, norm.xyz, distort);
 #endif
 
-    calcAtmosphericVarsLinear(pos.xyz, wavef, vary_light_dir, sunlit, amblit, additive, atten);
-
     vec3 sunlit_linear = srgb_to_linear(sunlit);
     float fade = 0;
 #ifdef TRANSPARENT_WATER
@@ -289,8 +284,8 @@ void main()
 #endif
 
     float metallic = 1.0;
-    float perceptualRoughness = 0.1;
-    float gloss      = 0.95;
+    float perceptualRoughness = blurMultiplier;
+    float gloss      = 1 - perceptualRoughness;
 
     vec3  irradiance = vec3(0);
     vec3  radiance  = vec3(0);
@@ -300,7 +295,7 @@ void main()
 #ifdef WATER_MINIMAL
     sampleReflectionProbesWater(irradiance, radiance, distort2, pos.xyz, wave_ibl.xyz, gloss, amblit);
 #elif WATER_MINIMAL_PLUS
-    sampleReflectionProbes(irradiance, radiance, distort2, pos.xyz, wave_ibl.xyz, 1, false, amblit);
+    sampleReflectionProbes(irradiance, radiance, distort2, pos.xyz, wave_ibl.xyz, gloss, false, amblit);
 #endif
 
     vec3 diffuseColor = vec3(0);
@@ -323,20 +318,26 @@ void main()
     pbrPunctual(diffuseColor, specularColor, perceptualRoughness, metallic, normalize(wavef+up*max(dist, 32.0)/32.0*(1.0-vdu)), v, normalize(light_dir), nl, diffPunc, specPunc);
 
     vec3 punctual = clamp(nl * (diffPunc + specPunc), vec3(0), vec3(10)) * sunlit_linear * shadow;
-
+    radiance *= df2.y;
+    //radiance = toneMapNoExposure(radiance);
     vec3 color = vec3(0);
-    color = mix(fb.rgb, radiance * df2.y, df2.x * 0.99999) + punctual.rgb;
+    color = mix(fb.rgb, radiance, min(1, df2.x)) + punctual.rgb;
+
+    float water_haze_scale = 4;
+
+    if (classic_mode > 0)
+        water_haze_scale = 1;
 
     // This looks super janky, but we do this to restore water haze in the distance.
     // These values were finagled in to try and bring back some of the distant brightening on legacy water.  Also works reasonably well on PBR skies such as PBR midday.
-    color += color * min(vec3(4),pow(1 - atten, vec3(1.35)) * 16 * fade);
+    // color = mix(color, additive * water_haze_scale, (1 - atten));
 
     // We shorten the fade here at the shoreline so it doesn't appear too soft from a distance.
     fade *= 60;
     fade = min(1, fade);
     color = mix(fb.rgb, color, fade);
 
-    float spec = min(max(max(punctual.r, punctual.g), punctual.b), 0.05);
+    float spec = min(max(max(punctual.r, punctual.g), punctual.b), 0);
 
     frag_color = min(vec4(1),max(vec4(color.rgb, spec * water_mask), vec4(0)));
 }
diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp
index c27f5ef486..32de0e5ee7 100644
--- a/indra/newview/lldrawpoolwater.cpp
+++ b/indra/newview/lldrawpoolwater.cpp
@@ -176,154 +176,133 @@ void LLDrawPoolWater::renderPostDeferred(S32 pass)
         light_diffuse *= (1.5f + (6.f * ground_proj_sq));
     }
 
-    // set up normal maps filtering
-    for (auto norm_map : mWaterNormp)
-        {
-        if (norm_map) norm_map->setFilteringOption(has_normal_mips ? LLTexUnit::TFO_ANISOTROPIC : LLTexUnit::TFO_POINT);
-        }
+    LLTexUnit::eTextureFilterOptions filter_mode = has_normal_mips ? LLTexUnit::TFO_ANISOTROPIC : LLTexUnit::TFO_POINT;
 
     LLColor4      specular(sun_up ? psky->getSunlightColor() : psky->getMoonlightColor());
     F32           phase_time = (F32) LLFrameTimer::getElapsedSeconds() * 0.5f;
     LLGLSLShader *shader     = nullptr;
 
-    // two passes, first with standard water shader bound, second with edge water shader bound
-    for (int edge = 0; edge < 2; edge++)
+    // One pass, one of two shaders.  Void water and region water share state.
+    // There isn't a good reason anymore to really have void water run in a separate pass.
+    // It also just introduced a bunch of weird state consistency stuff that we really don't need.
+    // Not to mention, re-binding the the same shader and state for that shader is kind of wasteful.
+    // - Geenz 2025-02-11
+    // select shader
+    if (underwater)
     {
-        // select shader
-        if (underwater)
-        {
-            shader = &gUnderWaterProgram;
-        }
-        else
-        {
-            if (edge)
-            {
-                shader = &gWaterEdgeProgram;
-            }
-            else
-            {
-                shader = &gWaterProgram;
-            }
-        }
-
-        gPipeline.bindDeferredShader(*shader, nullptr, &gPipeline.mWaterDis);
-
-        //bind normal map
-        S32 bumpTex = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP);
-        S32 bumpTex2 = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP2);
-
-        LLViewerTexture* tex_a = mWaterNormp[0];
-        LLViewerTexture* tex_b = mWaterNormp[1];
+        shader = &gUnderWaterProgram;
+    }
+    else
+    {
+        shader = &gWaterProgram;
+    }
 
-        F32 blend_factor = (F32)pwater->getBlendFactor();
+    gPipeline.bindDeferredShader(*shader, nullptr, &gPipeline.mWaterDis);
 
-        gGL.getTexUnit(bumpTex)->unbind(LLTexUnit::TT_TEXTURE);
-        gGL.getTexUnit(bumpTex2)->unbind(LLTexUnit::TT_TEXTURE);
+    LLViewerTexture* tex_a = mWaterNormp[0];
+    LLViewerTexture* tex_b = mWaterNormp[1];
 
-        if (tex_a && (!tex_b || (tex_a == tex_b)))
-        {
-            gGL.getTexUnit(bumpTex)->bind(tex_a);
-            blend_factor = 0; // only one tex provided, no blending
-        }
-        else if (tex_b && !tex_a)
-        {
-            gGL.getTexUnit(bumpTex)->bind(tex_b);
-            blend_factor = 0; // only one tex provided, no blending
-        }
-        else if (tex_b != tex_a)
-        {
-            gGL.getTexUnit(bumpTex)->bind(tex_a);
-            gGL.getTexUnit(bumpTex2)->bind(tex_b);
-        }
+    F32 blend_factor = (F32)pwater->getBlendFactor();
 
-        shader->bindTexture(LLShaderMgr::WATER_EXCLUSIONTEX, &gPipeline.mWaterExclusionMask);
+    if (tex_a && (!tex_b || (tex_a == tex_b)))
+    {
+        shader->bindTexture(LLViewerShaderMgr::BUMP_MAP, tex_a);
+        tex_a->setFilteringOption(filter_mode);
+        blend_factor = 0; // only one tex provided, no blending
+    }
+    else if (tex_b && !tex_a)
+    {
+        shader->bindTexture(LLViewerShaderMgr::BUMP_MAP, tex_b);
+        tex_a->setFilteringOption(filter_mode);
+        blend_factor = 0; // only one tex provided, no blending
+    }
+    else if (tex_b != tex_a)
+    {
+        shader->bindTexture(LLViewerShaderMgr::BUMP_MAP, tex_a);
+        tex_a->setFilteringOption(filter_mode);
+        shader->bindTexture(LLViewerShaderMgr::BUMP_MAP2, tex_b);
+        tex_b->setFilteringOption(filter_mode);
+    }
 
-        // bind reflection texture from RenderTarget
-        S32 screentex = shader->enableTexture(LLShaderMgr::WATER_SCREENTEX);
+    shader->bindTexture(LLShaderMgr::WATER_EXCLUSIONTEX, &gPipeline.mWaterExclusionMask);
 
-        F32 screenRes[] = { 1.f / gGLViewport[2], 1.f / gGLViewport[3] };
+    shader->uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
 
-        shader->uniform2fv(LLShaderMgr::DEFERRED_SCREEN_RES, 1, screenRes);
-        shader->uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
+    F32      fog_density = pwater->getModifiedWaterFogDensity(underwater);
 
-        F32      fog_density = pwater->getModifiedWaterFogDensity(underwater);
+    shader->bindTexture(LLShaderMgr::WATER_SCREENTEX, &gPipeline.mWaterDis);
 
-        if (screentex > -1)
-        {
-            shader->uniform1f(LLShaderMgr::WATER_FOGDENSITY, fog_density);
-            gGL.getTexUnit(screentex)->bind(&gPipeline.mWaterDis);
-        }
+    if (mShaderLevel == 1)
+    {
+        fog_color.mV[VALPHA] = (F32)(log(fog_density) / log(2));
+    }
 
-        if (mShaderLevel == 1)
-        {
-            fog_color.mV[VALPHA] = (F32)(log(fog_density) / log(2));
-        }
+    F32 water_height = environment.getWaterHeight();
+    F32 camera_height = LLViewerCamera::getInstance()->getOrigin().mV[2];
+    shader->uniform1f(LLShaderMgr::WATER_WATERHEIGHT, camera_height - water_height);
+    shader->uniform1f(LLShaderMgr::WATER_TIME, phase_time);
+    shader->uniform3fv(LLShaderMgr::WATER_EYEVEC, 1, LLViewerCamera::getInstance()->getOrigin().mV);
 
-        F32 water_height = environment.getWaterHeight();
-        F32 camera_height = LLViewerCamera::getInstance()->getOrigin().mV[2];
-        shader->uniform1f(LLShaderMgr::WATER_WATERHEIGHT, camera_height - water_height);
-        shader->uniform1f(LLShaderMgr::WATER_TIME, phase_time);
-        shader->uniform3fv(LLShaderMgr::WATER_EYEVEC, 1, LLViewerCamera::getInstance()->getOrigin().mV);
+    shader->uniform3fv(LLShaderMgr::WATER_SPECULAR, 1, light_diffuse.mV);
 
-        shader->uniform4fv(LLShaderMgr::SPECULAR_COLOR, 1, specular.mV);
-        shader->uniform4fv(LLShaderMgr::WATER_FOGCOLOR, 1, fog_color.mV);
-        shader->uniform3fv(LLShaderMgr::WATER_FOGCOLOR_LINEAR, 1, fog_color_linear.mV);
+    shader->uniform2fv(LLShaderMgr::WATER_WAVE_DIR1, 1, pwater->getWave1Dir().mV);
+    shader->uniform2fv(LLShaderMgr::WATER_WAVE_DIR2, 1, pwater->getWave2Dir().mV);
 
-        shader->uniform3fv(LLShaderMgr::WATER_SPECULAR, 1, light_diffuse.mV);
-        shader->uniform1f(LLShaderMgr::WATER_SPECULAR_EXP, light_exp);
+    shader->uniform3fv(LLShaderMgr::WATER_LIGHT_DIR, 1, light_dir.mV);
 
-        shader->uniform2fv(LLShaderMgr::WATER_WAVE_DIR1, 1, pwater->getWave1Dir().mV);
-        shader->uniform2fv(LLShaderMgr::WATER_WAVE_DIR2, 1, pwater->getWave2Dir().mV);
+    shader->uniform3fv(LLShaderMgr::WATER_NORM_SCALE, 1, pwater->getNormalScale().mV);
+    shader->uniform1f(LLShaderMgr::WATER_FRESNEL_SCALE, pwater->getFresnelScale());
+    shader->uniform1f(LLShaderMgr::WATER_FRESNEL_OFFSET, pwater->getFresnelOffset());
+    shader->uniform1f(LLShaderMgr::WATER_BLUR_MULTIPLIER, fmaxf(0, pwater->getBlurMultiplier()) * 2);
 
-        shader->uniform3fv(LLShaderMgr::WATER_LIGHT_DIR, 1, light_dir.mV);
+    static LLStaticHashedString s_exposure("exposure");
+    static LLStaticHashedString tonemap_mix("tonemap_mix");
+    static LLStaticHashedString tonemap_type("tonemap_type");
 
-        shader->uniform3fv(LLShaderMgr::WATER_NORM_SCALE, 1, pwater->getNormalScale().mV);
-        shader->uniform1f(LLShaderMgr::WATER_FRESNEL_SCALE, pwater->getFresnelScale());
-        shader->uniform1f(LLShaderMgr::WATER_FRESNEL_OFFSET, pwater->getFresnelOffset());
-        shader->uniform1f(LLShaderMgr::WATER_BLUR_MULTIPLIER, pwater->getBlurMultiplier());
+    static LLCachedControl<F32> exposure(gSavedSettings, "RenderExposure", 1.f);
 
-        F32 sunAngle = llmax(0.f, light_dir.mV[1]);
-        F32 scaledAngle = 1.f - sunAngle;
+    F32 e = llclamp(exposure(), 0.5f, 4.f);
 
-        shader->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up ? 1 : 0);
-        shader->uniform1f(LLShaderMgr::WATER_SUN_ANGLE, sunAngle);
-        shader->uniform1f(LLShaderMgr::WATER_SCALED_ANGLE, scaledAngle);
-        shader->uniform1f(LLShaderMgr::WATER_SUN_ANGLE2, 0.1f + 0.2f * sunAngle);
-        shader->uniform1i(LLShaderMgr::WATER_EDGE_FACTOR, edge ? 1 : 0);
+    static LLCachedControl<bool> should_auto_adjust(gSavedSettings, "RenderSkyAutoAdjustLegacy", false);
 
-        // SL-15861 This was changed from getRotatedLightNorm() as it was causing
-        // lightnorm in shaders\class1\windlight\atmosphericsFuncs.glsl in have inconsistent additive lighting for 180 degrees of the FOV.
-        LLVector4 rotated_light_direction = LLEnvironment::instance().getClampedLightNorm();
-        shader->uniform3fv(LLViewerShaderMgr::LIGHTNORM, 1, rotated_light_direction.mV);
+    shader->uniform1f(s_exposure, e);
+    static LLCachedControl<U32> tonemap_type_setting(gSavedSettings, "RenderTonemapType", 0U);
+    shader->uniform1i(tonemap_type, tonemap_type_setting);
+    shader->uniform1f(tonemap_mix, psky->getTonemapMix(should_auto_adjust()));
 
-        shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
+    F32 sunAngle = llmax(0.f, light_dir.mV[1]);
+    F32 scaledAngle = 1.f - sunAngle;
 
-        if (LLViewerCamera::getInstance()->cameraUnderWater())
-        {
-            shader->uniform1f(LLShaderMgr::WATER_REFSCALE, pwater->getScaleBelow());
-        }
-        else
-        {
-            shader->uniform1f(LLShaderMgr::WATER_REFSCALE, pwater->getScaleAbove());
-        }
+    shader->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up ? 1 : 0);
 
-        LLGLDisable cullface(GL_CULL_FACE);
+    // SL-15861 This was changed from getRotatedLightNorm() as it was causing
+    // lightnorm in shaders\class1\windlight\atmosphericsFuncs.glsl in have inconsistent additive lighting for 180 degrees of the FOV.
+    LLVector4 rotated_light_direction = LLEnvironment::instance().getClampedLightNorm();
+    shader->uniform3fv(LLViewerShaderMgr::LIGHTNORM, 1, rotated_light_direction.mV);
 
-        pushWaterPlanes(edge);
+    shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
 
-        shader->disableTexture(LLShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
-        shader->disableTexture(LLShaderMgr::WATER_SCREENTEX);
-        shader->disableTexture(LLShaderMgr::BUMP_MAP);
+    if (LLViewerCamera::getInstance()->cameraUnderWater())
+    {
+        shader->uniform1f(LLShaderMgr::WATER_REFSCALE, pwater->getScaleBelow());
+    }
+    else
+    {
+        shader->uniform1f(LLShaderMgr::WATER_REFSCALE, pwater->getScaleAbove());
+    }
 
-        // clean up
-        gPipeline.unbindDeferredShader(*shader);
+    LLGLDisable cullface(GL_CULL_FACE);
 
-        gGL.getTexUnit(bumpTex)->unbind(LLTexUnit::TT_TEXTURE);
-        gGL.getTexUnit(bumpTex2)->unbind(LLTexUnit::TT_TEXTURE);
-    }
+    // Only push the water planes once.
+    // Previously we did this twice: once for void water and one for region water.
+    // However, the void water and region water shaders are the same exact shader.
+    // They also had the same exact state with the sole exception setting an edge water flag.
+    // That flag was not actually used anywhere in the shaders.
+    // - Geenz 2025-02-11
+    pushWaterPlanes(0);
 
-    gGL.getTexUnit(0)->activate();
-    gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
+    // clean up
+    gPipeline.unbindDeferredShader(*shader);
 
     gGL.setColorMask(true, false);
 }
@@ -333,22 +312,18 @@ void LLDrawPoolWater::pushWaterPlanes(int pass)
     LLVOWater* water = nullptr;
     for (LLFace* const& face : mDrawFace)
     {
-        if (!face)
-            continue;
         water = static_cast<LLVOWater*>(face->getViewerObject());
-        if (!water)
-            continue;
 
-        if ((bool)pass == (bool)water->getIsEdgePatch())
+        face->renderIndexed();
+
+        // Note non-void water being drawn, updates required
+        // Previously we had some logic to determine if this pass was also our water edge pass.
+        // Now we only have one pass.  Check if we're doing a region water plane or void water plane.
+        // - Geenz 2025-02-11
+        if (!water->getIsEdgePatch())
         {
-            face->renderIndexed();
-
-            // Note non-void water being drawn, updates required
-            if (!pass) // SL-16461 remove !LLPipeline::sUseOcclusion check
-            {
-                sNeedsReflectionUpdate = true;
-                sNeedsDistortionUpdate = true;
-            }
+            sNeedsReflectionUpdate = true;
+            sNeedsDistortionUpdate = true;
         }
     }
 }
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index ac4519e593..a0a9906724 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -114,7 +114,6 @@ LLGLSLShader        gObjectAlphaMaskNoColorProgram;
 
 //environment shaders
 LLGLSLShader        gWaterProgram;
-LLGLSLShader        gWaterEdgeProgram;
 LLGLSLShader        gUnderWaterProgram;
 
 //interface shaders
@@ -410,7 +409,6 @@ void LLViewerShaderMgr::finalizeShaderList()
     //ONLY shaders that need WL Param management should be added here
     mShaderList.push_back(&gAvatarProgram);
     mShaderList.push_back(&gWaterProgram);
-    mShaderList.push_back(&gWaterEdgeProgram);
     mShaderList.push_back(&gAvatarEyeballProgram);
     mShaderList.push_back(&gImpostorProgram);
     mShaderList.push_back(&gObjectBumpProgram);
@@ -877,6 +875,7 @@ std::string LLViewerShaderMgr::loadBasicShaders()
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/shadowUtil.glsl",                      1) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/aoUtil.glsl",                          1) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/pbrterrainUtilF.glsl",                 1) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/tonemapUtilF.glsl",                    1) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/reflectionProbeF.glsl",                has_reflection_probes ? 3 : 2) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/screenSpaceReflUtil.glsl",             ssr ? 3 : 1) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "lighting/lightNonIndexedF.glsl",                    mShaderLevel[SHADER_LIGHTING] ) );
@@ -909,7 +908,6 @@ bool LLViewerShaderMgr::loadShadersWater()
     if (mShaderLevel[SHADER_WATER] == 0)
     {
         gWaterProgram.unload();
-        gWaterEdgeProgram.unload();
         gUnderWaterProgram.unload();
         return true;
     }
@@ -923,6 +921,7 @@ bool LLViewerShaderMgr::loadShadersWater()
         gWaterProgram.mFeatures.hasGamma = true;
         gWaterProgram.mFeatures.hasSrgb = true;
         gWaterProgram.mFeatures.hasReflectionProbes = true;
+        gWaterProgram.mFeatures.hasTonemap = true;
         gWaterProgram.mFeatures.hasShadows = use_sun_shadow;
         gWaterProgram.mShaderFiles.clear();
         gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
@@ -944,36 +943,6 @@ bool LLViewerShaderMgr::loadShadersWater()
         llassert(success);
     }
 
-    if (success)
-    {
-    // load water shader
-        gWaterEdgeProgram.mName = "Water Edge Shader";
-        gWaterEdgeProgram.mFeatures.calculatesAtmospherics = true;
-        gWaterEdgeProgram.mFeatures.hasAtmospherics = true;
-        gWaterEdgeProgram.mFeatures.hasGamma = true;
-        gWaterEdgeProgram.mFeatures.hasSrgb = true;
-        gWaterEdgeProgram.mFeatures.hasReflectionProbes = true;
-        gWaterEdgeProgram.mFeatures.hasShadows = use_sun_shadow;
-        gWaterEdgeProgram.mShaderFiles.clear();
-        gWaterEdgeProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
-        gWaterEdgeProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER));
-        gWaterEdgeProgram.clearPermutations();
-        gWaterEdgeProgram.addPermutation("WATER_EDGE", "1");
-        if (LLPipeline::sRenderTransparentWater)
-        {
-            gWaterEdgeProgram.addPermutation("TRANSPARENT_WATER", "1");
-        }
-
-        if (use_sun_shadow)
-        {
-            gWaterEdgeProgram.addPermutation("HAS_SUN_SHADOW", "1");
-        }
-        gWaterEdgeProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-        gWaterEdgeProgram.mShaderLevel = mShaderLevel[SHADER_WATER];
-        success = gWaterEdgeProgram.createShader();
-        llassert(success);
-    }
-
     if (success)
     {
         //load under water vertex shader
@@ -2484,6 +2453,7 @@ bool LLViewerShaderMgr::loadShadersDeferred()
         gDeferredPostTonemapProgram.mName = "Deferred Tonemap Post Process";
         gDeferredPostTonemapProgram.mFeatures.hasSrgb = true;
         gDeferredPostTonemapProgram.mFeatures.isDeferred = true;
+        gDeferredPostTonemapProgram.mFeatures.hasTonemap = true;
         gDeferredPostTonemapProgram.mShaderFiles.clear();
         gDeferredPostTonemapProgram.clearPermutations();
         gDeferredPostTonemapProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
@@ -2498,6 +2468,7 @@ bool LLViewerShaderMgr::loadShadersDeferred()
         gNoPostTonemapProgram.mName = "No Post Tonemap Post Process";
         gNoPostTonemapProgram.mFeatures.hasSrgb = true;
         gNoPostTonemapProgram.mFeatures.isDeferred = true;
+        gNoPostTonemapProgram.mFeatures.hasTonemap = true;
         gNoPostTonemapProgram.mShaderFiles.clear();
         gNoPostTonemapProgram.clearPermutations();
         gNoPostTonemapProgram.addPermutation("NO_POST", "1");
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index 6326de9a6b..7ad2da9464 100644
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -192,7 +192,6 @@ extern LLGLSLShader     gObjectAlphaMaskNoColorProgram;
 
 //environment shaders
 extern LLGLSLShader         gWaterProgram;
-extern LLGLSLShader         gWaterEdgeProgram;
 extern LLGLSLShader         gUnderWaterProgram;
 extern LLGLSLShader         gGlowProgram;
 extern LLGLSLShader         gGlowExtractProgram;

From e708d69fb09963c4829dc6cd095b3e174e268b60 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Tue, 11 Feb 2025 22:57:53 +0200
Subject: [PATCH 13/29] #3332 Fix buffers not accounting for dynamic cache
 values

And fix previous lapse of judgement with GLYPH_BATCH_SIZE
---
 indra/llrender/llfontbitmapcache.cpp  |  4 ++--
 indra/llrender/llfontfreetype.h       |  1 +
 indra/llrender/llfontgl.cpp           | 26 +++++++++++++++++++-------
 indra/llrender/llfontgl.h             |  1 +
 indra/llrender/llfontvertexbuffer.cpp |  4 +++-
 indra/llrender/llfontvertexbuffer.h   |  4 ++++
 6 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/indra/llrender/llfontbitmapcache.cpp b/indra/llrender/llfontbitmapcache.cpp
index ee9cfd0719..83f5d31186 100644
--- a/indra/llrender/llfontbitmapcache.cpp
+++ b/indra/llrender/llfontbitmapcache.cpp
@@ -107,7 +107,7 @@ bool LLFontBitmapCache::nextOpenPos(S32 width, S32& pos_x, S32& pos_y, EFontGlyp
             mBitmapHeight = image_height;
 
             S32 num_components = getNumComponents(bitmap_type);
-            mImageRawVec[bitmap_idx].push_back(new LLImageRaw(mBitmapWidth, mBitmapHeight, num_components));
+            mImageRawVec[bitmap_idx].emplace_back(new LLImageRaw(mBitmapWidth, mBitmapHeight, num_components));
             bitmap_num = static_cast<U32>(mImageRawVec[bitmap_idx].size()) - 1;
 
             LLImageRaw* image_raw = getImageRaw(bitmap_type, bitmap_num);
@@ -117,7 +117,7 @@ bool LLFontBitmapCache::nextOpenPos(S32 width, S32& pos_x, S32& pos_y, EFontGlyp
             }
 
             // Make corresponding GL image.
-            mImageGLVec[bitmap_idx].push_back(new LLImageGL(image_raw, false, false));
+            mImageGLVec[bitmap_idx].emplace_back(new LLImageGL(image_raw, false, false));
             LLImageGL* image_gl = getImageGL(bitmap_type, bitmap_num);
 
             // Start at beginning of the new image.
diff --git a/indra/llrender/llfontfreetype.h b/indra/llrender/llfontfreetype.h
index 1ad795060a..a2d925c5f6 100644
--- a/indra/llrender/llfontfreetype.h
+++ b/indra/llrender/llfontfreetype.h
@@ -148,6 +148,7 @@ class LLFontFreetype : public LLRefCount
 
     void setStyle(U8 style);
     U8 getStyle() const;
+    S32 getAddedGlyphs() const { return mAddGlyphCount; }
 
 private:
     void resetBitmapCache();
diff --git a/indra/llrender/llfontgl.cpp b/indra/llrender/llfontgl.cpp
index 91242f4947..4037c036e5 100644
--- a/indra/llrender/llfontgl.cpp
+++ b/indra/llrender/llfontgl.cpp
@@ -110,6 +110,11 @@ S32 LLFontGL::getNumFaces(const std::string& filename)
     return mFontFreetype->getNumFaces(filename);
 }
 
+S32 LLFontGL::getKnownGlyphCount() const
+{
+    return mFontFreetype ? mFontFreetype->getAddedGlyphs() : 0;
+}
+
 S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, const LLRect& rect, const LLColor4 &color, HAlign halign, VAlign valign, U8 style,
     ShadowType shadow, S32 max_chars, F32* right_x, bool use_ellipses, bool use_color) const
 {
@@ -250,6 +255,10 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
 
     const LLFontBitmapCache* font_bitmap_cache = mFontFreetype->getFontBitmapCache();
 
+    // This looks wrong, value is dynamic.
+    // LLFontBitmapCache::nextOpenPos can alter these values when
+    // new characters get added to cache, which affects whole string.
+    // Todo: Perhaps value should update after symbols were added?
     F32 inv_width = 1.f / font_bitmap_cache->getBitmapWidth();
     F32 inv_height = 1.f / font_bitmap_cache->getBitmapHeight();
 
@@ -271,12 +280,14 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
 
     const LLFontGlyphInfo* next_glyph = NULL;
 
+    // string can have more than one glyph per char (ex: bold or shadow),
+    // make sure that GLYPH_BATCH_SIZE won't end up with half a symbol.
+    // See drawGlyph.
+    // Ex: with shadows it's 6 glyps per char. 30 fits exactly 5 chars.
     static constexpr S32 GLYPH_BATCH_SIZE = 30;
-    // string can have more than one glyph per char, make sure last one can fit
-    static constexpr S32 BUFFER_SIZE = GLYPH_BATCH_SIZE * 2;
-    static thread_local LLVector4a vertices[BUFFER_SIZE * 6];
-    static thread_local LLVector2 uvs[BUFFER_SIZE * 6];
-    static thread_local LLColor4U colors[BUFFER_SIZE * 6];
+    static thread_local LLVector4a vertices[GLYPH_BATCH_SIZE * 6];
+    static thread_local LLVector2 uvs[GLYPH_BATCH_SIZE * 6];
+    static thread_local LLColor4U colors[GLYPH_BATCH_SIZE * 6];
 
     LLColor4U text_color(color);
     // Preserve the transparency to render fading emojis in fading text (e.g.
@@ -321,8 +332,9 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
             LLImageGL* font_image = font_bitmap_cache->getImageGL(bitmap_entry.first, bitmap_entry.second);
             gGL.getTexUnit(0)->bind(font_image);
 
-            // For multi-byte characters just draw each time character changes
-            // Might be overkill and might be better to detect multybyte
+            // For some reason it's not enough to compare by bitmap_entry.
+            // Issue hits emojis, japenese and chinese glyphs, only on first run.
+            // Todo: figure it out, there might be a bug with raw image data.
             last_char = wch;
         }
 
diff --git a/indra/llrender/llfontgl.h b/indra/llrender/llfontgl.h
index 9b63fc7c38..73efc6b1eb 100644
--- a/indra/llrender/llfontgl.h
+++ b/indra/llrender/llfontgl.h
@@ -90,6 +90,7 @@ class LLFontGL
     bool loadFace(const std::string& filename, F32 point_size, const F32 vert_dpi, const F32 horz_dpi, bool is_fallback, S32 face_n);
 
     S32 getNumFaces(const std::string& filename);
+    S32 getKnownGlyphCount() const;
 
     S32 render(const LLWString &text, S32 begin_offset,
                 const LLRect& rect,
diff --git a/indra/llrender/llfontvertexbuffer.cpp b/indra/llrender/llfontvertexbuffer.cpp
index 17b23c420d..b53a841a87 100644
--- a/indra/llrender/llfontvertexbuffer.cpp
+++ b/indra/llrender/llfontvertexbuffer.cpp
@@ -147,7 +147,8 @@ S32 LLFontVertexBuffer::render(
              || mLastVertDPI != LLFontGL::sVertDPI
              || mLastHorizDPI != LLFontGL::sHorizDPI
              || mLastOrigin != LLFontGL::sCurOrigin
-             || mLastResGeneration != LLFontGL::sResolutionGeneration)
+             || mLastResGeneration != LLFontGL::sResolutionGeneration
+             || mLastFontGlyphCount != fontp->getKnownGlyphCount())
     {
         genBuffers(fontp, text, begin_offset, x, y, color, halign, valign,
             style, shadow, max_chars, max_pixels, right_x, use_ellipses, use_color);
@@ -203,6 +204,7 @@ void LLFontVertexBuffer::genBuffers(
     mLastHorizDPI = LLFontGL::sHorizDPI;
     mLastOrigin = LLFontGL::sCurOrigin;
     mLastResGeneration = LLFontGL::sResolutionGeneration;
+    mLastFontGlyphCount = fontp->getKnownGlyphCount();
 
     if (right_x)
     {
diff --git a/indra/llrender/llfontvertexbuffer.h b/indra/llrender/llfontvertexbuffer.h
index f244e7fefa..d5e1280dbf 100644
--- a/indra/llrender/llfontvertexbuffer.h
+++ b/indra/llrender/llfontvertexbuffer.h
@@ -120,6 +120,10 @@ class LLFontVertexBuffer
     S32 mLastResGeneration = 0;
     LLCoordGL mLastOrigin;
 
+    // Adding new characters to bitmap cache can alter value from getBitmapWidth();
+    // which alters whole string. So rerender when new characters were added to cache.
+    S32 mLastFontGlyphCount = 0;
+
     static bool sEnableBufferCollection;
 };
 

From 09c60de43c7f6a43607ab9ce3937071d1706830d Mon Sep 17 00:00:00 2001
From: Maxim Nikolenko <maximnproductengine@lindenlab.com>
Date: Wed, 12 Feb 2025 17:09:44 +0200
Subject: [PATCH 14/29] #3210 Fix for "Texture will be downscaled" log message
 happening too often

---
 indra/newview/llviewertexturelist.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 0c186c0ed2..12543089c9 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -1081,7 +1081,8 @@ F32 LLViewerTextureList::updateImagesCreateTextures(F32 max_time)
         imagep->mCreatePending = false;
         mCreateTextureList.pop();
 
-        if (imagep->hasGLTexture() && imagep->getDiscardLevel() < imagep->getDesiredDiscardLevel())
+        if (imagep->hasGLTexture() && imagep->getDiscardLevel() < imagep->getDesiredDiscardLevel() &&
+           (imagep->getDesiredDiscardLevel() <= MAX_DISCARD_LEVEL))
         {
             // NOTE: this may happen if the desired discard reduces while a decode is in progress and does not
             // necessarily indicate a problem, but if log occurrences excede that of dsiplay_stats: FPS,

From bec382698b4fd4bf3e1ad7673cfd4770ebebdd9b Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Wed, 12 Feb 2025 14:21:18 +0200
Subject: [PATCH 15/29] viewer-private#395 Fix voice not reconnecting

---
 indra/newview/llvoicevivox.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/indra/newview/llvoicevivox.cpp b/indra/newview/llvoicevivox.cpp
index 7d6ad743bd..8792ae3285 100644
--- a/indra/newview/llvoicevivox.cpp
+++ b/indra/newview/llvoicevivox.cpp
@@ -2004,7 +2004,7 @@ bool LLVivoxVoiceClient::waitForChannel()
             {
                 recordingAndPlaybackMode();
             }
-            else if (mProcessChannels && (mNextAudioSession == NULL) && checkParcelChanged())
+            else if (mProcessChannels && ((mNextAudioSession == NULL) || checkParcelChanged()))
             {
                 // the parcel is changed, or we have no pending audio sessions,
                 // so try to request the parcel voice info

From 646d0779bd81feefbcf64fc9e8f129b94ce91117 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Wed, 12 Feb 2025 18:29:42 +0200
Subject: [PATCH 16/29] viewer-private#396 Use benefits for picks count

---
 indra/newview/llagentpicksinfo.cpp | 12 +++++++++---
 indra/newview/llagentpicksinfo.h   | 12 +++---------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/indra/newview/llagentpicksinfo.cpp b/indra/newview/llagentpicksinfo.cpp
index e2a2d2d8a9..265e4060ff 100644
--- a/indra/newview/llagentpicksinfo.cpp
+++ b/indra/newview/llagentpicksinfo.cpp
@@ -28,6 +28,7 @@
 #include "llagentpicksinfo.h"
 
 #include "llagent.h"
+#include "llagentbenefits.h"
 #include "llavatarpropertiesprocessor.h"
 
 const S32 MAX_AVATAR_PICKS = 10;
@@ -85,10 +86,9 @@ class LLAgentPicksInfo::LLAgentPicksObserver : public LLAvatarPropertiesObserver
 
 LLAgentPicksInfo::LLAgentPicksInfo()
  : mAgentPicksObserver(NULL)
- , mMaxNumberOfPicks(MAX_AVATAR_PICKS)
  // Disable Pick creation until we get number of Picks from server - in case
  // avatar has maximum number of Picks.
- , mNumberOfPicks(mMaxNumberOfPicks)
+ , mNumberOfPicks(S32_MAX)
 {
 }
 
@@ -110,7 +110,13 @@ void LLAgentPicksInfo::requestNumberOfPicks()
     mAgentPicksObserver->sendAgentPicksRequest();
 }
 
-bool LLAgentPicksInfo::isPickLimitReached()
+// static
+S32 LLAgentPicksInfo::getMaxNumberOfPicks()
+{
+    return LLAgentBenefitsMgr::current().getPicksLimit();
+}
+
+bool LLAgentPicksInfo::isPickLimitReached() const
 {
     return getNumberOfPicks() >= getMaxNumberOfPicks();
 }
diff --git a/indra/newview/llagentpicksinfo.h b/indra/newview/llagentpicksinfo.h
index 9bc105a655..3514ade65d 100644
--- a/indra/newview/llagentpicksinfo.h
+++ b/indra/newview/llagentpicksinfo.h
@@ -52,17 +52,17 @@ class LLAgentPicksInfo : public LLSingleton<LLAgentPicksInfo>
     /**
      * Returns number of Picks.
      */
-    S32 getNumberOfPicks() { return mNumberOfPicks; }
+    S32 getNumberOfPicks() const { return mNumberOfPicks; }
 
     /**
      * Returns maximum number of Picks.
      */
-    S32 getMaxNumberOfPicks() { return mMaxNumberOfPicks; }
+    static S32 getMaxNumberOfPicks();
 
     /**
      * Returns true if Agent has maximum allowed number of Picks.
      */
-    bool isPickLimitReached();
+    bool isPickLimitReached() const;
 
     /**
      * After creating or deleting a Pick we can assume operation on server will be
@@ -83,15 +83,9 @@ class LLAgentPicksInfo : public LLSingleton<LLAgentPicksInfo>
     */
     void setNumberOfPicks(S32 number) { mNumberOfPicks = number; }
 
-    /**
-    * Sets maximum number of Picks.
-    */
-    void setMaxNumberOfPicks(S32 max_picks) { mMaxNumberOfPicks = max_picks; }
-
 private:
 
     LLAgentPicksObserver* mAgentPicksObserver;
-    S32 mMaxNumberOfPicks;
     S32 mNumberOfPicks;
 };
 

From 0679cbdec89fbd3ec470768bdf469f6a1d326859 Mon Sep 17 00:00:00 2001
From: Maxim Nikolenko <maximnproductengine@lindenlab.com>
Date: Thu, 13 Feb 2025 16:10:49 +0200
Subject: [PATCH 17/29] viewer-private#394 Ensure correct item id is used on
 mac

---
 indra/newview/llinventorypanel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/indra/newview/llinventorypanel.cpp b/indra/newview/llinventorypanel.cpp
index 5066a7da7f..5a067ba454 100644
--- a/indra/newview/llinventorypanel.cpp
+++ b/indra/newview/llinventorypanel.cpp
@@ -579,7 +579,7 @@ void LLInventoryPanel::itemChanged(const LLUUID& item_id, U32 mask, const LLInve
     {
         if (model_item && view_item && viewmodel_item)
         {
-            const LLUUID& idp = viewmodel_item->getUUID();
+            const LLUUID idp = viewmodel_item->getUUID();
             view_item->destroyView();
             removeItemID(idp);
         }

From ddbe1ff98159e5eae3153067e3ca6f90c10bceb4 Mon Sep 17 00:00:00 2001
From: Andrey Lihatskiy <alihatskiy@productengine.com>
Date: Thu, 13 Feb 2025 16:13:50 +0200
Subject: [PATCH 18/29] Fix xcode16 build errors

---
 indra/llcommon/fsyspath.h                 |  6 +++++-
 indra/llcommon/llqueuedthread.cpp         |  4 ++--
 indra/llrender/llfontfreetype.cpp         |  2 +-
 indra/llrender/llimagegl.cpp              |  2 +-
 indra/llwindow/llwindowmacosx.cpp         |  8 ++++----
 indra/newview/gltfscenemanager.cpp        |  2 +-
 indra/newview/llmeshrepository.cpp        |  6 +++---
 indra/newview/llmeshrepository.h          |  4 ++--
 indra/newview/llpanelemojicomplete.cpp    |  2 +-
 indra/newview/lltexturefetch.cpp          | 18 ++++++++++--------
 indra/newview/llviewermedia.cpp           |  4 ++--
 indra/newview/llviewerwindow.cpp          |  2 +-
 indra/newview/llvoicewebrtc.cpp           | 20 ++++++++++----------
 indra/viewer_components/login/lllogin.cpp |  2 +-
 14 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/indra/llcommon/fsyspath.h b/indra/llcommon/fsyspath.h
index 1b4aec09b4..e9c96edce3 100644
--- a/indra/llcommon/fsyspath.h
+++ b/indra/llcommon/fsyspath.h
@@ -68,7 +68,11 @@ class fsyspath: public std::filesystem::path
     }
 
     // shadow base-class string() method with UTF-8 aware method
-    std::string string() const { return super::u8string(); }
+    std::string string() const
+    {
+        auto u8 = super::u8string();
+        return std::string(u8.begin(), u8.end());
+    }
     // On Posix systems, where value_type is already char, this operator
     // std::string() method shadows the base class operator string_type()
     // method. But on Windows, where value_type is wchar_t, the base class
diff --git a/indra/llcommon/llqueuedthread.cpp b/indra/llcommon/llqueuedthread.cpp
index 1c4ac5a7bf..0196a24b18 100644
--- a/indra/llcommon/llqueuedthread.cpp
+++ b/indra/llcommon/llqueuedthread.cpp
@@ -146,7 +146,7 @@ size_t LLQueuedThread::updateQueue(F32 max_time_ms)
         // schedule a call to threadedUpdate for every call to updateQueue
         if (!isQuitting())
         {
-            mRequestQueue.post([=]()
+            mRequestQueue.post([=, this]()
                 {
                     LL_PROFILE_ZONE_NAMED_CATEGORY_THREAD("qt - update");
                     mIdleThread = false;
@@ -474,7 +474,7 @@ void LLQueuedThread::processRequest(LLQueuedThread::QueuedRequest* req)
 #else
                 using namespace std::chrono_literals;
                 auto retry_time = LL::WorkQueue::TimePoint::clock::now() + 16ms;
-                mRequestQueue.post([=]
+                mRequestQueue.post([=, this]
                     {
                         LL_PROFILE_ZONE_NAMED("processRequest - retry");
                         if (LL::WorkQueue::TimePoint::clock::now() < retry_time)
diff --git a/indra/llrender/llfontfreetype.cpp b/indra/llrender/llfontfreetype.cpp
index 1f14d82bf1..c8cfe88ec3 100644
--- a/indra/llrender/llfontfreetype.cpp
+++ b/indra/llrender/llfontfreetype.cpp
@@ -715,7 +715,7 @@ void LLFontFreetype::renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index, ll
         if (error == FT_Err_Out_Of_Memory)
         {
             LLError::LLUserWarningMsg::showOutOfMemory();
-            LL_ERRS() << "Out of memory loading glyph for character " << wch << LL_ENDL;
+            LL_ERRS() << "Out of memory loading glyph for character " << static_cast<unsigned int>(wch) << LL_ENDL;
         }
 
         std::string message = llformat(
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index 3858811a50..0bfcb5d9d2 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -1773,7 +1773,7 @@ void LLImageGL::syncToMainThread(LLGLuint new_tex_name)
     ref();
     LL::WorkQueue::postMaybe(
         mMainQueue,
-        [=]()
+        [=, this]()
         {
             LL_PROFILE_ZONE_NAMED("cglt - delete callback");
             syncTexName(new_tex_name);
diff --git a/indra/llwindow/llwindowmacosx.cpp b/indra/llwindow/llwindowmacosx.cpp
index f26d692363..6c3be3eef8 100644
--- a/indra/llwindow/llwindowmacosx.cpp
+++ b/indra/llwindow/llwindowmacosx.cpp
@@ -1060,7 +1060,7 @@ F32 LLWindowMacOSX::getGamma()
         &greenGamma,
         &blueMin,
         &blueMax,
-        &blueGamma) == noErr)
+        &blueGamma) == kCGErrorSuccess)
     {
         // So many choices...
         // Let's just return the green channel gamma for now.
@@ -1111,7 +1111,7 @@ bool LLWindowMacOSX::setGamma(const F32 gamma)
         &greenGamma,
         &blueMin,
         &blueMax,
-        &blueGamma) != noErr)
+        &blueGamma) != kCGErrorSuccess)
     {
         return false;
     }
@@ -1126,7 +1126,7 @@ bool LLWindowMacOSX::setGamma(const F32 gamma)
         gamma,
         blueMin,
         blueMax,
-        gamma) != noErr)
+        gamma) != kCGErrorSuccess)
     {
         return false;
     }
@@ -1178,7 +1178,7 @@ bool LLWindowMacOSX::setCursorPosition(const LLCoordWindow position)
     newPosition.y = screen_pos.mY;
 
     CGSetLocalEventsSuppressionInterval(0.0);
-    if(CGWarpMouseCursorPosition(newPosition) == noErr)
+    if(CGWarpMouseCursorPosition(newPosition) == kCGErrorSuccess)
     {
         result = true;
     }
diff --git a/indra/newview/gltfscenemanager.cpp b/indra/newview/gltfscenemanager.cpp
index 2d6d9a153e..7863d25696 100644
--- a/indra/newview/gltfscenemanager.cpp
+++ b/indra/newview/gltfscenemanager.cpp
@@ -500,7 +500,7 @@ void GLTFSceneManager::update()
             LLNewBufferedResourceUploadInfo::uploadFinish_f finish = [this, buffer](LLUUID assetId, LLSD response)
             {
                 LLAppViewer::instance()->postToMainCoro(
-                    [=]()
+                    [=, this]()
                     {
                         if (mUploadingAsset)
                         {
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index a5bed1dbe6..93453f507c 100644
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -548,8 +548,8 @@ LLViewerFetchedTexture* LLMeshUploadThread::FindViewerTexture(const LLImportMate
     return ppTex ? (*ppTex).get() : NULL;
 }
 
-volatile S32 LLMeshRepoThread::sActiveHeaderRequests = 0;
-volatile S32 LLMeshRepoThread::sActiveLODRequests = 0;
+std::atomic<S32> LLMeshRepoThread::sActiveHeaderRequests = 0;
+std::atomic<S32> LLMeshRepoThread::sActiveLODRequests = 0;
 U32 LLMeshRepoThread::sMaxConcurrentRequests = 1;
 S32 LLMeshRepoThread::sRequestLowWater = REQUEST2_LOW_WATER_MIN;
 S32 LLMeshRepoThread::sRequestHighWater = REQUEST2_HIGH_WATER_MIN;
@@ -3916,7 +3916,7 @@ void LLMeshRepository::notifyLoadedMeshes()
             }
 
             // erase from background thread
-            mThread->mWorkQueue.post([=]()
+            mThread->mWorkQueue.post([=, this]()
                 {
                     mThread->mSkinMap.erase(id);
                 });
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index b5c2424578..3d25a4dd78 100644
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -256,8 +256,8 @@ class LLMeshRepoThread : public LLThread
 {
 public:
 
-    volatile static S32 sActiveHeaderRequests;
-    volatile static S32 sActiveLODRequests;
+    static std::atomic<S32> sActiveHeaderRequests;
+    static std::atomic<S32> sActiveLODRequests;
     static U32 sMaxConcurrentRequests;
     static S32 sRequestLowWater;
     static S32 sRequestHighWater;
diff --git a/indra/newview/llpanelemojicomplete.cpp b/indra/newview/llpanelemojicomplete.cpp
index cb89a5910e..fc1bf6ca93 100644
--- a/indra/newview/llpanelemojicomplete.cpp
+++ b/indra/newview/llpanelemojicomplete.cpp
@@ -438,7 +438,7 @@ void LLPanelEmojiComplete::updateConstraints()
 {
     mRenderRect = getLocalRect();
 
-    mEmojiWidth = (U16)(mIconFont->getWidthF32(u8"\U0001F431") + mPadding * 2);
+    mEmojiWidth = (U16)(mIconFont->getWidthF32(LLWString(1, 0x1F431).c_str()) + mPadding * 2);
     if (mVertical)
     {
         mEmojiHeight = mIconFont->getLineHeight() + mPadding * 2;
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index bac0c736b1..087761cbd0 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -29,6 +29,7 @@
 #include <iostream>
 #include <map>
 #include <algorithm>
+#include <atomic>
 
 #include "lltexturefetch.h"
 
@@ -2843,7 +2844,7 @@ bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level, S3
 bool LLTextureFetch::updateRequestPriority(const LLUUID& id, F32 priority)
 {
     LL_PROFILE_ZONE_SCOPED;
-    mRequestQueue.tryPost([=]()
+    mRequestQueue.tryPost([=, this]()
         {
             LLTextureFetchWorker* worker = getWorker(id);
             if (worker)
@@ -3571,29 +3572,30 @@ TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
     //if (! gViewerAssetStatsThread1)
     //  return true;
 
-    static volatile bool reporting_started(false);
-    static volatile S32 report_sequence(0);
+    static std::atomic<bool> reporting_started(false);
+    static std::atomic<S32> report_sequence(0);
 
     // In mStatsSD, we have a copy we own of the LLSD representation
     // of the asset stats. Add some additional fields and ship it off.
 
     static const S32 metrics_data_version = 2;
 
-    bool initial_report = !reporting_started;
+    bool initial_report = !reporting_started.load();
     mStatsSD["session_id"] = mSessionID;
     mStatsSD["agent_id"] = mAgentID;
     mStatsSD["message"] = "ViewerAssetMetrics";
-    mStatsSD["sequence"] = report_sequence;
+    mStatsSD["sequence"] = report_sequence.load();
     mStatsSD["initial"] = initial_report;
     mStatsSD["version"] = metrics_data_version;
     mStatsSD["break"] = static_cast<bool>(LLTextureFetch::svMetricsDataBreak);
 
     // Update sequence number
-    if (S32_MAX == ++report_sequence)
+    if (S32_MAX == report_sequence.fetch_add(1))
     {
-        report_sequence = 0;
+        report_sequence.store(0);
     }
-    reporting_started = true;
+
+    reporting_started.store(true);
 
     // Limit the size of the stats report if necessary.
 
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index 4e7416bb63..d688d5930c 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -2902,14 +2902,14 @@ void LLViewerMediaImpl::update()
             media_tex->ref();
             main_queue->postTo(
                 mTexUpdateQueue, // Worker thread queue
-                [=]() // work done on update worker thread
+                [=, this]() // work done on update worker thread
                 {
 #if LL_IMAGEGL_THREAD_CHECK
                     media_tex->getGLTexture()->mActiveThread = LLThread::currentID();
 #endif
                     doMediaTexUpdate(media_tex, data, data_width, data_height, x_pos, y_pos, width, height, true);
                 },
-                [=]() // callback to main thread
+                [=, this]() // callback to main thread
                 {
 #if LL_IMAGEGL_THREAD_CHECK
                     media_tex->getGLTexture()->mActiveThread = LLThread::currentID();
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 5a7d507b74..1795d62adc 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -1331,7 +1331,7 @@ LLWindowCallbacks::DragNDropResult LLViewerWindow::handleDragNDrop( LLWindow *wi
                                 // Check the whitelist, if there's media (otherwise just show it)
                                 if (te->getMediaData() == NULL || te->getMediaData()->checkCandidateUrl(url))
                                 {
-                                    if ( obj != mDragHoveredObject)
+                                    if ( obj != mDragHoveredObject.get())
                                     {
                                         // Highlight the dragged object
                                         LLSelectMgr::getInstance()->unhighlightObjectOnly(mDragHoveredObject);
diff --git a/indra/newview/llvoicewebrtc.cpp b/indra/newview/llvoicewebrtc.cpp
index 0bb65f7431..93c217a7ba 100644
--- a/indra/newview/llvoicewebrtc.cpp
+++ b/indra/newview/llvoicewebrtc.cpp
@@ -556,7 +556,7 @@ void LLWebRTCVoiceClient::voiceConnectionCoro()
                 }
             }
             LL::WorkQueue::postMaybe(mMainQueue,
-                [=] {
+                [=, this] {
                     if  (sShuttingDown)
                     {
                         return;
@@ -674,7 +674,7 @@ void LLWebRTCVoiceClient::OnDevicesChanged(const llwebrtc::LLWebRTCVoiceDeviceLi
 {
 
     LL::WorkQueue::postMaybe(mMainQueue,
-                             [=]
+                             [=, this]
         {
             OnDevicesChangedImpl(render_devices, capture_devices);
         });
@@ -2211,7 +2211,7 @@ LLVoiceWebRTCConnection::~LLVoiceWebRTCConnection()
 void LLVoiceWebRTCConnection::OnIceGatheringState(llwebrtc::LLWebRTCSignalingObserver::EIceGatheringState state)
 {
     LL::WorkQueue::postMaybe(mMainQueue,
-        [=] {
+        [=, this] {
             LL_DEBUGS("Voice") << "Ice Gathering voice account. " << state << LL_ENDL;
 
             switch (state)
@@ -2234,7 +2234,7 @@ void LLVoiceWebRTCConnection::OnIceGatheringState(llwebrtc::LLWebRTCSignalingObs
 // callback from llwebrtc
 void LLVoiceWebRTCConnection::OnIceCandidate(const llwebrtc::LLWebRTCIceCandidate& candidate)
 {
-    LL::WorkQueue::postMaybe(mMainQueue, [=] { mIceCandidates.push_back(candidate); });
+    LL::WorkQueue::postMaybe(mMainQueue, [=, this] { mIceCandidates.push_back(candidate); });
 }
 
 void LLVoiceWebRTCConnection::processIceUpdates()
@@ -2352,7 +2352,7 @@ void LLVoiceWebRTCConnection::processIceUpdatesCoro(connectionPtr_t connection)
 void LLVoiceWebRTCConnection::OnOfferAvailable(const std::string &sdp)
 {
     LL::WorkQueue::postMaybe(mMainQueue,
-        [=] {
+        [=, this] {
             if (mShutDown)
             {
                 return;
@@ -2379,7 +2379,7 @@ void LLVoiceWebRTCConnection::OnOfferAvailable(const std::string &sdp)
 void LLVoiceWebRTCConnection::OnAudioEstablished(llwebrtc::LLWebRTCAudioInterface* audio_interface)
 {
     LL::WorkQueue::postMaybe(mMainQueue,
-        [=] {
+        [=, this] {
             if (mShutDown)
             {
                 return;
@@ -2401,7 +2401,7 @@ void LLVoiceWebRTCConnection::OnAudioEstablished(llwebrtc::LLWebRTCAudioInterfac
 void LLVoiceWebRTCConnection::OnRenegotiationNeeded()
 {
     LL::WorkQueue::postMaybe(mMainQueue,
-        [=] {
+        [=, this] {
             LL_DEBUGS("Voice") << "Voice channel requires renegotiation." << LL_ENDL;
             if (!mShutDown)
             {
@@ -2415,7 +2415,7 @@ void LLVoiceWebRTCConnection::OnRenegotiationNeeded()
 void LLVoiceWebRTCConnection::OnPeerConnectionClosed()
 {
     LL::WorkQueue::postMaybe(mMainQueue,
-        [=] {
+        [=, this] {
             LL_DEBUGS("Voice") << "Peer connection has closed." << LL_ENDL;
             if (mVoiceConnectionState == VOICE_STATE_WAIT_FOR_CLOSE)
             {
@@ -2888,7 +2888,7 @@ bool LLVoiceWebRTCConnection::connectionStateMachine()
 // llwebrtc callback
 void LLVoiceWebRTCConnection::OnDataReceived(const std::string& data, bool binary)
 {
-    LL::WorkQueue::postMaybe(mMainQueue, [=] { LLVoiceWebRTCConnection::OnDataReceivedImpl(data, binary); });
+    LL::WorkQueue::postMaybe(mMainQueue, [=, this] { LLVoiceWebRTCConnection::OnDataReceivedImpl(data, binary); });
 }
 
 //
@@ -3044,7 +3044,7 @@ void LLVoiceWebRTCConnection::OnDataReceivedImpl(const std::string &data, bool b
 void LLVoiceWebRTCConnection::OnDataChannelReady(llwebrtc::LLWebRTCDataInterface *data_interface)
 {
     LL::WorkQueue::postMaybe(mMainQueue,
-        [=] {
+        [=, this] {
             if (mShutDown)
             {
                 return;
diff --git a/indra/viewer_components/login/lllogin.cpp b/indra/viewer_components/login/lllogin.cpp
index feebecf4cb..425df0e0f9 100644
--- a/indra/viewer_components/login/lllogin.cpp
+++ b/indra/viewer_components/login/lllogin.cpp
@@ -128,7 +128,7 @@ void LLLogin::Impl::connect(const std::string& uri, const LLSD& login_params)
     // Launch a coroutine with our login_() method. Run the coroutine until
     // its first wait; at that point, return here.
     std::string coroname =
-        LLCoros::instance().launch("LLLogin::Impl::login_", [=]() { loginCoro(uri, login_params); });
+        LLCoros::instance().launch("LLLogin::Impl::login_", [=, this]() { loginCoro(uri, login_params); });
 
     LL_DEBUGS("LLLogin") << " connected with uri '" << uri << "', login_params " << login_params << LL_ENDL;
 }

From 34c3eed88ab21bf3c8419a051dfc41853a831ca7 Mon Sep 17 00:00:00 2001
From: Andrey Lihatskiy <alihatskiy@productengine.com>
Date: Thu, 13 Feb 2025 17:40:40 +0200
Subject: [PATCH 19/29] Bump macos runner to os version 15 with xcode 16.1

---
 .github/workflows/build.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index 7d6bcd2bc4..60ad7e8fe5 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -42,7 +42,7 @@ jobs:
     needs: setup
     strategy:
       matrix:
-        runner: [windows-large, macos-12-large]
+        runner: [windows-large, macos-15-xlarge]
         configuration: ${{ fromJSON(needs.setup.outputs.configurations) }}
     runs-on: ${{ matrix.runner }}
     outputs:
@@ -64,7 +64,7 @@ jobs:
       # autobuild-package.xml.
       AUTOBUILD_VCS_INFO: "true"
       AUTOBUILD_VSVER: "170"
-      DEVELOPER_DIR: "/Applications/Xcode_14.0.1.app/Contents/Developer"
+      DEVELOPER_DIR: "/Applications/Xcode_16.1.app/Contents/Developer"
       # Ensure that Linden viewer builds engage Bugsplat.
       BUGSPLAT_DB: ${{ needs.setup.outputs.bugsplat_db }}
       build_coverity: false

From d74b30b4ec3b1974ee0d781fb34b1c9518b9985d Mon Sep 17 00:00:00 2001
From: Andrey Lihatskiy <alihatskiy@productengine.com>
Date: Thu, 13 Feb 2025 17:53:06 +0200
Subject: [PATCH 20/29] Follow-up fixes from develop

---
 indra/CMakeLists.txt              | 5 +++++
 indra/llrender/llfontfreetype.cpp | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/indra/CMakeLists.txt b/indra/CMakeLists.txt
index 422927704a..3170dbc180 100644
--- a/indra/CMakeLists.txt
+++ b/indra/CMakeLists.txt
@@ -29,6 +29,11 @@ else()
   set( USE_AUTOBUILD_3P ON )
 endif()
 
+if (NOT DEFINED CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 20)
+endif()
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 include(Variables)
 include(BuildVersion)
 
diff --git a/indra/llrender/llfontfreetype.cpp b/indra/llrender/llfontfreetype.cpp
index c8cfe88ec3..38dc23d1dc 100644
--- a/indra/llrender/llfontfreetype.cpp
+++ b/indra/llrender/llfontfreetype.cpp
@@ -715,7 +715,7 @@ void LLFontFreetype::renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index, ll
         if (error == FT_Err_Out_Of_Memory)
         {
             LLError::LLUserWarningMsg::showOutOfMemory();
-            LL_ERRS() << "Out of memory loading glyph for character " << static_cast<unsigned int>(wch) << LL_ENDL;
+            LL_ERRS() << "Out of memory loading glyph for character " << llformat("U+%xu", U32(wch)) << LL_ENDL;
         }
 
         std::string message = llformat(

From c60061b504c7d72e627cdf24ba1c9131c4057286 Mon Sep 17 00:00:00 2001
From: "Jonathan \"Geenz\" Goodman" <geenz@lindenlab.com>
Date: Fri, 14 Feb 2025 13:16:35 -0500
Subject: [PATCH 21/29] Switch from GL_RGB16F to GL_R11F_G11F_B10F for probes
 (#3562)

* #3561 Switch from GL_RGB16F to GL_R11F_G11F_B10F for reflection probes to help reduce memory bandwidth and VRAM pressure.
---
 indra/llrender/llcubemaparray.cpp        | 2 +-
 indra/llrender/llimagegl.cpp             | 1 +
 indra/newview/llreflectionmapmanager.cpp | 4 ++--
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/indra/llrender/llcubemaparray.cpp b/indra/llrender/llcubemaparray.cpp
index 635f079581..d0a97dc2c6 100644
--- a/indra/llrender/llcubemaparray.cpp
+++ b/indra/llrender/llcubemaparray.cpp
@@ -127,7 +127,7 @@ void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, bool us
     bind(0);
     free_cur_tex_image();
 
-    U32 format = components == 4 ? GL_RGBA16F : GL_RGB16F;
+    U32 format = components == 4 ? GL_RGBA16F : GL_R11F_G11F_B10F;
     if (!hdr)
     {
         format = components == 4 ? GL_RGBA8 : GL_RGB8;
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index 0bfcb5d9d2..3f8903ca09 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -330,6 +330,7 @@ S32 LLImageGL::dataFormatBits(S32 dataformat)
     case GL_RGB:                                    return 24;
     case GL_SRGB:                                   return 24;
     case GL_RGB8:                                   return 24;
+    case GL_R11F_G11F_B10F:                         return 32;
     case GL_RGBA:                                   return 32;
     case GL_RGBA8:                                  return 32;
     case GL_RGB10_A2:                               return 32;
diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp
index 4760ab376e..9a20977652 100644
--- a/indra/newview/llreflectionmapmanager.cpp
+++ b/indra/newview/llreflectionmapmanager.cpp
@@ -227,7 +227,7 @@ void LLReflectionMapManager::update()
 
     if (!mRenderTarget.isComplete())
     {
-        U32 color_fmt = render_hdr ? GL_RGBA16F : GL_RGBA8;
+        U32 color_fmt = render_hdr ? GL_R11F_G11F_B10F : GL_RGB8;
         U32 targetRes = mProbeResolution * 4; // super sample
         mRenderTarget.allocate(targetRes, targetRes, color_fmt, true);
     }
@@ -240,7 +240,7 @@ void LLReflectionMapManager::update()
         mMipChain.resize(count);
         for (U32 i = 0; i < count; ++i)
         {
-            mMipChain[i].allocate(res, res, render_hdr ? GL_RGB16F : GL_RGB8);
+            mMipChain[i].allocate(res, res, render_hdr ? GL_R11F_G11F_B10F : GL_RGB8);
             res /= 2;
         }
     }

From b0d80552b3177269eb24ef9a1e0d58a98d95a96f Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <117672381+akleshchev@users.noreply.github.com>
Date: Sat, 15 Feb 2025 09:51:22 +0200
Subject: [PATCH 22/29] #2639 GPU test twice to fix misreported bandwidth
 (#3558)

A workaround, hopefully temporary.
First test returns half the throughput, do two tests. May be caused by
driver, may be some 'energy saving', will need to be checked later.
It was working the same way prior to ExtraFPS, but viewer was running
an extra CPU test.
---
 indra/newview/llglsandbox.cpp | 66 +++++++++++++++++++++--------------
 1 file changed, 39 insertions(+), 27 deletions(-)

diff --git a/indra/newview/llglsandbox.cpp b/indra/newview/llglsandbox.cpp
index 112008172e..5484ce6276 100644
--- a/indra/newview/llglsandbox.cpp
+++ b/indra/newview/llglsandbox.cpp
@@ -903,6 +903,39 @@ class ShaderBinder
 };
 
 
+F32 shader_timer_benchmark(std::vector<LLRenderTarget> & dest, TextureHolder & texHolder, U32 textures_count, LLVertexBuffer * buff, F32 &seconds)
+{
+    // run GPU timer benchmark
+
+    //number of samples to take
+    const S32 samples = 64;
+
+    {
+        ShaderProfileHelper initProfile;
+        dest[0].bindTarget();
+        gBenchmarkProgram.bind();
+        for (S32 c = 0; c < samples; ++c)
+        {
+            for (U32 i = 0; i < textures_count; ++i)
+            {
+                texHolder.bind(i);
+                buff->setBuffer();
+                buff->drawArrays(LLRender::TRIANGLES, 0, 3);
+            }
+        }
+        gBenchmarkProgram.unbind();
+        dest[0].flush();
+    }
+
+    F32 ms = gBenchmarkProgram.mTimeElapsed / 1000000.f;
+    seconds = ms / 1000.f;
+
+    F64 samples_drawn = (F64)gBenchmarkProgram.mSamplesDrawn;
+    F64 gpixels_drawn = samples_drawn / 1000000000.0;
+    F32 samples_sec = (F32)(gpixels_drawn / seconds);
+    return samples_sec * 4;  // 4 bytes per sample
+}
+
 //-----------------------------------------------------------------------------
 // gpu_benchmark()
 //  returns measured memory bandwidth of GPU in gigabytes per second
@@ -944,9 +977,6 @@ F32 gpu_benchmark()
     //number of textures
     const U32 count = 32;
 
-    //number of samples to take
-    const S32 samples = 64;
-
     //time limit, allocation operations shouldn't take longer then 30 seconds, same for actual benchmark.
     const F32 time_limit = 30;
 
@@ -1036,33 +1066,15 @@ F32 gpu_benchmark()
 
     LLGLSLShader::unbind();
 
-    // run GPU timer benchmark
-    {
-        ShaderProfileHelper initProfile;
-        dest[0].bindTarget();
-        gBenchmarkProgram.bind();
-        for (S32 c = 0; c < samples; ++c)
-        {
-            for (U32 i = 0; i < count; ++i)
-            {
-                texHolder.bind(i);
-                buff->setBuffer();
-                buff->drawArrays(LLRender::TRIANGLES, 0, 3);
-            }
-        }
-        gBenchmarkProgram.unbind();
-        dest[0].flush();
-    }
+    // run GPU timer benchmark twice
+    F32 seconds = 0;
+    F32 gbps = shader_timer_benchmark(dest, texHolder, count, buff.get(), seconds);
 
-    F32 ms = gBenchmarkProgram.mTimeElapsed/1000000.f;
-    F32 seconds = ms/1000.f;
+    LL_INFOS("Benchmark") << "Memory bandwidth, 1st run is " << llformat("%.3f", gbps) << " GB/sec according to ARB_timer_query, total time " << seconds << " seconds" << LL_ENDL;
 
-    F64 samples_drawn = (F64)gBenchmarkProgram.mSamplesDrawn;
-    F64 gpixels_drawn = samples_drawn / 1000000000.0;
-    F32 samples_sec = (F32)(gpixels_drawn/seconds);
-    F32 gbps = samples_sec*4;  // 4 bytes per sample
+    gbps = shader_timer_benchmark(dest, texHolder, count, buff.get(), seconds);
 
-    LL_INFOS("Benchmark") << "Memory bandwidth is " << llformat("%.3f", gbps) << " GB/sec according to ARB_timer_query, total time " << seconds << " seconds" << LL_ENDL;
+    LL_INFOS("Benchmark") << "Memory bandwidth, final run is " << llformat("%.3f", gbps) << " GB/sec according to ARB_timer_query, total time " << seconds << " seconds" << LL_ENDL;
 
     return gbps;
 }

From 9b0c167b84f4f5a1f691ab57270dc30fa58bc800 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Mon, 17 Feb 2025 22:22:37 +0200
Subject: [PATCH 23/29] #3557 Waves not applying without Transparent Water

---
 .../newview/app_settings/shaders/class3/environment/waterF.glsl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/indra/newview/app_settings/shaders/class3/environment/waterF.glsl b/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
index c56e38d016..35b2f8bd10 100644
--- a/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class3/environment/waterF.glsl
@@ -256,7 +256,7 @@ void main()
 #endif
 
     vec3 sunlit_linear = srgb_to_linear(sunlit);
-    float fade = 0;
+    float fade = 1;
 #ifdef TRANSPARENT_WATER
     float depth = texture(depthMap, distort).r;
 

From 8114850e947f2a76e54912524722c48f22851228 Mon Sep 17 00:00:00 2001
From: Maxim Nikolenko <maximnproductengine@lindenlab.com>
Date: Tue, 18 Feb 2025 11:33:32 +0200
Subject: [PATCH 24/29] #3511 fix for PBR skies being too bright on Low
 Graphics

---
 indra/llinventory/llsettingssky.cpp | 3 ++-
 indra/llinventory/llsettingssky.h   | 1 +
 indra/newview/llsettingsvo.cpp      | 4 ++++
 3 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/indra/llinventory/llsettingssky.cpp b/indra/llinventory/llsettingssky.cpp
index be64578d54..ff28c30563 100644
--- a/indra/llinventory/llsettingssky.cpp
+++ b/indra/llinventory/llsettingssky.cpp
@@ -137,7 +137,8 @@ const std::string LLSettingsSky::SETTING_REFLECTION_PROBE_AMBIANCE("reflection_p
 
 const LLUUID LLSettingsSky::DEFAULT_ASSET_ID("651510b8-5f4d-8991-1592-e7eeab2a5a06");
 
-F32 LLSettingsSky::sAutoAdjustProbeAmbiance = 1.f;
+const F32 LLSettingsSky::DEFAULT_AUTO_ADJUST_PROBE_AMBIANCE = 1.f;
+F32 LLSettingsSky::sAutoAdjustProbeAmbiance = DEFAULT_AUTO_ADJUST_PROBE_AMBIANCE;
 
 static const LLUUID DEFAULT_SUN_ID("32bfbcea-24b1-fb9d-1ef9-48a28a63730f"); // dataserver
 static const LLUUID DEFAULT_MOON_ID("d07f6eed-b96a-47cd-b51d-400ad4a1c428"); // dataserver
diff --git a/indra/llinventory/llsettingssky.h b/indra/llinventory/llsettingssky.h
index 801fafff4b..ff75aea549 100644
--- a/indra/llinventory/llsettingssky.h
+++ b/indra/llinventory/llsettingssky.h
@@ -103,6 +103,7 @@ class LLSettingsSky: public LLSettingsBase
 
     static const LLUUID DEFAULT_ASSET_ID;
 
+    static const F32 DEFAULT_AUTO_ADJUST_PROBE_AMBIANCE;
     static F32 sAutoAdjustProbeAmbiance;
 
     typedef PTR_NAMESPACE::shared_ptr<LLSettingsSky> ptr_t;
diff --git a/indra/newview/llsettingsvo.cpp b/indra/newview/llsettingsvo.cpp
index 62df6cd275..6023f6885d 100644
--- a/indra/newview/llsettingsvo.cpp
+++ b/indra/newview/llsettingsvo.cpp
@@ -832,6 +832,10 @@ void LLSettingsVOSky::applySpecial(void *ptarget, bool force)
         {
             shader->uniform3fv(LLShaderMgr::AMBIENT, LLVector3(ambient.mV));
             shader->uniform1f(LLShaderMgr::SKY_HDR_SCALE, sqrtf(g)*2.0f); // use a modifier here so 1.0 maps to the "most desirable" default and the maximum value doesn't go off the rails
+
+            // Low quality setting
+            if (!LLPipeline::sReflectionProbesEnabled)
+                probe_ambiance = DEFAULT_AUTO_ADJUST_PROBE_AMBIANCE;
         }
         else if (psky->canAutoAdjust() && should_auto_adjust)
         { // auto-adjust legacy sky to take advantage of probe ambiance

From 8a527d676e54f90794705f7e9476ae07752892e5 Mon Sep 17 00:00:00 2001
From: minerjr <minerjrminerjr@hotmail.com>
Date: Fri, 21 Feb 2025 09:45:34 -0400
Subject: [PATCH 25/29] Add restore to mBoostLevel (mPrevBoostLevel) for
 BOOST_SELECTED interactions

Added to the llgltexture a second boost level which will be used to properly restore the boost level after an object is right clicked on as the BOOST_SELECTED code does not restore the value the previous value. This does now and on all the child objects assigned to the object.

Also fixed up the lltextureview.cpp as it had some merge issues from a long time ago and was missed.
---
 indra/llrender/llgltexture.cpp    | 16 ++++++++++++++++
 indra/llrender/llgltexture.h      |  8 ++++++++
 indra/newview/lltextureview.cpp   | 14 ++++++++------
 indra/newview/llviewerobject.cpp  | 20 +++++++++++++++++++-
 indra/newview/llviewertexture.cpp |  5 ++++-
 5 files changed, 55 insertions(+), 8 deletions(-)

diff --git a/indra/llrender/llgltexture.cpp b/indra/llrender/llgltexture.cpp
index 87e7400a24..89f2a75002 100644
--- a/indra/llrender/llgltexture.cpp
+++ b/indra/llrender/llgltexture.cpp
@@ -63,6 +63,10 @@ LLGLTexture::~LLGLTexture()
 void LLGLTexture::init()
 {
     mBoostLevel = LLGLTexture::BOOST_NONE;
+    // <FS:minerjr>
+    // Added a previous boost level to allow for restorign boost after BOOST_SELECTED is applied
+    mPrevBoostLevel = LLGLTexture::BOOST_NONE;
+    // </FS:minerjr>
 
     mFullWidth = 0;
     mFullHeight = 0;
@@ -107,6 +111,18 @@ void LLGLTexture::setBoostLevel(S32 level)
     }
 }
 
+// <FS:minerjr>
+// Changes the current boost level to the previous value
+void LLGLTexture::restoreBoostLevel()
+{
+    mBoostLevel = mPrevBoostLevel;
+}
+// Stores the current boost level in a the previous boost.
+void LLGLTexture::storeBoostLevel()
+{
+    mPrevBoostLevel = mBoostLevel;
+}
+// </FS:minerjr>
 void LLGLTexture::forceActive()
 {
     mTextureState = ACTIVE ;
diff --git a/indra/llrender/llgltexture.h b/indra/llrender/llgltexture.h
index 48132fa956..3cf97d5c6b 100644
--- a/indra/llrender/llgltexture.h
+++ b/indra/llrender/llgltexture.h
@@ -101,6 +101,10 @@ class LLGLTexture : public LLTexture
 
     void setBoostLevel(S32 level);
     S32  getBoostLevel() { return mBoostLevel; }
+    // <FS:minerjr>
+    void restoreBoostLevel(); // Now restores the mBoostLevel with the mPrevBoostLevel
+    void storeBoostLevel(); // Stores the current mBoostLevel in mPrevBoostLevel
+    // </FS:minerjr>
 
     S32 getFullWidth() const { return mFullWidth; }
     S32 getFullHeight() const { return mFullHeight; }
@@ -183,6 +187,10 @@ class LLGLTexture : public LLTexture
 
 protected:
     S32 mBoostLevel;                // enum describing priority level
+    // <FS:minerjr>
+    // Added previous value to allow for restoring of BOOST_SELECTED overriding current state
+    S32 mPrevBoostLevel;            // enum describing priority level (Previous Value for BOOST_SELECTION restore)
+    // </FS:minerjr>
     U32 mFullWidth;
     U32 mFullHeight;
     bool mUseMipMaps;
diff --git a/indra/newview/lltextureview.cpp b/indra/newview/lltextureview.cpp
index 47e5cd1053..26627e6ce4 100644
--- a/indra/newview/lltextureview.cpp
+++ b/indra/newview/lltextureview.cpp
@@ -711,19 +711,21 @@ void LLGLTexMemBar::draw()
     //text = llformat("Textures: %d Fetch: %d(%d) Pkts:%d(%d) Cache R/W: %d/%d LFS:%d RAW:%d HTP:%d DEC:%d CRE:%d ",
     text = llformat("Tex: %d Fetch: %d(%d) Pkts:%d(%d) CAC R/W: %d/%d LFS:%d RAW:%d HTP:%d DEC:%d CRE:%d FCA:%d ",
     // </FS:Ansariel>
+	// <FS:minerjr> Fixed up the missing variables and converted 64bit size_t's to S32's to allow proper numbers to appear
                     gTextureList.getNumImages(),
                     LLAppViewer::getTextureFetch()->getNumRequests(), LLAppViewer::getTextureFetch()->getNumDeletes(),
+                    LLAppViewer::getTextureFetch()->mPacketCount, LLAppViewer::getTextureFetch()->mBadPacketCount,
                     LLAppViewer::getTextureCache()->getNumReads(), LLAppViewer::getTextureCache()->getNumWrites(),
-                    LLLFSThread::sLocal->getPending(),
-                    LLImageRaw::sRawImageCount,
+                    (S32)LLLFSThread::sLocal->getPending(),
+                    (S32)LLImageRaw::sRawImageCount,
                     LLAppViewer::getTextureFetch()->getNumHTTPRequests(),
-                    LLAppViewer::getImageDecodeThread()->getPending(),
+                    (S32)LLAppViewer::getImageDecodeThread()->getPending(),
                     // <FS:Ansariel> Fast cache stats
                     //gTextureList.mCreateTextureList.size());
-                    gTextureList.mCreateTextureList.size(),
-                    gTextureList.mFastCacheList.size());
+                    (S32)gTextureList.mCreateTextureList.size(),
+                    (S32)gTextureList.mFastCacheList.size());
                     // </FS:Ansariel>
-
+	// </FS:minerjr>
     x_right = 550.0f;
     LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0.f, (F32)(v_offset + line_height*3),
                                              text_color, LLFontGL::LEFT, LLFontGL::TOP,
diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp
index 38b3c5d31e..5f2f5569db 100644
--- a/indra/newview/llviewerobject.cpp
+++ b/indra/newview/llviewerobject.cpp
@@ -4192,6 +4192,14 @@ void LLViewerObject::boostTexturePriority(bool boost_children /* = true */)
     S32 tex_count = getNumTEs();
     for (i = 0; i < tex_count; i++)
     {
+        // <FS:minerjr>
+        // This isused to fix the textures becoming blury when object interacted with by the user and unselected.
+        // If this is changing the boost level for the TEImage for the first time, store the boost level before modifying it.
+        if (getTEImage(i)->getBoostLevel() != LLGLTexture::BOOST_SELECTED)
+        {
+            getTEImage(i)->storeBoostLevel();
+        }
+        // </FS:minerjr>
         getTEImage(i)->setBoostLevel(LLGLTexture::BOOST_SELECTED);
     }
 
@@ -4199,7 +4207,17 @@ void LLViewerObject::boostTexturePriority(bool boost_children /* = true */)
     {
         LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
         LLUUID sculpt_id = sculpt_params->getSculptTexture();
-        LLViewerTextureManager::getFetchedTexture(sculpt_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE)->setBoostLevel(LLGLTexture::BOOST_SELECTED);
+        // <FS:minerjr>        
+        //LLViewerTextureManager::getFetchedTexture(sculpt_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE)->setBoostLevel(LLGLTexture::BOOST_SELECTED);
+        // This isused to fix the textures becoming blury when object interacted with by the user and unselected.
+        // If this is changing the boost level for the sculpted for the first time, store the boost level before modifying it.
+        LLViewerFetchedTexture* sculptedTexture = LLViewerTextureManager::getFetchedTexture(sculpt_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
+        if (sculptedTexture->getBoostLevel() != LLGLTexture::BOOST_SELECTED)
+        {
+            sculptedTexture->storeBoostLevel();
+        }
+        // </FS:minerjr>
+        sculptedTexture->setBoostLevel(LLGLTexture::BOOST_SELECTED);
     }
 
     if (boost_children)
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index 58daf580bc..22f872ec3f 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -3134,7 +3134,10 @@ void LLViewerLODTexture::processTextureStats()
     // unset it immediately after we consume it
     if (getBoostLevel() == BOOST_SELECTED)
     {
-        setBoostLevel(BOOST_NONE);
+        // <FS:minerjr>
+        //setBoostLevel(BOOST_NONE);
+        restoreBoostLevel();
+        // </FS:minerjr>
     }
 }
 

From c121c12f771d2f87e0af3de25a0a036773f134fe Mon Sep 17 00:00:00 2001
From: minerjr <minerjrminerjr@hotmail.com>
Date: Fri, 21 Feb 2025 12:01:54 -0400
Subject: [PATCH 26/29] Fixed fast cache read creating invalid textures
 (1024x1024+ sized)

When saving textures to the fast cache, which only supports 16x16 textures at 4 bytes per pixel, the system will force scale down textures to fit, even beyond the allowed MAX_DISCARD_LEVEL, such as 1024x1024 having Discard = 6 and 2048x2048 texture having Discard = 7 and writing it to the headers.

Updated the readFromFastCache to expand invalid textures to be at the MAX_DISCARD_LEVEL(5) discard instead of at 6, 7 or 8. Scale up the 16x16 textures to match the requirements for the textures at MAX_DISCARD_LEVEL.

Mostly for re-loading after high bias scenario as these can cause crashes in the KDU decoder codebase. Which can possibly lead to deadlocked threads as well as bad textures clogging up the fetch system.

Example Firestorm.log output of the error in action.

2025-02-21T13:47:43Z INFO   LLKDUMessage::put_text : KDU Error: Attempting to access a non-existent resolution level within some tile-component.  Problem almost certainly caused by trying to discard more resolution levels than the number of DWT levels used to compress a tile-component.
Exception thrown at 0x00007FFA77A1BB0A in firestorm-bin.exe: Microsoft C++ exception: boost::wrapexcept<`anonymous namespace'::KDUError> at memory location 0x000000C3985FF470.
2025-02-21T13:47:43Z WARNING   LLTextureFetchWorker::callbackDecoded : DECODE FAILED: 0c699ab7-dd72-bfc9-d695-267e1a3f936a Discard: 6, reason: LLKDUMessageError::flush()
2025-02-21T13:47:43Z WARNING   _ll_apr_warn_status : APR: firestorm\phoenix-firestorm-foreverfps\indra\llcommon\llapr.cpp:651 The system cannot find the file specified.
2025-02-21T13:47:43Z WARNING   LLAPRFile::remove :  Attempting to remove filename: AppData\Local\FirestormOS_x64\texturecache\0\0c699ab7-dd72-bfc9-d695-267e1a3f936a.texture
2025-02-21T13:47:43Z INFO   LLKDUMessage::put_text : KDU Error: Kakadu Core Error:
---
 indra/newview/lltexturecache.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/indra/newview/lltexturecache.cpp b/indra/newview/lltexturecache.cpp
index 7143c19ec9..b633dc4fed 100644
--- a/indra/newview/lltexturecache.cpp
+++ b/indra/newview/lltexturecache.cpp
@@ -2082,6 +2082,28 @@ LLPointer<LLImageRaw> LLTextureCache::readFromFastCache(const LLUUID& id, S32& d
     }
     LLPointer<LLImageRaw> raw = new LLImageRaw(data, head[0], head[1], head[2], true);
 
+    // <FS:minerjr>
+    // This fixes the invalid discard values from being created which cause the decoder code to fail when trying to handle 6 and 7's which are above the MAX_DISCARD_LEVEL of 5
+    // especially on load
+    // We will expand the 16x16 texture to the actual MAX_DISCARD_LEVEL texture size, it may be blurry until the user gets closer but 5 discard value should be objects far from the camera.
+    // So a 1024x1024 texture with a dicard of 6 will become 32x32 and a 2048x2048 texture with a discard of 7 will become a 64x64 texture.
+    if (discardlevel > MAX_DISCARD_LEVEL)
+    {
+        S32 w = head[0]; // Get the current width from the header (16)
+        S32 h = head[1]; // Get the current height from the header (16)
+
+        // Expand the width and height by teh difference between the discard and MAX_DISCARD_LEVEL bit shifted to the left. (Expand power of 2 textures)
+        w <<= MAX_DISCARD_LEVEL - discardlevel;
+        h <<= MAX_DISCARD_LEVEL - discardlevel;
+
+        // Set the discard level to the MAX_DISCARD_LEVEL
+        discardlevel = MAX_DISCARD_LEVEL;
+
+        // Scale up the texture and scale the actual data, as we just created it above, it should be fine.
+        raw->scale(w, h, true);
+    }
+    // </FS:minerjr>
+
     return raw;
 }
 

From 7bd44050a69de084fad51dbe04dc0835c1a9a876 Mon Sep 17 00:00:00 2001
From: minerjr <minerjrminerjr@hotmail.com>
Date: Sat, 22 Feb 2025 00:12:07 -0400
Subject: [PATCH 27/29] FIRE-35081 Blurry prims not changing with graphics
 settings, not happening with SL Viewer

Added new logic in the LLViewerTextureList::updateImageDecodePriority method to better handle the texture quality.

- Apply new rules to bias discard, there are now 2 bias, off-screen and on-screen.
        On-screen Bias
        Only applied to LOD Textures and one that have Discard > 1 (0, 1 protected)

- Off-screen Bias
        Will be using the old method of applying the mMaxVirtualSize, however
        only on LOD textures and fetched textures get bias applied.

         Local (UI & Icons), Media and Dynamic textures should not have any discard applied to them.

Without this, textures will become blurry that are on screen, which is one of the #1 user complaints.

So now, only LOD textures will change on screen, except for Fetched textures when the bias is greater then 2.00.

Also made possible fix for edge case of multiple faces for 1 texture, the last face dictates which happens to the texture. Now any that are in camera will flip signal that it is on screen.

System can be made to be be flexible.

To test out, Go to Preferences->Graphics->Rendering Settings and move the VRAM override to the far left. Then walk around and try to notice if there are any downscaled or blurry textures. To test a blurry object. Right click on it and pick edit. All of the game objects will have a max quality texture applied. Click off and see if the texture on the object changes quality to a blurred mess.
---
 indra/newview/llviewertexturelist.cpp | 123 +++++++++++++++++++++++++-
 1 file changed, 119 insertions(+), 4 deletions(-)

diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 8f6431cee9..91d15d8f8f 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -919,6 +919,26 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
         // convert bias into a vsize scaler
         bias = (F32) llroundf(powf(4, bias - 1.f));
 
+        // <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings, not happening with SL Viewer
+        // Apply new rules to bias discard, there are now 2 bias, off-screen and on-screen.
+        // On-screen Bias
+        // Only applied to LOD Textures and one that have Discard > 1 (0, 1 protected)
+        // 
+        // Off-screen Bias
+        // Will be using the old method of applying the mMaxVirtualSize, however
+        // only on LOD textures and fetched textures get bias applied.
+        // 
+        // Local (UI & Icons), Media and Dynamic textures should not have any discard applied to them.
+        // 
+        // Without this, textures will become blurry that are on screen, which is one of the #1
+        // user complaints.
+
+        // Store a seperate max on screen vsize without bias applied.
+        F32 max_on_screen_vsize = 0.0f;        
+        F32 on_screen_value = 0.0f;
+        F32 importance_to_camera = 0.0f;
+        // </FS:minerjr> [FIRE-35081]
+
         LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
         for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i)
         {
@@ -941,8 +961,11 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
                     }
 
                     F32 vsize = face->getPixelArea();
-
-                    on_screen = face->mInFrustum;
+                    // <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings, not happening with SL Viewer
+                    //on_screen = face->mInFrustum;
+                    bool current_on_screen = face->mInFrustum; // Create a new var to store the current on screen status
+                    on_screen = face->mInFrustum ? true : on_screen; // As we want to keep track of if we have an on screen image perminatly as the last face dictates if it scales or not.
+                    // </FS:minerjr> [FIRE-35081]
 
                     // Scale desired texture resolution higher or lower depending on texture scale
                     //
@@ -958,6 +981,8 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
                     min_scale = llclamp(min_scale * min_scale, texture_scale_min(), texture_scale_max());
                     vsize /= min_scale;
 
+                    // <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings, not happening with SL Viewer
+                    /*
                     // apply bias to offscreen faces all the time, but only to onscreen faces when bias is large
                     if (!face->mInFrustum || LLViewerTexture::sDesiredDiscardBias > 2.f)
                     {
@@ -972,6 +997,37 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
                     }
 
                     max_vsize = llmax(max_vsize, vsize);
+                    */
+                    // Store the vsize before the bias is applied
+                    F32 on_screen_vsize = vsize;
+
+                    // As we calculate both with and with-out bias, by doing this, you can skip the if statement in the middle of
+                    // expensive loop
+                    vsize /= bias;
+
+                    // boost resolution of textures that are important to the camera
+                    static LLCachedControl<F32> texture_camera_boost(gSavedSettings, "TextureCameraBoost", 8.f);
+                    //vsize *= llmax(face->mImportanceToCamera * texture_camera_boost, 1.f);
+                    // Use math to skip having to use a conditaional check
+                    // Bools are stored as 0 false, 1 true, use to cheat
+                    // Lerp instead of doing conditional input
+                    // If the image is import to the camera, even a little then make the on screen true
+                    on_screen = face->mImportanceToCamera > 0.0f ? true : on_screen; // This branching should be optimized away.
+                    importance_to_camera = llmax(face->mImportanceToCamera * texture_camera_boost, 1.f);
+                    on_screen_value = F32(current_on_screen);
+
+                    vsize = lerp(vsize, vsize * importance_to_camera, on_screen_value);
+
+                    // Apply the mImportanceToCamera to the on screen vsize
+                    // Bools are stored as 0 false, 1 true, use to cheat
+                    // Perform a LERP on the value between the on screen vsize and the importance * on screen vsize                    
+                    on_screen_vsize = lerp(on_screen_vsize, on_screen_vsize * importance_to_camera, on_screen_value);
+
+                    max_vsize = llmax(max_vsize, vsize);
+                    // <FS:minerjr>
+                    // Update the max on screen vsize based upon the on screen vsize
+                    max_on_screen_vsize = llmax(max_on_screen_vsize, on_screen_vsize);                    
+                    // </FS:minerjr> [FIRE-35081]
                 }
             }
         }
@@ -992,9 +1048,68 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
             {
                 imagep->mMaxVirtualSize = 0.f;
             }
+        }        
+        // <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings, not happening with SL Viewer        
+        //imagep->addTextureStats(max_vsize);
+        // Recaluclate the
+        on_screen_value = F32(on_screen);
+        // New logic block for the bias system
+        // Switch on the type of texture first
+        switch(imagep->getType())
+        {
+            // All dynamic or local textures block
+            case LLViewerTexture::DYNAMIC_TEXTURE:
+            case LLViewerTexture::LOCAL_TEXTURE:
+            case LLViewerTexture::MEDIA_TEXTURE:
+            {
+                // Only apply the max on screen virtual size to textures that should not be scaled
+                imagep->addTextureStats(max_on_screen_vsize);
+                break;
+            }
+            
+            // Fetched Textures (Non LOD normal textures)
+            case LLViewerTexture::FETCHED_TEXTURE:
+            {
+                // Only apply the bias when off screen, otherwise use the non bias caculated value
+                imagep->addTextureStats(lerp(max_vsize, max_on_screen_vsize, on_screen_value));
+                break;
+            }
+            // Handle the LOD texture
+            case LLViewerTexture::LOD_TEXTURE:            
+            {
+                // Switch on the get discard level
+                switch(imagep->getDiscardLevel())
+                {
+                    // We want the 2 best quality discards to always be good quality
+                    case 0:
+                    case 1:
+                    {
+                        // If the texture is really in screen, use the max on screen virtual size, otherwise the max virtual size (off-screen) use the Lerp to
+                        // instead of if statement
+                        imagep->addTextureStats(lerp(max_vsize, max_on_screen_vsize, on_screen_value));                       
+                        break;
+                    }
+                    // All other discard levels (2 to MAX_DISCARD_LEVEL)
+                    default:
+                    {
+                        // If the discard level is between 1 and 2
+                        if (LLViewerTexture::sDesiredDiscardBias >= 1.0f && LLViewerTexture::sDesiredDiscardBias < 2.0f)
+                        {
+                            // Only apply the bias when off screen, otherwise use the non bias caculated value
+                            imagep->addTextureStats(lerp(max_vsize, max_on_screen_vsize, on_screen_value));
+                        }
+                        else
+                        {
+                            // Apply the off screen texture max virtual size
+                            imagep->addTextureStats(max_vsize);
+                        }
+                        break;
+                    }
+                }
+                break;
+            }
         }
-
-        imagep->addTextureStats(max_vsize);
+        // </FS:minerjr> [FIRE-35081]
     }
 
 #if 0

From 6a4ec7a0b451edebeefd7b7635cd21149499b81b Mon Sep 17 00:00:00 2001
From: minerjr <minerjrminerjr@hotmail.com>
Date: Sat, 22 Feb 2025 10:46:40 -0400
Subject: [PATCH 28/29] FIRE-35081 - Updated logic

Cleaned up the logic to be 1, cleaner and 2, more performant.
Moved allocations outside the loop as well as the static texture_camera_boost setup as it should be only done once and not every time a face is on screen.
Cleaned up switch statements into couple of if statements as switch logic would be only good if only 1 level to be used.
---
 indra/newview/llviewertexturelist.cpp | 149 ++++++++++----------------
 1 file changed, 59 insertions(+), 90 deletions(-)

diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 91d15d8f8f..c1c26be210 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -917,9 +917,11 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
         F32 bias = llclamp(max_discard - 2.f, 1.f, LLViewerTexture::sDesiredDiscardBias);
 
         // convert bias into a vsize scaler
-        bias = (F32) llroundf(powf(4, bias - 1.f));
-
         // <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings, not happening with SL Viewer
+        //bias = (F32) llroundf(powf(4, bias - 1.f));
+        // Pre-divied the bias so you can just use multiiply in the loop
+        bias = (F32) 1.0f / llroundf(powf(4, bias - 1.f));
+
         // Apply new rules to bias discard, there are now 2 bias, off-screen and on-screen.
         // On-screen Bias
         // Only applied to LOD Textures and one that have Discard > 1 (0, 1 protected)
@@ -934,11 +936,19 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
         // user complaints.
 
         // Store a seperate max on screen vsize without bias applied.
-        F32 max_on_screen_vsize = 0.0f;        
-        F32 on_screen_value = 0.0f;
+        F32 max_on_screen_vsize = 0.0f;
         F32 importance_to_camera = 0.0f;
+        S32 on_screen_count = 0;
+        // Moved all the variables outside of the loop
+        bool current_on_screen = false;
+        F32 radius; // Moved outside the loop to save reallocation every loop
+        F32 cos_angle_to_view_dir; // Moved outside the loop to save reallocation every loop
+        F32 vsize = 0.0f; // Moved outside the loop to save reallocation every loop
+        F32 important_to_camera = 0.0f;
         // </FS:minerjr> [FIRE-35081]
-
+        // boost resolution of textures that are important to the camera
+        // Can instead of using max for a min of 1.0, just subtract 1 from the boost and just do a 1 + (TextureCameraBoost - 1) * importanceToCamera)
+        static LLCachedControl<F32> texture_camera_boost(gSavedSettings, "TextureCameraBoost", 7.f); 
         LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
         for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i)
         {
@@ -949,8 +959,11 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
                 if (face && face->getViewerObject())
                 {
                     ++face_count;
-                    F32 radius;
-                    F32 cos_angle_to_view_dir;
+                    // <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings, not happening with SL Viewer
+                    // Moved outside the loop to stop createing new memory every loop
+                    //F32 radius;
+                    //F32 cos_angle_to_view_dir;
+                    // </FS:minerjr> [FIRE-35081]
 
                     if ((gFrameCount - face->mLastTextureUpdate) > 10)
                     { // only call calcPixelArea at most once every 10 frames for a given face
@@ -960,11 +973,15 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
                         face->mLastTextureUpdate = gFrameCount;
                     }
 
-                    F32 vsize = face->getPixelArea();
+                    
+                    // Also moved allocation outside the loop
                     // <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings, not happening with SL Viewer
+                    //F32 vsize = face->getPixelArea();
                     //on_screen = face->mInFrustum;
-                    bool current_on_screen = face->mInFrustum; // Create a new var to store the current on screen status
-                    on_screen = face->mInFrustum ? true : on_screen; // As we want to keep track of if we have an on screen image perminatly as the last face dictates if it scales or not.
+                    vsize = face->getPixelArea();
+                    current_on_screen = face->mInFrustum; // Create a new var to store the current on screen status                    
+                    on_screen_count += current_on_screen; // Count the number of on sceen faces instead of using brach
+                    important_to_camera = face->mImportanceToCamera; // Store so we don't have to do 2 indirects later on
                     // </FS:minerjr> [FIRE-35081]
 
                     // Scale desired texture resolution higher or lower depending on texture scale
@@ -998,40 +1015,29 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
 
                     max_vsize = llmax(max_vsize, vsize);
                     */
-                    // Store the vsize before the bias is applied
-                    F32 on_screen_vsize = vsize;
 
-                    // As we calculate both with and with-out bias, by doing this, you can skip the if statement in the middle of
-                    // expensive loop
-                    vsize /= bias;
-
-                    // boost resolution of textures that are important to the camera
-                    static LLCachedControl<F32> texture_camera_boost(gSavedSettings, "TextureCameraBoost", 8.f);
-                    //vsize *= llmax(face->mImportanceToCamera * texture_camera_boost, 1.f);
                     // Use math to skip having to use a conditaional check
                     // Bools are stored as 0 false, 1 true, use to cheat
                     // Lerp instead of doing conditional input
-                    // If the image is import to the camera, even a little then make the on screen true
-                    on_screen = face->mImportanceToCamera > 0.0f ? true : on_screen; // This branching should be optimized away.
-                    importance_to_camera = llmax(face->mImportanceToCamera * texture_camera_boost, 1.f);
-                    on_screen_value = F32(current_on_screen);
-
-                    vsize = lerp(vsize, vsize * importance_to_camera, on_screen_value);
-
-                    // Apply the mImportanceToCamera to the on screen vsize
-                    // Bools are stored as 0 false, 1 true, use to cheat
-                    // Perform a LERP on the value between the on screen vsize and the importance * on screen vsize                    
-                    on_screen_vsize = lerp(on_screen_vsize, on_screen_vsize * importance_to_camera, on_screen_value);
-
-                    max_vsize = llmax(max_vsize, vsize);
-                    // <FS:minerjr>
+                    // If the image is import to the camera, even a little then make the on screen true                    
+                    on_screen_count += S32(important_to_camera * 1000.0f);
+                    importance_to_camera = 1.0f + important_to_camera * texture_camera_boost;// llmax(important_to_camera * texture_camera_boost, 1.f);
+                    vsize = vsize + (vsize * importance_to_camera - vsize) * F32(current_on_screen); //lerp(vsize, vsize * importance_to_camera, F32(current_on_screen));
+                                        
                     // Update the max on screen vsize based upon the on screen vsize
-                    max_on_screen_vsize = llmax(max_on_screen_vsize, on_screen_vsize);                    
+                    max_on_screen_vsize = llmax(max_on_screen_vsize, vsize);
+                    max_vsize = llmax(max_vsize, vsize * bias);
                     // </FS:minerjr> [FIRE-35081]
                 }
             }
         }
 
+        // <FS:minerjr>
+        // Replaced all the checks for this bool to be only in this 1 place instead of in the loop.
+        // If the on screen counter is greater then 0, then there was at least 1 on screen texture
+        on_screen = bool(on_screen_count);
+        // <FS:minerjr>
+
         if (face_count > 1024)
         { // this texture is used in so many places we should just boost it and not bother checking its vsize
             // this is especially important because the above is not time sliced and can hit multiple ms for a single texture
@@ -1048,66 +1054,29 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
             {
                 imagep->mMaxVirtualSize = 0.f;
             }
-        }        
+        }
         // <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings, not happening with SL Viewer        
         //imagep->addTextureStats(max_vsize);
-        // Recaluclate the
-        on_screen_value = F32(on_screen);
         // New logic block for the bias system
-        // Switch on the type of texture first
-        switch(imagep->getType())
+        // Fetched Textures (Non LOD normal textures) Or LOD Textures with a discard level of 0 or 1 or have a Bias < 2.0
+        if (imagep->getType() == LLViewerTexture::FETCHED_TEXTURE || (imagep->getType() == LLViewerTexture::LOD_TEXTURE && (imagep->getDiscardLevel() < 2 || LLViewerTexture::sDesiredDiscardBias < 2.0f)))
         {
-            // All dynamic or local textures block
-            case LLViewerTexture::DYNAMIC_TEXTURE:
-            case LLViewerTexture::LOCAL_TEXTURE:
-            case LLViewerTexture::MEDIA_TEXTURE:
-            {
-                // Only apply the max on screen virtual size to textures that should not be scaled
-                imagep->addTextureStats(max_on_screen_vsize);
-                break;
-            }
-            
-            // Fetched Textures (Non LOD normal textures)
-            case LLViewerTexture::FETCHED_TEXTURE:
-            {
-                // Only apply the bias when off screen, otherwise use the non bias caculated value
-                imagep->addTextureStats(lerp(max_vsize, max_on_screen_vsize, on_screen_value));
-                break;
-            }
-            // Handle the LOD texture
-            case LLViewerTexture::LOD_TEXTURE:            
-            {
-                // Switch on the get discard level
-                switch(imagep->getDiscardLevel())
-                {
-                    // We want the 2 best quality discards to always be good quality
-                    case 0:
-                    case 1:
-                    {
-                        // If the texture is really in screen, use the max on screen virtual size, otherwise the max virtual size (off-screen) use the Lerp to
-                        // instead of if statement
-                        imagep->addTextureStats(lerp(max_vsize, max_on_screen_vsize, on_screen_value));                       
-                        break;
-                    }
-                    // All other discard levels (2 to MAX_DISCARD_LEVEL)
-                    default:
-                    {
-                        // If the discard level is between 1 and 2
-                        if (LLViewerTexture::sDesiredDiscardBias >= 1.0f && LLViewerTexture::sDesiredDiscardBias < 2.0f)
-                        {
-                            // Only apply the bias when off screen, otherwise use the non bias caculated value
-                            imagep->addTextureStats(lerp(max_vsize, max_on_screen_vsize, on_screen_value));
-                        }
-                        else
-                        {
-                            // Apply the off screen texture max virtual size
-                            imagep->addTextureStats(max_vsize);
-                        }
-                        break;
-                    }
-                }
-                break;
-            }
+            // Perform Lerp without function call
+            max_vsize = max_vsize + (max_on_screen_vsize - max_vsize) * F32(on_screen);
+            // Only apply the bias when off screen, otherwise use the non bias caculated value
+            imagep->addTextureStats(max_vsize);
+        }
+        // All other LOD texture textures
+        else if (imagep->getType() == LLViewerTexture::LOD_TEXTURE)
+        {
+            // Apply the off screen texture max virtual size
+            imagep->addTextureStats(max_vsize);
+        }
+        // All dynamic or local textures block
+        else
+        {
+            // Only apply the max on screen virtual size to textures that should not be scaled
+            imagep->addTextureStats(max_on_screen_vsize);
         }
         // </FS:minerjr> [FIRE-35081]
     }

From 097bbc7c26aeb0d9a1a95d793401eec44260e10e Mon Sep 17 00:00:00 2001
From: minerjr <minerjrminerjr@hotmail.com>
Date: Sat, 22 Feb 2025 11:12:36 -0400
Subject: [PATCH 29/29] FIRE-35081 - Updated logic

Updated the math to remove the need to store the variable and use it again
Updated the "TextureCameraBoost" to default to 7, as we add 1 to the value now instead of using max (TextureCameraBoost, 1.0f)
---
 indra/newview/app_settings/settings.xml | 2 +-
 indra/newview/llviewertexturelist.cpp   | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index f790953cb2..759a1fefa6 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -15212,7 +15212,7 @@ Change of this parameter will affect the layout of buttons in notification toast
       <key>Type</key>
       <string>F32</string>
       <key>Value</key>
-      <real>8.0</real>
+      <real>7.0</real>
       <key>Backup</key>
       <integer>0</integer>
     </map>
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index c1c26be210..6376287f20 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -937,7 +937,6 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
 
         // Store a seperate max on screen vsize without bias applied.
         F32 max_on_screen_vsize = 0.0f;
-        F32 importance_to_camera = 0.0f;
         S32 on_screen_count = 0;
         // Moved all the variables outside of the loop
         bool current_on_screen = false;
@@ -1021,8 +1020,7 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
                     // Lerp instead of doing conditional input
                     // If the image is import to the camera, even a little then make the on screen true                    
                     on_screen_count += S32(important_to_camera * 1000.0f);
-                    importance_to_camera = 1.0f + important_to_camera * texture_camera_boost;// llmax(important_to_camera * texture_camera_boost, 1.f);
-                    vsize = vsize + (vsize * importance_to_camera - vsize) * F32(current_on_screen); //lerp(vsize, vsize * importance_to_camera, F32(current_on_screen));
+                    vsize = vsize + (vsize * (1.0f + important_to_camera * texture_camera_boost) - vsize) * F32(current_on_screen);
                                         
                     // Update the max on screen vsize based upon the on screen vsize
                     max_on_screen_vsize = llmax(max_on_screen_vsize, vsize);