Merge branch develop into project/fonts-update

# Conflicts:
#	indra/llrender/llfontfreetype.cpp

15 files changed, 363 insertions, 285 deletions

diff --git a/indra/llrender/llcubemaparray.cpp b/indra/llrender/llcubemaparray.cpp
index d0a97dc2c6..998b57217d 100644
--- a/indra/llrender/llcubemaparray.cpp
+++ b/indra/llrender/llcubemaparray.cpp
@@ -105,6 +105,36 @@ LLCubeMapArray::LLCubeMapArray()
 
 }
 
+LLCubeMapArray::LLCubeMapArray(LLCubeMapArray& lhs, U32 width, U32 count) : mTextureStage(0)
+{
+    mWidth = width;
+    mCount = count;
+
+    // Allocate a new cubemap array with the same criteria as the incoming cubemap array
+    allocate(mWidth, lhs.mImage->getComponents(), count, lhs.mImage->getUseMipMaps(), lhs.mHDR);
+
+    // Copy each cubemap from the incoming array to the new array
+    U32 min_count = std::min(count, lhs.mCount);
+    for (U32 i = 0; i < min_count * 6; ++i)
+    {
+        U32 src_resolution = lhs.mWidth;
+        U32 dst_resolution = mWidth;
+        {
+            GLint components = GL_RGB;
+            if (mImage->getComponents() == 4)
+                components = GL_RGBA;
+            GLint format = GL_RGB;
+
+            // Handle different resolutions by scaling the image
+            LLPointer<LLImageRaw> src_image = new LLImageRaw(lhs.mWidth, lhs.mWidth, lhs.mImage->getComponents());
+            glGetTexImage(GL_TEXTURE_CUBE_MAP_ARRAY, 0, components, GL_UNSIGNED_BYTE, src_image->getData());
+
+            LLPointer<LLImageRaw> scaled_image = src_image->scaled(mWidth, mWidth);
+            glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, i, mWidth, mWidth, 1, components, GL_UNSIGNED_BYTE, scaled_image->getData());
+        }
+    }
+}
+
 LLCubeMapArray::~LLCubeMapArray()
 {
 }
@@ -115,6 +145,8 @@ void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, bool us
     mWidth = resolution;
     mCount = count;
 
+    mHDR = hdr;
+
     LLImageGL::generateTextures(1, &texname);
 
     mImage = new LLImageGL(resolution, resolution, components, use_mips);
diff --git a/indra/llrender/llcubemaparray.h b/indra/llrender/llcubemaparray.h
index bfc72a321d..6b4288cb23 100644
--- a/indra/llrender/llcubemaparray.h
+++ b/indra/llrender/llcubemaparray.h
@@ -36,6 +36,7 @@ class LLCubeMapArray : public LLRefCount
 {
 public:
     LLCubeMapArray();
+    LLCubeMapArray(LLCubeMapArray& lhs, U32 width, U32 count);
 
     static GLenum sTargets[6];
 
@@ -73,4 +74,5 @@ protected:
     U32 mWidth = 0;
     U32 mCount = 0;
     S32 mTextureStage;
+    bool mHDR;
 };
diff --git a/indra/llrender/llfontfreetype.cpp b/indra/llrender/llfontfreetype.cpp
index 9a3ae6c55f..063e308da0 100644
--- a/indra/llrender/llfontfreetype.cpp
+++ b/indra/llrender/llfontfreetype.cpp
@@ -56,9 +56,9 @@
 
 FT_Render_Mode gFontRenderMode = FT_RENDER_MODE_NORMAL;
 
-LLFontManager *gFontManagerp = NULL;
+LLFontManager *gFontManagerp = nullptr;
 
-FT_Library gFTLibrary = NULL;
+FT_Library gFTLibrary = nullptr;
 
 //static
 void LLFontManager::initClass()
@@ -73,7 +73,7 @@ void LLFontManager::initClass()
 void LLFontManager::cleanupClass()
 {
     delete gFontManagerp;
-    gFontManagerp = NULL;
+    gFontManagerp = nullptr;
 }
 
 LLFontManager::LLFontManager()
@@ -101,6 +101,7 @@ LLFontManager::LLFontManager()
 LLFontManager::~LLFontManager()
 {
     FT_Done_FreeType(gFTLibrary);
+    unloadAllFonts();
 }
 
 
@@ -139,13 +140,9 @@ LLFontFreetype::LLFontFreetype()
     mAscender(0.f),
     mDescender(0.f),
     mLineHeight(0.f),
-#ifdef LL_WINDOWS
-    pFileStream(NULL),
-    pFtStream(NULL),
-#endif
     mIsFallback(false),
     mHinting(EFontHinting::FORCE_AUTOHINT),
-    mFTFace(NULL),
+    mFTFace(nullptr),
     mRenderGlyphCount(0),
     mStyle(0),
     mPointSize(0)
@@ -158,35 +155,16 @@ LLFontFreetype::~LLFontFreetype()
     // Clean up freetype libs.
     if (mFTFace)
         FT_Done_Face(mFTFace);
-    mFTFace = NULL;
+    mFTFace = nullptr;
 
     // Delete glyph info
     std::for_each(mCharGlyphInfoMap.begin(), mCharGlyphInfoMap.end(), DeletePairedPointer());
     mCharGlyphInfoMap.clear();
 
-#ifdef LL_WINDOWS
-    delete pFileStream; // closed by FT_Done_Face
-    delete pFtStream;
-#endif
     delete mFontBitmapCachep;
     // mFallbackFonts cleaned up by LLPointer destructor
 }
 
