From 3400e5fd302c0d9dea6386c4d5bf38876f2cc287 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 16 May 2022 17:21:08 +0000
Subject: SL-17284 Reflection probe tuning and optimization take 1

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index eebd89f77f..47330debd3 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -129,6 +129,8 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
     }
 }
 
+extern BOOL gCubeSnapshot;
+
 void LLDrawPoolAlpha::renderPostDeferred(S32 pass) 
 { 
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
@@ -155,7 +157,7 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     forwardRender();
 
     // final pass, render to depth for depth of field effects
-    if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField"))
+    if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField") && !gCubeSnapshot)
     { 
         //update depth buffer sampler
         gPipeline.mScreen.flush();
-- 
cgit v1.2.3


From 6eaf8521abae0deeb1162f9c61747183110176b0 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 20 May 2022 19:05:28 -0500
Subject: SL-17287 Instrument and optimize cubemap render.  Fix for cubemap
 snapshots doing a full resolution render instead of a 512x512 render.

---
 indra/newview/lldrawpoolalpha.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index a43b30465b..89b8ec1ba2 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -160,10 +160,10 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField") && !gCubeSnapshot)
     { 
         //update depth buffer sampler
-        gPipeline.mScreen.flush();
-        gPipeline.mDeferredDepth.copyContents(gPipeline.mDeferredScreen, 0, 0, gPipeline.mDeferredScreen.getWidth(), gPipeline.mDeferredScreen.getHeight(),
-            0, 0, gPipeline.mDeferredDepth.getWidth(), gPipeline.mDeferredDepth.getHeight(), GL_DEPTH_BUFFER_BIT, GL_NEAREST);
-        gPipeline.mDeferredDepth.bindTarget();
+        gPipeline.mRT->screen.flush();
+        gPipeline.mRT->deferredDepth.copyContents(gPipeline.mRT->deferredScreen, 0, 0, gPipeline.mRT->deferredScreen.getWidth(), gPipeline.mRT->deferredScreen.getHeight(),
+            0, 0, gPipeline.mRT->deferredDepth.getWidth(), gPipeline.mRT->deferredDepth.getHeight(), GL_DEPTH_BUFFER_BIT, GL_NEAREST);
+        gPipeline.mRT->deferredDepth.bindTarget();
         simple_shader = fullbright_shader = &gObjectFullbrightAlphaMaskProgram;
 
         simple_shader->bind();
@@ -177,8 +177,8 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
         renderAlpha(getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2, 
             true); // <--- discard mostly transparent faces
 
-        gPipeline.mDeferredDepth.flush();
-        gPipeline.mScreen.bindTarget();
+        gPipeline.mRT->deferredDepth.flush();
+        gPipeline.mRT->screen.bindTarget();
         gGL.setColorMask(true, false);
     }
 
-- 
cgit v1.2.3


From 049fc419d1d1f41ac05e424d599a89366cee7ca7 Mon Sep 17 00:00:00 2001
From: Ptolemy <ptolemy@lindenlab.com>
Date: Fri, 9 Sep 2022 03:28:12 -0700
Subject: SL-17701: PBR: WIP Alpha Blending

---
 indra/newview/lldrawpoolalpha.cpp | 161 ++++++++++++++++++++++++++------------
 1 file changed, 111 insertions(+), 50 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 89b8ec1ba2..883ba72c3c 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -50,6 +50,8 @@
 #include "llglcommonfunc.h"
 #include "llvoavatar.h"
 
+#include "llenvironment.h"
+
 BOOL LLDrawPoolAlpha::sShowDebugAlpha = FALSE;
 
 #define current_shader (LLGLSLShader::sCurBoundShaderPtr)
@@ -602,65 +604,74 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 					}
 				}
 
-				LLRenderPass::applyModelMatrix(params);
+                LLRenderPass::applyModelMatrix(params);
 
-				LLMaterial* mat = NULL;
+                LLMaterial* mat = NULL;
+                LLGLTFMaterial *gltf_mat = params.mGLTFMaterial; // Also see: LLPipeline::getPoolTypeFromTE()
+                bool is_pbr = LLPipeline::sRenderPBR && gltf_mat;
 
-				if (deferred_render)
-				{
-					mat = params.mMaterial;
-				}
-				
-				if (params.mFullbright)
-				{
-					// Turn off lighting if it hasn't already been so.
-					if (light_enabled || !initialized_lighting)
-					{
-						initialized_lighting = TRUE;
-						target_shader = fullbright_shader;
+                if (is_pbr && gltf_mat->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_BLEND)
+                {
+                    target_shader = &gDeferredPBRAlphaProgram[rigged];
+                }
+                else
+                {
+                    if (deferred_render)
+                    {
+                        mat = params.mMaterial;
+                    }
 
-						light_enabled = FALSE;
-					}
-				}
-				// Turn on lighting if it isn't already.
-				else if (!light_enabled || !initialized_lighting)
-				{
-					initialized_lighting = TRUE;
-					target_shader = simple_shader;
-					light_enabled = TRUE;
-				}
+                    if (params.mFullbright)
+                    {
+                        // Turn off lighting if it hasn't already been so.
+                        if (light_enabled || !initialized_lighting)
+                        {
+                            initialized_lighting = TRUE;
+                            target_shader = fullbright_shader;
 
-				if (deferred_render && mat)
-				{
-					U32 mask = params.mShaderMask;
+                            light_enabled = FALSE;
+                        }
+                    }
+                    // Turn on lighting if it isn't already.
+                    else if (!light_enabled || !initialized_lighting)
+                    {
+                        initialized_lighting = TRUE;
+                        target_shader = simple_shader;
+                        light_enabled = TRUE;
+                    }
 
-					llassert(mask < LLMaterial::SHADER_COUNT);
-					target_shader = &(gDeferredMaterialProgram[mask]);
+                    if (deferred_render && mat)
+                    {
+                        U32 mask = params.mShaderMask;
 
-					if (LLPipeline::sUnderWaterRender)
-					{
-						target_shader = &(gDeferredMaterialWaterProgram[mask]);
-					}
+                        llassert(mask < LLMaterial::SHADER_COUNT);
+                        target_shader = &(gDeferredMaterialProgram[mask]);
 
-                    if (params.mAvatar != nullptr)
+                        if (LLPipeline::sUnderWaterRender)
+                        {
+                            target_shader = &(gDeferredMaterialWaterProgram[mask]);
+                        }
+
+                        if (params.mAvatar != nullptr)
+                        {
+                            llassert(target_shader->mRiggedVariant != nullptr);
+                            target_shader = target_shader->mRiggedVariant;
+                        }
+
+                        if (current_shader != target_shader)
+                        {
+                            gPipeline.bindDeferredShader(*target_shader);
+                        }
+                    }
+                    else if (!params.mFullbright)
                     {
-                        llassert(target_shader->mRiggedVariant != nullptr);
-                        target_shader = target_shader->mRiggedVariant;
+                        target_shader = simple_shader;
                     }
-
-					if (current_shader != target_shader)
-					{
-						gPipeline.bindDeferredShader(*target_shader);
-					}
-				}
-				else if (!params.mFullbright)
-				{
-					target_shader = simple_shader;
-				}
-				else
-				{
-					target_shader = fullbright_shader;
-				}
+                    else
+                    {
+                        target_shader = fullbright_shader;
+                    }
+                }
 				
                 if (params.mAvatar != nullptr)
                 {
@@ -673,6 +684,56 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     target_shader->bind();
                 }
 
+                if (is_pbr)
+                {
+                    if (params.mTexture.notNull())
+                    {
+                        gGL.getTexUnit(0)->bindFast(params.mTexture); // diffuse
+                    }
+                    else
+                    {
+                        gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::sWhiteImagep);
+                    }
+
+                    if (params.mNormalMap)
+                    {
+                        target_shader->bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
+                    }
+                    else
+                    {
+                        target_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);
+                    }
+
+                    if (params.mSpecularMap)
+                    {
+                        target_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap); // PBR linear packed Occlusion, Roughness, Metal.
+                    }
+                    else
+                    {
+                        target_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
+                    }
+
+                    if (params.mEmissiveMap)
+                    {
+                        target_shader->bindTexture(LLShaderMgr::EMISSIVE_MAP, params.mEmissiveMap);  // PBR sRGB Emissive
+                    }
+                    else
+                    {
+                        target_shader->bindTexture(LLShaderMgr::EMISSIVE_MAP, LLViewerFetchedTexture::sWhiteImagep);
+                    }
+
+                    target_shader->uniform1f(LLShaderMgr::ROUGHNESS_FACTOR, params.mGLTFMaterial->mRoughnessFactor);
+                    target_shader->uniform1f(LLShaderMgr::METALLIC_FACTOR, params.mGLTFMaterial->mMetallicFactor);
+                    target_shader->uniform3fv(LLShaderMgr::EMISSIVE_COLOR, 1, params.mGLTFMaterial->mEmissiveColor.mV);
+
+                    LLEnvironment& environment = LLEnvironment::instance();
+                    target_shader->uniform1i(LLShaderMgr::SUN_UP_FACTOR, environment.getIsSunUp() ? 1 : 0);
+
+                    // TODO? prepare_alpha_shader( target_shader, false, true );
+                    target_shader->uniform3fv(LLShaderMgr::DEFERRED_SUN_DIR, 1, gPipeline.mTransformedSunDir.mV);
+                    target_shader->uniform3fv(LLShaderMgr::DEFERRED_MOON_DIR, 1, gPipeline.mTransformedMoonDir.mV);
+                }
+
                 LLVector4 spec_color(1, 1, 1, 1);
                 F32 env_intensity = 0.0f;
                 F32 brightness = 1.0f;
-- 
cgit v1.2.3


From 9cb8ed92105f2bd5f99da44e4d00b464d4bb659d Mon Sep 17 00:00:00 2001
From: Ptolemy <ptolemy@lindenlab.com>
Date: Fri, 9 Sep 2022 03:57:39 -0700
Subject: SL-17701 PBR: Cleanup alpha setting EEP shader uniforms

---
 indra/newview/lldrawpoolalpha.cpp | 94 ++++++++++++++++++---------------------
 1 file changed, 44 insertions(+), 50 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 883ba72c3c..3d456d069f 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -613,6 +613,50 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                 if (is_pbr && gltf_mat->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_BLEND)
                 {
                     target_shader = &gDeferredPBRAlphaProgram[rigged];
+                    if (current_shader != target_shader)
+                    {
+                        gPipeline.bindDeferredShader(*target_shader);
+                    }
+
+                    if (params.mTexture.notNull())
+                    {
+                        gGL.getTexUnit(0)->bindFast(params.mTexture); // diffuse
+                    }
+                    else
+                    {
+                        gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::sWhiteImagep);
+                    }
+
+                    if (params.mNormalMap)
+                    {
+                        target_shader->bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
+                    }
+                    else
+                    {
+                        target_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);
+                    }
+
+                    if (params.mSpecularMap)
+                    {
+                        target_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap); // PBR linear packed Occlusion, Roughness, Metal.
+                    }
+                    else
+                    {
+                        target_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
+                    }
+
+                    if (params.mEmissiveMap)
+                    {
+                        target_shader->bindTexture(LLShaderMgr::EMISSIVE_MAP, params.mEmissiveMap);  // PBR sRGB Emissive
+                    }
+                    else
+                    {
+                        target_shader->bindTexture(LLShaderMgr::EMISSIVE_MAP, LLViewerFetchedTexture::sWhiteImagep);
+                    }
+
+                    target_shader->uniform1f(LLShaderMgr::ROUGHNESS_FACTOR, params.mGLTFMaterial->mRoughnessFactor);
+                    target_shader->uniform1f(LLShaderMgr::METALLIC_FACTOR, params.mGLTFMaterial->mMetallicFactor);
+                    target_shader->uniform3fv(LLShaderMgr::EMISSIVE_COLOR, 1, params.mGLTFMaterial->mEmissiveColor.mV);
                 }
                 else
                 {
@@ -684,56 +728,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     target_shader->bind();
                 }
 
