From 12303e21c9bfa6a32bef2a6a5f2f5a7978356b50 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Mon, 6 Jan 2025 22:54:59 +0200
Subject: #3347 Crashes in LLFontFreetype::renderGlyph

Try to handle this more gracefully, but primary purpose of this change
is to log wchars in case issue is reproducible.
---
 indra/llrender/llfontfreetype.cpp | 25 +++++++++++++++++++++----
 indra/llrender/llfontfreetype.h   |  2 +-
 2 files changed, 22 insertions(+), 5 deletions(-)

(limited to 'indra/llrender')

diff --git a/indra/llrender/llfontfreetype.cpp b/indra/llrender/llfontfreetype.cpp
index 6128e03fa7..1f14d82bf1 100644
--- a/indra/llrender/llfontfreetype.cpp
+++ b/indra/llrender/llfontfreetype.cpp
@@ -552,7 +552,7 @@ LLFontGlyphInfo* LLFontFreetype::addGlyphFromFont(const LLFontFreetype *fontp, l
         return NULL;
 
     llassert(!mIsFallback);
-    fontp->renderGlyph(requested_glyph_type, glyph_index);
+    fontp->renderGlyph(requested_glyph_type, glyph_index, wch);
 
     EFontGlyphType bitmap_glyph_type = EFontGlyphType::Unspecified;
     switch (fontp->mFTFace->glyph->bitmap.pixel_mode)
@@ -697,7 +697,7 @@ void LLFontFreetype::insertGlyphInfo(llwchar wch, LLFontGlyphInfo* gi) const
     }
 }
 
-void LLFontFreetype::renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index) const
+void LLFontFreetype::renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index, llwchar wch) const
 {
     if (mFTFace == NULL)
         return;
@@ -712,11 +712,28 @@ void LLFontFreetype::renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index) co
     FT_Error error = FT_Load_Glyph(mFTFace, glyph_index, load_flags);
     if (FT_Err_Ok != error)
     {
+        if (error == FT_Err_Out_Of_Memory)
+        {
+            LLError::LLUserWarningMsg::showOutOfMemory();
+            LL_ERRS() << "Out of memory loading glyph for character " << wch << LL_ENDL;
+        }
+
         std::string message = llformat(
-            "Error %d (%s) loading glyph %u: bitmap_type=%u, load_flags=%d",
-            error, FT_Error_String(error), glyph_index, bitmap_type, load_flags);
+            "Error %d (%s) loading wchar %u glyph %u/%u: bitmap_type=%u, load_flags=%d",
+            error, FT_Error_String(error), wch, glyph_index, mFTFace->num_glyphs, bitmap_type, load_flags);
         LL_WARNS_ONCE() << message << LL_ENDL;
         error = FT_Load_Glyph(mFTFace, glyph_index, load_flags ^ FT_LOAD_COLOR);
+        if (FT_Err_Invalid_Outline == error
+            || FT_Err_Invalid_Composite == error
+            || (FT_Err_Ok != error && LLStringOps::isEmoji(wch)))
+        {
+            glyph_index = FT_Get_Char_Index(mFTFace, '?');
+            // if '?' is not present, potentially can use last index, that's supposed to be null glyph
+            if (glyph_index > 0)
+            {
+                error = FT_Load_Glyph(mFTFace, glyph_index, load_flags ^ FT_LOAD_COLOR);
+            }
+        }
         llassert_always_msg(FT_Err_Ok == error, message.c_str());
     }
 
diff --git a/indra/llrender/llfontfreetype.h b/indra/llrender/llfontfreetype.h
index eba89f5def..1ad795060a 100644
--- a/indra/llrender/llfontfreetype.h
+++ b/indra/llrender/llfontfreetype.h
@@ -156,7 +156,7 @@ private:
     bool hasGlyph(llwchar wch) const;       // Has a glyph for this character
     LLFontGlyphInfo* addGlyph(llwchar wch, EFontGlyphType glyph_type) const;        // Add a new character to the font if necessary
     LLFontGlyphInfo* addGlyphFromFont(const LLFontFreetype *fontp, llwchar wch, U32 glyph_index, EFontGlyphType bitmap_type) const; // Add a glyph from this font to the other (returns the glyph_index, 0 if not found)
-    void renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index) const;
+    void renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index, llwchar wch) const;
     void insertGlyphInfo(llwchar wch, LLFontGlyphInfo* gi) const;
 
     std::string mName;
-- 
cgit v1.3


From c883c7f2d97787c8db0050b1cfac9c22cb5e2309 Mon Sep 17 00:00:00 2001
From: Rye <rye@lindenlab.com>
Date: Thu, 9 Jan 2025 20:43:45 -0500
Subject: Drop reflection probes and mirrors to RGBA8 when hdr is disabled to
 minimize vram usage and chance of probe nans (#2558)

---
 indra/llrender/llcubemaparray.cpp        |  6 +++++-
 indra/llrender/llcubemaparray.h          |  2 +-
 indra/newview/llheroprobemanager.cpp     | 10 +++++++---
 indra/newview/llreflectionmapmanager.cpp | 12 ++++++++----
 indra/newview/llviewercontrol.cpp        |  6 ++++--
 5 files changed, 25 insertions(+), 11 deletions(-)

(limited to 'indra/llrender')

diff --git a/indra/llrender/llcubemaparray.cpp b/indra/llrender/llcubemaparray.cpp
index 4f5e13765a..635f079581 100644
--- a/indra/llrender/llcubemaparray.cpp
+++ b/indra/llrender/llcubemaparray.cpp
@@ -109,7 +109,7 @@ LLCubeMapArray::~LLCubeMapArray()
 {
 }
 
-void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, bool use_mips)
+void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, bool use_mips, bool hdr)
 {
     U32 texname = 0;
     mWidth = resolution;
@@ -128,6 +128,10 @@ void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, bool us
     free_cur_tex_image();
 
     U32 format = components == 4 ? GL_RGBA16F : GL_RGB16F;
+    if (!hdr)
+    {
+        format = components == 4 ? GL_RGBA8 : GL_RGB8;
+    }
     U32 mip = 0;
     U32 mip_resolution = resolution;
     while (mip_resolution >= 1)
diff --git a/indra/llrender/llcubemaparray.h b/indra/llrender/llcubemaparray.h
index 675aaaf07c..bfc72a321d 100644
--- a/indra/llrender/llcubemaparray.h
+++ b/indra/llrender/llcubemaparray.h
@@ -52,7 +52,7 @@ public:
     // components - number of components per pixel
     // count - number of cube maps in the array
     // use_mips - if true, mipmaps will be allocated for this cube map array and anisotropic filtering will be used
-    void allocate(U32 res, U32 components, U32 count, bool use_mips = true);
+    void allocate(U32 res, U32 components, U32 count, bool use_mips = true, bool hdr = true);
     void bind(S32 stage);
     void unbind();
 
diff --git a/indra/newview/llheroprobemanager.cpp b/indra/newview/llheroprobemanager.cpp
index ce419498cf..aa6371eff4 100644
--- a/indra/newview/llheroprobemanager.cpp
+++ b/indra/newview/llheroprobemanager.cpp
@@ -89,9 +89,11 @@ void LLHeroProbeManager::update()
 
     initReflectionMaps();
 
+    static LLCachedControl<bool> render_hdr(gSavedSettings, "RenderHDREnabled", true);
+
     if (!mRenderTarget.isComplete())
     {
-        U32 color_fmt = GL_RGBA16F;
+        U32 color_fmt = render_hdr ? GL_RGBA16F : GL_RGBA8;
         mRenderTarget.allocate(mProbeResolution, mProbeResolution, color_fmt, true);
     }
 
@@ -103,7 +105,7 @@ void LLHeroProbeManager::update()
         mMipChain.resize(count);
         for (U32 i = 0; i < count; ++i)
         {
-            mMipChain[i].allocate(res, res, GL_RGBA16F);
+            mMipChain[i].allocate(res, res, render_hdr ? GL_RGBA16F : GL_RGBA8);
             res /= 2;
         }
     }