-#ifdef LL_WINDOWS
-unsigned long ft_read_cb(FT_Stream stream, unsigned long offset, unsigned char *buffer, unsigned long count) {
-    if (count <= 0) return count;
-    llifstream *file_stream = static_cast<llifstream *>(stream->descriptor.pointer);
-    file_stream->seekg(offset, std::ios::beg);
-    file_stream->read((char*)buffer, count);
-    return (unsigned long)file_stream->gcount();
-}
-
-void ft_close_cb(FT_Stream stream) {
-    llifstream *file_stream = static_cast<llifstream *>(stream->descriptor.pointer);
-    file_stream->close();
-}
-#endif
-
 bool LLFontFreetype::loadFace(const std::string& filename, F32 point_size, F32 vert_dpi, F32 horz_dpi, bool is_fallback, S32 face_n, EFontHinting hinting, S32 flags)
 {
     // Don't leak face objects.  This is also needed to deal with
@@ -194,26 +172,21 @@ bool LLFontFreetype::loadFace(const std::string& filename, F32 point_size, F32 v
     if (mFTFace)
     {
         FT_Done_Face(mFTFace);
-        mFTFace = NULL;
+        mFTFace = nullptr;
     }
 
-    int error;
-#ifdef LL_WINDOWS
-    error = ftOpenFace(filename, face_n);
-#else
-    error = FT_New_Face( gFTLibrary,
-                         filename.c_str(),
-                         0,
-                         &mFTFace);
-#endif
+    FT_Open_Args openArgs;
+    memset( &openArgs, 0, sizeof( openArgs ) );
+    openArgs.memory_base = gFontManagerp->loadFont( filename, openArgs.memory_size );
+
+    if( !openArgs.memory_base )
+        return false;
+
+    openArgs.flags = FT_OPEN_MEMORY;
+    int error = FT_Open_Face( gFTLibrary, &openArgs, 0, &mFTFace );
 
     if (error)
-    {
-#ifdef LL_WINDOWS
-        clearFontStreams();
-#endif
         return false;
-    }
 
     mIsFallback = is_fallback;
     mHinting = hinting;
@@ -230,10 +203,8 @@ bool LLFontFreetype::loadFace(const std::string& filename, F32 point_size, F32 v
     {
         // Clean up freetype libs.
         FT_Done_Face(mFTFace);
-#ifdef LL_WINDOWS
-        clearFontStreams();
-#endif
-        mFTFace = NULL;
+
+        mFTFace = nullptr;
         return false;
     }
 
@@ -295,73 +266,30 @@ S32 LLFontFreetype::getNumFaces(const std::string& filename)
     if (mFTFace)
     {
         FT_Done_Face(mFTFace);
-        mFTFace = NULL;
+        mFTFace = nullptr;
     }
 
     S32 num_faces = 1;
 
-#ifdef LL_WINDOWS
-    int error = ftOpenFace(filename, 0);
+    FT_Open_Args openArgs;
+    memset( &openArgs, 0, sizeof( openArgs ) );
+    openArgs.memory_base = gFontManagerp->loadFont( filename, openArgs.memory_size );
+    if( !openArgs.memory_base )
+        return 0;
+    openArgs.flags = FT_OPEN_MEMORY;
+    int error = FT_Open_Face( gFTLibrary, &openArgs, 0, &mFTFace );
 
     if (error)
-    {
         return 0;
-    }
     else
-    {
         num_faces = mFTFace->num_faces;
-    }
 
     FT_Done_Face(mFTFace);
-    clearFontStreams();
-    mFTFace = NULL;
-#endif
+    mFTFace = nullptr;
 
     return num_faces;
 }
 
-#ifdef LL_WINDOWS
-S32 LLFontFreetype::ftOpenFace(const std::string& filename, S32 face_n)
-{
-    S32 error = -1;
-    pFileStream = new llifstream(filename, std::ios::binary);
-    if (pFileStream->is_open())
-    {
-        std::streampos beg = pFileStream->tellg();
-        pFileStream->seekg(0, std::ios::end);
-        std::streampos end = pFileStream->tellg();
-        std::size_t file_size = end - beg;
-        pFileStream->seekg(0, std::ios::beg);
-
-        pFtStream = new LLFT_Stream();
-        pFtStream->base = 0;
-        pFtStream->pos = 0;
-        pFtStream->size = static_cast<unsigned long>(file_size);
-        pFtStream->descriptor.pointer = pFileStream;
-        pFtStream->read = ft_read_cb;
-        pFtStream->close = ft_close_cb;
-
-        FT_Open_Args args;
-        args.flags = FT_OPEN_STREAM;
-        args.stream = (FT_StreamRec*)pFtStream;
-        error = FT_Open_Face(gFTLibrary, &args, face_n, &mFTFace);
-    }
-    return error;
-}
-
-void LLFontFreetype::clearFontStreams()
-{
-    if (pFileStream)
-    {
-        pFileStream->close();
-    }
-    delete pFileStream;
-    delete pFtStream;
-    pFileStream = NULL;
-    pFtStream = NULL;
-}
-#endif
-
 void LLFontFreetype::addFallbackFont(const LLPointer<LLFontFreetype>& fallback_font,
                                      const char_functor_t& functor)
 {
@@ -385,7 +313,7 @@ F32 LLFontFreetype::getDescenderHeight() const
 
 F32 LLFontFreetype::getXAdvance(llwchar wch) const
 {
-    if (mFTFace == NULL)
+    if (mFTFace == nullptr)
         return 0.0;
 
     // Return existing info only if it is current
@@ -409,7 +337,7 @@ F32 LLFontFreetype::getXAdvance(llwchar wch) const
 
 F32 LLFontFreetype::getXAdvance(const LLFontGlyphInfo* glyph) const
 {
-    if (mFTFace == NULL)
+    if (mFTFace == nullptr)
         return 0.0;
 
     return glyph->mXAdvance;
@@ -417,7 +345,7 @@ F32 LLFontFreetype::getXAdvance(const LLFontGlyphInfo* glyph) const
 
 F32 LLFontFreetype::getXKerning(llwchar char_left, llwchar char_right) const
 {
-    if (mFTFace == NULL)
+    if (mFTFace == nullptr)
         return 0.0;
 
     //llassert(!mIsFallback);
@@ -441,7 +369,7 @@ F32 LLFontFreetype::getXKerning(llwchar char_left, llwchar char_right) const
 
 F32 LLFontFreetype::getXKerning(const LLFontGlyphInfo* left_glyph_info, const LLFontGlyphInfo* right_glyph_info) const
 {
-    if (mFTFace == NULL)
+    if (mFTFace == nullptr)
         return 0.0;
 
     U32 left_glyph = left_glyph_info ? left_glyph_info->mGlyphIndex : 0;
@@ -469,7 +397,7 @@ LLFontGlyphInfo* LLFontFreetype::addGlyph(llwchar wch, EFontGlyphType glyph_type
 {
     if (!mFTFace)
     {
-        return NULL;
+        return nullptr;
     }
 
     llassert(!mIsFallback);
@@ -560,14 +488,14 @@ LLFontGlyphInfo* LLFontFreetype::addGlyph(llwchar wch, EFontGlyphType glyph_type
     {
         return addGlyphFromFont(this, wch, glyph_index, glyph_type);
     }
-    return NULL;
+    return nullptr;
 }
 
 LLFontGlyphInfo* LLFontFreetype::addGlyphFromFont(const LLFontFreetype *fontp, llwchar wch, U32 glyph_index, EFontGlyphType requested_glyph_type) const
 {
     LL_PROFILE_ZONE_SCOPED;
-    if (mFTFace == NULL)
-        return NULL;
+    if (mFTFace == nullptr)
+        return nullptr;
 
     llassert(!mIsFallback);
     fontp->renderGlyph(requested_glyph_type, glyph_index, wch);
@@ -619,7 +547,7 @@ LLFontGlyphInfo* LLFontFreetype::addGlyphFromFont(const LLFontFreetype *fontp, l
     {
         U8 *buffer_data = fontp->mFTFace->glyph->bitmap.buffer;
         S32 buffer_row_stride = fontp->mFTFace->glyph->bitmap.pitch;
-        U8 *tmp_graydata = NULL;
+        U8 *tmp_graydata = nullptr;
 
         if (fontp->mFTFace->glyph->bitmap.pixel_mode
             == FT_PIXEL_MODE_MONO)
@@ -673,7 +601,14 @@ LLFontGlyphInfo* LLFontFreetype::addGlyphFromFont(const LLFontFreetype *fontp, l
 
     LLImageGL *image_gl = mFontBitmapCachep->getImageGL(bitmap_glyph_type, bitmap_num);
     LLImageRaw *image_raw = mFontBitmapCachep->getImageRaw(bitmap_glyph_type, bitmap_num);
-    image_gl->setSubImage(image_raw, 0, 0, image_gl->getWidth(), image_gl->getHeight());
+    if (image_gl && image_raw)
+    {
+        image_gl->setSubImage(image_raw, 0, 0, image_gl->getWidth(), image_gl->getHeight());
+    }
+    else
+    {
+        llassert(false); //images were just inserted by nextOpenPos, they shouldn't be missing
+    }
 
     return gi;
 }
@@ -716,7 +651,7 @@ void LLFontFreetype::insertGlyphInfo(llwchar wch, LLFontGlyphInfo* gi) const
 
 void LLFontFreetype::renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index, llwchar wch) const
 {
-    if (mFTFace == NULL)
+    if (mFTFace == nullptr)
         return;
 
     FT_Int32 load_flags = (FT_Int32)mHinting;
@@ -744,11 +679,11 @@ void LLFontFreetype::renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index, ll
             || FT_Err_Invalid_Composite == error
             || (FT_Err_Ok != error && LLStringOps::isEmoji(wch)))
         {
-            glyph_index = FT_Get_Char_Index(mFTFace, '?');
-            // if '?' is not present, potentially can use last index, that's supposed to be null glyph
-            if (glyph_index > 0)
+            // value~0 always corresponds to the 'missing glyph'
+            error = FT_Load_Glyph(mFTFace, 0, FT_LOAD_FORCE_AUTOHINT);
+            if (FT_Err_Ok != error)
             {
-                error = FT_Load_Glyph(mFTFace, glyph_index, load_flags ^ FT_LOAD_COLOR);
+                LL_ERRS() << "Loading fallback for char '" << (U32)wch << "', glyph " << glyph_index << " failed with error : " << (S32)error << LL_ENDL;
             }
         }
         llassert_always_msg(FT_Err_Ok == error, message.c_str());
@@ -857,7 +792,12 @@ bool LLFontFreetype::setSubImageBGRA(U32 x, U32 y, U32 bitmap_num, U16 width, U1
 {
     LLImageRaw* image_raw = mFontBitmapCachep->getImageRaw(EFontGlyphType::Color, bitmap_num);
     llassert(!mIsFallback);
-    llassert(image_raw && (image_raw->getComponents() == 4));
+    if (!image_raw)
+    {
+        llassert(false);
+        return false;
+    }
+    llassert(image_raw->getComponents() == 4);
 
     // NOTE: inspired by LLImageRaw::setSubImage()
     U32* image_data = (U32*)image_raw->getData();
@@ -885,10 +825,17 @@ bool LLFontFreetype::setSubImageBGRA(U32 x, U32 y, U32 bitmap_num, U16 width, U1
 void LLFontFreetype::setSubImageLuminanceAlpha(U32 x, U32 y, U32 bitmap_num, U32 width, U32 height, U8 *data, S32 stride) const
 {
     LLImageRaw *image_raw = mFontBitmapCachep->getImageRaw(EFontGlyphType::Grayscale, bitmap_num);
-    LLImageDataLock lock(image_raw);
 
     llassert(!mIsFallback);
-    llassert(image_raw && (image_raw->getComponents() == 2));
+    if (!image_raw)
+    {
+        llassert(false);
+        return;
+    }
+
+    LLImageDataLock lock(image_raw);
+
+    llassert(image_raw->getComponents() == 2);
 
     U8 *target = image_raw->getData();
     llassert(target);
@@ -918,3 +865,58 @@ void LLFontFreetype::setSubImageLuminanceAlpha(U32 x, U32 y, U32 bitmap_num, U32
     }
 }
 
+
+namespace ll
+{
+    namespace fonts
+    {
+        class LoadedFont
+        {
+            public:
+            LoadedFont( std::string aName , std::string const &aAddress, std::size_t aSize )
+            : mAddress( aAddress )
+            {
+                mName = aName;
+                mSize = aSize;
+                mRefs = 1;
+            }
+            std::string mName;
+            std::string mAddress;
+            std::size_t mSize;
+            U32  mRefs;
+        };
+    }
+}
+
+U8 const* LLFontManager::loadFont( std::string const &aFilename, long &a_Size)
+{
+    a_Size = 0;
+    std::map< std::string, std::shared_ptr<ll::fonts::LoadedFont> >::iterator itr = m_LoadedFonts.find( aFilename );
+    if( itr != m_LoadedFonts.end() )
+    {
+        ++itr->second->mRefs;
+        // A possible overflow cannot happen here, as it is asserted that the size is less than std::numeric_limits<long>::max() a few lines below.
+        a_Size = static_cast<long>(itr->second->mSize);
+        return reinterpret_cast<U8 const*>(itr->second->mAddress.c_str());
+    }
+
+    auto strContent = LLFile::getContents(aFilename);
+
+    if( strContent.empty() )
+        return nullptr;
+
+    // For fontconfig a type of long is required, std::string::size() returns size_t. I think it is safe to limit this to 2GiB and not support fonts that huge (can that even be a thing?)
+    llassert_always( strContent.size() < std::numeric_limits<long>::max() );
+
+    a_Size = static_cast<long>(strContent.size());
+
+    auto pCache = std::make_shared<ll::fonts::LoadedFont>( aFilename,  strContent, a_Size );
+    itr = m_LoadedFonts.insert( std::make_pair( aFilename, pCache ) ).first;
+
+    return reinterpret_cast<U8 const*>(itr->second->mAddress.c_str());
+}
+
+void LLFontManager::unloadAllFonts()
+{
+    m_LoadedFonts.clear();
+}
diff --git a/indra/llrender/llfontfreetype.h b/indra/llrender/llfontfreetype.h
index 0045768d54..f1e18776bf 100644
--- a/indra/llrender/llfontfreetype.h
+++ b/indra/llrender/llfontfreetype.h
@@ -44,15 +44,28 @@ struct FT_StreamRec_;
 typedef struct FT_StreamRec_ LLFT_Stream;
 enum class EFontHinting : S32;
 
+namespace ll
+{
+    namespace fonts
+    {
+        class LoadedFont;
+    }
+}
+
 class LLFontManager
 {
 public:
     static void initClass();
     static void cleanupClass();
 
+    U8 const *loadFont( std::string const &aFilename, long &a_Size );
+
 private:
     LLFontManager();
     ~LLFontManager();
+
+    void unloadAllFonts();
+    std::map< std::string, std::shared_ptr<ll::fonts::LoadedFont> > m_LoadedFonts;
 };
 
 struct LLFontGlyphInfo
@@ -91,11 +104,6 @@ public:
 
     S32 getNumFaces(const std::string& filename);
 
-#ifdef LL_WINDOWS
-    S32 ftOpenFace(const std::string& filename, S32 face_n);
-    void clearFontStreams();
-#endif
-
     typedef std::function<bool(llwchar)> char_functor_t;
     void addFallbackFont(const LLPointer<LLFontFreetype>& fallback_font, const char_functor_t& functor = nullptr);
 
@@ -175,11 +183,6 @@ private:
 
     LLFT_Face mFTFace;
 
-#ifdef LL_WINDOWS
-    llifstream *pFileStream;
-    LLFT_Stream *pFtStream;
-#endif
-
     bool mIsFallback;
     EFontHinting mHinting;
     S32 mFontFlags;
diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index 1bc5e79835..d13b98e274 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -1123,17 +1123,6 @@ bool LLGLManager::initGL()
     if (mGLVersion >= 2.f)
     {
         parse_glsl_version(mGLSLVersionMajor, mGLSLVersionMinor);
-
-#if 0 && LL_DARWIN
-        // TODO maybe switch to using a core profile for GL 3.2?
-        // https://stackoverflow.com/a/19868861
-        //never use GLSL greater than 1.20 on OSX
-        if (mGLSLVersionMajor > 1 || mGLSLVersionMinor > 30)
-        {
-            mGLSLVersionMajor = 1;
-            mGLSLVersionMinor = 30;
-        }
-#endif
     }
 
     if (mGLVersion >= 2.1f && LLImageGL::sCompressTextures)
@@ -1228,28 +1217,9 @@ bool LLGLManager::initGL()
     }
 #endif
 
-#if LL_WINDOWS
-    if (mVRAM < 256)
-    {
-        // Something likely went wrong using the above extensions
-        // try WMI first and fall back to old method (from dxdiag) if all else fails
-        // Function will check all GPUs WMI knows of and will pick up the one with most
-        // memory. We need to check all GPUs because system can switch active GPU to
-        // weaker one, to preserve power when not under load.
-        U32 mem = LLDXHardware::getMBVideoMemoryViaWMI();
-        if (mem != 0)
-        {
-            mVRAM = mem;
-            LL_WARNS("RenderInit") << "VRAM Detected (WMI):" << mVRAM<< LL_ENDL;
-        }
-    }
-#endif
-
     if (mVRAM < 256 && old_vram > 0)
     {
         // fall back to old method
-        // Note: on Windows value will be from LLDXHardware.
-        // Either received via dxdiag or via WMI by id from dxdiag.
         mVRAM = old_vram;
     }
 
@@ -1266,7 +1236,7 @@ bool LLGLManager::initGL()
     // there's some implementation that reports a crazy value
     mMaxUniformBlockSize = llmin(mMaxUniformBlockSize, 65536);
 
-    if (mGLVersion >= 4.59f)
+    if (mHasAnisotropic)
     {
         glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY, &mMaxAnisotropy);
     }
@@ -1430,6 +1400,11 @@ void LLGLManager::initExtensions()
     mHasCubeMapArray = mGLVersion >= 3.99f;
     mHasTransformFeedback = mGLVersion >= 3.99f;
     mHasDebugOutput = mGLVersion >= 4.29f;
+    mHasAnisotropic = mGLVersion >= 4.59f;
+    if(!mHasAnisotropic && gGLHExts.mSysExts)
+    {
+        mHasAnisotropic = ExtensionExists("GL_EXT_texture_filter_anisotropic", gGLHExts.mSysExts);
+    }
 
     // Misc
     glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, (GLint*) &mGLMaxVertexRange);
@@ -2458,12 +2433,15 @@ void LLGLState::checkStates(GLboolean writeAlpha)
         return;
     }
 
-    GLint src;
-    GLint dst;
-    glGetIntegerv(GL_BLEND_SRC, &src);
-    glGetIntegerv(GL_BLEND_DST, &dst);
-    llassert_always(src == GL_SRC_ALPHA);
-    llassert_always(dst == GL_ONE_MINUS_SRC_ALPHA);
+    GLint srcRGB, dstRGB, srcAlpha, dstAlpha;
+    glGetIntegerv(GL_BLEND_SRC_RGB, &srcRGB);
+    glGetIntegerv(GL_BLEND_DST_RGB, &dstRGB);
+    glGetIntegerv(GL_BLEND_SRC_ALPHA, &srcAlpha);
+    glGetIntegerv(GL_BLEND_DST_ALPHA, &dstAlpha);
+    llassert_always(srcRGB == GL_SRC_ALPHA);
+    llassert_always(srcAlpha == GL_SRC_ALPHA);
+    llassert_always(dstRGB == GL_ONE_MINUS_SRC_ALPHA);
+    llassert_always(dstAlpha == GL_ONE_MINUS_SRC_ALPHA);
 
     // disable for now until usage is consistent
     //GLboolean colorMask[4];
@@ -2744,7 +2722,7 @@ void LLGLUserClipPlane::setPlane(F32 a, F32 b, F32 c, F32 d)
     if(cplane[2] < 0)
         cplane *= -1;
 
-    glm::mat4 suffix;
+    glm::mat4 suffix = glm::identity<glm::mat4>();
     suffix = glm::row(suffix, 2, cplane);
     glm::mat4 newP = suffix * P;
     gGL.matrixMode(LLRender::MM_PROJECTION);
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index b3f32fdc83..9cd5dc8145 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -421,8 +421,11 @@ bool LLGLSLShader::createShader()
     llassert_always(!mShaderFiles.empty());
 
 #if LL_DARWIN
-    // work-around missing mix(vec3,vec3,bvec3)
-    mDefines["OLD_SELECT"] = "1";
+    if(!gGLManager.mIsApple)
+    {
+        // work-around missing mix(vec3,vec3,bvec3)
+        mDefines["OLD_SELECT"] = "1";
+    }
 #endif
 
     mShaderHash = hash();
@@ -543,7 +546,7 @@ bool LLGLSLShader::createShader()
         }
     }
 
-#ifdef LL_PROFILER_ENABLE_RENDER_DOC
+#if LL_PROFILER_ENABLE_RENDER_DOC
     setLabel(mName.c_str());
 #endif
 
@@ -1076,8 +1079,8 @@ void LLGLSLShader::bind()
 
 void LLGLSLShader::bind(U8 variant)
 {
-    llassert(mGLTFVariants.size() == LLGLSLShader::NUM_GLTF_VARIANTS);
-    llassert(variant < LLGLSLShader::NUM_GLTF_VARIANTS);
+    llassert_always(mGLTFVariants.size() == LLGLSLShader::NUM_GLTF_VARIANTS);
+    llassert_always(variant < LLGLSLShader::NUM_GLTF_VARIANTS);
     mGLTFVariants[variant].bind();
 }
 
@@ -1085,7 +1088,7 @@ void LLGLSLShader::bind(bool rigged)
 {
     if (rigged)
     {
-        llassert(mRiggedVariant);
+        llassert_always(mRiggedVariant);
         mRiggedVariant->bind();
     }
     else
@@ -1247,23 +1250,40 @@ S32 LLGLSLShader::disableTexture(S32 uniform, LLTexUnit::eTextureType mode)
         llassert(false);
         return -1;
     }
+
     S32 index = mTexture[uniform];
-    if (index != -1 && gGL.getTexUnit(index)->getCurrType() != LLTexUnit::TT_NONE)
+    if (index < 0)
+    {
+        // Invalid texture index - nothing to disable
+        return index;
+    }
+
+    LLTexUnit* tex_unit = gGL.getTexUnit(index);
+    if (!tex_unit)
     {
-        if (gDebugGL && gGL.getTexUnit(index)->getCurrType() != mode)
+        // Invalid texture unit
+        LL_WARNS_ONCE("Shader") << "Invalid texture unit at index: " << index << LL_ENDL;
+        return index;
+    }
+
+    LLTexUnit::eTextureType curr_type = tex_unit->getCurrType();
+    if (curr_type != LLTexUnit::TT_NONE)
+    {
+        if (gDebugGL && curr_type != mode)
         {
             if (gDebugSession)
             {
-                gFailLog << "Texture channel " << index << " texture type corrupted." << std::endl;
+                gFailLog << "Texture channel " << index << " texture type corrupted. Expected: " << mode << ", Found: " << curr_type << std::endl;
                 ll_fail("LLGLSLShader::disableTexture failed");
             }
             else
             {
-                LL_ERRS() << "Texture channel " << index << " texture type corrupted." << LL_ENDL;
+                LL_ERRS() << "Texture channel " << index << " texture type corrupted. Expected: " << mode << ", Found: " << curr_type << LL_ENDL;
             }
         }
-        gGL.getTexUnit(index)->disable();
+        tex_unit->disable();
     }
+
     return index;
 }
 
@@ -2061,7 +2081,7 @@ LLUUID LLGLSLShader::hash()
     return hash_obj.digest();
 }
 
-#ifdef LL_PROFILER_ENABLE_RENDER_DOC
+#if LL_PROFILER_ENABLE_RENDER_DOC
 void LLGLSLShader::setLabel(const char* label) {
     LL_LABEL_OBJECT_GL(GL_PROGRAM, mProgramObject, strlen(label), label);
 }
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 873ab0cff5..4702a27cc5 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -361,7 +361,7 @@ public:
     // hacky flag used for optimization in LLDrawPoolAlpha
     bool mCanBindFast = false;
 
-#ifdef LL_PROFILER_ENABLE_RENDER_DOC
+#if LL_PROFILER_ENABLE_RENDER_DOC
     void setLabel(const char* label);
 #endif
 
@@ -381,7 +381,7 @@ extern LLGLSLShader         gSolidColorProgram;
 //Alpha mask shader (declared here so llappearance can access properly)
 extern LLGLSLShader         gAlphaMaskProgram;
 
-#ifdef LL_PROFILER_ENABLE_RENDER_DOC
+#if LL_PROFILER_ENABLE_RENDER_DOC
 #define LL_SET_SHADER_LABEL(shader) shader.setLabel(#shader)
 #else
 #define LL_SET_SHADER_LABEL(shader, label)
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index 3f8903ca09..97ea6f67bd 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -338,6 +338,7 @@ S32 LLImageGL::dataFormatBits(S32 dataformat)
     case GL_BGRA:                                   return 32;      // Used for QuickTime media textures on the Mac
     case GL_DEPTH_COMPONENT:                        return 24;
     case GL_DEPTH_COMPONENT24:                      return 24;
+    case GL_RGBA16:                                 return 64;
     case GL_R16F:                                   return 16;
     case GL_RG16F:                                  return 32;
     case GL_RGB16F:                                 return 48;
@@ -1096,6 +1097,8 @@ void sub_image_lines(U32 target, S32 miplevel, S32 x_offset, S32 y_offset, S32 w
         // full width texture, do 32 lines at a time
         for (U32 y_pos = y_offset; y_pos < y_offset_end; y_pos += batch_size)
         {
+            // If this keeps crashing, pass down data_size, looks like it is using
+            // imageraw->getData(); for data, but goes way over allocated size limit
             glTexSubImage2D(target, miplevel, x_offset, y_pos, width, batch_size, pixformat, pixtype, src);
             src += line_width * batch_size;
         }
@@ -1105,6 +1108,8 @@ void sub_image_lines(U32 target, S32 miplevel, S32 x_offset, S32 y_offset, S32 w
         // partial width or strange height
         for (U32 y_pos = y_offset; y_pos < y_offset_end; y_pos += 1)
         {
+            // If this keeps crashing, pass down data_size, looks like it is using
+            // imageraw->getData(); for data, but goes way over allocated size limit
             glTexSubImage2D(target, miplevel, x_offset, y_pos, width, 1, pixformat, pixtype, src);
             src += line_width;
         }
@@ -1545,6 +1550,7 @@ bool LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
         llassert(mCurrentDiscardLevel >= 0);
         discard_level = mCurrentDiscardLevel;
     }
+    discard_level = llmin(discard_level, MAX_DISCARD_LEVEL);
 
     // Actual image width/height = raw image width/height * 2^discard_level
     S32 raw_w = imageraw->getWidth() ;
@@ -1643,6 +1649,7 @@ bool LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, bool data_
         discard_level = mCurrentDiscardLevel;
     }
     discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
+    discard_level = llmin(discard_level, MAX_DISCARD_LEVEL);
 
     if (main_thread // <--- always force creation of new_texname when not on main thread ...
         && !defer_copy // <--- ... or defer copy is set
@@ -1870,8 +1877,17 @@ bool LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
         glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, (GLint*)&glbytes);
         if(!imageraw->allocateDataSize(width, height, ncomponents, glbytes))
         {
-            LL_WARNS() << "Memory allocation failed for reading back texture. Size is: " << glbytes << LL_ENDL ;
-            LL_WARNS() << "width: " << width << "height: " << height << "components: " << ncomponents << LL_ENDL ;
+            constexpr S64 MAX_GL_BYTES = 2048 * 2048;
+            if (glbytes > 0 && glbytes <= MAX_GL_BYTES)
+            {
+                LLError::LLUserWarningMsg::showOutOfMemory();
+                LL_ERRS() << "Memory allocation failed for reading back texture. Data size: " << glbytes << LL_ENDL;
+            }
+            else
+            {
+                LL_WARNS() << "Memory allocation failed for reading back texture. Data size is: " << glbytes << LL_ENDL;
+                LL_WARNS() << "width: " << width << "height: " << height << "components: " << ncomponents << LL_ENDL;
+            }
             return false ;
         }
 
@@ -1882,8 +1898,18 @@ bool LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
     {
         if(!imageraw->allocateDataSize(width, height, ncomponents))
         {
-            LL_WARNS() << "Memory allocation failed for reading back texture." << LL_ENDL ;
-            LL_WARNS() << "width: " << width << "height: " << height << "components: " << ncomponents << LL_ENDL ;
+            constexpr F32 MAX_IMAGE_SIZE = 2048 * 2048;
+            F32 size = (F32)width * (F32)height * (F32)ncomponents;
+            if (size > 0 && size <= MAX_IMAGE_SIZE)
+            {
+                LLError::LLUserWarningMsg::showOutOfMemory();
+                LL_ERRS() << "Memory allocation failed for reading back texture. Data size: " << size << LL_ENDL;
+            }
+            else
+            {
+                LL_WARNS() << "Memory allocation failed for reading back texture." << LL_ENDL;
+                LL_WARNS() << "width: " << width << "height: " << height << "components: " << ncomponents << LL_ENDL;
+            }
             return false ;
         }
 
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index 1dc87a66ce..57be8570af 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -118,7 +118,7 @@ static const GLenum sGLBlendFactor[] =
 
 LLTexUnit::LLTexUnit(S32 index)
     : mCurrTexType(TT_NONE),
-    mCurrColorScale(1), mCurrAlphaScale(1), mCurrTexture(0),
+    mCurrTexture(0),
     mHasMipMaps(false),
     mIndex(index)
 {
@@ -207,6 +207,12 @@ void LLTexUnit::bindFast(LLTexture* texture)
     }
     glBindTexture(sGLTextureType[gl_tex->getTarget()], mCurrTexture);
     mHasMipMaps = gl_tex->mHasMipMaps;
+    if (gl_tex->mTexOptionsDirty)
+    {
+        gl_tex->mTexOptionsDirty = false;
+        setTextureAddressModeFast(gl_tex->mAddressMode, gl_tex->getTarget());
+        setTextureFilteringOptionFast(gl_tex->mFilterOption, gl_tex->getTarget());
+    }
 }
 
 bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
@@ -461,11 +467,16 @@ void LLTexUnit::setTextureAddressMode(eTextureAddressMode mode)
 
     activate();
 
-    glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_S, sGLAddressMode[mode]);
-    glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_T, sGLAddressMode[mode]);
-    if (mCurrTexType == TT_CUBE_MAP)
+    setTextureAddressModeFast(mode, mCurrTexType);
+}
+
+void LLTexUnit::setTextureAddressModeFast(eTextureAddressMode mode, eTextureType tex_type)
+{
+    glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_WRAP_S, sGLAddressMode[mode]);
+    glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_WRAP_T, sGLAddressMode[mode]);
+    if (tex_type == TT_CUBE_MAP || tex_type == TT_CUBE_MAP_ARRAY || tex_type == TT_TEXTURE_3D)
     {
-        glTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, sGLAddressMode[mode]);
+        glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_WRAP_R, sGLAddressMode[mode]);
     }
 }
 