-                if (is_pbr)
-                {
-                    if (params.mTexture.notNull())
-                    {
-                        gGL.getTexUnit(0)->bindFast(params.mTexture); // diffuse
-                    }
-                    else
-                    {
-                        gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::sWhiteImagep);
-                    }
-
-                    if (params.mNormalMap)
-                    {
-                        target_shader->bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
-                    }
-                    else
-                    {
-                        target_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);
-                    }
-
-                    if (params.mSpecularMap)
-                    {
-                        target_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap); // PBR linear packed Occlusion, Roughness, Metal.
-                    }
-                    else
-                    {
-                        target_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
-                    }
-
-                    if (params.mEmissiveMap)
-                    {
-                        target_shader->bindTexture(LLShaderMgr::EMISSIVE_MAP, params.mEmissiveMap);  // PBR sRGB Emissive
-                    }
-                    else
-                    {
-                        target_shader->bindTexture(LLShaderMgr::EMISSIVE_MAP, LLViewerFetchedTexture::sWhiteImagep);
-                    }
-
-                    target_shader->uniform1f(LLShaderMgr::ROUGHNESS_FACTOR, params.mGLTFMaterial->mRoughnessFactor);
-                    target_shader->uniform1f(LLShaderMgr::METALLIC_FACTOR, params.mGLTFMaterial->mMetallicFactor);
-                    target_shader->uniform3fv(LLShaderMgr::EMISSIVE_COLOR, 1, params.mGLTFMaterial->mEmissiveColor.mV);
-
-                    LLEnvironment& environment = LLEnvironment::instance();
-                    target_shader->uniform1i(LLShaderMgr::SUN_UP_FACTOR, environment.getIsSunUp() ? 1 : 0);
-
-                    // TODO? prepare_alpha_shader( target_shader, false, true );
-                    target_shader->uniform3fv(LLShaderMgr::DEFERRED_SUN_DIR, 1, gPipeline.mTransformedSunDir.mV);
-                    target_shader->uniform3fv(LLShaderMgr::DEFERRED_MOON_DIR, 1, gPipeline.mTransformedMoonDir.mV);
-                }
-
                 LLVector4 spec_color(1, 1, 1, 1);
                 F32 env_intensity = 0.0f;
                 F32 brightness = 1.0f;
-- 
cgit v1.2.3


From 03df9545092cc3917e1c3f947ce2270d0ba31134 Mon Sep 17 00:00:00 2001
From: Ptolemy <ptolemy@lindenlab.com>
Date: Mon, 12 Sep 2022 01:22:47 -0700
Subject: SL-17701: PBR: Tweak lighting in alpha blending

---
 indra/newview/lldrawpoolalpha.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 3d456d069f..ee085a65c2 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -83,6 +83,11 @@ void LLDrawPoolAlpha::prerender()
     // TODO: is this even necessay?  These are probably set to never discard
     LLViewerFetchedTexture::sFlatNormalImagep->addTextureStats(1024.f*1024.f);
     LLViewerFetchedTexture::sWhiteImagep->addTextureStats(1024.f * 1024.f);
+
+    if (LLPipeline::sRenderPBR)
+    {
+        gPipeline.setupHWLights(NULL);
+    }
 }
 
 S32 LLDrawPoolAlpha::getNumPostDeferredPasses() 
@@ -657,6 +662,9 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     target_shader->uniform1f(LLShaderMgr::ROUGHNESS_FACTOR, params.mGLTFMaterial->mRoughnessFactor);
                     target_shader->uniform1f(LLShaderMgr::METALLIC_FACTOR, params.mGLTFMaterial->mMetallicFactor);
                     target_shader->uniform3fv(LLShaderMgr::EMISSIVE_COLOR, 1, params.mGLTFMaterial->mEmissiveColor.mV);
+
+                    target_shader->mLightHash = 0;
+                    gGL.syncLightState(); // Set light uniforms
                 }
                 else
                 {
-- 
cgit v1.2.3


From 402ab8c8f657f050a2ea30ebe562008130cb9bcd Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 13 Sep 2022 15:25:15 -0500
Subject: SL-17701 WIP -- Cleanup/refactor PBR lighting implementation and get
 parity between deferred and alpha passes for sunlight and IBL.

---
 indra/newview/lldrawpoolalpha.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index ee085a65c2..b992ab0394 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -617,7 +617,12 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
                 if (is_pbr && gltf_mat->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_BLEND)
                 {
-                    target_shader = &gDeferredPBRAlphaProgram[rigged];
+                    target_shader = &gDeferredPBRAlphaProgram;
+                    if (params.mAvatar != nullptr)
+                    {
+                        target_shader = target_shader->mRiggedVariant;
+                    }
+
                     if (current_shader != target_shader)
                     {
                         gPipeline.bindDeferredShader(*target_shader);
@@ -662,9 +667,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     target_shader->uniform1f(LLShaderMgr::ROUGHNESS_FACTOR, params.mGLTFMaterial->mRoughnessFactor);
                     target_shader->uniform1f(LLShaderMgr::METALLIC_FACTOR, params.mGLTFMaterial->mMetallicFactor);
                     target_shader->uniform3fv(LLShaderMgr::EMISSIVE_COLOR, 1, params.mGLTFMaterial->mEmissiveColor.mV);
-
-                    target_shader->mLightHash = 0;
-                    gGL.syncLightState(); // Set light uniforms
                 }
                 else
                 {
-- 
cgit v1.2.3


From 2a5219b23f5f91a2415a51324bb5c160a0139663 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 13 Sep 2022 18:41:24 -0500
Subject: SL-17701 WIP -- Correct color space management for base color and
 emissive color factors and textures.  Support for double sided alpha blended
 PBR materials.

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index b992ab0394..90cf596345 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -615,6 +615,8 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                 LLGLTFMaterial *gltf_mat = params.mGLTFMaterial; // Also see: LLPipeline::getPoolTypeFromTE()
                 bool is_pbr = LLPipeline::sRenderPBR && gltf_mat;
 
+                LLGLDisable cull_face(is_pbr && gltf_mat->mDoubleSided ? GL_CULL_FACE : 0);
+
                 if (is_pbr && gltf_mat->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_BLEND)
                 {
                     target_shader = &gDeferredPBRAlphaProgram;
-- 
cgit v1.2.3


From 47e039ce1fb30f0e44cd6a79c0655b94794bc577 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 14 Sep 2022 12:37:23 -0500
Subject: SL-17701 Fix for legacy material parameters/textures overriding GLTF
 materials in alpha pool.

---
 indra/newview/lldrawpoolalpha.cpp | 171 +++++++++++++++++++++-----------------
 1 file changed, 93 insertions(+), 78 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 90cf596345..b4807e8d35 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -405,62 +405,76 @@ bool LLDrawPoolAlpha::TexSetup(LLDrawInfo* draw, bool use_material)
 {
     bool tex_setup = false;
 
-    if (deferred_render && use_material && current_shader)
+    if (draw->mGLTFMaterial)
     {
-        if (draw->mNormalMap)
-		{
-			draw->mNormalMap->addTextureStats(draw->mVSize);
-			current_shader->bindTexture(LLShaderMgr::BUMP_MAP, draw->mNormalMap);
-		} 
-
-		if (draw->mSpecularMap)
-		{
-			draw->mSpecularMap->addTextureStats(draw->mVSize);
-			current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, draw->mSpecularMap);
-		} 
+        if (draw->mTextureMatrix)
+        {
+            tex_setup = true;
+            gGL.getTexUnit(0)->activate();
+            gGL.matrixMode(LLRender::MM_TEXTURE);
+            gGL.loadMatrix((GLfloat*)draw->mTextureMatrix->mMatrix);
+            gPipeline.mTextureMatrixOps++;
+        }
     }
-    else if (current_shader == simple_shader || current_shader == simple_shader->mRiggedVariant)
+    else
     {
-        current_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);
-	    current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
-    }
-	if (draw->mTextureList.size() > 1)
-	{
-		for (U32 i = 0; i < draw->mTextureList.size(); ++i)
-		{
-			if (draw->mTextureList[i].notNull())
-			{
-				gGL.getTexUnit(i)->bindFast(draw->mTextureList[i]);
-			}
-		}
-	}
-	else
-	{ //not batching textures or batch has only 1 texture -- might need a texture matrix
-		if (draw->mTexture.notNull())
-		{
-			if (use_material)
-			{
-				current_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, draw->mTexture);
-			}
-			else
-			{
-			    gGL.getTexUnit(0)->bindFast(draw->mTexture);
-			}
+        if (deferred_render && use_material && current_shader)
+        {
+            if (draw->mNormalMap)
+            {
+                draw->mNormalMap->addTextureStats(draw->mVSize);
+                current_shader->bindTexture(LLShaderMgr::BUMP_MAP, draw->mNormalMap);
+            }
 
-			if (draw->mTextureMatrix)
-			{
-				tex_setup = true;
-				gGL.getTexUnit(0)->activate();
-				gGL.matrixMode(LLRender::MM_TEXTURE);
-				gGL.loadMatrix((GLfloat*) draw->mTextureMatrix->mMatrix);
-				gPipeline.mTextureMatrixOps++;
-			}
-		}
-		else
-		{
-			gGL.getTexUnit(0)->unbindFast(LLTexUnit::TT_TEXTURE);
-		}
-	}
+            if (draw->mSpecularMap)
+            {
+                draw->mSpecularMap->addTextureStats(draw->mVSize);
+                current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, draw->mSpecularMap);
+            }
+        }
+        else if (current_shader == simple_shader || current_shader == simple_shader->mRiggedVariant)
+        {
+            current_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);
+            current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
+        }
+        if (draw->mTextureList.size() > 1)
+        {
+            for (U32 i = 0; i < draw->mTextureList.size(); ++i)
+            {
+                if (draw->mTextureList[i].notNull())
+                {
+                    gGL.getTexUnit(i)->bindFast(draw->mTextureList[i]);
+                }
+            }
+        }
+        else
+        { //not batching textures or batch has only 1 texture -- might need a texture matrix
+            if (draw->mTexture.notNull())
+            {
+                if (use_material)
+                {
+                    current_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, draw->mTexture);
+                }
+                else
+                {
+                    gGL.getTexUnit(0)->bindFast(draw->mTexture);
+                }
+
+                if (draw->mTextureMatrix)
+                {
+                    tex_setup = true;
+                    gGL.getTexUnit(0)->activate();
+                    gGL.matrixMode(LLRender::MM_TEXTURE);
+                    gGL.loadMatrix((GLfloat*)draw->mTextureMatrix->mMatrix);
+                    gPipeline.mTextureMatrixOps++;
+                }
+            }
+            else
+            {
+                gGL.getTexUnit(0)->unbindFast(LLTexUnit::TT_TEXTURE);
+            }
+        }
+    }
     
     return tex_setup;
 }
@@ -727,36 +741,37 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     {
                         target_shader = fullbright_shader;
                     }
-                }
-				
-                if (params.mAvatar != nullptr)
-                {
-                    target_shader = target_shader->mRiggedVariant;
-                }
 
-                if (current_shader != target_shader)
-                {// If we need shaders, and we're not ALREADY using the proper shader, then bind it
-                // (this way we won't rebind shaders unnecessarily).
-                    target_shader->bind();
-                }
 
-                LLVector4 spec_color(1, 1, 1, 1);
-                F32 env_intensity = 0.0f;
-                F32 brightness = 1.0f;
+                    if (params.mAvatar != nullptr)
+                    {
+                        target_shader = target_shader->mRiggedVariant;
+                    }
 
-                // We have a material.  Supply the appropriate data here.
-				if (mat && deferred_render)
-				{
-					spec_color    = params.mSpecColor;
-                    env_intensity = params.mEnvIntensity;
-                    brightness    = params.mFullbright ? 1.f : 0.f;
-                }
+                    if (current_shader != target_shader)
+                    {// If we need shaders, and we're not ALREADY using the proper shader, then bind it
+                    // (this way we won't rebind shaders unnecessarily).
+                        target_shader->bind();
+                    }
 
-                if (current_shader)
-                {
-                    current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, spec_color.mV[0], spec_color.mV[1], spec_color.mV[2], spec_color.mV[3]);
-				    current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, env_intensity);
-					current_shader->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, brightness);
+                    LLVector4 spec_color(1, 1, 1, 1);
+                    F32 env_intensity = 0.0f;
+                    F32 brightness = 1.0f;
+
+                    // We have a material.  Supply the appropriate data here.
+                    if (mat && deferred_render)
+                    {
+                        spec_color = params.mSpecColor;
+                        env_intensity = params.mEnvIntensity;
+                        brightness = params.mFullbright ? 1.f : 0.f;
+                    }
+
+                    if (current_shader)
+                    {
+                        current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, spec_color.mV[0], spec_color.mV[1], spec_color.mV[2], spec_color.mV[3]);
+                        current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, env_intensity);
+                        current_shader->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, brightness);
+                    }
                 }
 
 				if (params.mGroup)
-- 
cgit v1.2.3