@@ -537,8 +539,10 @@ void LLHeroProbeManager::initReflectionMaps()
 
         mTexture = new LLCubeMapArray();
 
+        static LLCachedControl<bool> render_hdr(gSavedSettings, "RenderHDREnabled", true);
+
         // store mReflectionProbeCount+2 cube maps, final two cube maps are used for render target and radiance map generation source)
-        mTexture->allocate(mProbeResolution, 3, mReflectionProbeCount + 2);
+        mTexture->allocate(mProbeResolution, 3, mReflectionProbeCount + 2, true, render_hdr);
 
         if (mDefaultProbe.isNull())
         {
diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp
index 4a2ecee694..4760ab376e 100644
--- a/indra/newview/llreflectionmapmanager.cpp
+++ b/indra/newview/llreflectionmapmanager.cpp
@@ -223,9 +223,11 @@ void LLReflectionMapManager::update()
 
     initReflectionMaps();
 
+    static LLCachedControl<bool> render_hdr(gSavedSettings, "RenderHDREnabled", true);
+
     if (!mRenderTarget.isComplete())
     {
-        U32 color_fmt = GL_RGB16F;
+        U32 color_fmt = render_hdr ? GL_RGBA16F : GL_RGBA8;
         U32 targetRes = mProbeResolution * 4; // super sample
         mRenderTarget.allocate(targetRes, targetRes, color_fmt, true);
     }
@@ -238,7 +240,7 @@ void LLReflectionMapManager::update()
         mMipChain.resize(count);
         for (U32 i = 0; i < count; ++i)
         {
-            mMipChain[i].allocate(res, res, GL_RGB16F);
+            mMipChain[i].allocate(res, res, render_hdr ? GL_RGB16F : GL_RGB8);
             res /= 2;
         }
     }
@@ -1415,11 +1417,13 @@ void LLReflectionMapManager::initReflectionMaps()
         {
             mTexture = new LLCubeMapArray();
 
+            static LLCachedControl<bool> render_hdr(gSavedSettings, "RenderHDREnabled", true);
+
             // store mReflectionProbeCount+2 cube maps, final two cube maps are used for render target and radiance map generation source)
-            mTexture->allocate(mProbeResolution, 3, mReflectionProbeCount + 2);
+            mTexture->allocate(mProbeResolution, 3, mReflectionProbeCount + 2, true, render_hdr);
 
             mIrradianceMaps = new LLCubeMapArray();
-            mIrradianceMaps->allocate(LL_IRRADIANCE_MAP_RESOLUTION, 3, mReflectionProbeCount, false);
+            mIrradianceMaps->allocate(LL_IRRADIANCE_MAP_RESOLUTION, 3, mReflectionProbeCount, false, render_hdr);
         }
 
         // reset probe state
diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp
index 18746e76fc..d4a033bd42 100644
--- a/indra/newview/llviewercontrol.cpp
+++ b/indra/newview/llviewercontrol.cpp
@@ -261,6 +261,8 @@ static bool handleDisableVintageMode(const LLSD& newvalue)
 
 static bool handleEnableHDR(const LLSD& newvalue)
 {
+    gPipeline.mReflectionMapManager.reset();
+    gPipeline.mHeroProbeManager.reset();
     return handleReleaseGLBufferChanged(newvalue) && handleSetShaderChanged(newvalue);
 }
 
@@ -448,11 +450,11 @@ static bool handleReflectionProbeDetailChanged(const LLSD& newvalue)
     if (gPipeline.isInit())
     {
         LLPipeline::refreshCachedSettings();
+        gPipeline.mReflectionMapManager.reset();
+        gPipeline.mHeroProbeManager.reset();
         gPipeline.releaseGLBuffers();
         gPipeline.createGLBuffers();
         LLViewerShaderMgr::instance()->setShaders();
-        gPipeline.mReflectionMapManager.reset();
-        gPipeline.mHeroProbeManager.reset();
     }
     return true;
 }
-- 
cgit v1.3