@@ -475,51 +486,56 @@ void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions optio
 
     gGL.flush();
 
+    setTextureFilteringOptionFast(option, mCurrTexType);
+}
+
+void LLTexUnit::setTextureFilteringOptionFast(LLTexUnit::eTextureFilterOptions option, eTextureType tex_type)
+{
     if (option == TFO_POINT)
     {
-        glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     }
     else
     {
-        glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     }
 
     if (option >= TFO_TRILINEAR && mHasMipMaps)
     {
-        glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+        glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
     }
     else if (option >= TFO_BILINEAR)
     {
         if (mHasMipMaps)
         {
-            glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
+            glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
         }
         else
         {
-            glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+            glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         }
     }
     else
     {
         if (mHasMipMaps)
         {
-            glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+            glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
         }
         else
         {
-            glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+            glTexParameteri(sGLTextureType[tex_type], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         }
     }
 
-    if (gGLManager.mGLVersion >= 4.59f)
+    if (gGLManager.mHasAnisotropic)
     {
         if (LLImageGL::sGlobalUseAnisotropic && option == TFO_ANISOTROPIC)
         {
-            glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY, gGLManager.mMaxAnisotropy);
+            glTexParameterf(sGLTextureType[tex_type], GL_TEXTURE_MAX_ANISOTROPY, gGLManager.mMaxAnisotropy);
         }
         else
         {
-            glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY, 1.f);
+            glTexParameterf(sGLTextureType[tex_type], GL_TEXTURE_MAX_ANISOTROPY, 1.f);
         }
     }
 }
