Merge tag '7.1.8-release'

source for viewer 7.1.8.9375512768

11 files changed, 229 insertions, 94 deletions

diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 884938d4e4..0c1519824c 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -1229,6 +1229,8 @@ S32 LLGLSLShader::enableTexture(S32 uniform, LLTexUnit::eTextureType mode, LLTex
         LL_SHADER_UNIFORM_ERRS() << "Uniform out of range: " << uniform << LL_ENDL;
         return -1;
     }
+
+
     S32 index = mTexture[uniform];
     if (index != -1)
     {
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index df568bfea5..d7741c51bb 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -49,13 +49,14 @@ public:
     bool hasShadows = false;
     bool hasAmbientOcclusion = false;
     bool hasSrgb = false;
-    bool encodesNormal = false; // include: shaders\class1\environment\encodeNormF.glsl
     bool isDeferred = false;
     bool hasScreenSpaceReflections = false;
     bool disableTextureIndex = false;
     bool hasAlphaMask = false;
     bool hasReflectionProbes = false;
     bool attachNothing = false;
+    bool hasHeroProbes = false;
+    bool isPBRTerrain = false;
 };
 
 // ============= Structure for caching shader uniforms ===============
diff --git a/indra/llrender/llgltexture.cpp b/indra/llrender/llgltexture.cpp
index 944a3d0235..104976fcc6 100644
--- a/indra/llrender/llgltexture.cpp
+++ b/indra/llrender/llgltexture.cpp
@@ -49,6 +49,10 @@ LLGLTexture::LLGLTexture(const LLImageRaw* raw, BOOL usemipmaps)
     mUseMipMaps = usemipmaps ;
     // Create an empty image of the specified size and width
     mGLTexturep = new LLImageGL(raw, usemipmaps) ;
+    mFullWidth = mGLTexturep->getCurrentWidth();
+    mFullHeight = mGLTexturep->getCurrentHeight();
+    mComponents = mGLTexturep->getComponents();
+    setTexelsPerImage();
 }
 
 LLGLTexture::~LLGLTexture()
@@ -95,7 +99,8 @@ void LLGLTexture::setBoostLevel(S32 level)
         mBoostLevel = level ;
         if(mBoostLevel != LLGLTexture::BOOST_NONE
            && mBoostLevel != LLGLTexture::BOOST_ICON
-           && mBoostLevel != LLGLTexture::BOOST_THUMBNAIL)
+           && mBoostLevel != LLGLTexture::BOOST_THUMBNAIL
+           && mBoostLevel != LLGLTexture::BOOST_TERRAIN)
         {
             setNoDelete() ;
         }
diff --git a/indra/llrender/llgltexture.h b/indra/llrender/llgltexture.h
index 88057d7920..f5bef0e291 100644
--- a/indra/llrender/llgltexture.h
+++ b/indra/llrender/llgltexture.h
@@ -42,7 +42,7 @@ class LLGLTexture : public LLTexture
 public:
     enum
     {
-        MAX_IMAGE_SIZE_DEFAULT = 1024,
+        MAX_IMAGE_SIZE_DEFAULT = 2048,
         INVALID_DISCARD_LEVEL = 0x7fff
     };
 
@@ -52,10 +52,11 @@ public:
         BOOST_AVATAR        ,
         BOOST_AVATAR_BAKED  ,
         BOOST_SCULPTED      ,
+        BOOST_TERRAIN       , // Needed for minimap generation for now. Lower than BOOST_HIGH so the texture stats don't get forced, i.e. texture stats are manually managed by minimap/terrain instead.
 
         BOOST_HIGH          = 10,
         BOOST_BUMP          ,
-        BOOST_TERRAIN       , // has to be high priority for minimap / low detail
+        BOOST_UNUSED_1      , // Placeholder to avoid disrupting habits around texture debug
         BOOST_SELECTED      ,
         BOOST_AVATAR_BAKED_SELF ,
         BOOST_AVATAR_SELF   , // needed for baking avatar
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index 7f4ae89657..f28eefcb63 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -2084,12 +2084,6 @@ void LLRender::diffuseColor3f(F32 r, F32 g, F32 b)
     {
         shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r,g,b,1.f);
     }
-#if GL_VERSION_1_1
-    else
-    {
-        glColor3f(r,g,b);
-    }
-#endif
 }
 
 void LLRender::diffuseColor3fv(const F32* c)