From 4763195e186f8c56c2ee92d4e0154c95aa011997 Mon Sep 17 00:00:00 2001
From: Rye <rye@lindenlab.com>
Date: Thu, 23 Jan 2025 18:40:19 -0500
Subject: Fix potential undefined behavior when converting to and from glm
 types from LLVector3/4 and fall back mul_mat4_vec3 to scalar implementation
 to attempt crash mitigation (#3339)

---
 indra/llmath/llvector4a.h                  | 13 ++++++++
 indra/llmath/v3math.h                      | 51 ++++++++++++++++++++++++++++++
 indra/llmath/v4math.h                      | 51 ++++++++++++++++++++++++++++++
 indra/llrender/llrender.cpp                | 22 +++++++------
 indra/newview/gltfscenemanager.cpp         |  4 +--
 indra/newview/llgltfmaterialpreviewmgr.cpp |  4 +--
 indra/newview/llhudrender.cpp              |  2 +-
 indra/newview/llpanelprimmediacontrols.cpp |  4 +--
 indra/newview/llreflectionmap.cpp          |  2 +-
 indra/newview/llsettingsvo.cpp             |  4 +--
 indra/newview/llviewercamera.cpp           |  4 +--
 indra/newview/llvoavatar.cpp               | 10 +++---
 indra/newview/pipeline.cpp                 | 30 ++++++++----------
 13 files changed, 157 insertions(+), 44 deletions(-)

(limited to 'indra/llrender')

diff --git a/indra/llmath/llvector4a.h b/indra/llmath/llvector4a.h
index 8ef560dadf..4004852e06 100644
--- a/indra/llmath/llvector4a.h
+++ b/indra/llmath/llvector4a.h
@@ -33,6 +33,9 @@ class LLRotation;
 #include <assert.h>
 #include "llpreprocessor.h"
 #include "llmemory.h"
+#include "glm/vec3.hpp"
+#include "glm/vec4.hpp"
+#include "glm/gtc/type_ptr.hpp"
 
 ///////////////////////////////////
 // FIRST TIME USERS PLEASE READ
@@ -364,6 +367,16 @@ public:
 
     inline operator LLQuad() const;
 
+    explicit inline operator glm::vec3() const
+    {
+        return glm::make_vec3(getF32ptr());
+    };
+
+    explicit inline operator glm::vec4() const
+    {
+        return glm::make_vec4(getF32ptr());
+    };
+
 private:
     LLQuad mQ{};
 };
diff --git a/indra/llmath/v3math.h b/indra/llmath/v3math.h
index d063b15c74..a3bfa68060 100644
--- a/indra/llmath/v3math.h
+++ b/indra/llmath/v3math.h
@@ -31,6 +31,11 @@
 #include "llmath.h"
 
 #include "llsd.h"
+
+#include "glm/vec3.hpp"
+#include "glm/vec4.hpp"
+#include "glm/gtc/type_ptr.hpp"
+
 class LLVector2;
 class LLVector4;
 class LLVector4a;
@@ -66,6 +71,11 @@ class LLVector3
         explicit LLVector3(const LLVector4a& vec);              // Initializes LLVector4 to (vec[0]. vec[1], vec[2])
         explicit LLVector3(const LLSD& sd);
 
+        // GLM interop
+        explicit LLVector3(const glm::vec3& vec);   // Initializes LLVector3 to (vec[0]. vec[1], vec[2])
+        explicit LLVector3(const glm::vec4& vec);   // Initializes LLVector3 to (vec[0]. vec[1], vec[2])
+        explicit inline operator glm::vec3() const; // Initializes glm::vec3 to (vec[0]. vec[1], vec[2])
+        explicit inline operator glm::vec4() const; // Initializes glm::vec4 to (vec[0]. vec[1], vec[2], 1)
 
         LLSD getValue() const;
 
@@ -92,6 +102,8 @@ class LLVector3
         inline void set(const F32 *vec);            // Sets LLVector3 to vec
         const LLVector3& set(const LLVector4 &vec);
         const LLVector3& set(const LLVector3d &vec);// Sets LLVector3 to vec
+        inline void set(const glm::vec4& vec); // Sets LLVector3 to vec
+        inline void set(const glm::vec3& vec); // Sets LLVector3 to vec
 
         inline void setVec(F32 x, F32 y, F32 z);    // deprecated
         inline void setVec(const LLVector3 &vec);   // deprecated
@@ -190,6 +202,20 @@ inline LLVector3::LLVector3(const F32 *vec)
     mV[VZ] = vec[VZ];
 }
 