@@ -600,26 +616,6 @@ GLint LLTexUnit::getTextureSourceType(eTextureBlendSrc src, bool isAlpha)
     }
 }
 
-void LLTexUnit::setColorScale(S32 scale)
-{
-    if (mCurrColorScale != scale || gGL.mDirty)
-    {
-        mCurrColorScale = scale;
-        gGL.flush();
-        glTexEnvi( GL_TEXTURE_ENV, GL_RGB_SCALE, scale );
-    }
-}
-
-void LLTexUnit::setAlphaScale(S32 scale)
-{
-    if (mCurrAlphaScale != scale || gGL.mDirty)
-    {
-        mCurrAlphaScale = scale;
-        gGL.flush();
-        glTexEnvi( GL_TEXTURE_ENV, GL_ALPHA_SCALE, scale );
-    }
-}
-
 // Useful for debugging that you've manually assigned a texture operation to the correct
 // texture unit based on the currently set active texture in opengl.
 void LLTexUnit::debugTextureUnit(void)
@@ -1283,9 +1279,7 @@ void LLRender::translateUI(F32 x, F32 y, F32 z)
         LL_ERRS() << "Need to push a UI translation frame before offsetting" << LL_ENDL;
     }
 
-    mUIOffset.back().mV[0] += x;
-    mUIOffset.back().mV[1] += y;
-    mUIOffset.back().mV[2] += z;
+    mUIOffset.back().add(LLVector4a(x, y, z));
 }
 
 void LLRender::scaleUI(F32 x, F32 y, F32 z)