@@ -2101,12 +2095,6 @@ void LLRender::diffuseColor3fv(const F32* c)
     {
         shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, c[0], c[1], c[2], 1.f);
     }
-#if GL_VERSION_1_1
-    else
-    {
-        glColor3fv(c);
-    }
-#endif
 }
 
 void LLRender::diffuseColor4f(F32 r, F32 g, F32 b, F32 a)
@@ -2118,12 +2106,6 @@ void LLRender::diffuseColor4f(F32 r, F32 g, F32 b, F32 a)
     {
         shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r,g,b,a);
     }
-#if GL_VERSION_1_1
-    else
-    {
-        glColor4f(r,g,b,a);
-    }
-#endif
 }
 
 void LLRender::diffuseColor4fv(const F32* c)
@@ -2135,12 +2117,6 @@ void LLRender::diffuseColor4fv(const F32* c)
     {
         shader->uniform4fv(LLShaderMgr::DIFFUSE_COLOR, 1, c);
     }
-#if GL_VERSION_1_1
-    else
-    {
-        glColor4fv(c);
-    }
-#endif
 }
 
 void LLRender::diffuseColor4ubv(const U8* c)
@@ -2152,12 +2128,6 @@ void LLRender::diffuseColor4ubv(const U8* c)
     {
         shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, c[0]/255.f, c[1]/255.f, c[2]/255.f, c[3]/255.f);
     }
-#if GL_VERSION_1_1
-    else
-    {
-        glColor4ubv(c);
-    }
-#endif
 }
 
 void LLRender::diffuseColor4ub(U8 r, U8 g, U8 b, U8 a)
@@ -2169,12 +2139,6 @@ void LLRender::diffuseColor4ub(U8 r, U8 g, U8 b, U8 a)
     {
         shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r/255.f, g/255.f, b/255.f, a/255.f);
     }
-#if GL_VERSION_1_1
-    else
-    {
-        glColor4ub(r,g,b,a);
-    }
-#endif
 }
 
 
diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp
index 735fa8925f..aa5bcd0864 100644
--- a/indra/llrender/llrendertarget.cpp
+++ b/indra/llrender/llrendertarget.cpp
@@ -1,25 +1,25 @@
-/**
+/** 
  * @file llrendertarget.cpp
  * @brief LLRenderTarget implementation
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- *
+ * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- *
+ * 
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- *
+ * 
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
+ * 
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -44,7 +44,7 @@ void check_framebuffer_status()
             break;
         default:
             LL_WARNS() << "check_framebuffer_status failed -- " << std::hex << status << LL_ENDL;
-            ll_fail("check_framebuffer_status failed");
+            ll_fail("check_framebuffer_status failed");    
             break;
         }
     }
@@ -75,10 +75,10 @@ LLRenderTarget::~LLRenderTarget()
 }
 
 void LLRenderTarget::resize(U32 resx, U32 resy)
-{
+{ 
     //for accounting, get the number of pixels added/subtracted
     S32 pix_diff = (resx*resy)-(mResX*mResY);
-
+        
     mResX = resx;
     mResY = resy;
 
@@ -92,7 +92,7 @@ void LLRenderTarget::resize(U32 resx, U32 resy)
     }
 
     if (mDepth)
-    {
+    { 
         gGL.getTexUnit(0)->bindManual(mUsage, mDepth);
         U32 internal_type = LLTexUnit::getInternalType(mUsage);
         LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT24, mResX, mResY, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL, false);
@@ -100,7 +100,7 @@ void LLRenderTarget::resize(U32 resx, U32 resy)
         sBytesAllocated += pix_diff*4;
     }
 }
-
+    
 
 bool LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, LLTexUnit::eTextureType usage, LLTexUnit::eTextureMipGeneration generateMipMaps)
 {
@@ -112,7 +112,7 @@ bool LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, LLT
     resy = llmin(resy, (U32) gGLManager.mGLMaxTextureSize);
 
     release();
-
+    
     mResX = resx;
     mResY = resy;
 
@@ -125,7 +125,7 @@ bool LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, LLT
         // Calculate the number of mip levels based upon resolution that we should have.
         mMipLevels = 1 + floor(log10((float)llmax(mResX, mResY))/log10(2.0));
     }
-
+    
     if (depth)
     {
         if (!allocateDepth())
@@ -140,12 +140,12 @@ bool LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, LLT
     if (mDepth)
     {
         glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-
+            
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
 
         glBindFramebuffer(GL_FRAMEBUFFER, sCurFBO);
     }
-
+    
     return addColorAttachment(color_fmt);
 }
 
@@ -190,7 +190,7 @@ void LLRenderTarget::releaseColorAttachment()
     llassert(!isBoundInStack());
     llassert(mTex.size() == 1); //cannot use releaseColorAttachment with LLRenderTarget managed color targets
     llassert(mFBO != 0);  // mFBO must be valid
-
+    
     glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, LLTexUnit::getInternalType(mUsage), 0, 0);
     glBindFramebuffer(GL_FRAMEBUFFER, sCurFBO);
@@ -238,12 +238,12 @@ bool LLRenderTarget::addColorAttachment(U32 color_fmt)
             return false;
         }
     }
-
+    
     sBytesAllocated += mResX*mResY*4;
 
     stop_glerror();
 
-
+    
     if (offset == 0)
     { //use bilinear filtering on single texture render targets that aren't multisampled
         gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
@@ -266,15 +266,15 @@ bool LLRenderTarget::addColorAttachment(U32 color_fmt)
         gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
         stop_glerror();
     }
-
+        
     if (mFBO)
     {
         glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+offset,
             LLTexUnit::getInternalType(mUsage), tex, 0);
-
+     
         check_framebuffer_status();
-
+        
         glBindFramebuffer(GL_FRAMEBUFFER, sCurFBO);
     }
 
@@ -286,8 +286,8 @@ bool LLRenderTarget::addColorAttachment(U32 color_fmt)
         bindTarget();
         flush();
     }
-
-
+    
+    
     return true;
 }
 
@@ -296,7 +296,7 @@ bool LLRenderTarget::allocateDepth()
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DISPLAY;
     LLImageGL::generateTextures(1, &mDepth);
     gGL.getTexUnit(0)->bindManual(mUsage, mDepth);
-
+        
     U32 internal_type = LLTexUnit::getInternalType(mUsage);
     stop_glerror();
     clear_glerror();
@@ -336,7 +336,7 @@ void LLRenderTarget::shareDepthBuffer(LLRenderTarget& target)
     if (mDepth)
     {
         glBindFramebuffer(GL_FRAMEBUFFER, target.mFBO);
-
+        
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
 
         check_framebuffer_status();
@@ -355,7 +355,7 @@ void LLRenderTarget::release()
     if (mDepth)
     {
         LLImageGL::deleteTextures(1, &mDepth);
-
+        
         mDepth = 0;
 
         sBytesAllocated -= mResX*mResY*4;
@@ -408,7 +408,7 @@ void LLRenderTarget::release()
 
     mTex.clear();
     mInternalFormat.clear();
-
+    
     mResX = mResY = 0;
 }
 
@@ -417,7 +417,7 @@ void LLRenderTarget::bindTarget()
     LL_PROFILE_GPU_ZONE("bindTarget");
     llassert(mFBO);
     llassert(!isBoundInStack());
-
+        
     glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
     sCurFBO = mFBO;
 
@@ -427,7 +427,7 @@ void LLRenderTarget::bindTarget()
                             GL_COLOR_ATTACHMENT2,
                             GL_COLOR_ATTACHMENT3};
     glDrawBuffers(mTex.size(), drawbuffers);
-
+            
     if (mTex.empty())
     { //no color buffer to draw to
         GLenum drawbuffers[] = {GL_NONE};
@@ -453,7 +453,7 @@ void LLRenderTarget::clear(U32 mask_in)
     if (mUseDepth)
     {
         mask |= GL_DEPTH_BUFFER_BIT;
-
+        
     }
     if (mFBO)
     {
@@ -563,11 +563,38 @@ bool LLRenderTarget::isBoundInStack() const
 {
     LLRenderTarget* cur = sBoundTarget;
     while (cur && cur != this)
-    {
+    { 
         cur = cur->mPreviousRT;
     }
 
     return cur == this;
 }
 
+void LLRenderTarget::swapFBORefs(LLRenderTarget& other)
+{
+    // Must be initialized
+    llassert(mFBO);
+    llassert(other.mFBO);
 
+    // Must be unbound
+    // *NOTE: mPreviousRT can be non-null even if this target is unbound - presumably for debugging purposes?
+    llassert(sCurFBO != mFBO);
+    llassert(sCurFBO != other.mFBO);
+    llassert(!isBoundInStack());
+    llassert(!other.isBoundInStack());
+
+    // Must be same type
+    llassert(sUseFBO == other.sUseFBO);
+    llassert(mResX == other.mResX);
+    llassert(mResY == other.mResY);
+    llassert(mInternalFormat == other.mInternalFormat);
+    llassert(mTex.size() == other.mTex.size());
+    llassert(mDepth == other.mDepth);
+    llassert(mUseDepth == other.mUseDepth);
+    llassert(mGenerateMipMaps == other.mGenerateMipMaps);
+    llassert(mMipLevels == other.mMipLevels);
+    llassert(mUsage == other.mUsage);
+
+    std::swap(mFBO, other.mFBO);
+    std::swap(mTex, other.mTex);
+}
diff --git a/indra/llrender/llrendertarget.h b/indra/llrender/llrendertarget.h
index b5745b5b49..340276a752 100644
--- a/indra/llrender/llrendertarget.h
+++ b/indra/llrender/llrendertarget.h
@@ -169,6 +169,9 @@ public:
 
     static LLRenderTarget* getCurrentBoundTarget() { return sBoundTarget; }
 
+    // *HACK
+    void swapFBORefs(LLRenderTarget& other);
+
 protected:
     U32 mResX;
     U32 mResY;
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 85644a95fb..0f3716bc18 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -44,6 +44,7 @@ using std::make_pair;
 using std::string;
 
 LLShaderMgr * LLShaderMgr::sInstance = NULL;
+bool LLShaderMgr::sMirrorsEnabled = false;
 
 LLShaderMgr::LLShaderMgr()
 {
@@ -183,7 +184,13 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     // Attach Fragment Shader Features Next
     ///////////////////////////////////////
 
-// NOTE order of shader object attaching is VERY IMPORTANT!!!
+    // NOTE order of shader object attaching is VERY IMPORTANT!!!
+
+    if (!shader->attachFragmentObject("deferred/globalF.glsl"))
+    {
+        return FALSE;
+    }
+
     if (features->hasSrgb || features->hasAtmospherics || features->calculatesAtmospherics || features->isDeferred)
     {
         if (!shader->attachFragmentObject("environment/srgbF.glsl"))
@@ -257,14 +264,6 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
         }
     }
 
-    if (features->encodesNormal)
-    {
-        if (!shader->attachFragmentObject("environment/encodeNormF.glsl"))
-        {
-            return FALSE;
-        }
-    }
-
     if (features->hasAtmospherics || features->isDeferred)
     {
         if (!shader->attachFragmentObject("windlight/atmosphericsFuncs.glsl")) {
@@ -277,6 +276,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
         }
     }
 
+    if (features->isPBRTerrain)
+    {
+        if (!shader->attachFragmentObject("deferred/pbrterrainUtilF.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
     // NOTE order of shader object attaching is VERY IMPORTANT!!!
     if (features->hasAtmospherics)
     {
@@ -321,7 +328,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
                     return FALSE;
                 }
             }
-            shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels, 1);
         }
     }
 
@@ -572,21 +579,38 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
         }
         else
         {
-            //set version to 1.40
-            shader_code_text[shader_code_count++] = strdup("#version 140\n");
-            //some implementations of GLSL 1.30 require integer precision be explicitly declared
-            extra_code_text[extra_code_count++] = strdup("precision mediump int;\n");
-            extra_code_text[extra_code_count++] = strdup("precision highp float;\n");
+            if (type == GL_GEOMETRY_SHADER)
+            {
+                //set version to 1.50
+                shader_code_text[shader_code_count++] = strdup("#version 150\n");
+                //some implementations of GLSL 1.30 require integer precision be explicitly declared
+                extra_code_text[extra_code_count++] = strdup("precision mediump int;\n");
+                extra_code_text[extra_code_count++] = strdup("precision highp float;\n");
+            }
+            else
+            {
+                //set version to 1.40
+                shader_code_text[shader_code_count++] = strdup("#version 140\n");
+                //some implementations of GLSL 1.30 require integer precision be explicitly declared
+                extra_code_text[extra_code_count++] = strdup("precision mediump int;\n");
+                extra_code_text[extra_code_count++] = strdup("precision highp float;\n");
+            }
         }
 
         extra_code_text[extra_code_count++] = strdup("#define FXAA_GLSL_130 1\n");
     }
 
+    if (sMirrorsEnabled)
+    {
+        extra_code_text[extra_code_count++] = strdup("#define HERO_PROBES 1\n");
+    }
+
     // Use alpha float to store bit flags
     // See: C++: addDeferredAttachment(), shader: frag_data[2]
     extra_code_text[extra_code_count++] = strdup("#define GBUFFER_FLAG_SKIP_ATMOS   0.0 \n"); // atmo kill
     extra_code_text[extra_code_count++] = strdup("#define GBUFFER_FLAG_HAS_ATMOS    0.34\n"); // bit 0
     extra_code_text[extra_code_count++] = strdup("#define GBUFFER_FLAG_HAS_PBR      0.67\n"); // bit 1
+    extra_code_text[extra_code_count++] = strdup("#define GBUFFER_FLAG_HAS_HDRI      1.0\n");  // bit 2
     extra_code_text[extra_code_count++] = strdup("#define GET_GBUFFER_FLAG(flag)    (abs(norm.w-flag)< 0.1)\n");
 
     if (defines)
@@ -1192,6 +1216,9 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("emissiveColor");
     mReservedUniforms.push_back("metallicFactor");
     mReservedUniforms.push_back("roughnessFactor");
+    mReservedUniforms.push_back("mirror_flag");
+    mReservedUniforms.push_back("clipPlane");
+    mReservedUniforms.push_back("clipSign");
 
     mReservedUniforms.push_back("diffuseMap");
     mReservedUniforms.push_back("altDiffuseMap");
@@ -1204,6 +1231,7 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("sceneDepth");
     mReservedUniforms.push_back("reflectionProbes");
     mReservedUniforms.push_back("irradianceProbes");
+    mReservedUniforms.push_back("heroProbes");
     mReservedUniforms.push_back("cloud_noise_texture");
     mReservedUniforms.push_back("cloud_noise_texture_next");
     mReservedUniforms.push_back("fullbright");
@@ -1374,8 +1402,32 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("detail_1");
     mReservedUniforms.push_back("detail_2");
     mReservedUniforms.push_back("detail_3");
+
     mReservedUniforms.push_back("alpha_ramp");
 
+    mReservedUniforms.push_back("detail_0_base_color");
+    mReservedUniforms.push_back("detail_1_base_color");
+    mReservedUniforms.push_back("detail_2_base_color");
+    mReservedUniforms.push_back("detail_3_base_color");
+    mReservedUniforms.push_back("detail_0_normal");
+    mReservedUniforms.push_back("detail_1_normal");
+    mReservedUniforms.push_back("detail_2_normal");
+    mReservedUniforms.push_back("detail_3_normal");
+    mReservedUniforms.push_back("detail_0_metallic_roughness");
+    mReservedUniforms.push_back("detail_1_metallic_roughness");
+    mReservedUniforms.push_back("detail_2_metallic_roughness");
+    mReservedUniforms.push_back("detail_3_metallic_roughness");
+    mReservedUniforms.push_back("detail_0_emissive");
+    mReservedUniforms.push_back("detail_1_emissive");
+    mReservedUniforms.push_back("detail_2_emissive");
+    mReservedUniforms.push_back("detail_3_emissive");
+
+    mReservedUniforms.push_back("baseColorFactors");
+    mReservedUniforms.push_back("metallicFactors");
+    mReservedUniforms.push_back("roughnessFactors");
+    mReservedUniforms.push_back("emissiveColors");
+    mReservedUniforms.push_back("minimum_alphas");
+
     mReservedUniforms.push_back("origin");
     mReservedUniforms.push_back("display_gamma");
 
@@ -1397,6 +1449,7 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("cloud_variance");
     mReservedUniforms.push_back("reflection_probe_ambiance");
     mReservedUniforms.push_back("max_probe_lod");
+    mReservedUniforms.push_back("probe_strength");
 
     mReservedUniforms.push_back("sh_input_r");
     mReservedUniforms.push_back("sh_input_g");
@@ -1407,6 +1460,8 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("sun_up_factor");
     mReservedUniforms.push_back("moonlight_color");
 
+    mReservedUniforms.push_back("debug_normal_draw_length");
+
     llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);
 
     std::set<std::string> dupe_check;
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index e655dda98d..8b13e822d5 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -85,6 +85,9 @@ public:
         EMISSIVE_COLOR,                     //  "emissiveColor"
         METALLIC_FACTOR,                    //  "metallicFactor"
         ROUGHNESS_FACTOR,                   //  "roughnessFactor"
+        MIRROR_FLAG,                        //  "mirror_flag"
+        CLIP_PLANE,                         //  "clipPlane"
+        CLIP_SIGN,                          //  "clipSign"
         DIFFUSE_MAP,                        //  "diffuseMap"
         ALTERNATE_DIFFUSE_MAP,              //  "altDiffuseMap"
         SPECULAR_MAP,                       //  "specularMap"
@@ -96,6 +99,7 @@ public:
         SCENE_DEPTH,                        //  "sceneDepth"
         REFLECTION_PROBES,                  //  "reflectionProbes"
         IRRADIANCE_PROBES,                  //  "irradianceProbes"
+        HERO_PROBE,                         //  "heroProbes"
         CLOUD_NOISE_MAP,                    //  "cloud_noise_texture"
         CLOUD_NOISE_MAP_NEXT,               //  "cloud_noise_texture_next"
         FULLBRIGHT,                         //  "fullbright"
@@ -251,8 +255,32 @@ public:
         TERRAIN_DETAIL1,                    //  "detail_1"
         TERRAIN_DETAIL2,                    //  "detail_2"
         TERRAIN_DETAIL3,                    //  "detail_3"
+
         TERRAIN_ALPHARAMP,                  //  "alpha_ramp"
 
+        TERRAIN_DETAIL0_BASE_COLOR,                //  "detail_0_base_color" (GLTF)
+        TERRAIN_DETAIL1_BASE_COLOR,                //  "detail_1_base_color" (GLTF)
+        TERRAIN_DETAIL2_BASE_COLOR,                //  "detail_2_base_color" (GLTF)
+        TERRAIN_DETAIL3_BASE_COLOR,                //  "detail_3_base_color" (GLTF)
+        TERRAIN_DETAIL0_NORMAL,                    //  "detail_0_normal" (GLTF)
+        TERRAIN_DETAIL1_NORMAL,                    //  "detail_1_normal" (GLTF)
+        TERRAIN_DETAIL2_NORMAL,                    //  "detail_2_normal" (GLTF)
+        TERRAIN_DETAIL3_NORMAL,                    //  "detail_3_normal" (GLTF)
+        TERRAIN_DETAIL0_METALLIC_ROUGHNESS,        //  "detail_0_metallic_roughness" (GLTF)
+        TERRAIN_DETAIL1_METALLIC_ROUGHNESS,        //  "detail_1_metallic_roughness" (GLTF)
+        TERRAIN_DETAIL2_METALLIC_ROUGHNESS,        //  "detail_2_metallic_roughness" (GLTF)
+        TERRAIN_DETAIL3_METALLIC_ROUGHNESS,        //  "detail_3_metallic_roughness" (GLTF)
+        TERRAIN_DETAIL0_EMISSIVE,                  //  "detail_0_emissive" (GLTF)
+        TERRAIN_DETAIL1_EMISSIVE,                  //  "detail_1_emissive" (GLTF)
+        TERRAIN_DETAIL2_EMISSIVE,                  //  "detail_2_emissive" (GLTF)
+        TERRAIN_DETAIL3_EMISSIVE,                  //  "detail_3_emissive" (GLTF)
+
+        TERRAIN_BASE_COLOR_FACTORS,                //  "baseColorFactors" (GLTF)
+        TERRAIN_METALLIC_FACTORS,                  //  "metallicFactors" (GLTF)
+        TERRAIN_ROUGHNESS_FACTORS,                 //  "roughnessFactors" (GLTF)
+        TERRAIN_EMISSIVE_COLORS,                   //  "emissiveColors" (GLTF)
+        TERRAIN_MINIMUM_ALPHAS,                    //  "minimum_alphas" (GLTF)
+
         SHINY_ORIGIN,                       //  "origin"
         DISPLAY_GAMMA,                      //  "display_gamma"
 
@@ -279,6 +307,7 @@ public:
 
         REFLECTION_PROBE_AMBIANCE,          //  "reflection_probe_ambiance"
         REFLECTION_PROBE_MAX_LOD,            //  "max_probe_lod"
+        REFLECTION_PROBE_STRENGTH,            //  "probe_strength"
         SH_INPUT_L1R,                       //  "sh_input_r"
         SH_INPUT_L1G,                       //  "sh_input_g"
         SH_INPUT_L1B,                       //  "sh_input_b"
@@ -287,6 +316,9 @@ public:
         WATER_EDGE_FACTOR,                  //  "water_edge"
         SUN_UP_FACTOR,                      //  "sun_up_factor"
         MOONLIGHT_COLOR,                    //  "moonlight_color"
+
+        DEBUG_NORMAL_DRAW_LENGTH,           //  "debug_normal_draw_length"
+
         END_RESERVED_UNIFORMS
     } eGLSLReservedUniforms;
     // clang-format on
@@ -336,6 +368,7 @@ public:
     bool mShaderCacheInitialized = false;
     bool mShaderCacheEnabled = false;
     std::string mShaderCacheDir;
+    static bool sMirrorsEnabled;
 
 protected:
 
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index c98de6bf06..7caf20f40b 100644
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -657,7 +657,7 @@ void LLVertexBuffer::drawElements(U32 mode, const LLVector4a* pos, const LLVecto
             U16 idx = indicesp[i];
             gGL.vertex3fv(pos[idx].getF32ptr());
         }
-}
+    }
     gGL.end();
     gGL.flush();
 }
@@ -741,8 +741,8 @@ void LLVertexBuffer::drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indi
     llassert(mGLBuffer == sGLRenderBuffer);
     llassert(mGLIndices == sGLRenderIndices);
     gGL.syncMatrices();
-    glDrawRangeElements(sGLMode[mode], start, end, count, GL_UNSIGNED_SHORT,
-        (GLvoid*) (indices_offset * sizeof(U16)));
+    glDrawRangeElements(sGLMode[mode], start, end, count, mIndicesType,
+        (GLvoid*) (indices_offset * (size_t) mIndicesStride));
 }
 
 void LLVertexBuffer::draw(U32 mode, U32 count, U32 indices_offset) const
@@ -1139,7 +1139,7 @@ U8* LLVertexBuffer::mapIndexBuffer(U32 index, S32 count)
 }
 
 // flush the given byte range
-//  target -- "targret" parameter for glBufferSubData
+//  target -- "target" parameter for glBufferSubData
 //  start -- first byte to copy
 //  end -- last byte to copy (NOT last byte + 1)
 //  data -- mMappedData or mMappedIndexData
@@ -1301,6 +1301,8 @@ bool LLVertexBuffer::getVertexStrider(LLStrider<LLVector4a>& strider, U32 index,
 }
 bool LLVertexBuffer::getIndexStrider(LLStrider<U16>& strider, U32 index, S32 count)
 {
+    llassert(mIndicesStride == 2); // cannot access 32-bit indices with U16 strider
+    llassert(mIndicesType == GL_UNSIGNED_SHORT);
     return VertexBufferStrider<U16,TYPE_INDEX>::get(*this, strider, index, count);
 }
 bool LLVertexBuffer::getTexCoord0Strider(LLStrider<LLVector2>& strider, U32 index, S32 count)
@@ -1319,6 +1321,10 @@ bool LLVertexBuffer::getNormalStrider(LLStrider<LLVector3>& strider, U32 index,
 {
     return VertexBufferStrider<LLVector3,TYPE_NORMAL>::get(*this, strider, index, count);
 }
+bool LLVertexBuffer::getNormalStrider(LLStrider<LLVector4a>& strider, U32 index, S32 count)
+{
+    return VertexBufferStrider<LLVector4a, TYPE_NORMAL>::get(*this, strider, index, count);
+}
 bool LLVertexBuffer::getTangentStrider(LLStrider<LLVector3>& strider, U32 index, S32 count)
 {
     return VertexBufferStrider<LLVector3,TYPE_TANGENT>::get(*this, strider, index, count);
@@ -1503,4 +1509,39 @@ void LLVertexBuffer::setColorData(const LLColor4U* data)
     flush_vbo(GL_ARRAY_BUFFER, mOffsets[TYPE_COLOR], mOffsets[TYPE_COLOR] + sTypeSize[TYPE_COLOR] * getNumVerts() - 1, (U8*) data);
 }
 
+void LLVertexBuffer::setNormalData(const LLVector4a* data)
+{
+    llassert(sGLRenderBuffer == mGLBuffer);
+    flush_vbo(GL_ARRAY_BUFFER, mOffsets[TYPE_NORMAL], mOffsets[TYPE_NORMAL] + sTypeSize[TYPE_NORMAL] * getNumVerts() - 1, (U8*) data);
+}
+
+void LLVertexBuffer::setTangentData(const LLVector4a* data)
+{
+    llassert(sGLRenderBuffer == mGLBuffer);
+    flush_vbo(GL_ARRAY_BUFFER, mOffsets[TYPE_TANGENT], mOffsets[TYPE_TANGENT] + sTypeSize[TYPE_TANGENT] * getNumVerts() - 1, (U8*) data);
+}
+
+void LLVertexBuffer::setWeight4Data(const LLVector4a* data)
+{
+    llassert(sGLRenderBuffer == mGLBuffer);
+    flush_vbo(GL_ARRAY_BUFFER, mOffsets[TYPE_WEIGHT4], mOffsets[TYPE_WEIGHT4] + sTypeSize[TYPE_WEIGHT4] * getNumVerts() - 1, (U8*) data);
+}
+
+void LLVertexBuffer::setIndexData(const U16* data)
+{
+    llassert(sGLRenderIndices == mGLIndices);
+    flush_vbo(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(U16) * getNumIndices() - 1, (U8*) data);
+}
+
+void LLVertexBuffer::setIndexData(const U32* data)
+{
+    llassert(sGLRenderIndices == mGLIndices);
+    if (mIndicesType != GL_UNSIGNED_INT)
+    { // HACK -- vertex buffers are initialized as 16-bit indices, but can be switched to 32-bit indices
+        mIndicesType = GL_UNSIGNED_INT;
+        mIndicesStride = 4;
+        mNumIndices /= 2;
+    }
+    flush_vbo(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(U32) * getNumIndices() - 1, (U8*)data);
+}
 
diff --git a/indra/llrender/llvertexbuffer.h b/indra/llrender/llvertexbuffer.h
index 545917cdec..b634609929 100644
--- a/indra/llrender/llvertexbuffer.h
+++ b/indra/llrender/llvertexbuffer.h
@@ -180,6 +180,7 @@ public:
     bool getTexCoord1Strider(LLStrider<LLVector2>& strider, U32 index=0, S32 count = -1);
     bool getTexCoord2Strider(LLStrider<LLVector2>& strider, U32 index=0, S32 count = -1);
     bool getNormalStrider(LLStrider<LLVector3>& strider, U32 index=0, S32 count = -1);
+    bool getNormalStrider(LLStrider<LLVector4a>& strider, U32 index = 0, S32 count = -1);
     bool getTangentStrider(LLStrider<LLVector3>& strider, U32 index=0, S32 count = -1);
     bool getTangentStrider(LLStrider<LLVector4a>& strider, U32 index=0, S32 count = -1);
     bool getColorStrider(LLStrider<LLColor4U>& strider, U32 index=0, S32 count = -1);
@@ -187,15 +188,15 @@ public:
     bool getWeightStrider(LLStrider<F32>& strider, U32 index=0, S32 count = -1);
     bool getWeight4Strider(LLStrider<LLVector4>& strider, U32 index=0, S32 count = -1);
     bool getClothWeightStrider(LLStrider<LLVector4>& strider, U32 index=0, S32 count = -1);
-    bool getBasecolorTexcoordStrider(LLStrider<LLVector2>& strider, U32 index=0, S32 count = -1);
-    bool getNormalTexcoordStrider(LLStrider<LLVector2>& strider, U32 index=0, S32 count = -1);
-    bool getMetallicRoughnessTexcoordStrider(LLStrider<LLVector2>& strider, U32 index=0, S32 count = -1);
-    bool getEmissiveTexcoordStrider(LLStrider<LLVector2>& strider, U32 index=0, S32 count = -1);
 
     void setPositionData(const LLVector4a* data);
+    void setNormalData(const LLVector4a* data);
+    void setTangentData(const LLVector4a* data);
+    void setWeight4Data(const LLVector4a* data);
     void setTexCoordData(const LLVector2* data);
     void setColorData(const LLColor4U* data);
-
+    void setIndexData(const U16* data);
+    void setIndexData(const U32* data);
 
     U32 getNumVerts() const                 { return mNumVerts; }
     U32 getNumIndices() const               { return mNumIndices; }
@@ -227,6 +228,8 @@ protected:
     U32     mGLIndices = 0;     // GL IBO handle
     U32     mNumVerts = 0;      // Number of vertices allocated
     U32     mNumIndices = 0;    // Number of indices allocated
+    U32     mIndicesType = GL_UNSIGNED_SHORT; // type of indices in index buffer
+    U32     mIndicesStride = 2;     // size of each index in bytes
     U32     mOffsets[TYPE_MAX]; // byte offsets into mMappedData of each attribute
 
     U8* mMappedData = nullptr;  // pointer to currently mapped data (NULL if unmapped)