+inline LLVector3::LLVector3(const glm::vec3& vec)
+{
+    mV[VX] = vec.x;
+    mV[VY] = vec.y;
+    mV[VZ] = vec.z;
+}
+
+inline LLVector3::LLVector3(const glm::vec4& vec)
+{
+    mV[VX] = vec.x;
+    mV[VY] = vec.y;
+    mV[VZ] = vec.z;
+}
+
 /*
 inline LLVector3::LLVector3(const LLVector3 &copy)
 {
@@ -259,6 +285,20 @@ inline void LLVector3::set(const F32 *vec)
     mV[2] = vec[2];
 }
 
+inline void LLVector3::set(const glm::vec4& vec)
+{
+    mV[VX] = vec.x;
+    mV[VY] = vec.y;
+    mV[VZ] = vec.z;
+}
+
+inline void LLVector3::set(const glm::vec3& vec)
+{
+    mV[VX] = vec.x;
+    mV[VY] = vec.y;
+    mV[VZ] = vec.z;
+}
+
 // deprecated
 inline void LLVector3::setVec(F32 x, F32 y, F32 z)
 {
@@ -471,6 +511,17 @@ inline LLVector3 operator-(const LLVector3 &a)
     return LLVector3( -a.mV[0], -a.mV[1], -a.mV[2] );
 }
 
+inline LLVector3::operator glm::vec3() const
+{
+    // Do not use glm::make_vec3 it can result in a buffer overrun on some platforms due to glm::vec3 being a simd vector internally
+    return glm::vec3(mV[VX], mV[VY], mV[VZ]);
+}
+
+inline LLVector3::operator glm::vec4() const
+{
+    return glm::vec4(mV[VX], mV[VY], mV[VZ], 1.f);
+}
+
 inline F32  dist_vec(const LLVector3 &a, const LLVector3 &b)
 {
     F32 x = a.mV[0] - b.mV[0];
diff --git a/indra/llmath/v4math.h b/indra/llmath/v4math.h
index a5b6f506d7..a4c9668fdd 100644
--- a/indra/llmath/v4math.h
+++ b/indra/llmath/v4math.h
@@ -32,6 +32,10 @@
 #include "v3math.h"
 #include "v2math.h"
 
+#include "glm/vec3.hpp"
+#include "glm/vec4.hpp"
+#include "glm/gtc/type_ptr.hpp"
+
 class LLMatrix3;
 class LLMatrix4;
 class LLQuaternion;
@@ -73,6 +77,11 @@ class LLVector4
             mV[3] = (F32)sd[3].asReal();
         }
 
+        // GLM interop
+        explicit LLVector4(const glm::vec3& vec); // Initializes LLVector4 to (vec, 1)
+        explicit LLVector4(const glm::vec4& vec); // Initializes LLVector4 to vec
+        explicit operator glm::vec3() const;      // Initializes glm::vec3 to (vec[0]. vec[1], vec[2])
+        explicit operator glm::vec4() const;      // Initializes glm::vec4 to (vec[0]. vec[1], vec[2], vec[3])
 
         inline bool isFinite() const;                                   // checks to see if all values of LLVector3 are finite
 
@@ -85,6 +94,8 @@ class LLVector4
         inline void set(const LLVector4 &vec);          // Sets LLVector4 to vec
         inline void set(const LLVector3 &vec, F32 w = 1.f); // Sets LLVector4 to LLVector3 vec
         inline void set(const F32 *vec);                // Sets LLVector4 to vec
+        inline void set(const glm::vec4& vec); // Sets LLVector4 to vec
+        inline void set(const glm::vec3& vec, F32 w = 1.f); // Sets LLVector4 to LLVector3 vec with w defaulted to 1
 
         inline void setVec(F32 x, F32 y, F32 z);        // deprecated
         inline void setVec(F32 x, F32 y, F32 z, F32 w); // deprecated
@@ -223,6 +234,21 @@ inline LLVector4::LLVector4(const LLSD &sd)
     setValue(sd);
 }
 
+inline LLVector4::LLVector4(const glm::vec3& vec)
+{
+    mV[VX] = vec.x;
+    mV[VY] = vec.y;
+    mV[VZ] = vec.z;
+    mV[VW] = 1.f;
+}
+
+inline LLVector4::LLVector4(const glm::vec4& vec)
+{
+    mV[VX] = vec.x;
+    mV[VY] = vec.y;
+    mV[VZ] = vec.z;
+    mV[VW] = vec.w;
+}
 
 inline bool LLVector4::isFinite() const
 {
@@ -297,6 +323,21 @@ inline void LLVector4::set(const F32 *vec)
     mV[VW] = vec[VW];
 }
 
+inline void LLVector4::set(const glm::vec4& vec)
+{
+    mV[VX] = vec.x;
+    mV[VY] = vec.y;
+    mV[VZ] = vec.z;
+    mV[VW] = vec.w;
+}
+
+inline void LLVector4::set(const glm::vec3& vec, F32 w)
+{
+    mV[VX] = vec.x;
+    mV[VY] = vec.y;
+    mV[VZ] = vec.z;
+    mV[VW] = w;
+}
 
 // deprecated
 inline void LLVector4::setVec(F32 x, F32 y, F32 z)
@@ -466,6 +507,16 @@ inline LLVector4 operator-(const LLVector4 &a)
     return LLVector4( -a.mV[VX], -a.mV[VY], -a.mV[VZ] );
 }
 
+inline LLVector4::operator glm::vec3() const
+{
+    return glm::vec3(mV[VX], mV[VY], mV[VZ]);
+}
+
+inline LLVector4::operator glm::vec4() const
+{
+    return glm::make_vec4(mV);
+}
+
 inline F32  dist_vec(const LLVector4 &a, const LLVector4 &b)
 {
     LLVector4 vec = a - b;
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index 1d53850f74..1dc87a66ce 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -737,9 +737,8 @@ void LLLightState::setPosition(const LLVector4& position)
     ++gGL.mLightHash;
     mPosition = position;
     //transform position by current modelview matrix
-    glm::vec4 pos(glm::make_vec4(position.mV));
-    const glm::mat4& mat = gGL.getModelviewMatrix();
-    pos = mat * pos;
+    glm::vec4 pos(position);
+    pos = gGL.getModelviewMatrix() * pos;
     mPosition.set(glm::value_ptr(pos));
 }
 
@@ -794,7 +793,7 @@ void LLLightState::setSpotDirection(const LLVector3& direction)
     ++gGL.mLightHash;
 
     //transform direction by current modelview matrix
-    glm::vec3 dir(glm::make_vec3(direction.mV));
+    glm::vec3 dir(direction);
     const glm::mat3 mat(gGL.getModelviewMatrix());
     dir = mat * dir;
 
@@ -2088,12 +2087,14 @@ void set_last_projection(const glm::mat4& mat)
 
 glm::vec3 mul_mat4_vec3(const glm::mat4& mat, const glm::vec3& vec)
 {
-    //const float w = vec[0] * mat[0][3] + vec[1] * mat[1][3] + vec[2] * mat[2][3] + mat[3][3];
-    //return glm::vec3(
-    //    (vec[0] * mat[0][0] + vec[1] * mat[1][0] + vec[2] * mat[2][0] + mat[3][0]) / w,
-    //    (vec[0] * mat[0][1] + vec[1] * mat[1][1] + vec[2] * mat[2][1] + mat[3][1]) / w,
-    //    (vec[0] * mat[0][2] + vec[1] * mat[1][2] + vec[2] * mat[2][2] + mat[3][2]) / w
-    //);
+#if 1 // SIMD path results in strange crashes. Fall back to scalar for now.
+    const float w = vec[0] * mat[0][3] + vec[1] * mat[1][3] + vec[2] * mat[2][3] + mat[3][3];
+    return glm::vec3(
+       (vec[0] * mat[0][0] + vec[1] * mat[1][0] + vec[2] * mat[2][0] + mat[3][0]) / w,
+       (vec[0] * mat[0][1] + vec[1] * mat[1][1] + vec[2] * mat[2][1] + mat[3][1]) / w,
+       (vec[0] * mat[0][2] + vec[1] * mat[1][2] + vec[2] * mat[2][2] + mat[3][2]) / w
+    );
+#else
     LLVector4a x, y, z, s, t, p, q;
 
     x.splat(vec.x);
@@ -2123,4 +2124,5 @@ glm::vec3 mul_mat4_vec3(const glm::mat4& mat, const glm::vec3& vec)
     res.setAdd(x, z);
     res.div(q);
     return glm::make_vec3(res.getF32ptr());
+#endif
 }
diff --git a/indra/newview/gltfscenemanager.cpp b/indra/newview/gltfscenemanager.cpp
index ed66753267..2d6d9a153e 100644
--- a/indra/newview/gltfscenemanager.cpp
+++ b/indra/newview/gltfscenemanager.cpp
@@ -975,9 +975,9 @@ void renderAssetDebug(LLViewerObject* obj, Asset* asset)
 
     LLVector4a t;
     agent_to_asset.affineTransform(gDebugRaycastStart, t);
-    start = glm::make_vec4(t.getF32ptr());
+    start = vec4(t);
     agent_to_asset.affineTransform(gDebugRaycastEnd, t);
-    end = glm::make_vec4(t.getF32ptr());
+    end = vec4(t);
 
     start.w = end.w = 1.0;
 
diff --git a/indra/newview/llgltfmaterialpreviewmgr.cpp b/indra/newview/llgltfmaterialpreviewmgr.cpp
index cf6b08797d..da1f1a466f 100644
--- a/indra/newview/llgltfmaterialpreviewmgr.cpp
+++ b/indra/newview/llgltfmaterialpreviewmgr.cpp
@@ -472,9 +472,9 @@ bool LLGLTFPreviewTexture::render()
 
     gPipeline.setupHWLights();
     glm::mat4 mat = get_current_modelview();
-    glm::vec4 transformed_light_dir = glm::make_vec4(light_dir.mV);
+    glm::vec4 transformed_light_dir(light_dir);
     transformed_light_dir = mat * transformed_light_dir;
-    SetTemporarily<LLVector4> force_sun_direction_high_graphics(&gPipeline.mTransformedSunDir, LLVector4(glm::value_ptr(transformed_light_dir)));
+    SetTemporarily<LLVector4> force_sun_direction_high_graphics(&gPipeline.mTransformedSunDir, LLVector4(transformed_light_dir));
     // Override lights to ensure the sun is always shining from a certain direction (low graphics)
     // See also force_sun_direction_high_graphics and fixup_shader_constants
     {
diff --git a/indra/newview/llhudrender.cpp b/indra/newview/llhudrender.cpp
index 135fba7897..6850e57b94 100644
--- a/indra/newview/llhudrender.cpp
+++ b/indra/newview/llhudrender.cpp
@@ -106,7 +106,7 @@ void hud_render_text(const LLWString &wstr, const LLVector3 &pos_agent,
     LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();
     glm::ivec4 viewport(world_view_rect.mLeft, world_view_rect.mBottom, world_view_rect.getWidth(), world_view_rect.getHeight());
 
-    glm::vec3 win_coord = glm::project(glm::make_vec3(render_pos.mV), get_current_modelview(), get_current_projection(), viewport);
+    glm::vec3 win_coord = glm::project(glm::vec3(render_pos), get_current_modelview(), get_current_projection(), viewport);
 
     //fonts all render orthographically, set up projection``
     gGL.matrixMode(LLRender::MM_PROJECTION);
diff --git a/indra/newview/llpanelprimmediacontrols.cpp b/indra/newview/llpanelprimmediacontrols.cpp
index 4db0a5b59d..b8c12ce0b9 100644
--- a/indra/newview/llpanelprimmediacontrols.cpp
+++ b/indra/newview/llpanelprimmediacontrols.cpp
@@ -660,11 +660,11 @@ void LLPanelPrimMediaControls::updateShape()
         for(; vert_it != vert_end; ++vert_it)
         {
             // project silhouette vertices into screen space
-            glm::vec3 screen_vert(glm::make_vec3(vert_it->mV));
+            glm::vec3 screen_vert(*vert_it);
             screen_vert = mul_mat4_vec3(mat, screen_vert);
 
             // add to screenspace bounding box
-            update_min_max(min, max, LLVector3(glm::value_ptr(screen_vert)));
+            update_min_max(min, max, LLVector3(screen_vert));
         }
 
         // convert screenspace bbox to pixels (in screen coords)
diff --git a/indra/newview/llreflectionmap.cpp b/indra/newview/llreflectionmap.cpp
index 1196d138e9..f3adb52d5e 100644
--- a/indra/newview/llreflectionmap.cpp
+++ b/indra/newview/llreflectionmap.cpp
@@ -259,7 +259,7 @@ bool LLReflectionMap::getBox(LLMatrix4& box)
             glm::mat4 mv(get_current_modelview());
             LLVector3 s = mViewerObject->getScale().scaledVec(LLVector3(0.5f, 0.5f, 0.5f));
             mRadius = s.magVec();
-            glm::mat4 scale = glm::scale(glm::make_vec3(s.mV));
+            glm::mat4 scale = glm::scale(glm::vec3(s));
             if (mViewerObject->mDrawable != nullptr)
             {
                 // object to agent space (no scale)
diff --git a/indra/newview/llsettingsvo.cpp b/indra/newview/llsettingsvo.cpp
index 6f9d4a24bc..62df6cd275 100644
--- a/indra/newview/llsettingsvo.cpp
+++ b/indra/newview/llsettingsvo.cpp
@@ -1093,8 +1093,8 @@ void LLSettingsVOWater::applySpecial(void *ptarget, bool force)
 
         LLVector4 waterPlane(enorm.x, enorm.y, enorm.z, -glm::dot(ep, enorm));
 
-        norm = glm::make_vec3(gPipeline.mHeroProbeManager.mMirrorNormal.mV);
-        p    = glm::make_vec3(gPipeline.mHeroProbeManager.mMirrorPosition.mV);
+        norm = glm::vec3(gPipeline.mHeroProbeManager.mMirrorNormal);
+        p    = glm::vec3(gPipeline.mHeroProbeManager.mMirrorPosition);
         enorm = mul_mat4_vec3(invtrans, norm);
         enorm = glm::normalize(enorm);
         ep = mul_mat4_vec3(mat, p);
diff --git a/indra/newview/llviewercamera.cpp b/indra/newview/llviewercamera.cpp
index aa43b2dbad..7d777162ed 100644
--- a/indra/newview/llviewercamera.cpp
+++ b/indra/newview/llviewercamera.cpp
@@ -420,7 +420,7 @@ bool LLViewerCamera::projectPosAgentToScreen(const LLVector3 &pos_agent, LLCoord
 
     LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();
     glm::ivec4 viewport(world_view_rect.mLeft, world_view_rect.mBottom, world_view_rect.getWidth(), world_view_rect.getHeight());
-    glm::vec3 win_coord = glm::project(glm::make_vec3(pos_agent.mV), get_current_modelview(), get_current_projection(), viewport);
+    glm::vec3 win_coord = glm::project(glm::vec3(pos_agent), get_current_modelview(), get_current_projection(), viewport);
 
     {
         // convert screen coordinates to virtual UI coordinates
@@ -514,7 +514,7 @@ bool LLViewerCamera::projectPosAgentToScreenEdge(const LLVector3 &pos_agent,
     LLRect world_view_rect = gViewerWindow->getWorldViewRectRaw();
 
     glm::ivec4 viewport(world_view_rect.mLeft, world_view_rect.mBottom, world_view_rect.getWidth(), world_view_rect.getHeight());
-    glm::vec3 win_coord = glm::project(glm::make_vec3(pos_agent.mV), get_current_modelview(), get_current_projection(), viewport);
+    glm::vec3 win_coord = glm::project(glm::vec3(pos_agent), get_current_modelview(), get_current_projection(), viewport);
 
     {
         win_coord.x /= gViewerWindow->getDisplayScale().mV[VX];
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 7bc9d06f9a..7bf9c88b99 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -1928,8 +1928,8 @@ bool LLVOAvatar::lineSegmentIntersect(const LLVector4a& start, const LLVector4a&
             glm::mat4 inverse = glm::inverse(mat);
             glm::mat4 norm_mat = glm::transpose(inverse);
 
-            glm::vec3 p1(glm::make_vec3(start.getF32ptr()));
-            glm::vec3 p2(glm::make_vec3(end.getF32ptr()));
+            glm::vec3 p1(start);
+            glm::vec3 p2(end);
 
             p1 = mul_mat4_vec3(inverse, p1);
             p2 = mul_mat4_vec3(inverse, p2);
@@ -1937,12 +1937,12 @@ bool LLVOAvatar::lineSegmentIntersect(const LLVector4a& start, const LLVector4a&
             LLVector3 position;
             LLVector3 norm;
 
-            if (linesegment_sphere(LLVector3(glm::value_ptr(p1)), LLVector3(glm::value_ptr(p2)), LLVector3(0,0,0), 1.f, position, norm))
+            if (linesegment_sphere(LLVector3(p1), LLVector3(p2), LLVector3(0,0,0), 1.f, position, norm))
             {
-                glm::vec3 res_pos(glm::make_vec3(position.mV));
+                glm::vec3 res_pos(position);
                 res_pos = mul_mat4_vec3(mat, res_pos);
 
-                 glm::vec3 res_norm(glm::make_vec3(norm.mV));
+                 glm::vec3 res_norm(norm);
                 res_norm = glm::normalize(res_norm);
                 res_norm = glm::mat3(norm_mat) * res_norm;
 
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index c6e6c454de..f91b054dd7 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -8396,13 +8396,13 @@ void LLPipeline::renderDeferredLighting()
 
         setupHWLights();  // to set mSun/MoonDir;
 
-        glm::vec4 tc(glm::make_vec4(mSunDir.mV));
+        glm::vec4 tc(mSunDir);
         tc = mat * tc;
-        mTransformedSunDir.set(glm::value_ptr(tc));
+        mTransformedSunDir.set(tc);
 
-        glm::vec4 tc_moon(glm::make_vec4(mMoonDir.mV));
+        glm::vec4 tc_moon(mMoonDir);
         tc_moon = mat * tc_moon;
-        mTransformedMoonDir.set(glm::value_ptr(tc_moon));
+        mTransformedMoonDir.set(tc_moon);
 
         if ((RenderDeferredSSAO && !gCubeSnapshot) || RenderShadowDetail > 0)
         {
@@ -8655,7 +8655,7 @@ void LLPipeline::renderDeferredLighting()
                             continue;
                         }
 
-                        glm::vec3 tc(glm::make_vec3(c));
+                        glm::vec3 tc(center);
                         tc = mul_mat4_vec3(mat, tc);
 
                         fullscreen_lights.push_back(LLVector4(tc.x, tc.y, tc.z, s));
@@ -8762,13 +8762,12 @@ void LLPipeline::renderDeferredLighting()
                     LLDrawable* drawablep = *iter;
                     LLVOVolume* volume = drawablep->getVOVolume();
                     LLVector3   center = drawablep->getPositionAgent();
-                    F32* c = center.mV;
                     F32         light_size_final = volume->getLightRadius() * 1.5f;
                     F32         light_falloff_final = volume->getLightFalloff(DEFERRED_LIGHT_FALLOFF);
 
                     sVisibleLightCount++;
 
-                    glm::vec3 tc(glm::make_vec3(c));
+                    glm::vec3 tc(center);
                     tc = mul_mat4_vec3(mat, tc);
 
                     setupSpotLight(gDeferredMultiSpotLightProgram, drawablep);
@@ -9903,10 +9902,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
     LLVector3 lightDir = -caster_dir;
     lightDir.normVec();
 
-    glm::vec3 light_dir(glm::make_vec3(lightDir.mV));
-
     //create light space camera matrix
-
     LLVector3 at = lightDir;
 
     LLVector3 up = camera.getAtAxis();
@@ -9958,9 +9954,9 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
         //get good split distances for frustum
         for (U32 i = 0; i < fp.size(); ++i)
         {
-            glm::vec3 v(glm::make_vec3(fp[i].mV));
+            glm::vec3 v(fp[i]);
             v = mul_mat4_vec3(saved_view, v);
-            fp[i].setVec(glm::value_ptr(v));
+            fp[i] = LLVector3(v);
         }
 
         min = fp[0];
@@ -10109,9 +10105,9 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
 
             for (U32 i = 0; i < fp.size(); i++)
             {
-                glm::vec3 p = glm::make_vec3(fp[i].mV);
+                glm::vec3 p(fp[i]);
                 p = mul_mat4_vec3(view[j], p);
-                wpf.push_back(LLVector3(glm::value_ptr(p)));
+                wpf.push_back(LLVector3(p));
             }
 
             min = wpf[0];
@@ -10312,19 +10308,19 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
                         view[j] = glm::inverse(view[j]);
                         //llassert(origin.isFinite());
 
-                        glm::vec3 origin_agent(glm::make_vec3(origin.mV));
+                        glm::vec3 origin_agent(origin);
 
                         //translate view to origin
                         origin_agent = mul_mat4_vec3(view[j], origin_agent);
 
-                        eye = LLVector3(glm::value_ptr(origin_agent));
+                        eye = LLVector3(origin_agent);
                         //llassert(eye.isFinite());
                         if (!hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA) && !gCubeSnapshot)
                         {
                             mShadowFrustOrigin[j] = eye;
                         }
 
-                        view[j] = look(LLVector3(glm::value_ptr(origin_agent)), lightDir, -up);
+                        view[j] = look(LLVector3(origin_agent), lightDir, -up);
 
                         F32 fx = 1.f/tanf(fovx);
                         F32 fz = 1.f/tanf(fovz);
-- 
cgit v1.3


From d5c6eb92da968886e1afca299d55196557a06a10 Mon Sep 17 00:00:00 2001
From: Brad Linden <46733234+brad-linden@users.noreply.github.com>
Date: Fri, 24 Jan 2025 11:30:47 -0800
Subject: Attempt to get more log info in secondlife/viewer#3335 crash reports
 (#3470)

when failing to load basic vertex shaders
---
 indra/llrender/llshadermgr.cpp      | 3 +++
 indra/newview/llviewershadermgr.cpp | 4 +++-
 2 files changed, 6 insertions(+), 1 deletion(-)

(limited to 'indra/llrender')

diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 0885740934..37697f8a15 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -466,6 +466,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
 
     if (filename.empty())
     {
+        LL_WARNS("ShaderLoading") << "tried loading empty filename" << LL_ENDL;
         return 0;
     }
 
@@ -923,6 +924,8 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
         }
         LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;
     }
+
+    LL_DEBUGS("ShaderLoading") << "loadShaderFile() completed, ret: " << U32(ret) << LL_ENDL;
     return ret;
 }
 
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 5b4648a0bf..2619bbbfcb 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -623,6 +623,8 @@ void LLViewerShaderMgr::setShaders()
     else
     {
         // "ShaderLoading" and "Shader" need to be logged
+        LL_WARNS("Shader") << "Failed loading basic shaders.  Retrying with increased log level..." << LL_ENDL;
+
         LLError::ELevel lvl = LLError::getDefaultLevel();
         LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
         loadBasicShaders();
@@ -843,7 +845,7 @@ std::string LLViewerShaderMgr::loadBasicShaders()
         // Note usage of GL_VERTEX_SHADER
         if (loadShaderFile(shaders[i].first, shaders[i].second, GL_VERTEX_SHADER, &attribs) == 0)
         {
-            LL_WARNS("Shader") << "Failed to load vertex shader " << shaders[i].first << LL_ENDL;
+            LL_WARNS("Shader") << "Failed to load basic vertex shader " << i << ": " << shaders[i].first << LL_ENDL;
             return shaders[i].first;
         }
     }
-- 
cgit v1.3


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: 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 ++++++++++++++++
 .../shaders/class1/objects/simpleNoAtmosV.glsl     | 43 ++++++++++++
 .../shaders/class3/deferred/waterHazeF.glsl        | 14 ++++
 .../shaders/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

(limited to 'indra/llrender')

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 @@ public:
     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 @@ public:
         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 @@ public:
         // 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 @@ public:
         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 @@ public:
     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 @@ public:
     // 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 @@ public:
         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 @@ public:
     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 @@ protected:
     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
 
-- 
cgit v1.3


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: #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(-)

(limited to 'indra/llrender')

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 @@ public:
     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 @@ private:
     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
-- 
cgit v1.3


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: #3332 Font issues with multy-byte and multy-glyps characters

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

(limited to 'indra/llrender')

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))
-- 
cgit v1.3


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: 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

(limited to 'indra/llrender')

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 @@ public:
     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;
-- 
cgit v1.3


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: #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(-)

(limited to 'indra/llrender')

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 @@ public:
 
     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 @@ public:
     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 @@ private:
     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;
 };
 
-- 
cgit v1.3


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: 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(-)

(limited to 'indra/llrender')

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 @@ public:
     }
 
     // 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;
 }
-- 
cgit v1.3


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: Follow-up fixes from develop

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

(limited to 'indra/llrender')

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(
-- 
cgit v1.3


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: 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(-)

(limited to 'indra/llrender')

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;
         }
     }
-- 
cgit v1.3


From 5b968b7209d5e104e4b6152b8fc0fbbb37d1674a Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Mon, 24 Feb 2025 17:22:54 +0200
Subject: #3332 Remake glyph count into cache generation

1. Cover reset with 'generation'
2. Fix lapse of judgement with mLastFontGlyphCount, it should have been
saved before render(), not after
---
 indra/llrender/llfontbitmapcache.cpp  | 2 ++
 indra/llrender/llfontbitmapcache.h    | 2 ++
 indra/llrender/llfontfreetype.cpp     | 2 --
 indra/llrender/llfontfreetype.h       | 2 --
 indra/llrender/llfontgl.cpp           | 5 +++--
 indra/llrender/llfontgl.h             | 2 +-
 indra/llrender/llfontvertexbuffer.cpp | 6 ++++--
 indra/llrender/llfontvertexbuffer.h   | 2 +-
 8 files changed, 13 insertions(+), 10 deletions(-)

(limited to 'indra/llrender')

diff --git a/indra/llrender/llfontbitmapcache.cpp b/indra/llrender/llfontbitmapcache.cpp
index 83f5d31186..6a3af1e608 100644
--- a/indra/llrender/llfontbitmapcache.cpp
+++ b/indra/llrender/llfontbitmapcache.cpp
@@ -141,6 +141,7 @@ bool LLFontBitmapCache::nextOpenPos(S32 width, S32& pos_x, S32& pos_y, EFontGlyp
     bitmap_num = getNumBitmaps(bitmap_type) - 1;
 
     mCurrentOffsetX[bitmap_idx] += width + 1;
+    mGeneration++;
 
     return true;
 }
@@ -168,6 +169,7 @@ void LLFontBitmapCache::reset()
 
     mBitmapWidth = 0;
     mBitmapHeight = 0;
+    mGeneration++;
 }
 
 //static
diff --git a/indra/llrender/llfontbitmapcache.h b/indra/llrender/llfontbitmapcache.h
index f2dfd87877..0ae4e6bed0 100644
--- a/indra/llrender/llfontbitmapcache.h
+++ b/indra/llrender/llfontbitmapcache.h
@@ -63,6 +63,7 @@ public:
     U32 getNumBitmaps(EFontGlyphType bitmapType) const { return (bitmapType < EFontGlyphType::Count) ? static_cast<U32>(mImageRawVec[static_cast<U32>(bitmapType)].size()) : 0U; }
     S32 getBitmapWidth() const { return mBitmapWidth; }
     S32 getBitmapHeight() const { return mBitmapHeight; }
+    S32 getCacheGeneration() const { return mGeneration; }
 
 protected:
     static U32 getNumComponents(EFontGlyphType bitmap_type);
@@ -74,6 +75,7 @@ private:
     S32 mCurrentOffsetY[static_cast<U32>(EFontGlyphType::Count)] = { 1 };
     S32 mMaxCharWidth = 0;
     S32 mMaxCharHeight = 0;
+    S32 mGeneration = 0;
     std::vector<LLPointer<LLImageRaw>> mImageRawVec[static_cast<U32>(EFontGlyphType::Count)];
     std::vector<LLPointer<LLImageGL>> mImageGLVec[static_cast<U32>(EFontGlyphType::Count)];
 };
diff --git a/indra/llrender/llfontfreetype.cpp b/indra/llrender/llfontfreetype.cpp
index 38dc23d1dc..62b551f1e0 100644
--- a/indra/llrender/llfontfreetype.cpp
+++ b/indra/llrender/llfontfreetype.cpp
@@ -146,7 +146,6 @@ LLFontFreetype::LLFontFreetype()
     mIsFallback(false),
     mFTFace(NULL),
     mRenderGlyphCount(0),
-    mAddGlyphCount(0),
     mStyle(0),
     mPointSize(0)
 {
@@ -574,7 +573,6 @@ LLFontGlyphInfo* LLFontFreetype::addGlyphFromFont(const LLFontFreetype *fontp, l
     S32 pos_x, pos_y;
     U32 bitmap_num;
     mFontBitmapCachep->nextOpenPos(width, pos_x, pos_y, bitmap_glyph_type, bitmap_num);
-    mAddGlyphCount++;
 
     LLFontGlyphInfo* gi = new LLFontGlyphInfo(glyph_index, requested_glyph_type);
     gi->mXBitmapOffset = pos_x;
diff --git a/indra/llrender/llfontfreetype.h b/indra/llrender/llfontfreetype.h
index a2d925c5f6..783bf4a4b3 100644
--- a/indra/llrender/llfontfreetype.h
+++ b/indra/llrender/llfontfreetype.h
@@ -148,7 +148,6 @@ public:
 
     void setStyle(U8 style);
     U8 getStyle() const;
-    S32 getAddedGlyphs() const { return mAddGlyphCount; }
 
 private:
     void resetBitmapCache();
@@ -188,7 +187,6 @@ private:
     mutable LLFontBitmapCache* mFontBitmapCachep;
 
     mutable S32 mRenderGlyphCount;
-    mutable S32 mAddGlyphCount;
 };
 
 #endif // LL_FONTFREETYPE_H
diff --git a/indra/llrender/llfontgl.cpp b/indra/llrender/llfontgl.cpp
index 4037c036e5..16eec1fdd2 100644
--- a/indra/llrender/llfontgl.cpp
+++ b/indra/llrender/llfontgl.cpp
@@ -110,9 +110,10 @@ S32 LLFontGL::getNumFaces(const std::string& filename)
     return mFontFreetype->getNumFaces(filename);
 }
 
-S32 LLFontGL::getKnownGlyphCount() const
+S32 LLFontGL::getCacheGeneration() const
 {
-    return mFontFreetype ? mFontFreetype->getAddedGlyphs() : 0;
+    const LLFontBitmapCache* font_bitmap_cache = mFontFreetype->getFontBitmapCache();
+    return font_bitmap_cache->getCacheGeneration();
 }
 
 S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, const LLRect& rect, const LLColor4 &color, HAlign halign, VAlign valign, U8 style,
diff --git a/indra/llrender/llfontgl.h b/indra/llrender/llfontgl.h
index 73efc6b1eb..1c8e036f58 100644
--- a/indra/llrender/llfontgl.h
+++ b/indra/llrender/llfontgl.h
@@ -90,7 +90,7 @@ public:
     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 getCacheGeneration() 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 b53a841a87..a223509d30 100644
--- a/indra/llrender/llfontvertexbuffer.cpp
+++ b/indra/llrender/llfontvertexbuffer.cpp
@@ -148,7 +148,7 @@ S32 LLFontVertexBuffer::render(
              || mLastHorizDPI != LLFontGL::sHorizDPI
              || mLastOrigin != LLFontGL::sCurOrigin
              || mLastResGeneration != LLFontGL::sResolutionGeneration
-             || mLastFontGlyphCount != fontp->getKnownGlyphCount())
+             || mLastFontCacheGen != fontp->getCacheGeneration())
     {
         genBuffers(fontp, text, begin_offset, x, y, color, halign, valign,
             style, shadow, max_chars, max_pixels, right_x, use_ellipses, use_color);
@@ -180,6 +180,9 @@ void LLFontVertexBuffer::genBuffers(
 {
     // todo: add a debug build assert if this triggers too often for to long?
     mBufferList.clear();
+    // Save before rendreing, it can change mid-render,
+    // so will need to rerender previous characters
+    mLastFontCacheGen = fontp->getCacheGeneration();
 
     gGL.beginList(&mBufferList);
     mChars = fontp->render(text, begin_offset, x, y, color, halign, valign,
@@ -204,7 +207,6 @@ 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 d5e1280dbf..a9e1e2337c 100644
--- a/indra/llrender/llfontvertexbuffer.h
+++ b/indra/llrender/llfontvertexbuffer.h
@@ -122,7 +122,7 @@ private:
 
     // 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;
+    S32 mLastFontCacheGen = 0;
 
     static bool sEnableBufferCollection;
 };
-- 
cgit v1.3