@@ -1295,14 +1289,14 @@ void LLRender::scaleUI(F32 x, F32 y, F32 z)
         LL_ERRS() << "Need to push a UI transformation frame before scaling." << LL_ENDL;
     }
 
-    mUIScale.back().scaleVec(LLVector3(x,y,z));
+    mUIScale.back().mul(LLVector4a(x, y, z));
 }
 
 void LLRender::pushUIMatrix()
 {
     if (mUIOffset.empty())
     {
-        mUIOffset.emplace_back(0.f,0.f,0.f);
+        mUIOffset.emplace_back(0.f);
     }
     else
     {
@@ -1311,7 +1305,7 @@ void LLRender::pushUIMatrix()
 
     if (mUIScale.empty())
     {
-        mUIScale.emplace_back(1.f,1.f,1.f);
+        mUIScale.emplace_back(1.f);
     }
     else
     {
@@ -1333,18 +1327,20 @@ LLVector3 LLRender::getUITranslation()
 {
     if (mUIOffset.empty())
     {
-        return LLVector3(0,0,0);
+        return LLVector3::zero;
     }
-    return mUIOffset.back();
+
+    return LLVector3(mUIOffset.back().getF32ptr());
 }
 
 LLVector3 LLRender::getUIScale()
 {
     if (mUIScale.empty())
     {
-        return LLVector3(1,1,1);
+        return LLVector3::all_one;
     }
-    return mUIScale.back();
+
+    return LLVector3(mUIScale.back().getF32ptr());
 }
 
 
@@ -1354,8 +1350,9 @@ void LLRender::loadUIIdentity()
     {
         LL_ERRS() << "Need to push UI translation frame before clearing offset." << LL_ENDL;
     }
-    mUIOffset.back().setVec(0,0,0);
-    mUIScale.back().setVec(1,1,1);
+
+    mUIOffset.back().clear();
+    mUIScale.back().splat(1);
 }
 
 void LLRender::setColorMask(bool writeColor, bool writeAlpha)
@@ -1783,8 +1780,10 @@ void LLRender::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
     }
     else
     {
-        LLVector3 vert = (LLVector3(x,y,z)+mUIOffset.back()).scaledVec(mUIScale.back());
-        mVerticesp[mCount].set(vert.mV[VX], vert.mV[VY], vert.mV[VZ]);
+        LLVector4a vert(x, y, z);
+        vert.add(mUIOffset.back());
+        vert.mul(mUIScale.back());
+        mVerticesp[mCount] = vert;
     }
 
     mCount++;
diff --git a/indra/llrender/llrender.h b/indra/llrender/llrender.h
index 7b6bd4198b..0801c12fb4 100644
--- a/indra/llrender/llrender.h
+++ b/indra/llrender/llrender.h
@@ -43,6 +43,7 @@
 #include "llglheaders.h"
 #include "llmatrix4a.h"
 #include "glm/mat4x4.hpp"
+#include <boost/align/aligned_allocator.hpp>
 
 #include <array>
 #include <list>
@@ -207,11 +208,15 @@ public:
     // Warning: this stays set for the bound texture forever,
     // make sure you want to permanently change the address mode  for the bound texture.
     void setTextureAddressMode(eTextureAddressMode mode);
+    // MUST already be active and bound
+    void setTextureAddressModeFast(eTextureAddressMode mode, eTextureType tex_type);
 
     // Sets the filtering options used to sample the texture
     // Warning: this stays set for the bound texture forever,
     // make sure you want to permanently change the filtering for the bound texture.
     void setTextureFilteringOption(LLTexUnit::eTextureFilterOptions option);
+    // MUST already be active and bound
+    void setTextureFilteringOptionFast(LLTexUnit::eTextureFilterOptions option, eTextureType tex_type);
 
     static U32 getInternalType(eTextureType type);
 
@@ -227,13 +232,9 @@ protected:
     S32                 mIndex;
     U32                 mCurrTexture;
     eTextureType        mCurrTexType;
-    S32                 mCurrColorScale;
-    S32                 mCurrAlphaScale;
     bool                mHasMipMaps;
 
     void debugTextureUnit(void);
-    void setColorScale(S32 scale);
-    void setAlphaScale(S32 scale);
     GLint getTextureSource(eTextureBlendSrc src);
     GLint getTextureSourceType(eTextureBlendSrc src, bool isAlpha = false);
 };