From 725d042640f5b0474b58e6a1af0a4063c7e5cfc2 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 26 Sep 2022 17:17:34 -0500
Subject: SL-18190 WIP - Windlight to linear space proof of concept, better
 parity between release viewer and materials viewer when reflections disabled.
  Avoid run-away probe ambiance.

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index b4807e8d35..8d07c6f8dd 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -150,7 +150,7 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
 
     fullbright_shader   = (LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
         (LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterProgram : &gDeferredFullbrightAlphaMaskProgram;
-    prepare_alpha_shader(fullbright_shader, true, false);
+    prepare_alpha_shader(fullbright_shader, true, true);
 
     simple_shader   = (LLPipeline::sImpostorRender) ? &gDeferredAlphaImpostorProgram :
         (LLPipeline::sUnderWaterRender) ? &gDeferredAlphaWaterProgram : &gDeferredAlphaProgram;
-- 
cgit v1.2.3


From 44f2286e42a10270c23ea11e308143948d1e3288 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 26 Sep 2022 18:08:42 -0500
Subject: SL-18190 Use bindDeferredShader in alpha pool.  Don't redundantly
 apply ao to irradiance.

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 8d07c6f8dd..a985807a38 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -751,7 +751,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     if (current_shader != target_shader)
                     {// If we need shaders, and we're not ALREADY using the proper shader, then bind it
                     // (this way we won't rebind shaders unnecessarily).
-                        target_shader->bind();
+                        gPipeline.bindDeferredShader(*target_shader);
                     }
 
                     LLVector4 spec_color(1, 1, 1, 1);
-- 
cgit v1.2.3


From 9448db5d4af7bba094e5bc51f85e5c2491d3f5a1 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 6 Oct 2022 18:40:01 -0500
Subject: SL-18190 Water shader WIP.  Better parallax correction for sphere
 probes.  Reduce probe memory footprint.  Remove framebuffer copies and move
 to deprecate stencil buffer usage.

---
 indra/newview/lldrawpoolalpha.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index a985807a38..fb2a4d78fc 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -167,10 +167,10 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField") && !gCubeSnapshot)
     { 
         //update depth buffer sampler
-        gPipeline.mRT->screen.flush();
+        /*gPipeline.mRT->screen.flush();
         gPipeline.mRT->deferredDepth.copyContents(gPipeline.mRT->deferredScreen, 0, 0, gPipeline.mRT->deferredScreen.getWidth(), gPipeline.mRT->deferredScreen.getHeight(),
             0, 0, gPipeline.mRT->deferredDepth.getWidth(), gPipeline.mRT->deferredDepth.getHeight(), GL_DEPTH_BUFFER_BIT, GL_NEAREST);
-        gPipeline.mRT->deferredDepth.bindTarget();
+        gPipeline.mRT->deferredDepth.bindTarget();*/
         simple_shader = fullbright_shader = &gObjectFullbrightAlphaMaskProgram;
 
         simple_shader->bind();
@@ -798,7 +798,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                 bool tex_setup = TexSetup(&params, (mat != nullptr));
 
 				{
-					LLGLEnableFunc stencil_test(GL_STENCIL_TEST, params.mSelected, &LLGLCommonFunc::selected_stencil_test);
+					//LLGLEnableFunc stencil_test(GL_STENCIL_TEST, params.mSelected, &LLGLCommonFunc::selected_stencil_test);
 
 					gGL.blendFunc((LLRender::eBlendFactor) params.mBlendFuncSrc, (LLRender::eBlendFactor) params.mBlendFuncDst, mAlphaSFactor, mAlphaDFactor);
 
-- 
cgit v1.2.3


From 18309bc7fbfefa7aec29b24b727de7fe07da96fe Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 7 Oct 2022 15:25:48 -0500
Subject: SL-18190 Fix for DoF

---
 indra/newview/lldrawpoolalpha.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index fb2a4d78fc..8a912b00d9 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -184,8 +184,8 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
         renderAlpha(getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2, 
             true); // <--- discard mostly transparent faces
 
-        gPipeline.mRT->deferredDepth.flush();
-        gPipeline.mRT->screen.bindTarget();
+        //gPipeline.mRT->deferredDepth.flush();
+        //gPipeline.mRT->screen.bindTarget();
         gGL.setColorMask(true, false);
     }
 
-- 
cgit v1.2.3


From 07bca31e06e4219401f82ae04539418c65e22ea8 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 10 Oct 2022 18:53:43 -0500
Subject: SL-18190 Fix alpha not playing nice with water surface by split
 LLDrawPoolAlpha into two passes, one above water, one below water, and clip
 against water plane.  Currently brute forces two complete alpha passes, still
 need to cull against water plane and add support for fullbright shaders.

---
 indra/newview/lldrawpoolalpha.cpp | 36 +++++++++++++++++++++++++++++++-----
 1 file changed, 31 insertions(+), 5 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 8a912b00d9..0d9e83a976 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -56,6 +56,8 @@ BOOL LLDrawPoolAlpha::sShowDebugAlpha = FALSE;
 
 #define current_shader (LLGLSLShader::sCurBoundShaderPtr)
 
+LLVector4 LLDrawPoolAlpha::sWaterPlane;
+
 static BOOL deferred_render = FALSE;
 
 // minimum alpha before discarding a fragment
@@ -96,11 +98,13 @@ S32 LLDrawPoolAlpha::getNumPostDeferredPasses()
 }
 
 // set some common parameters on the given shader to prepare for alpha rendering
-static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool deferredEnvironment)
+static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool deferredEnvironment, F32 water_sign)
 {
     static LLCachedControl<F32> displayGamma(gSavedSettings, "RenderDeferredDisplayGamma");
     F32 gamma = displayGamma;
 
+    static LLStaticHashedString waterSign("waterSign");
+
     // Does this deferred shader need environment uniforms set such as sun_dir, etc. ?
     // NOTE: We don't actually need a gbuffer since we are doing forward rendering (for transparency) post deferred rendering
     // TODO: bindDeferredShader() probably should have the updating of the environment uniforms factored out into updateShaderEnvironmentUniforms()
@@ -115,6 +119,8 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
     }
     shader->uniform1i(LLShaderMgr::NO_ATMO, (LLPipeline::sRenderingHUDs) ? 1 : 0);
     shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f / 2.2f));
+    shader->uniform1f(waterSign, water_sign);
+    shader->uniform4fv(LLShaderMgr::WATER_WATERPLANE, 1, LLDrawPoolAlpha::sWaterPlane.mV);
 
     if (LLPipeline::sImpostorRender)
     {
@@ -132,7 +138,7 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
     //also prepare rigged variant
     if (shader->mRiggedVariant && shader->mRiggedVariant != shader)
     { 
-        prepare_alpha_shader(shader->mRiggedVariant, textureGamma, deferredEnvironment);
+        prepare_alpha_shader(shader->mRiggedVariant, textureGamma, deferredEnvironment, water_sign);
     }
 }
 
@@ -143,19 +149,39 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
     deferred_render = TRUE;
 
+    F32 water_sign = 1.f;
+
+    if (getType() == LLDrawPool::POOL_ALPHA_PRE_WATER)
+    {
+        water_sign = -1.f;
+    }
+
+    if (LLPipeline::sUnderWaterRender)
+    {
+        water_sign *= -1.f;
+    }
+
     // prepare shaders
     emissive_shader = (LLPipeline::sRenderDeferred)   ? &gDeferredEmissiveProgram    :
                       (LLPipeline::sUnderWaterRender) ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
-    prepare_alpha_shader(emissive_shader, true, false);
+    prepare_alpha_shader(emissive_shader, true, false, water_sign);
 
     fullbright_shader   = (LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
         (LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterProgram : &gDeferredFullbrightAlphaMaskProgram;
-    prepare_alpha_shader(fullbright_shader, true, true);
+    prepare_alpha_shader(fullbright_shader, true, true, water_sign);
 
     simple_shader   = (LLPipeline::sImpostorRender) ? &gDeferredAlphaImpostorProgram :
         (LLPipeline::sUnderWaterRender) ? &gDeferredAlphaWaterProgram : &gDeferredAlphaProgram;
-    prepare_alpha_shader(simple_shader, false, true); //prime simple shader (loads shadow relevant uniforms)
+    prepare_alpha_shader(simple_shader, false, true, water_sign); //prime simple shader (loads shadow relevant uniforms)
+
+
+    LLGLSLShader* materialShader = LLPipeline::sUnderWaterRender ? gDeferredMaterialWaterProgram : gDeferredMaterialProgram;
+    for (int i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
+    {
+        prepare_alpha_shader(&materialShader[i], false, false, water_sign);
+    }
 
+    prepare_alpha_shader(&gDeferredPBRAlphaProgram, false, false, water_sign);
 
     // first pass, render rigged objects only and render to depth buffer
     forwardRender(true);
-- 
cgit v1.2.3


From 42ec639c860e172803753b9cb41ae9483305f2f8 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 12 Oct 2022 14:46:51 -0500
Subject: SL-18190 Remove water reflection detail combo box and reimplement
 "Transparent Water" checkbox.

---
 indra/newview/lldrawpoolalpha.cpp | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 0d9e83a976..01b2647eaa 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -147,6 +147,11 @@ extern BOOL gCubeSnapshot;
 void LLDrawPoolAlpha::renderPostDeferred(S32 pass) 
 { 
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
+
+    if ((!LLPipeline::sRenderTransparentWater || gCubeSnapshot) && getType() == LLDrawPool::POOL_ALPHA_PRE_WATER)
+    { // don't render alpha objects on the other side of the water plane if water is opaque
+        return;
+    }
     deferred_render = TRUE;
 
     F32 water_sign = 1.f;
-- 
cgit v1.2.3


From de4c018499ddaebbe466fb5a8938554a2d4a3b19 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 19 Oct 2022 14:41:17 -0500
Subject: SL-18105 Hook up render pipe directly to
 LLTextureEntry::mGLTFMaterial and add LLViewerFetchedTextures to
 LLFetchedGLTFMaterial.  Lower reflection probe resolution to 128x128 per
 side.

---
 indra/newview/lldrawpoolalpha.cpp | 40 +--------------------------------------
 1 file changed, 1 insertion(+), 39 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 01b2647eaa..41e52846b3 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -675,45 +675,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         gPipeline.bindDeferredShader(*target_shader);
                     }
 
-                    if (params.mTexture.notNull())
-                    {
-                        gGL.getTexUnit(0)->bindFast(params.mTexture); // diffuse
-                    }
-                    else
-                    {
-                        gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::sWhiteImagep);
-                    }
-
-                    if (params.mNormalMap)
-                    {
-                        target_shader->bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
-                    }
-                    else
-                    {
-                        target_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);
-                    }
-
-                    if (params.mSpecularMap)
-                    {
-                        target_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap); // PBR linear packed Occlusion, Roughness, Metal.
-                    }
-                    else
-                    {
-                        target_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
-                    }
-
-                    if (params.mEmissiveMap)
-                    {
-                        target_shader->bindTexture(LLShaderMgr::EMISSIVE_MAP, params.mEmissiveMap);  // PBR sRGB Emissive
-                    }
-                    else
-                    {
-                        target_shader->bindTexture(LLShaderMgr::EMISSIVE_MAP, LLViewerFetchedTexture::sWhiteImagep);
-                    }
-
-                    target_shader->uniform1f(LLShaderMgr::ROUGHNESS_FACTOR, params.mGLTFMaterial->mRoughnessFactor);
-                    target_shader->uniform1f(LLShaderMgr::METALLIC_FACTOR, params.mGLTFMaterial->mMetallicFactor);
-                    target_shader->uniform3fv(LLShaderMgr::EMISSIVE_COLOR, 1, params.mGLTFMaterial->mEmissiveColor.mV);
+                    params.mGLTFMaterial->bind(target_shader);
                 }
                 else
                 {
-- 
cgit v1.2.3


From 8d2ac419b22c8c9475f2efb312dd198ac8eb9fb7 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 16 Nov 2022 14:49:17 -0600
Subject: SL-18154 Profile guided optimizations vs release viewer.  Trim some
 unused abilities and remove some more fast timers.

---
 indra/newview/lldrawpoolalpha.cpp | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index aa8d4d167e..71b568a436 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -406,7 +406,7 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
                         params.mGroup->rebuildMesh();
                     }
                     params.mVertexBuffer->setBufferFast(rigged ? mask | LLVertexBuffer::MAP_WEIGHT4 : mask);
-                    params.mVertexBuffer->drawRangeFast(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
+                    params.mVertexBuffer->drawRangeFast(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
                 }
             }
         }
@@ -435,7 +435,7 @@ inline void Draw(LLDrawInfo* draw, U32 mask)
 {
     draw->mVertexBuffer->setBufferFast(mask);
     LLRenderPass::applyModelMatrix(*draw);
-	draw->mVertexBuffer->drawRangeFast(draw->mDrawMode, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);                    
+	draw->mVertexBuffer->drawRangeFast(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);                    
 }
 
 bool LLDrawPoolAlpha::TexSetup(LLDrawInfo* draw, bool use_material)