@@ -526,8 +527,8 @@ private:
     eBlendFactor mCurrBlendAlphaSFactor;
     eBlendFactor mCurrBlendAlphaDFactor;
 
-    std::vector<LLVector3> mUIOffset;
-    std::vector<LLVector3> mUIScale;
+    std::vector<LLVector4a, boost::alignment::aligned_allocator<LLVector4a, 16> > mUIOffset;
+    std::vector<LLVector4a, boost::alignment::aligned_allocator<LLVector4a, 16> > mUIScale;
 };
 
 extern F32 gGLModelView[16];
diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp
index 38bc5ff331..0b0d69812f 100644
--- a/indra/llrender/llrendertarget.cpp
+++ b/indra/llrender/llrendertarget.cpp
@@ -492,22 +492,6 @@ U32 LLRenderTarget::getNumTextures() const
 void LLRenderTarget::bindTexture(U32 index, S32 channel, LLTexUnit::eTextureFilterOptions filter_options)
 {
     gGL.getTexUnit(channel)->bindManual(mUsage, getTexture(index), filter_options == LLTexUnit::TFO_TRILINEAR || filter_options == LLTexUnit::TFO_ANISOTROPIC);
-
-    bool isSRGB = false;
-    llassert(mInternalFormat.size() > index);
-    switch (mInternalFormat[index])
-    {
-        case GL_SRGB:
-        case GL_SRGB8:
-        case GL_SRGB_ALPHA:
-        case GL_SRGB8_ALPHA8:
-            isSRGB = true;
-            break;
-
-        default:
-            break;
-    }
-
     gGL.getTexUnit(channel)->setTextureFilteringOption(filter_options);
 }
 
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 4807c12226..2c35a6acae 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -458,7 +458,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
 
 // endsure work-around for missing GLSL funcs gets propogated to feature shader files (e.g. srgbF.glsl)
 #if LL_DARWIN
-    if (defines)
+    if (!gGLManager.mIsApple && defines)
     {
         (*defines)["OLD_SELECT"] = "1";
     }
@@ -511,7 +511,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
         {   //search from the current gpu class down to class 1 to find the most relevant shader
             std::stringstream fname;
             fname << getShaderDirPrefix();
-            fname << gpu_class << "/" << filename;
+            fname << gpu_class << gDirUtilp->getDirDelimiter() << filename;
 
             open_file_name = fname.str();
 
@@ -540,7 +540,14 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
 
     if (file == NULL)
     {
-        LL_WARNS("ShaderLoading") << "GLSL Shader file not found: " << open_file_name << LL_ENDL;
+        if (gDirUtilp->fileExists(open_file_name))
+        {
+            LL_WARNS("ShaderLoading") << "GLSL Shader file failed to open: " << open_file_name << LL_ENDL;
+        }
+        else
+        {
+            LL_WARNS("ShaderLoading") << "GLSL Shader file not found: " << open_file_name << LL_ENDL;
+        }
         return 0;
     }
 
@@ -857,6 +864,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
     //load source
     if (ret)
     {
+        LL_DEBUGS("ShaderLoading") << "glCreateShader done" << LL_ENDL;
         glShaderSource(ret, shader_code_count, (const GLchar**)shader_code_text, NULL);
 
         error = glGetError();
@@ -871,6 +879,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
     //compile source
     if (ret)
     {
+        LL_DEBUGS("ShaderLoading") << "glShaderSource done" << U32(ret) << LL_ENDL;
         glCompileShader(ret);
 
         error = glGetError();
@@ -885,6 +894,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
     if (error == GL_NO_ERROR)
     {
         //check for errors
+        LL_DEBUGS("ShaderLoading") << "glCompileShader done" << U32(ret) << LL_ENDL;
         GLint success = GL_TRUE;
         glGetShaderiv(ret, GL_COMPILE_STATUS, &success);
 
@@ -901,6 +911,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
     }
     else
     {
+        LL_DEBUGS("ShaderLoading") << "loadShaderFile() completed, ret: " << U32(ret) << LL_ENDL;
         ret = 0;
     }
     stop_glerror();
@@ -989,16 +1000,17 @@ bool LLShaderMgr::validateProgramObject(GLuint obj)
     return success;
 }
 
-void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version, const LLUUID& current_cache_version)
+void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version, const LLUUID& current_cache_version, bool second_instance)
 {
-    LL_INFOS() << "Initializing shader cache" << LL_ENDL;
+    LL_PROFILE_ZONE_SCOPED;
+    LL_INFOS("ShaderMgr") << "Initializing shader cache" << LL_ENDL;
 
     mShaderCacheEnabled = gGLManager.mGLVersion >= 4.09 && enabled;
 
-    if(!mShaderCacheEnabled || mShaderCacheInitialized)
+    if(!mShaderCacheEnabled || mShaderCacheVersion.notNull())
         return;
 
-    mShaderCacheInitialized = true;
+    mShaderCacheVersion = current_cache_version;
 
     mShaderCacheDir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "shader_cache");
     LLFile::mkdir(mShaderCacheDir);