@@ -531,7 +531,7 @@ void LLDrawPoolAlpha::drawEmissive(U32 mask, LLDrawInfo* draw)
 {
     LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, 1.f);
     draw->mVertexBuffer->setBufferFast((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
-	draw->mVertexBuffer->drawRangeFast(draw->mDrawMode, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
+	draw->mVertexBuffer->drawRangeFast(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
 }
 
 
@@ -678,7 +678,8 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
                     if (current_shader != target_shader)
                     {
-                        gPipeline.bindDeferredShader(*target_shader);
+                        target_shader->bind();
+                        //gPipeline.bindDeferredShader(*target_shader);
                     }
 
                     params.mGLTFMaterial->bind(target_shader);
@@ -729,7 +730,8 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
                         if (current_shader != target_shader)
                         {
-                            gPipeline.bindDeferredShader(*target_shader);
+                            //gPipeline.bindDeferredShader(*target_shader);
+                            target_shader->bind();
                         }
                     }
                     else if (!params.mFullbright)
@@ -750,7 +752,8 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     if (current_shader != target_shader)
                     {// If we need shaders, and we're not ALREADY using the proper shader, then bind it
                     // (this way we won't rebind shaders unnecessarily).
-                        gPipeline.bindDeferredShader(*target_shader);
+                        //gPipeline.bindDeferredShader(*target_shader);
+                        target_shader->bind();
                     }
 
                     LLVector4 spec_color(1, 1, 1, 1);
@@ -821,7 +824,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     }
 
                     params.mVertexBuffer->setBufferFast(drawMask);
-                    params.mVertexBuffer->drawRangeFast(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
+                    params.mVertexBuffer->drawRangeFast(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
 
                     if (reset_minimum_alpha)
                     {
-- 
cgit v1.2.3


From e2d1af5c4f7bdc04becb4a4fd56b7e9057bdfedc Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 17 Nov 2022 13:35:39 -0600
Subject: SL-18154 Profile guided optimizations -- remove some unneeded
 operations and make LLDrawPoolMaterials less branchy.

---
 indra/newview/lldrawpoolalpha.cpp | 2 --
 1 file changed, 2 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 71b568a436..5ed6d3cc2a 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -459,13 +459,11 @@ bool LLDrawPoolAlpha::TexSetup(LLDrawInfo* draw, bool use_material)
         {
             if (draw->mNormalMap)
             {
-                draw->mNormalMap->addTextureStats(draw->mVSize);
                 current_shader->bindTexture(LLShaderMgr::BUMP_MAP, draw->mNormalMap);
             }
 
             if (draw->mSpecularMap)
             {
-                draw->mSpecularMap->addTextureStats(draw->mVSize);
                 current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, draw->mSpecularMap);
             }
         }
-- 
cgit v1.2.3


From b1dabc0f008bf0e6558a93bca2a2d818073a03c1 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 18 Nov 2022 11:45:04 -0600
Subject: SL-18669 Fix for broken lighting on transparent faces.  Optimize
 handling of "bindDeferredShader" and shadow map setup.

---
 indra/newview/lldrawpoolalpha.cpp | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 5ed6d3cc2a..437a0c2ea1 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -183,10 +183,10 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     LLGLSLShader* materialShader = LLPipeline::sUnderWaterRender ? gDeferredMaterialWaterProgram : gDeferredMaterialProgram;
     for (int i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
     {
-        prepare_alpha_shader(&materialShader[i], false, false, water_sign);
+        prepare_alpha_shader(&materialShader[i], false, true, water_sign);
     }
 
-    prepare_alpha_shader(&gDeferredPBRAlphaProgram, false, false, water_sign);
+    prepare_alpha_shader(&gDeferredPBRAlphaProgram, false, true, water_sign);
 
     // first pass, render rigged objects only and render to depth buffer
     forwardRender(true);
@@ -674,10 +674,10 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         target_shader = target_shader->mRiggedVariant;
                     }
 
+                    // shader must be bound before LLGLTFMaterial::bind
                     if (current_shader != target_shader)
                     {
-                        target_shader->bind();
-                        //gPipeline.bindDeferredShader(*target_shader);
+                        gPipeline.bindDeferredShaderFast(*target_shader);
                     }
 
                     params.mGLTFMaterial->bind(target_shader);
@@ -725,12 +725,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                             llassert(target_shader->mRiggedVariant != nullptr);
                             target_shader = target_shader->mRiggedVariant;
                         }
-
-                        if (current_shader != target_shader)
-                        {
-                            //gPipeline.bindDeferredShader(*target_shader);
-                            target_shader->bind();
-                        }
                     }
                     else if (!params.mFullbright)
                     {
@@ -750,8 +744,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     if (current_shader != target_shader)
                     {// If we need shaders, and we're not ALREADY using the proper shader, then bind it
                     // (this way we won't rebind shaders unnecessarily).
-                        //gPipeline.bindDeferredShader(*target_shader);
-                        target_shader->bind();
+                        gPipeline.bindDeferredShaderFast(*target_shader);
                     }
 
                     LLVector4 spec_color(1, 1, 1, 1);
-- 
cgit v1.2.3


From 8aa65f67975fc362d1fcf1d085d646f5fa68798d Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 22 Nov 2022 16:01:18 -0600
Subject: SL-18697 Fix for particle textures not loading.

---
 indra/newview/lldrawpoolalpha.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 437a0c2ea1..759aa078ff 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -767,10 +767,10 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     }
                 }
 
-				if (params.mGroup)
-				{
-					params.mGroup->rebuildMesh();
-				}
+				//if (params.mGroup) // TOO LATE
+				//{
+				//	params.mGroup->rebuildMesh();
+				//}
 
                 if (params.mAvatar != nullptr)
                 {
-- 
cgit v1.2.3


From 3c20f0b1d4dd7257dc608823d82b6f798c492b43 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 5 Dec 2022 11:48:50 -0600
Subject: SL-18692 Fix for fullbright alpha not clipping against water plane
 (also fixes ultraspace particles).

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 759aa078ff..c09de14b23 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -173,7 +173,7 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     prepare_alpha_shader(emissive_shader, true, false, water_sign);
 
     fullbright_shader   = (LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
-        (LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterProgram : &gDeferredFullbrightAlphaMaskProgram;
+        (LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterAlphaProgram : &gDeferredFullbrightAlphaMaskAlphaProgram;
     prepare_alpha_shader(fullbright_shader, true, true, water_sign);
 
     simple_shader   = (LLPipeline::sImpostorRender) ? &gDeferredAlphaImpostorProgram :
-- 
cgit v1.2.3


From 20c578b7ae512e7c8128eb78f9dc4080fd556a91 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 13 Dec 2022 11:40:14 -0600
Subject: SL-18808 Fix for highlight transparent texture missing.

---
 indra/newview/lldrawpoolalpha.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index c09de14b23..6e0913705d 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -315,8 +315,7 @@ void LLDrawPoolAlpha::renderDebugAlpha()
 	{
         gHighlightProgram.bind();
         gGL.diffuseColor4f(1, 0, 0, 1);
-        LLViewerFetchedTexture::sSmokeImagep->addTextureStats(1024.f * 1024.f);
-        gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::sSmokeImagep);
+        gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::getSmokeImage());
 
         renderAlphaHighlight(LLVertexBuffer::MAP_VERTEX |
             LLVertexBuffer::MAP_TEXCOORD0);
-- 
cgit v1.2.3


From d27d23ab269f6d22483c4b4dc1db1664cf3e441e Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 16 Dec 2022 11:12:06 -0600
Subject: SL-18852 Refactor GLTF material rendering to not be special compared
 to other types.  Hook GLTF alpha masking up to highlight transparent.

---
 indra/newview/lldrawpoolalpha.cpp | 41 +++++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 19 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 6e0913705d..dc7e5f51df 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -317,39 +317,42 @@ void LLDrawPoolAlpha::renderDebugAlpha()
         gGL.diffuseColor4f(1, 0, 0, 1);
         gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::getSmokeImage());
 
-        renderAlphaHighlight(LLVertexBuffer::MAP_VERTEX |
-            LLVertexBuffer::MAP_TEXCOORD0);
+        U32 mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0;
 
-		pushBatches(LLRenderPass::PASS_ALPHA_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-		pushBatches(LLRenderPass::PASS_ALPHA_INVISIBLE, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
+        renderAlphaHighlight(mask);
+
+		pushBatches(LLRenderPass::PASS_ALPHA_MASK, mask, FALSE);
+		pushBatches(LLRenderPass::PASS_ALPHA_INVISIBLE, mask, FALSE);
 
 		// Material alpha mask
 		gGL.diffuseColor4f(0, 0, 1, 1);
-		pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-		pushBatches(LLRenderPass::PASS_NORMMAP_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-		pushBatches(LLRenderPass::PASS_SPECMAP_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-		pushBatches(LLRenderPass::PASS_NORMSPEC_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-		pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
+		pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, mask, FALSE);
+		pushBatches(LLRenderPass::PASS_NORMMAP_MASK, mask, FALSE);
+		pushBatches(LLRenderPass::PASS_SPECMAP_MASK, mask, FALSE);
+		pushBatches(LLRenderPass::PASS_NORMSPEC_MASK, mask, FALSE);
+		pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, mask, FALSE);
+        pushBatches(LLRenderPass::PASS_GLTF_PBR_ALPHA_MASK, mask, FALSE);
 
 		gGL.diffuseColor4f(0, 1, 0, 1);
-		pushBatches(LLRenderPass::PASS_INVISIBLE, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
+		pushBatches(LLRenderPass::PASS_INVISIBLE, mask, FALSE);
 
         gHighlightProgram.mRiggedVariant->bind();
         gGL.diffuseColor4f(1, 0, 0, 1);
 
-        pushRiggedBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_ALPHA_INVISIBLE_RIGGED, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_ALPHA_INVISIBLE_RIGGED, mask, FALSE);
 
         // Material alpha mask
         gGL.diffuseColor4f(0, 0, 1, 1);
-        pushRiggedBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK_RIGGED, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_NORMMAP_MASK_RIGGED, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_SPECMAP_MASK_RIGGED, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_NORMSPEC_MASK_RIGGED, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_NORMMAP_MASK_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_SPECMAP_MASK_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_NORMSPEC_MASK_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_GLTF_PBR_ALPHA_MASK_RIGGED, mask, FALSE);
 
         gGL.diffuseColor4f(0, 1, 0, 1);
-        pushRiggedBatches(LLRenderPass::PASS_INVISIBLE_RIGGED, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_INVISIBLE_RIGGED, mask, FALSE);
         LLGLSLShader::sCurBoundShaderPtr->unbind();
 	}
 }
@@ -679,7 +682,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         gPipeline.bindDeferredShaderFast(*target_shader);
                     }
 
-                    params.mGLTFMaterial->bind(target_shader);
+                    params.mGLTFMaterial->bind();
                 }
                 else
                 {
-- 
cgit v1.2.3


From a710bf9067bd4c4217b9febc0ad277a1636ec882 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 9 Jan 2023 15:18:57 -0600
Subject: SL-18869 Optimizations -- Use _mm_prefetch to cut down on cache
 misses when iterating over render batches.

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index dc7e5f51df..3ce2ced255 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -634,7 +634,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     continue;
                 }
 
-                LL_PROFILE_ZONE_NAMED_CATEGORY_DRAWPOOL("ra - push batch")
+                LL_PROFILE_ZONE_NAMED_CATEGORY_DRAWPOOL("ra - push batch");
 
                 U32 have_mask = params.mVertexBuffer->getTypeMask() & mask;
 				if (have_mask != mask)
-- 
cgit v1.2.3


From 4abf39c968c31a9da943a53434388102b99d487f Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 10 Jan 2023 11:42:12 -0600
Subject: SL-18869 Optimizations -- Bring back water plane clipping for
 above/below water where applicable.

---
 indra/newview/lldrawpoolalpha.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 3ce2ced255..07381acd25 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -600,6 +600,16 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
         begin = gPipeline.beginAlphaGroups();
         end = gPipeline.endAlphaGroups();
     }