@@ -1007,16 +1019,19 @@ void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version,
         std::string meta_out_path = gDirUtilp->add(mShaderCacheDir, "shaderdata.llsd");
         if (gDirUtilp->fileExists(meta_out_path))
         {
-            LL_INFOS() << "Loading shader cache metadata" << LL_ENDL;
+            LL_PROFILE_ZONE_NAMED("shader_cache");
+            LL_INFOS("ShaderMgr") << "Loading shader cache metadata" << LL_ENDL;
 
-            llifstream instream(meta_out_path);
+            llifstream instream(meta_out_path, std::ifstream::in | std::ifstream::binary);
             LLSD in_data;
-            LLSDSerialize::fromNotation(in_data, instream, LLSDSerialize::SIZE_UNLIMITED);
+            // todo: this is likely very expensive to parse, should use binary
+            LLSDSerialize::fromBinary(in_data, instream, LLSDSerialize::SIZE_UNLIMITED);
             instream.close();
 
-            if (old_cache_version == current_cache_version)
+            if (old_cache_version == current_cache_version
+                && in_data["version"].asUUID() == current_cache_version)
             {
-                for (const auto& data_pair : llsd::inMap(in_data))
+                for (const auto& data_pair : llsd::inMap(in_data["shaders"]))
                 {
                     ProgramBinaryData binary_info = ProgramBinaryData();
                     binary_info.mBinaryFormat = data_pair.second["binary_format"].asInteger();
@@ -1025,11 +1040,15 @@ void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version,
                     mShaderBinaryCache.insert_or_assign(LLUUID(data_pair.first), binary_info);
                 }
             }
-            else
+            else if (!second_instance)
             {
-                LL_INFOS() << "Shader cache version mismatch detected. Purging." << LL_ENDL;
+                LL_INFOS("ShaderMgr") << "Shader cache version mismatch detected. Purging." << LL_ENDL;
                 clearShaderCache();
             }
+            else
+            {
+                LL_INFOS("ShaderMgr") << "Shader cache version mismatch detected." << LL_ENDL;
+            }
         }
     }
 }
@@ -1037,19 +1056,32 @@ void LLShaderMgr::initShaderCache(bool enabled, const LLUUID& old_cache_version,
 void LLShaderMgr::clearShaderCache()
 {
     std::string shader_cache = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "shader_cache");
-    LL_INFOS() << "Removing shader cache at " << shader_cache << LL_ENDL;
+    LL_INFOS("ShaderMgr") << "Removing shader cache at " << shader_cache << LL_ENDL;
     const std::string mask = "*";
     gDirUtilp->deleteFilesInDir(shader_cache, mask);
+    LLFile::rmdir(shader_cache);
     mShaderBinaryCache.clear();
 }
 
 void LLShaderMgr::persistShaderCacheMetadata()
 {
     if(!mShaderCacheEnabled) return;
+    if (mShaderCacheVersion.isNull())
+    {
+        LL_WARNS("ShaderMgr") << "Attempted to save shader cache with no version set" << LL_ENDL;
+        return;
+    }
 
-    LL_INFOS() << "Persisting shader cache metadata to disk" << LL_ENDL;
+    LL_INFOS("ShaderMgr") << "Persisting shader cache metadata to disk" << LL_ENDL;
 
-    LLSD out = LLSD::emptyMap();
+    LLSD out;
+    // Settings and shader cache get saved at different time, thus making
+    // RenderShaderCacheVersion unreliable when running multiple viewer
+    // instances, or for cases where viewer crashes before saving settings.
+    // Dupplicate version to the cache itself.
+    out["version"] = mShaderCacheVersion;
+    out["shaders"] = LLSD::emptyMap();
+    LLSD &shaders = out["shaders"];
 
     static const F32 LRU_TIME = (60.f * 60.f) * 24.f * 7.f; // 14 days
     const F32 current_time = (F32)LLTimer::getTotalSeconds();
@@ -1068,14 +1100,19 @@ void LLShaderMgr::persistShaderCacheMetadata()
             data["binary_format"] = LLSD::Integer(shader_metadata.mBinaryFormat);
             data["binary_size"] = LLSD::Integer(shader_metadata.mBinaryLength);
             data["last_used"] = LLSD::Real(shader_metadata.mLastUsedTime);
-            out[it->first.asString()] = data;
+            shaders[it->first.asString()] = data;
             ++it;
         }
     }
 
     std::string meta_out_path = gDirUtilp->add(mShaderCacheDir, "shaderdata.llsd");
-    llofstream outstream(meta_out_path);
-    LLSDSerialize::toNotation(out, outstream);
+    llofstream outstream(meta_out_path, std::ios_base::out | std::ios_base::binary);
+    if (!outstream.is_open())
+    {
+        LL_WARNS("ShaderMgr") << "Failed to open file. Unable to save shader cache to: " << mShaderCacheDir << LL_ENDL;
+        return;
+    }
+    LLSDSerialize::toBinary(out, outstream);
     outstream.close();
 }
 
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index 46788841a5..1b638e6e06 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -363,7 +363,7 @@ public:
     // Implemented in the application to actually update out of date uniforms for a particular shader
     virtual void updateShaderUniforms(LLGLSLShader * shader) = 0; // Pure Virtual
 
-    void initShaderCache(bool enabled, const LLUUID& old_cache_version, const LLUUID& current_cache_version);
+    void initShaderCache(bool enabled, const LLUUID& old_cache_version, const LLUUID& current_cache_version, bool second_instance);
     void clearShaderCache();
     void persistShaderCacheMetadata();
 
@@ -387,7 +387,7 @@ public:
         F32 mLastUsedTime = 0.0;
     };
     std::map<LLUUID, ProgramBinaryData> mShaderBinaryCache;
-    bool mShaderCacheInitialized = false;
+    LLUUID mShaderCacheVersion;
     bool mShaderCacheEnabled = false;
     std::string mShaderCacheDir;
 
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index 1f0c424188..d59ddd0fec 100644
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -787,12 +787,6 @@ void LLVertexBuffer::drawElements(U32 mode, const LLVector4a* pos, const LLVecto
 
     gGL.syncMatrices();
 
-    U32 mask = LLVertexBuffer::MAP_VERTEX;
-    if (tc)
-    {
-        mask = mask | LLVertexBuffer::MAP_TEXCOORD0;
-    }
-
     unbind();
 
     gGL.begin(mode);
@@ -885,7 +879,7 @@ bool LLVertexBuffer::validateRange(U32 start, U32 end, U32 count, U32 indices_of
     return true;
 }
 
-#ifdef LL_PROFILER_ENABLE_RENDER_DOC
+#if LL_PROFILER_ENABLE_RENDER_DOC
 void LLVertexBuffer::setLabel(const char* label) {
     LL_LABEL_OBJECT_GL(GL_BUFFER, mGLBuffer, strlen(label), label);
 }
diff --git a/indra/llrender/llvertexbuffer.h b/indra/llrender/llvertexbuffer.h
index 375ad76fb8..faaa6ba0f0 100644
--- a/indra/llrender/llvertexbuffer.h
+++ b/indra/llrender/llvertexbuffer.h
@@ -279,7 +279,7 @@ public:
     //for debugging, validate data in given range is valid
     bool validateRange(U32 start, U32 end, U32 count, U32 offset) const;
 
-    #ifdef LL_PROFILER_ENABLE_RENDER_DOC
+    #if LL_PROFILER_ENABLE_RENDER_DOC
     void setLabel(const char* label);
     #endif
 
@@ -340,7 +340,7 @@ public:
     static U32 sVertexCount;
 };
 
-#ifdef LL_PROFILER_ENABLE_RENDER_DOC
+#if LL_PROFILER_ENABLE_RENDER_DOC
 #define LL_LABEL_VERTEX_BUFFER(buf, name) buf->setLabel(name)
 #else
 #define LL_LABEL_VERTEX_BUFFER(buf, name)