+    
+    LLEnvironment& env = LLEnvironment::instance();
+    F32 water_height = env.getWaterHeight();
+
+    bool above_water = getType() == LLDrawPool::POOL_ALPHA_POST_WATER;
+    if (LLPipeline::sUnderWaterRender)
+    {
+        above_water = !above_water;
+    }
+
 
     for (LLCullResult::sg_iterator i = begin; i != end; ++i)
 	{
@@ -611,6 +621,25 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 		if (group->getSpatialPartition()->mRenderByGroup &&
 		    !group->isDead())
 		{
+
+            LLSpatialBridge* bridge = group->getSpatialPartition()->asBridge();
+            const LLVector4a* ext = bridge ? bridge->getSpatialExtents() : group->getExtents();
+
+            if (above_water)
+            { // reject any spatial groups that have no part above water
+                if (ext[1].getF32ptr()[2] < water_height)
+                {
+                    continue;
+                }
+            }
+            else
+            { // reject any spatial groups that he no part below water
+                if (ext[0].getF32ptr()[2] > water_height)
+                {
+                    continue;
+                }
+            }
+
             static std::vector<LLDrawInfo*> emissives;
             static std::vector<LLDrawInfo*> rigged_emissives;
             emissives.resize(0);
-- 
cgit v1.2.3


From 7bd9d21e19b923096ba2b5ea3cbc8be3e13d7aa0 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Thu, 19 Jan 2023 09:13:45 -0600
Subject: Optimizations, decruft, and intel compatibility pass (#53)

SL-18869, SL-18772  Overhaul VBO management, restore occlusion culling, intel compatibility pass, etc
---
 indra/newview/lldrawpoolalpha.cpp | 59 ++++++---------------------------------
 1 file changed, 8 insertions(+), 51 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 07381acd25..ed952689fa 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -379,11 +379,6 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
                 {
                     LLDrawInfo& params = **k;
 
-                    if (params.mParticle)
-                    {
-                        continue;
-                    }
-
                     bool rigged = (params.mAvatar != nullptr);
                     gHighlightProgram.bind(rigged);
                     gGL.diffuseColor4f(1, 0, 0, 1);
@@ -403,12 +398,8 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
                     }
 
                     LLRenderPass::applyModelMatrix(params);
-                    if (params.mGroup)
-                    {
-                        params.mGroup->rebuildMesh();
-                    }
-                    params.mVertexBuffer->setBufferFast(rigged ? mask | LLVertexBuffer::MAP_WEIGHT4 : mask);
-                    params.mVertexBuffer->drawRangeFast(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
+                    params.mVertexBuffer->setBuffer();
+                    params.mVertexBuffer->drawRange(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
                 }
             }
         }
@@ -435,9 +426,9 @@ inline bool IsEmissive(LLDrawInfo& params)
 
 inline void Draw(LLDrawInfo* draw, U32 mask)
 {
-    draw->mVertexBuffer->setBufferFast(mask);
+    draw->mVertexBuffer->setBuffer();
     LLRenderPass::applyModelMatrix(*draw);
-	draw->mVertexBuffer->drawRangeFast(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);                    
+	draw->mVertexBuffer->drawRange(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);                    
 }
 
 bool LLDrawPoolAlpha::TexSetup(LLDrawInfo* draw, bool use_material)
@@ -530,8 +521,8 @@ void LLDrawPoolAlpha::RestoreTexSetup(bool tex_setup)
 void LLDrawPoolAlpha::drawEmissive(U32 mask, LLDrawInfo* draw)
 {
     LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, 1.f);
-    draw->mVertexBuffer->setBufferFast((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
-	draw->mVertexBuffer->drawRangeFast(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
+    draw->mVertexBuffer->setBuffer();
+	draw->mVertexBuffer->drawRange(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
 }
 
 
@@ -665,30 +656,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
                 LL_PROFILE_ZONE_NAMED_CATEGORY_DRAWPOOL("ra - push batch");
 
-                U32 have_mask = params.mVertexBuffer->getTypeMask() & mask;
-				if (have_mask != mask)
-				{ //FIXME!
-					LL_WARNS_ONCE() << "Missing required components, expected mask: " << mask
-									<< " present: " << have_mask
-									<< ". Skipping render batch." << LL_ENDL;
-					continue;
-				}
-
-				if(depth_only)
-				{
-                    // when updating depth buffer, discard faces that are more than 90% transparent
-					LLFace*	face = params.mFace;
-					if(face)
-					{
-						const LLTextureEntry* tep = face->getTextureEntry();
-						if(tep)
-						{ // don't render faces that are more than 90% transparent
-							if(tep->getColor().mV[3] < MINIMUM_IMPOSTOR_ALPHA)
-								continue;
-						}
-					}
-				}
-
                 LLRenderPass::applyModelMatrix(params);
 
                 LLMaterial* mat = NULL;
@@ -835,18 +802,8 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         reset_minimum_alpha = true;
                     }
                     
-                    U32 drawMask = mask;
-                    if (params.mFullbright)
-                    {
-                        drawMask &= ~(LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2);
-                    }
-                    if (params.mAvatar != nullptr)
-                    {
-                        drawMask |= LLVertexBuffer::MAP_WEIGHT4;
-                    }
-
-                    params.mVertexBuffer->setBufferFast(drawMask);
-                    params.mVertexBuffer->drawRangeFast(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
+                    params.mVertexBuffer->setBuffer();
+                    params.mVertexBuffer->drawRange(LLRender::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset);
 
                     if (reset_minimum_alpha)
                     {
-- 
cgit v1.2.3


From c83e66414848e468cce01d36c1054b2e9314baf9 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 20 Jan 2023 13:00:40 -0600
Subject: SL-18869 GL 3 compatibility pass and minor decruft.

---
 indra/newview/lldrawpoolalpha.cpp | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index ed952689fa..20d3818934 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -86,11 +86,6 @@ void LLDrawPoolAlpha::prerender()
     // TODO: is this even necessay?  These are probably set to never discard
     LLViewerFetchedTexture::sFlatNormalImagep->addTextureStats(1024.f*1024.f);
     LLViewerFetchedTexture::sWhiteImagep->addTextureStats(1024.f * 1024.f);
-
-    if (LLPipeline::sRenderPBR)
-    {
-        gPipeline.setupHWLights(NULL);
-    }
 }
 
 S32 LLDrawPoolAlpha::getNumPostDeferredPasses() 
@@ -659,12 +654,11 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                 LLRenderPass::applyModelMatrix(params);
 
                 LLMaterial* mat = NULL;
-                LLGLTFMaterial *gltf_mat = params.mGLTFMaterial; // Also see: LLPipeline::getPoolTypeFromTE()
-                bool is_pbr = LLPipeline::sRenderPBR && gltf_mat;
+                LLGLTFMaterial *gltf_mat = params.mGLTFMaterial; 
 
-                LLGLDisable cull_face(is_pbr && gltf_mat->mDoubleSided ? GL_CULL_FACE : 0);
+                LLGLDisable cull_face(gltf_mat && gltf_mat->mDoubleSided ? GL_CULL_FACE : 0);
 
-                if (is_pbr && gltf_mat->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_BLEND)
+                if (gltf_mat && gltf_mat->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_BLEND)
                 {
                     target_shader = &gDeferredPBRAlphaProgram;
                     if (params.mAvatar != nullptr)
-- 
cgit v1.2.3


From a851aa83e705fa4a1c78919cfcac6709cfb1a875 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 24 Jan 2023 12:50:17 -0600
Subject: SL-18958 Fix for broken water distortion map and depth buffer. 
 Incidental decruft.

---
 indra/newview/lldrawpoolalpha.cpp | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 20d3818934..9f1dc979f8 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -193,10 +193,6 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField") && !gCubeSnapshot)
     { 
         //update depth buffer sampler
-        /*gPipeline.mRT->screen.flush();
-        gPipeline.mRT->deferredDepth.copyContents(gPipeline.mRT->deferredScreen, 0, 0, gPipeline.mRT->deferredScreen.getWidth(), gPipeline.mRT->deferredScreen.getHeight(),
-            0, 0, gPipeline.mRT->deferredDepth.getWidth(), gPipeline.mRT->deferredDepth.getHeight(), GL_DEPTH_BUFFER_BIT, GL_NEAREST);
-        gPipeline.mRT->deferredDepth.bindTarget();*/
         simple_shader = fullbright_shader = &gObjectFullbrightAlphaMaskProgram;
 
         simple_shader->bind();
@@ -210,8 +206,6 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
         renderAlpha(getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2, 
             true); // <--- discard mostly transparent faces
 
-        //gPipeline.mRT->deferredDepth.flush();
-        //gPipeline.mRT->screen.bindTarget();
         gGL.setColorMask(true, false);
     }
 
-- 
cgit v1.2.3


From 4694a46f7bbbb5ec57d4695d13e0a557b1d094da Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 2 Feb 2023 10:48:15 -0600
Subject: SL-18983 Fix for alpha HUDs not rendering.

---
 indra/newview/lldrawpoolalpha.cpp | 39 ++++++++++++++++++++++++++-------------
 1 file changed, 26 insertions(+), 13 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 9f1dc979f8..4c8d32fad2 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -115,8 +115,18 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
     }
     shader->uniform1i(LLShaderMgr::NO_ATMO, (LLPipeline::sRenderingHUDs) ? 1 : 0);
     shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f / 2.2f));
-    shader->uniform1f(waterSign, water_sign);
-    shader->uniform4fv(LLShaderMgr::WATER_WATERPLANE, 1, LLDrawPoolAlpha::sWaterPlane.mV);
+
+    if (LLPipeline::sRenderingHUDs)
+    { // for HUD attachments, only the pre-water pass is executed and we never want to clip anything
+        LLVector4 near_clip(0, 0, -1, 0);
+        shader->uniform1f(waterSign, 1.f);
+        shader->uniform4fv(LLShaderMgr::WATER_WATERPLANE, 1, near_clip.mV);
+    }
+    else
+    {
+        shader->uniform1f(waterSign, water_sign);
+        shader->uniform4fv(LLShaderMgr::WATER_WATERPLANE, 1, LLDrawPoolAlpha::sWaterPlane.mV);
+    }
 
     if (LLPipeline::sImpostorRender)
     {
@@ -605,18 +615,21 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
             LLSpatialBridge* bridge = group->getSpatialPartition()->asBridge();
             const LLVector4a* ext = bridge ? bridge->getSpatialExtents() : group->getExtents();
 
-            if (above_water)
-            { // reject any spatial groups that have no part above water
-                if (ext[1].getF32ptr()[2] < water_height)
-                {
-                    continue;
+            if (!LLPipeline::sRenderingHUDs) // ignore above/below water for HUD render
+            {
+                if (above_water)
+                { // reject any spatial groups that have no part above water
+                    if (ext[1].getF32ptr()[2] < water_height)
+                    {
+                        continue;
+                    }
                 }
-            }
-            else
-            { // reject any spatial groups that he no part below water
-                if (ext[0].getF32ptr()[2] > water_height)
-                {
-                    continue;
+                else
+                { // reject any spatial groups that he no part below water
+                    if (ext[0].getF32ptr()[2] > water_height)
+                    {
+                        continue;
+                    }
                 }
             }
 
-- 
cgit v1.2.3


From 93b1da52f56293663d9bfe5272a83a77185f4cff Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 2 Feb 2023 14:35:09 -0600
Subject: SL-18908 Make media texture override base color and emissive texture
 on PBR materials when present.

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 4c8d32fad2..d3d5235770 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -679,7 +679,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         gPipeline.bindDeferredShaderFast(*target_shader);
                     }
 
-                    params.mGLTFMaterial->bind();
+                    params.mGLTFMaterial->bind(params.mTexture);
                 }
                 else
                 {
-- 
cgit v1.2.3


From 830cb6b66551025285120fb628f0b5ebf3841756 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 3 Feb 2023 17:18:39 -0600
Subject: SL-19148 Decruft some forward shaders and drawpools.  Fix HUDs being
 in wrong color space.

---
 indra/newview/lldrawpoolalpha.cpp | 83 ++++++++++++---------------------------
 1 file changed, 25 insertions(+), 58 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index d3d5235770..a7ce1a9f87 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -113,7 +113,6 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
     {
         shader->bind();
     }
-    shader->uniform1i(LLShaderMgr::NO_ATMO, (LLPipeline::sRenderingHUDs) ? 1 : 0);
     shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f / 2.2f));
 
     if (LLPipeline::sRenderingHUDs)
@@ -173,16 +172,25 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     }
 
     // prepare shaders
-    emissive_shader = (LLPipeline::sRenderDeferred)   ? &gDeferredEmissiveProgram    :
-                      (LLPipeline::sUnderWaterRender) ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
+    llassert(LLPipeline::sRenderDeferred);
+
+    emissive_shader = &gDeferredEmissiveProgram;
+                      
     prepare_alpha_shader(emissive_shader, true, false, water_sign);
 
-    fullbright_shader   = (LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
-        (LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterAlphaProgram : &gDeferredFullbrightAlphaMaskAlphaProgram;
+    fullbright_shader   = 
+        (LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
+        (LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterAlphaProgram : 
+        (LLPipeline::sRenderingHUDs) ? &gHUDFullbrightAlphaMaskAlphaProgram :
+        &gDeferredFullbrightAlphaMaskAlphaProgram;
     prepare_alpha_shader(fullbright_shader, true, true, water_sign);
 
-    simple_shader   = (LLPipeline::sImpostorRender) ? &gDeferredAlphaImpostorProgram :
-        (LLPipeline::sUnderWaterRender) ? &gDeferredAlphaWaterProgram : &gDeferredAlphaProgram;
+    simple_shader   = 
+        (LLPipeline::sImpostorRender) ? &gDeferredAlphaImpostorProgram :
+        (LLPipeline::sUnderWaterRender) ? &gDeferredAlphaWaterProgram : 
+        (LLPipeline::sRenderingHUDs) ? &gHUDAlphaProgram :
+        &gDeferredAlphaProgram;
+
     prepare_alpha_shader(simple_shader, false, true, water_sign); //prime simple shader (loads shadow relevant uniforms)
 
     LLGLSLShader* materialShader = LLPipeline::sUnderWaterRender ? gDeferredMaterialWaterProgram : gDeferredMaterialProgram;
@@ -193,8 +201,11 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
 
     prepare_alpha_shader(&gDeferredPBRAlphaProgram, false, true, water_sign);
 
-    // first pass, render rigged objects only and render to depth buffer
-    forwardRender(true);
+    if (!LLPipeline::sRenderingHUDs)
+    {
+        // first pass, render rigged objects only and render to depth buffer
+        forwardRender(true);
+    }
 
     // second pass, regular forward alpha rendering
     forwardRender();
@@ -222,54 +233,6 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     deferred_render = FALSE;
 }
 
-//set some generic parameters for forward (non-deferred) rendering
-static void prepare_forward_shader(LLGLSLShader* shader, F32 minimum_alpha)
-{
-    shader->bind();
-    shader->setMinimumAlpha(minimum_alpha);
-    shader->uniform1i(LLShaderMgr::NO_ATMO, LLPipeline::sRenderingHUDs ? 1 : 0);
-
-    //also prepare rigged variant
-    if (shader->mRiggedVariant && shader->mRiggedVariant != shader)
-    {
-        prepare_forward_shader(shader->mRiggedVariant, minimum_alpha);
-    }
-}
-
-void LLDrawPoolAlpha::render(S32 pass)
-{
-    LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
-
-    simple_shader = (LLPipeline::sImpostorRender) ? &gObjectSimpleImpostorProgram :
-        (LLPipeline::sUnderWaterRender) ? &gObjectSimpleWaterProgram : &gObjectSimpleAlphaMaskProgram;
-
-    fullbright_shader = (LLPipeline::sImpostorRender) ? &gObjectFullbrightAlphaMaskProgram :
-        (LLPipeline::sUnderWaterRender) ? &gObjectFullbrightWaterProgram : &gObjectFullbrightAlphaMaskProgram;
-
-    emissive_shader = (LLPipeline::sImpostorRender) ? &gObjectEmissiveProgram :
-        (LLPipeline::sUnderWaterRender) ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
-
-    F32 minimum_alpha = MINIMUM_ALPHA;
-    if (LLPipeline::sImpostorRender)
-    {
-        minimum_alpha = MINIMUM_IMPOSTOR_ALPHA;
-    }
-
-    prepare_forward_shader(fullbright_shader, minimum_alpha);
-    prepare_forward_shader(simple_shader, minimum_alpha);
-
-    for (int i = 0; i < LLMaterial::SHADER_COUNT; ++i)
-    {
-        prepare_forward_shader(LLPipeline::sUnderWaterRender ? &gDeferredMaterialWaterProgram[i] : &gDeferredMaterialProgram[i], minimum_alpha);
-    }
-
-    //first pass -- rigged only and drawn to depth buffer
-    forwardRender(true);
-
-    //second pass -- non-rigged, no depth buffer writes
-    forwardRender();
-}
-
 void LLDrawPoolAlpha::forwardRender(bool rigged)
 {
     gPipeline.enableLightsDynamic();
@@ -707,7 +670,11 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         light_enabled = TRUE;
                     }
 
-                    if (deferred_render && mat)
+                    if (LLPipeline::sRenderingHUDs)
+                    {
+                        target_shader = fullbright_shader;
+                    }
+                    else if (deferred_render && mat)
                     {
                         U32 mask = params.mShaderMask;
 
-- 
cgit v1.2.3


From a2647e953aeee26ef99e62e0146adcd37c8afca1 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 7 Feb 2023 18:25:22 -0600
Subject: SL-18229 Fix for PBR materials on HUDs misbehaving.  Incidental
 decruft.

---
 indra/newview/lldrawpoolalpha.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index a7ce1a9f87..3dda24595e 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -199,7 +199,9 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
         prepare_alpha_shader(&materialShader[i], false, true, water_sign);
     }
 
-    prepare_alpha_shader(&gDeferredPBRAlphaProgram, false, true, water_sign);
+    pbr_shader = LLPipeline::sRenderingHUDs ? &gHUDPBRAlphaProgram : &gDeferredPBRAlphaProgram;
+
+    prepare_alpha_shader(pbr_shader, false, true, water_sign);
 
     if (!LLPipeline::sRenderingHUDs)
     {
@@ -211,10 +213,10 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     forwardRender();
 
     // final pass, render to depth for depth of field effects
-    if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField") && !gCubeSnapshot)
+    if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField") && !gCubeSnapshot && !LLPipeline::sRenderingHUDs)
     { 
         //update depth buffer sampler
-        simple_shader = fullbright_shader = &gObjectFullbrightAlphaMaskProgram;
+        simple_shader = fullbright_shader = &gDeferredFullbrightAlphaMaskProgram;
 
         simple_shader->bind();
         simple_shader->setMinimumAlpha(0.33f);
@@ -630,7 +632,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
                 if (gltf_mat && gltf_mat->mAlphaMode == LLGLTFMaterial::ALPHA_MODE_BLEND)
                 {
-                    target_shader = &gDeferredPBRAlphaProgram;
+                    target_shader = pbr_shader;
                     if (params.mAvatar != nullptr)
                     {
                         target_shader = target_shader->mRiggedVariant;
-- 
cgit v1.2.3


From 577f6a46f02ecfa4efabc0b379e44e4f53a0b391 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 9 Feb 2023 17:00:36 -0600
Subject: SL-19181 Modulate "glow" by PBR emissive.

---
 indra/newview/lldrawpoolalpha.cpp | 97 ++++++++++++++++++++++++++++++++++-----
 1 file changed, 85 insertions(+), 12 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 3dda24595e..f4b426c5ab 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -175,9 +175,12 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     llassert(LLPipeline::sRenderDeferred);
 
     emissive_shader = &gDeferredEmissiveProgram;
-                      
     prepare_alpha_shader(emissive_shader, true, false, water_sign);
 
+    pbr_emissive_shader = &gPBRGlowProgram;
+    prepare_alpha_shader(pbr_emissive_shader, true, false, water_sign);
+
+
     fullbright_shader   = 
         (LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
         (LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterAlphaProgram : 
@@ -482,7 +485,7 @@ void LLDrawPoolAlpha::RestoreTexSetup(bool tex_setup)
 	}
 }
 
-void LLDrawPoolAlpha::drawEmissive(U32 mask, LLDrawInfo* draw)
+void LLDrawPoolAlpha::drawEmissive(LLDrawInfo* draw)
 {
     LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, 1.f);
     draw->mVertexBuffer->setBuffer();
@@ -490,7 +493,7 @@ void LLDrawPoolAlpha::drawEmissive(U32 mask, LLDrawInfo* draw)
 }
 
 
-void LLDrawPoolAlpha::renderEmissives(U32 mask, std::vector<LLDrawInfo*>& emissives)
+void LLDrawPoolAlpha::renderEmissives(std::vector<LLDrawInfo*>& emissives)
 {
     emissive_shader->bind();
     emissive_shader->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, 1.f);
@@ -498,12 +501,25 @@ void LLDrawPoolAlpha::renderEmissives(U32 mask, std::vector<LLDrawInfo*>& emissi
     for (LLDrawInfo* draw : emissives)
     {
         bool tex_setup = TexSetup(draw, false);
-        drawEmissive(mask, draw);
+        drawEmissive(draw);
         RestoreTexSetup(tex_setup);
     }
 }
 
-void LLDrawPoolAlpha::renderRiggedEmissives(U32 mask, std::vector<LLDrawInfo*>& emissives)
+void LLDrawPoolAlpha::renderPbrEmissives(std::vector<LLDrawInfo*>& emissives)
+{
+    pbr_emissive_shader->bind();
+
+    for (LLDrawInfo* draw : emissives)
+    {
+        llassert(draw->mGLTFMaterial);
+        draw->mGLTFMaterial->bind(draw->mTexture);
+        draw->mVertexBuffer->setBuffer();
+        draw->mVertexBuffer->drawRange(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
+    }
+}
+
+void LLDrawPoolAlpha::renderRiggedEmissives(std::vector<LLDrawInfo*>& emissives)
 {
     LLGLDepthTest depth(GL_TRUE, GL_FALSE); //disable depth writes since "emissive" is additive so sorting doesn't matter
     LLGLSLShader* shader = emissive_shader->mRiggedVariant;
@@ -513,8 +529,6 @@ void LLDrawPoolAlpha::renderRiggedEmissives(U32 mask, std::vector<LLDrawInfo*>&
     LLVOAvatar* lastAvatar = nullptr;
     U64 lastMeshId = 0;
 
-    mask |= LLVertexBuffer::MAP_WEIGHT4;
-
     for (LLDrawInfo* draw : emissives)
     {
         bool tex_setup = TexSetup(draw, false);
@@ -527,11 +541,37 @@ void LLDrawPoolAlpha::renderRiggedEmissives(U32 mask, std::vector<LLDrawInfo*>&
             lastAvatar = draw->mAvatar;
             lastMeshId = draw->mSkinInfo->mHash;
         }
-        drawEmissive(mask, draw);
+        drawEmissive(draw);
         RestoreTexSetup(tex_setup);
     }
 }
 
+void LLDrawPoolAlpha::renderRiggedPbrEmissives(std::vector<LLDrawInfo*>& emissives)
+{
+    LLGLDepthTest depth(GL_TRUE, GL_FALSE); //disable depth writes since "emissive" is additive so sorting doesn't matter
+    pbr_emissive_shader->bind(true);
+    
+    LLVOAvatar* lastAvatar = nullptr;
+    U64 lastMeshId = 0;
+
+    for (LLDrawInfo* draw : emissives)
+    {
+        if (lastAvatar != draw->mAvatar || lastMeshId != draw->mSkinInfo->mHash)
+        {
+            if (!uploadMatrixPalette(*draw))
+            { // failed to upload matrix palette, skip rendering
+                continue;
+            }
+            lastAvatar = draw->mAvatar;
+            lastMeshId = draw->mSkinInfo->mHash;
+        }
+
+        draw->mGLTFMaterial->bind(draw->mTexture);
+        draw->mVertexBuffer->setBuffer();
+        draw->mVertexBuffer->drawRange(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
+    }
+}
+
 void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
@@ -600,8 +640,13 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
             static std::vector<LLDrawInfo*> emissives;
             static std::vector<LLDrawInfo*> rigged_emissives;
+            static std::vector<LLDrawInfo*> pbr_emissives;
+            static std::vector<LLDrawInfo*> pbr_rigged_emissives;
+
             emissives.resize(0);
             rigged_emissives.resize(0);
+            pbr_emissives.resize(0);
+            pbr_rigged_emissives.resize(0);
 
 			bool is_particle_or_hud_particle = group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
 													  || group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
@@ -787,11 +832,25 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 				{
                     if (params.mAvatar != nullptr)
                     {
-                        rigged_emissives.push_back(&params);
+                        if (params.mGLTFMaterial.isNull())
+                        {
+                            rigged_emissives.push_back(&params);
+                        }
+                        else
+                        {
+                            pbr_rigged_emissives.push_back(&params);
+                        }
                     }
                     else
                     {
-                        emissives.push_back(&params);
+                        if (params.mGLTFMaterial.isNull())
+                        {
+                            emissives.push_back(&params);
+                        }
+                        else
+                        {
+                            pbr_emissives.push_back(&params);
+                        }
                     }
 				}
 			
@@ -818,14 +877,28 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                 if (!emissives.empty())
                 {
                     light_enabled = true;
-                    renderEmissives(mask, emissives);
+                    renderEmissives(emissives);
+                    rebind = true;
+                }
+
+                if (!pbr_emissives.empty())
+                {
+                    light_enabled = true;
+                    renderPbrEmissives(pbr_emissives);
                     rebind = true;
                 }
 
                 if (!rigged_emissives.empty())
                 {
                     light_enabled = true;
-                    renderRiggedEmissives(mask, rigged_emissives);
+                    renderRiggedEmissives(rigged_emissives);
+                    rebind = true;
+                }
+
+                if (!pbr_rigged_emissives.empty())
+                {
+                    light_enabled = true;
+                    renderRiggedPbrEmissives(pbr_rigged_emissives);
                     rebind = true;
                 }
 
-- 
cgit v1.2.3


From 03bd681564f0b0a630f6330ab9c61daa4856e5fe Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Fri, 14 Apr 2023 19:24:21 -0500
Subject: DRTVWR-559 Balance night scenes against release, nudge glow down a
 smidge, remove exposure correction from legacy fullbright balance PBR
 materials against legacy.

---
 indra/newview/lldrawpoolalpha.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index f4b426c5ab..280be162bc 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -140,6 +140,12 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
         shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
     }
 
+    S32 channel = shader->enableTexture(LLShaderMgr::EXPOSURE_MAP);
+    if (channel > -1)
+    {
+        gGL.getTexUnit(channel)->bind(&gPipeline.mExposureMap);
+    }
+
     //also prepare rigged variant
     if (shader->mRiggedVariant && shader->mRiggedVariant != shader)
     { 
-- 
cgit v1.2.3


From e2dc40a76e1a6e191443c213d0f0474d36c83413 Mon Sep 17 00:00:00 2001
From: Brad Linden <brad@lindenlab.com>
Date: Wed, 26 Apr 2023 17:16:28 -0700
Subject: SL-19656 disabling trackAttachments() code after DRTVWR-559 &
 DRTVWR-539 merge

---
 indra/newview/lldrawpoolalpha.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index dd6cfab52c..da4c963a97 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -354,6 +354,7 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
                 {
                     LLDrawInfo& params = **k;
 
+# if 0 // TODO SL-19656 figure out how to reenable trackAttachments()
                     if(params.mFace)
                     {
                         LLViewerObject* vobj = (LLViewerObject *)params.mFace->getViewerObject();
@@ -362,6 +363,7 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
                             trackAttachments( vobj, params.mFace->isState(LLFace::RIGGED), &ratPtr );
                         }
                     }
+#endif
 
                     bool rigged = (params.mAvatar != nullptr);
                     gHighlightProgram.bind(rigged);
@@ -550,11 +552,13 @@ void LLDrawPoolAlpha::renderRiggedEmissives(std::vector<LLDrawInfo*>& emissives)
     for (LLDrawInfo* draw : emissives)
     {
         LL_PROFILE_ZONE_NAMED_CATEGORY_DRAWPOOL("Emissives");
+# if 0 // TODO SL-19656 figure out how to reenable trackAttachments()
         auto vobj = draw->mFace?draw->mFace->getViewerObject():nullptr;
         if(vobj && vobj->isAttachment())
         {
             trackAttachments( vobj, draw->mFace->isState(LLFace::RIGGED), &ratPtr );
         }
+#endif
 
         bool tex_setup = TexSetup(draw, false);
         if (lastAvatar != draw->mAvatar || lastMeshId != draw->mSkinInfo->mHash)
@@ -696,6 +700,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
                 LLRenderPass::applyModelMatrix(params);
 
+# if 0 // TODO SL-19656 figure out how to reenable trackAttachments()
                 if(params.mFace)
                 {
                     LLViewerObject* vobj = (LLViewerObject *)params.mFace->getViewerObject();
@@ -705,6 +710,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         trackAttachments( vobj, params.mFace->isState(LLFace::RIGGED), &ratPtr );
                     }
                 }
+#endif
 
                 LLMaterial* mat = NULL;
                 LLGLTFMaterial *gltf_mat = params.mGLTFMaterial; 
-- 
cgit v1.2.3


From 334d71e9107ae3c4d35b181f2ed6e5c9ff1de519 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Mon, 1 May 2023 17:05:09 -0500
Subject: SL-19656 Rewrite avatar and attachment render metrics to not
 interfere with render pipe and be representative of actual render cost
 instead of driver synchronization time.

* SL-19656 Rewrite avatar and attachment render metrics to not interfere with render pipe and be representative of actual render cost instead of driver synchronization time.

* SL-19656 Remove now dead code (trackAttachments et al).

* SL-19656 Fix for crash on GL <= 3.2
---
 indra/newview/lldrawpoolalpha.cpp | 36 ------------------------------------
 1 file changed, 36 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index da4c963a97..404039189b 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -49,7 +49,6 @@
 #include "llspatialpartition.h"
 #include "llglcommonfunc.h"
 #include "llvoavatar.h"
-#include "llperfstats.h"
 
 #include "llenvironment.h"
 
@@ -349,22 +348,10 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
             {
                 LLSpatialGroup::drawmap_elem_t& draw_info = group->mDrawMap[LLRenderPass::PASS_ALPHA+pass]; // <-- hacky + pass to use PASS_ALPHA_RIGGED on second pass 
 
-                std::unique_ptr<LLPerfStats::RecordAttachmentTime> ratPtr{}; // Render time Stats collection
                 for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)
                 {
                     LLDrawInfo& params = **k;
 
-# if 0 // TODO SL-19656 figure out how to reenable trackAttachments()
-                    if(params.mFace)
-                    {
-                        LLViewerObject* vobj = (LLViewerObject *)params.mFace->getViewerObject();
-                        if(vobj->isAttachment())
-                        {
-                            trackAttachments( vobj, params.mFace->isState(LLFace::RIGGED), &ratPtr );
-                        }
-                    }
-#endif
-
                     bool rigged = (params.mAvatar != nullptr);
                     gHighlightProgram.bind(rigged);
                     gGL.diffuseColor4f(1, 0, 0, 1);
@@ -548,17 +535,9 @@ void LLDrawPoolAlpha::renderRiggedEmissives(std::vector<LLDrawInfo*>& emissives)
     LLVOAvatar* lastAvatar = nullptr;
     U64 lastMeshId = 0;
 
-    std::unique_ptr<LLPerfStats::RecordAttachmentTime> ratPtr{}; // Render time Stats collection
     for (LLDrawInfo* draw : emissives)
     {
         LL_PROFILE_ZONE_NAMED_CATEGORY_DRAWPOOL("Emissives");
-# if 0 // TODO SL-19656 figure out how to reenable trackAttachments()
-        auto vobj = draw->mFace?draw->mFace->getViewerObject():nullptr;
-        if(vobj && vobj->isAttachment())
-        {
-            trackAttachments( vobj, draw->mFace->isState(LLFace::RIGGED), &ratPtr );
-        }
-#endif
 
         bool tex_setup = TexSetup(draw, false);
         if (lastAvatar != draw->mAvatar || lastMeshId != draw->mSkinInfo->mHash)
@@ -687,7 +666,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
 			LLSpatialGroup::drawmap_elem_t& draw_info = rigged ? group->mDrawMap[LLRenderPass::PASS_ALPHA_RIGGED] : group->mDrawMap[LLRenderPass::PASS_ALPHA];
 
-            std::unique_ptr<LLPerfStats::RecordAttachmentTime> ratPtr{}; // Render time Stats collection
             for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)	
 			{
 				LLDrawInfo& params = **k;
@@ -700,18 +678,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
                 LLRenderPass::applyModelMatrix(params);
 
-# if 0 // TODO SL-19656 figure out how to reenable trackAttachments()
-                if(params.mFace)
-                {
-                    LLViewerObject* vobj = (LLViewerObject *)params.mFace->getViewerObject();
-
-                    if(vobj->isAttachment())
-                    {
-                        trackAttachments( vobj, params.mFace->isState(LLFace::RIGGED), &ratPtr );
-                    }
-                }
-#endif
-
                 LLMaterial* mat = NULL;
                 LLGLTFMaterial *gltf_mat = params.mGLTFMaterial; 
 
@@ -905,8 +871,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 				}
 			}
 
-            ratPtr.reset(); // force the final batch to terminate to avoid double counting on the subsidiary batches for FB and Emmissives
-
             // render emissive faces into alpha channel for bloom effects
             if (!depth_only)
             {
-- 
cgit v1.2.3


From e09475713b7abe6fcb916f4a770081a1696b57ab Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Tue, 2 May 2023 18:47:21 -0500
Subject: DRTVWR-559 Optimization pass, make it so profileAvatar can read back
 GPU timer without a frame stall.

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 404039189b..ec57e20d35 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -107,12 +107,10 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
     // i.e. shaders\class1\deferred\alphaF.glsl
     if (deferredEnvironment)
     {
-        gPipeline.bindDeferredShader( *shader );
-    }
-    else
-    {
-        shader->bind();
+        shader->mCanBindFast = false;
     }
+    
+    shader->bind();
     shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f / 2.2f));
 
     if (LLPipeline::sRenderingHUDs)
-- 
cgit v1.2.3


From 7d0903533c20a395e12c2d4c290fcde3ec6b2a53 Mon Sep 17 00:00:00 2001
From: Cosmic Linden <cosmic@lindenlab.com>
Date: Thu, 11 May 2023 11:31:09 -0700
Subject: SL-19236: Fix HUDs not rendering when transparent water graphics
 setting is off

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index ec57e20d35..f8d2a9e942 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -157,7 +157,7 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
 { 
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
 
-    if ((!LLPipeline::sRenderTransparentWater || gCubeSnapshot) && getType() == LLDrawPool::POOL_ALPHA_PRE_WATER)
+    if (LLPipeline::isWaterClip() && getType() == LLDrawPool::POOL_ALPHA_PRE_WATER)
     { // don't render alpha objects on the other side of the water plane if water is opaque
         return;
     }
-- 
cgit v1.2.3


From cdc9852f052d804f8b25564ab7d90eb2b79cddd4 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Mon, 15 May 2023 11:01:24 -0500
Subject: SL-19709 Fix for fullbright shiny not factoring out exposure and
 flickering fullbright alpha.  Incidental decruft.

---
 indra/newview/lldrawpoolalpha.cpp | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index f8d2a9e942..7893caf3c0 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -138,12 +138,6 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
         shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
     }
 
-    S32 channel = shader->enableTexture(LLShaderMgr::EXPOSURE_MAP);
-    if (channel > -1)
-    {
-        gGL.getTexUnit(channel)->bind(&gPipeline.mExposureMap);
-    }
-
     //also prepare rigged variant
     if (shader->mRiggedVariant && shader->mRiggedVariant != shader)
     { 
@@ -754,7 +748,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         target_shader = fullbright_shader;
                     }
 
-
                     if (params.mAvatar != nullptr)
                     {
                         target_shader = target_shader->mRiggedVariant;
@@ -764,6 +757,15 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     {// If we need shaders, and we're not ALREADY using the proper shader, then bind it
                     // (this way we won't rebind shaders unnecessarily).
                         gPipeline.bindDeferredShaderFast(*target_shader);
+
+                        if (params.mFullbright)
+                        { // make sure the bind the exposure map for fullbright shaders so they can cancel out exposure
+                            S32 channel = target_shader->enableTexture(LLShaderMgr::EXPOSURE_MAP);
+                            if (channel > -1)
+                            {
+                                gGL.getTexUnit(channel)->bind(&gPipeline.mExposureMap);
+                            }
+                        }
                     }
 
                     LLVector4 spec_color(1, 1, 1, 1);
-- 
cgit v1.2.3


From 87bda552688bb38fe255cc7e6069c1be6ac20834 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 17 May 2023 19:30:27 -0400
Subject: Add a binary cache for compiled shaders using glProgramBinary (#216)

* Add a binary cache for compiled shaders using glProgramBinary

* Add additional sanity checking to shader binary save and load, hook up cache clear and menu option

* Fix default init of shader cache data struct and clear gl errors before glGetError calls

---------

Co-authored-by: RunitaiLinden <davep@lindenlab.com>
---
 indra/newview/lldrawpoolalpha.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 7893caf3c0..a96d480c78 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -732,12 +732,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                         {
                             target_shader = &(gDeferredMaterialWaterProgram[mask]);
                         }
-
-                        if (params.mAvatar != nullptr)
-                        {
-                            llassert(target_shader->mRiggedVariant != nullptr);
-                            target_shader = target_shader->mRiggedVariant;
-                        }
                     }
                     else if (!params.mFullbright)
                     {
@@ -750,6 +744,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 
                     if (params.mAvatar != nullptr)
                     {
+                        llassert(target_shader->mRiggedVariant != nullptr);
                         target_shader = target_shader->mRiggedVariant;
                     }
 
-- 
cgit v1.2.3


From cae8aa6ecf231302653091162aa0e13e06c25696 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Thu, 18 May 2023 18:03:17 -0500
Subject: SL-19726 Fix for llTargetOmega on child prim breaking shadow
 rendering.  Incidental decruft.

---
 indra/newview/lldrawpoolalpha.cpp | 42 +++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 22 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index a96d480c78..5b158d857a 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -282,47 +282,45 @@ void LLDrawPoolAlpha::renderDebugAlpha()
         gGL.diffuseColor4f(1, 0, 0, 1);
         gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::getSmokeImage());
 
-        U32 mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0;
+        renderAlphaHighlight();
 
-        renderAlphaHighlight(mask);
-
-		pushBatches(LLRenderPass::PASS_ALPHA_MASK, mask, FALSE);
-		pushBatches(LLRenderPass::PASS_ALPHA_INVISIBLE, mask, FALSE);
+		pushUntexturedBatches(LLRenderPass::PASS_ALPHA_MASK);
+		pushUntexturedBatches(LLRenderPass::PASS_ALPHA_INVISIBLE);
 
 		// Material alpha mask
 		gGL.diffuseColor4f(0, 0, 1, 1);
-		pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, mask, FALSE);
-		pushBatches(LLRenderPass::PASS_NORMMAP_MASK, mask, FALSE);
-		pushBatches(LLRenderPass::PASS_SPECMAP_MASK, mask, FALSE);
-		pushBatches(LLRenderPass::PASS_NORMSPEC_MASK, mask, FALSE);
-		pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, mask, FALSE);
-        pushBatches(LLRenderPass::PASS_GLTF_PBR_ALPHA_MASK, mask, FALSE);
+		pushUntexturedBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK);
+		pushUntexturedBatches(LLRenderPass::PASS_NORMMAP_MASK);
+		pushUntexturedBatches(LLRenderPass::PASS_SPECMAP_MASK);
+		pushUntexturedBatches(LLRenderPass::PASS_NORMSPEC_MASK);
+		pushUntexturedBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK);
+        pushUntexturedBatches(LLRenderPass::PASS_GLTF_PBR_ALPHA_MASK);
 
 		gGL.diffuseColor4f(0, 1, 0, 1);
-		pushBatches(LLRenderPass::PASS_INVISIBLE, mask, FALSE);
+        pushUntexturedBatches(LLRenderPass::PASS_INVISIBLE);
 
         gHighlightProgram.mRiggedVariant->bind();
         gGL.diffuseColor4f(1, 0, 0, 1);
 
-        pushRiggedBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, mask, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_ALPHA_INVISIBLE_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, false);
+        pushRiggedBatches(LLRenderPass::PASS_ALPHA_INVISIBLE_RIGGED, false);
 
         // Material alpha mask
         gGL.diffuseColor4f(0, 0, 1, 1);
-        pushRiggedBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK_RIGGED, mask, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_NORMMAP_MASK_RIGGED, mask, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_SPECMAP_MASK_RIGGED, mask, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_NORMSPEC_MASK_RIGGED, mask, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, mask, FALSE);
-        pushRiggedBatches(LLRenderPass::PASS_GLTF_PBR_ALPHA_MASK_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK_RIGGED, false);
+        pushRiggedBatches(LLRenderPass::PASS_NORMMAP_MASK_RIGGED, false);
+        pushRiggedBatches(LLRenderPass::PASS_SPECMAP_MASK_RIGGED, false);
+        pushRiggedBatches(LLRenderPass::PASS_NORMSPEC_MASK_RIGGED, false);
+        pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, false);
+        pushRiggedBatches(LLRenderPass::PASS_GLTF_PBR_ALPHA_MASK_RIGGED, false);
 
         gGL.diffuseColor4f(0, 1, 0, 1);
-        pushRiggedBatches(LLRenderPass::PASS_INVISIBLE_RIGGED, mask, FALSE);
+        pushRiggedBatches(LLRenderPass::PASS_INVISIBLE_RIGGED, false);
         LLGLSLShader::sCurBoundShaderPtr->unbind();
 	}
 }
 
-void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
+void LLDrawPoolAlpha::renderAlphaHighlight()
 {
     for (int pass = 0; pass < 2; ++pass)
     { //two passes, one rigged and one not
-- 
cgit v1.2.3


From 8251e1200dc248e9a6deb5373d3c3af022bd455c Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Mon, 22 May 2023 16:31:09 -0500
Subject: SL-19746 Fix for transparent HUDs showing the wrong texture.

---
 indra/newview/lldrawpoolalpha.cpp | 23 ++++-------------------
 1 file changed, 4 insertions(+), 19 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 5b158d857a..67bc0463c8 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -58,8 +58,6 @@ BOOL LLDrawPoolAlpha::sShowDebugAlpha = FALSE;
 
 LLVector4 LLDrawPoolAlpha::sWaterPlane;
 
-static BOOL deferred_render = FALSE;
-
 // minimum alpha before discarding a fragment
 static const F32 MINIMUM_ALPHA = 0.004f; // ~ 1/255
 
@@ -155,7 +153,6 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     { // don't render alpha objects on the other side of the water plane if water is opaque
         return;
     }
-    deferred_render = TRUE;
 
     F32 water_sign = 1.f;
 
@@ -232,8 +229,6 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
 
         gGL.setColorMask(true, false);
     }
-
-    deferred_render = FALSE;
 }
 
 void LLDrawPoolAlpha::forwardRender(bool rigged)
@@ -411,7 +406,7 @@ bool LLDrawPoolAlpha::TexSetup(LLDrawInfo* draw, bool use_material)
     }
     else
     {
-        if (deferred_render && use_material && current_shader)
+        if (!LLPipeline::sRenderingHUDs && use_material && current_shader)
         {
             if (draw->mNormalMap)
             {
@@ -691,10 +686,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                 }
                 else
                 {
-                    if (deferred_render)
-                    {
-                        mat = params.mMaterial;
-                    }
+                    mat = LLPipeline::sRenderingHUDs ? nullptr : params.mMaterial;
 
                     if (params.mFullbright)
                     {
@@ -719,7 +711,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     {
                         target_shader = fullbright_shader;
                     }
-                    else if (deferred_render && mat)
+                    else if (mat)
                     {
                         U32 mask = params.mShaderMask;
 
@@ -766,7 +758,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     F32 brightness = 1.0f;
 
                     // We have a material.  Supply the appropriate data here.
-                    if (mat && deferred_render)
+                    if (mat)
                     {
                         spec_color = params.mSpecColor;
                         env_intensity = params.mEnvIntensity;
@@ -781,11 +773,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                     }
                 }
 
-				//if (params.mGroup) // TOO LATE
-				//{
-				//	params.mGroup->rebuildMesh();
-				//}
-
                 if (params.mAvatar != nullptr)
                 {
                     if (lastAvatar != params.mAvatar ||
@@ -805,8 +792,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
                 bool tex_setup = TexSetup(&params, (mat != nullptr));
 
 				{
-					//LLGLEnableFunc stencil_test(GL_STENCIL_TEST, params.mSelected, &LLGLCommonFunc::selected_stencil_test);
-
 					gGL.blendFunc((LLRender::eBlendFactor) params.mBlendFuncSrc, (LLRender::eBlendFactor) params.mBlendFuncDst, mAlphaSFactor, mAlphaDFactor);
 
                     bool reset_minimum_alpha = false;
-- 
cgit v1.2.3


From cbd17fce86cc30434d6d665338a7d771bddcad8b Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Thu, 25 May 2023 16:09:22 -0400
Subject: Fix underwater fog mismatch between opaque and alpha blend when local
 lights are nearby (#227)

* Fix water fog mismatch between alpha blend and opaque when local light is nearby

* Add PBR underwater alpha blend shader
---
 indra/newview/lldrawpoolalpha.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 67bc0463c8..6aa2316589 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -197,7 +197,10 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
         prepare_alpha_shader(&materialShader[i], false, true, water_sign);
     }
 
-    pbr_shader = LLPipeline::sRenderingHUDs ? &gHUDPBRAlphaProgram : &gDeferredPBRAlphaProgram;
+    pbr_shader = 
+        (LLPipeline::sUnderWaterRender) ? &gDeferredPBRAlphaWaterProgram : 
+        (LLPipeline::sRenderingHUDs) ? &gHUDPBRAlphaProgram : 
+        &gDeferredPBRAlphaProgram;
 
     prepare_alpha_shader(pbr_shader, false, true, water_sign);
 
-- 
cgit v1.2.3


From b81aadae1b5026195103a5ae20404daf858ded0c Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Tue, 13 Jun 2023 15:36:51 -0500
Subject: SL-19835 Fix for inaccurate water fog on transparent objects when
 camera is above water.

---
 indra/newview/lldrawpoolalpha.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 6aa2316589..060129d275 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -243,11 +243,13 @@ void LLDrawPoolAlpha::forwardRender(bool rigged)
     //enable writing to alpha for emissive effects
     gGL.setColorMask(true, true);
 
-    bool write_depth = rigged || 
+    bool write_depth = rigged ||
         LLDrawPoolWater::sSkipScreenCopy
         // we want depth written so that rendered alpha will
         // contribute to the alpha mask used for impostors
-        || LLPipeline::sImpostorRenderAlphaDepthPass;
+        || LLPipeline::sImpostorRenderAlphaDepthPass
+        || getType() == LLDrawPoolAlpha::POOL_ALPHA_PRE_WATER; // needed for accurate water fog
+
 
     LLGLDepthTest depth(GL_TRUE, write_depth ? GL_TRUE : GL_FALSE);
 
-- 
cgit v1.2.3


From 47be24e467a9fe5a2c0466a49f58769f6b81fdc4 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Thu, 15 Jun 2023 14:51:57 -0500
Subject: SL-19835 Followup -- fix for emissive alpha objects blocking water
 rendering

---
 indra/newview/lldrawpoolalpha.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 060129d275..07b7be0fc8 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -649,8 +649,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 			bool is_particle_or_hud_particle = group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
 													  || group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
 
-			bool draw_glow_for_this_partition = mShaderLevel > 0; // no shaders = no glow.
-
 			bool disable_cull = is_particle_or_hud_particle;
 			LLGLDisable cull(disable_cull ? GL_CULL_FACE : 0);
 
@@ -818,7 +816,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
 				}
 
 				// If this alpha mesh has glow, then draw it a second time to add the destination-alpha (=glow).  Interleaving these state-changing calls is expensive, but glow must be drawn Z-sorted with alpha.
-				if (draw_glow_for_this_partition &&
+				if (getType() != LLDrawPool::POOL_ALPHA_PRE_WATER &&
 					params.mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_EMISSIVE))
 				{
                     if (params.mAvatar != nullptr)
-- 
cgit v1.2.3


From a0089c432ac9008f5d2f7ef2a332afa10c5a2615 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Tue, 18 Jul 2023 12:18:07 -0500
Subject: SL-19954 Fix for rigged alpha pbr sometimes not getting reflection
 probe parameters

---
 indra/newview/lldrawpoolalpha.cpp | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 07b7be0fc8..65c7c1413b 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -204,6 +204,10 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
 
     prepare_alpha_shader(pbr_shader, false, true, water_sign);
 
+    // explicitly unbind here so render loop doesn't make assumptions about the last shader
+    // already being setup for rendering
+    LLGLSLShader::unbind();
+
     if (!LLPipeline::sRenderingHUDs)
     {
         // first pass, render rigged objects only and render to depth buffer
-- 
cgit v1.2.3


From bb08f68db1233870fd4615a68543220c8d608b93 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Wed, 19 Jul 2023 09:40:33 -0500
Subject: SL-19977 Fix for glow not getting applied to both sides of double
 sided alpha

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 0f4466044c..7aa3450be1 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -514,6 +514,7 @@ void LLDrawPoolAlpha::renderPbrEmissives(std::vector<LLDrawInfo*>& emissives)
     for (LLDrawInfo* draw : emissives)
     {
         llassert(draw->mGLTFMaterial);
+        LLGLDisable cull_face(draw->mGLTFMaterial->mDoubleSided ? GL_CULL_FACE : 0);
         draw->mGLTFMaterial->bind(draw->mTexture);
         draw->mVertexBuffer->setBuffer();
         draw->mVertexBuffer->drawRange(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
@@ -569,6 +570,7 @@ void LLDrawPoolAlpha::renderRiggedPbrEmissives(std::vector<LLDrawInfo*>& emissiv
             lastMeshId = draw->mSkinInfo->mHash;
         }
 
+        LLGLDisable cull_face(draw->mGLTFMaterial->mDoubleSided ? GL_CULL_FACE : 0);
         draw->mGLTFMaterial->bind(draw->mTexture);
         draw->mVertexBuffer->setBuffer();
         draw->mVertexBuffer->drawRange(LLRender::TRIANGLES, draw->mStart, draw->mEnd, draw->mCount, draw->mOffset);
-- 
cgit v1.2.3


From bf0fea7b8894515522ed2e5f77497268bbf4a082 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Tue, 25 Jul 2023 09:59:04 -0500
Subject: DRTVWR-559 Fix for depth of field causing alpha objects to poke holes
 in water.

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

(limited to 'indra/newview/lldrawpoolalpha.cpp')

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 7aa3450be1..052a1d796a 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -218,7 +218,7 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
     forwardRender();
 
     // final pass, render to depth for depth of field effects
-    if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField") && !gCubeSnapshot && !LLPipeline::sRenderingHUDs)
+    if (!LLPipeline::sImpostorRender && gSavedSettings.getBOOL("RenderDepthOfField") && !gCubeSnapshot && !LLPipeline::sRenderingHUDs && getType() == LLDrawPool::POOL_ALPHA_POST_WATER)
     { 
         //update depth buffer sampler
         simple_shader = fullbright_shader = &gDeferredFullbrightAlphaMaskProgram;
-- 
cgit v1.2.3