Merge remote-tracking branch 'secondlife/release/2024.06-atlasaurus' into 2024.06-atlasaurus

31 files changed, 807 insertions, 580 deletions

diff --git a/indra/llrender/llcubemap.cpp b/indra/llrender/llcubemap.cpp
index f0158ec54f..53691bafe2 100644
--- a/indra/llrender/llcubemap.cpp
+++ b/indra/llrender/llcubemap.cpp
@@ -78,7 +78,7 @@ void LLCubeMap::initGL()
 
             for (int i = 0; i < 6; i++)
             {
-                mImages[i] = new LLImageGL(RESOLUTION, RESOLUTION, 4, FALSE);
+                mImages[i] = new LLImageGL(RESOLUTION, RESOLUTION, 4, false);
             #if USE_SRGB_DECODE
                 if (mIssRGB) {
                     mImages[i]->setExplicitFormat(GL_SRGB8_ALPHA8, GL_RGBA);
@@ -111,6 +111,9 @@ void LLCubeMap::initRawData(const std::vector<LLPointer<LLImageRaw> >& rawimages
     // Yes, I know that this is inefficient! - djs 08/08/02
     for (int i = 0; i < 6; i++)
     {
+        LLImageDataSharedLock lockIn(rawimages[i]);
+        LLImageDataLock lockOut(mRawImages[i]);
+
         const U8 *sd = rawimages[i]->getData();
         U8 *td = mRawImages[i]->getData();
 
@@ -173,7 +176,7 @@ void LLCubeMap::initReflectionMap(U32 resolution, U32 components)
 
     LLImageGL::generateTextures(1, &texname);
 
-    mImages[0] = new LLImageGL(resolution, resolution, components, TRUE);
+    mImages[0] = new LLImageGL(resolution, resolution, components, true);
     mImages[0]->setTexName(texname);
     mImages[0]->setTarget(mTargets[0], LLTexUnit::TT_CUBE_MAP);
     gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_CUBE_MAP, texname);
@@ -197,7 +200,7 @@ void LLCubeMap::initEnvironmentMap(const std::vector<LLPointer<LLImageRaw> >& ra
         llassert(rawimages[i]->getHeight() == resolution);
         llassert(rawimages[i]->getComponents() == components);
 
-        mImages[i] = new LLImageGL(resolution, resolution, components, TRUE);
+        mImages[i] = new LLImageGL(resolution, resolution, components, true);
         mImages[i]->setTarget(mTargets[i], LLTexUnit::TT_CUBE_MAP);
         mRawImages[i] = rawimages[i];
         mImages[i]->createGLTexture(0, mRawImages[i], texname);
@@ -223,8 +226,8 @@ void LLCubeMap::generateMipMaps()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 
-    mImages[0]->setUseMipMaps(TRUE);
-    mImages[0]->setHasMipMaps(TRUE);
+    mImages[0]->setUseMipMaps(true);
+    mImages[0]->setHasMipMaps(true);
     enableTexture(0);
     bind();
     mImages[0]->setFilteringOption(LLTexUnit::TFO_BILINEAR);
diff --git a/indra/llrender/llcubemaparray.cpp b/indra/llrender/llcubemaparray.cpp
index a758d7e22b..0242fe60ce 100644
--- a/indra/llrender/llcubemaparray.cpp
+++ b/indra/llrender/llcubemaparray.cpp
@@ -42,6 +42,8 @@
 
 //#pragma optimize("", off)
 
+using namespace LLImageGLMemory;
+
 // MUST match order of OpenGL face-layers
 GLenum LLCubeMapArray::sTargets[6] =
 {
@@ -107,7 +109,7 @@ LLCubeMapArray::~LLCubeMapArray()
 {
 }
 
-void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, BOOL use_mips)
+void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, bool use_mips)
 {
     U32 texname = 0;
     mWidth = resolution;
@@ -128,6 +130,8 @@ void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, BOOL us
 
     U32 mip = 0;
 
+    free_cur_tex_image();
+
     while (resolution >= 1)
     {
 #if GL_VERSION_4_0
@@ -143,6 +147,8 @@ void LLCubeMapArray::allocate(U32 resolution, U32 components, U32 count, BOOL us
         ++mip;
     }
 
+    alloc_tex_image(resolution * 6, resolution, format);
+
     mImage->setAddressMode(LLTexUnit::TAM_CLAMP);
 
     if (use_mips)
diff --git a/indra/llrender/llcubemaparray.h b/indra/llrender/llcubemaparray.h
index 9d78c5b0d4..675aaaf07c 100644
--- a/indra/llrender/llcubemaparray.h
+++ b/indra/llrender/llcubemaparray.h
@@ -51,8 +51,8 @@ public:
     // res - resolution of each cube face
     // components - number of components per pixel
     // count - number of cube maps in the array
-    // use_mips - if TRUE, mipmaps will be allocated for this cube map array and anisotropic filtering will be used
-    void allocate(U32 res, U32 components, U32 count, BOOL use_mips = TRUE);
+    // use_mips - if true, mipmaps will be allocated for this cube map array and anisotropic filtering will be used
+    void allocate(U32 res, U32 components, U32 count, bool use_mips = true);
     void bind(S32 stage);
     void unbind();
 
diff --git a/indra/llrender/llfontbitmapcache.cpp b/indra/llrender/llfontbitmapcache.cpp
index 243041945a..46c2e89797 100644
--- a/indra/llrender/llfontbitmapcache.cpp
+++ b/indra/llrender/llfontbitmapcache.cpp
@@ -78,11 +78,11 @@ LLImageGL *LLFontBitmapCache::getImageGL(EFontGlyphType bitmap_type, U32 bitmap_
 }
 
 
-BOOL LLFontBitmapCache::nextOpenPos(S32 width, S32& pos_x, S32& pos_y, EFontGlyphType bitmap_type, U32& bitmap_num)
+bool LLFontBitmapCache::nextOpenPos(S32 width, S32& pos_x, S32& pos_y, EFontGlyphType bitmap_type, U32& bitmap_num)
 {
     if (bitmap_type >= EFontGlyphType::Count)
     {
-        return FALSE;
+        return false;
     }
 
     const U32 bitmap_idx = static_cast<U32>(bitmap_type);
@@ -108,7 +108,7 @@ BOOL LLFontBitmapCache::nextOpenPos(S32 width, S32& pos_x, S32& pos_y, EFontGlyp
 
             S32 num_components = getNumComponents(bitmap_type);
             mImageRawVec[bitmap_idx].push_back(new LLImageRaw(mBitmapWidth, mBitmapHeight, num_components));
-            bitmap_num = mImageRawVec[bitmap_idx].size() - 1;
+            bitmap_num = static_cast<U32>(mImageRawVec[bitmap_idx].size()) - 1;
 
             LLImageRaw* image_raw = getImageRaw(bitmap_type, bitmap_num);
             if (EFontGlyphType::Grayscale == bitmap_type)
@@ -126,7 +126,7 @@ BOOL LLFontBitmapCache::nextOpenPos(S32 width, S32& pos_x, S32& pos_y, EFontGlyp
 
             // Attach corresponding GL texture. (*TODO: is this needed?)
             gGL.getTexUnit(0)->bind(image_gl);
-            image_gl->setFilteringOption(LLTexUnit::TFO_POINT); // was setMipFilterNearest(TRUE, TRUE);
+            image_gl->setFilteringOption(LLTexUnit::TFO_POINT); // was setMipFilterNearest(true, true);
         }
         else
         {
@@ -142,7 +142,7 @@ BOOL LLFontBitmapCache::nextOpenPos(S32 width, S32& pos_x, S32& pos_y, EFontGlyp
 
     mCurrentOffsetX[bitmap_idx] += width + 1;
 
-    return TRUE;
+    return true;
 }
 
 void LLFontBitmapCache::destroyGL()
diff --git a/indra/llrender/llfontbitmapcache.h b/indra/llrender/llfontbitmapcache.h
index 8f704df44f..f2dfd87877 100644
--- a/indra/llrender/llfontbitmapcache.h
+++ b/indra/llrender/llfontbitmapcache.h
@@ -52,7 +52,7 @@ public:
 
     void reset();
 
-    BOOL nextOpenPos(S32 width, S32& posX, S32& posY, EFontGlyphType bitmapType, U32& bitmapNum);
+    bool nextOpenPos(S32 width, S32& posX, S32& posY, EFontGlyphType bitmapType, U32& bitmapNum);
 
     void destroyGL();
 
@@ -60,7 +60,7 @@ public:
     LLImageGL* getImageGL(EFontGlyphType bitmapType, U32 bitmapNum) const;
 
     S32 getMaxCharWidth() const { return mMaxCharWidth; }
-    U32 getNumBitmaps(EFontGlyphType bitmapType) const { return (bitmapType < EFontGlyphType::Count) ? mImageRawVec[static_cast<U32>(bitmapType)].size() : 0; }
+    U32 getNumBitmaps(EFontGlyphType bitmapType) const { return (bitmapType < EFontGlyphType::Count) ? static_cast<U32>(mImageRawVec[static_cast<U32>(bitmapType)].size()) : 0U; }
     S32 getBitmapWidth() const { return mBitmapWidth; }
     S32 getBitmapHeight() const { return mBitmapHeight; }
 
diff --git a/indra/llrender/llfontfreetype.cpp b/indra/llrender/llfontfreetype.cpp
index 554e70d6a7..9766de1dfa 100644
--- a/indra/llrender/llfontfreetype.cpp
+++ b/indra/llrender/llfontfreetype.cpp
@@ -145,7 +145,7 @@ LLFontFreetype::LLFontFreetype()
     pFileStream(NULL),
     pFtStream(NULL),
 #endif
-    mIsFallback(FALSE),
+    mIsFallback(false),
     mFTFace(NULL),
     mRenderGlyphCount(0),
     mAddGlyphCount(0),
@@ -189,7 +189,7 @@ void ft_close_cb(FT_Stream stream) {
 }
 #endif
 
-BOOL LLFontFreetype::loadFace(const std::string& filename, F32 point_size, F32 vert_dpi, F32 horz_dpi, bool is_fallback, S32 face_n)
+bool LLFontFreetype::loadFace(const std::string& filename, F32 point_size, F32 vert_dpi, F32 horz_dpi, bool is_fallback, S32 face_n)
 {
     // Don't leak face objects.  This is also needed to deal with
     // changed font file names.
@@ -214,7 +214,7 @@ BOOL LLFontFreetype::loadFace(const std::string& filename, F32 point_size, F32 v
 #ifdef LL_WINDOWS
         clearFontStreams();
 #endif
-        return FALSE;
+        return false;
     }
 
     mIsFallback = is_fallback;
@@ -234,7 +234,7 @@ BOOL LLFontFreetype::loadFace(const std::string& filename, F32 point_size, F32 v
         clearFontStreams();
 #endif
         mFTFace = NULL;
-        return FALSE;
+        return false;
     }
 
     F32 y_max, y_min, x_max, x_min;
@@ -281,7 +281,7 @@ BOOL LLFontFreetype::loadFace(const std::string& filename, F32 point_size, F32 v
         mStyle |= LLFontGL::ITALIC;
     }
 
-    return TRUE;
+    return true;
 }
 
 S32 LLFontFreetype::getNumFaces(const std::string& filename)
@@ -330,7 +330,7 @@ S32 LLFontFreetype::ftOpenFace(const std::string& filename, S32 face_n)
         pFtStream = new LLFT_Stream();
         pFtStream->base = 0;
         pFtStream->pos = 0;
-        pFtStream->size = file_size;
+        pFtStream->size = static_cast<unsigned long>(file_size);
         pFtStream->descriptor.pointer = pFileStream;
         pFtStream->read = ft_read_cb;
         pFtStream->close = ft_close_cb;
@@ -443,7 +443,7 @@ F32 LLFontFreetype::getXKerning(const LLFontGlyphInfo* left_glyph_info, const LL
     return delta.x*(1.f/64.f);
 }
 
-BOOL LLFontFreetype::hasGlyph(llwchar wch) const
+bool LLFontFreetype::hasGlyph(llwchar wch) const
 {
     llassert(!mIsFallback);
     return(mCharGlyphInfoMap.find(wch) != mCharGlyphInfoMap.end());
@@ -853,6 +853,7 @@ 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));
diff --git a/indra/llrender/llfontfreetype.h b/indra/llrender/llfontfreetype.h
index 19112830a4..eba89f5def 100644
--- a/indra/llrender/llfontfreetype.h
+++ b/indra/llrender/llfontfreetype.h
@@ -86,7 +86,7 @@ public:
 
     // is_fallback should be true for fallback fonts that aren't used
     // to render directly (Unicode backup, primarily)
-    BOOL loadFace(const std::string& filename, F32 point_size, F32 vert_dpi, F32 horz_dpi, bool is_fallback, S32 face_n);
+    bool loadFace(const std::string& filename, F32 point_size, F32 vert_dpi, F32 horz_dpi, bool is_fallback, S32 face_n);
 
     S32 getNumFaces(const std::string& filename);
 
@@ -153,7 +153,7 @@ private:
     void resetBitmapCache();
     void setSubImageLuminanceAlpha(U32 x, U32 y, U32 bitmap_num, U32 width, U32 height, U8 *data, S32 stride = 0) const;
     bool setSubImageBGRA(U32 x, U32 y, U32 bitmap_num, U16 width, U16 height, const U8* data, U32 stride) const;
-    BOOL hasGlyph(llwchar wch) const;       // Has a glyph for this character
+    bool hasGlyph(llwchar wch) const;       // Has a glyph for this character
     LLFontGlyphInfo* addGlyph(llwchar wch, EFontGlyphType glyph_type) const;        // Add a new character to the font if necessary
     LLFontGlyphInfo* addGlyphFromFont(const LLFontFreetype *fontp, llwchar wch, U32 glyph_index, EFontGlyphType bitmap_type) const; // Add a glyph from this font to the other (returns the glyph_index, 0 if not found)
     void renderGlyph(EFontGlyphType bitmap_type, U32 glyph_index) const;
@@ -175,7 +175,7 @@ private:
     LLFT_Stream *pFtStream;
 #endif
 
-    BOOL mIsFallback;
+    bool mIsFallback;
     typedef std::pair<LLPointer<LLFontFreetype>, char_functor_t> fallback_font_t;
     typedef std::vector<fallback_font_t> fallback_font_vector_t;
     fallback_font_vector_t mFallbackFonts; // A list of fallback fonts to look for glyphs in (for Unicode chars)
diff --git a/indra/llrender/llfontfreetypesvg.h b/indra/llrender/llfontfreetypesvg.h
index 62aefd10b5..94b83d5fff 100644
--- a/indra/llrender/llfontfreetypesvg.h
+++ b/indra/llrender/llfontfreetypesvg.h
@@ -50,7 +50,7 @@ public:
     //   - right before the svg module calls the render callback hook. (with cache == true)
     static FT_Error OnPresetGlypthSlot(FT_GlyphSlot glyph_slot, FT_Bool cache, FT_Pointer* state);
 
-    // Called to render an OT-SVG glyph (right after the preset hook OnPresetGlypthSlot was called with cache set to TRUE)
+    // Called to render an OT-SVG glyph (right after the preset hook OnPresetGlypthSlot was called with cache set to true)
     static FT_Error OnRender(FT_GlyphSlot glyph_slot, FT_Pointer* state);
 
     // Called to deallocate our per glyph slot data
diff --git a/indra/llrender/llfontgl.cpp b/indra/llrender/llfontgl.cpp
index 2ac2615c0a..9482987970 100644
--- a/indra/llrender/llfontgl.cpp
+++ b/indra/llrender/llfontgl.cpp
@@ -58,7 +58,7 @@ F32 LLFontGL::sVertDPI = 96.f;
 F32 LLFontGL::sHorizDPI = 96.f;
 F32 LLFontGL::sScaleX = 1.f;
 F32 LLFontGL::sScaleY = 1.f;
-BOOL LLFontGL::sDisplayFont = TRUE ;
+bool LLFontGL::sDisplayFont = true ;
 std::string LLFontGL::sAppDir;
 
 LLColor4 LLFontGL::sShadowColor(0.f, 0.f, 0.f, 1.f);
@@ -89,7 +89,7 @@ void LLFontGL::destroyGL()
     mFontFreetype->destroyGL();
 }
 
-BOOL LLFontGL::loadFace(const std::string& filename, F32 point_size, const F32 vert_dpi, const F32 horz_dpi, bool is_fallback, S32 face_n)
+bool LLFontGL::loadFace(const std::string& filename, F32 point_size, const F32 vert_dpi, const F32 horz_dpi, bool is_fallback, S32 face_n)
 {
     if(mFontFreetype == reinterpret_cast<LLFontFreetype*>(NULL))
     {
@@ -110,14 +110,14 @@ S32 LLFontGL::getNumFaces(const std::string& filename)
 }
 
 S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, const LLRect& rect, const LLColor4 &color, HAlign halign, VAlign valign, U8 style,
-    ShadowType shadow, S32 max_chars, F32* right_x, BOOL use_ellipses, BOOL use_color) const
+    ShadowType shadow, S32 max_chars, F32* right_x, bool use_ellipses, bool use_color) const
 {
     LLRectf rect_float(rect.mLeft, rect.mTop, rect.mRight, rect.mBottom);
     return render(wstr, begin_offset, rect_float, color, halign, valign, style, shadow, max_chars, right_x, use_ellipses, use_color);
 }
 
 S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, const LLRectf& rect, const LLColor4 &color, HAlign halign, VAlign valign, U8 style,
-                     ShadowType shadow, S32 max_chars, F32* right_x, BOOL use_ellipses, BOOL use_color) const
+                     ShadowType shadow, S32 max_chars, F32* right_x, bool use_ellipses, bool use_color) const
 {
     F32 x = rect.mLeft;
     F32 y = 0.f;
@@ -143,13 +143,13 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, const LLRectf& rec
 
 
 S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, const LLColor4 &color, HAlign halign, VAlign valign, U8 style,
-                     ShadowType shadow, S32 max_chars, S32 max_pixels, F32* right_x, BOOL use_ellipses, BOOL use_color) const
+                     ShadowType shadow, S32 max_chars, S32 max_pixels, F32* right_x, bool use_ellipses, bool use_color) const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
 
     if(!sDisplayFont) //do not display texts
     {
-        return wstr.length() ;
+        return static_cast<S32>(wstr.length());
     }
 
     if (wstr.empty())
@@ -254,7 +254,7 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
 
     const S32 LAST_CHARACTER = LLFontFreetype::LAST_CHAR_FULL;
 
-    BOOL draw_ellipses = FALSE;
+    bool draw_ellipses = false;
     if (use_ellipses)
     {
         // check for too long of a string
@@ -264,7 +264,7 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
             // use four dots for ellipsis width to generate padding
             const LLWString dots(utf8str_to_wstring(std::string("....")));
             scaled_max_pixels = llmax(0, scaled_max_pixels - ll_round(getWidthF32(dots.c_str())));
-            draw_ellipses = TRUE;
+            draw_ellipses = true;
         }
     }
 
@@ -278,7 +278,7 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
     LLColor4U text_color(color);
     // Preserve the transparency to render fading emojis in fading text (e.g.
     // for the chat console)... HB
-    LLColor4U emoji_color(255, 255, 255, text_color.mV[VW]);
+    LLColor4U emoji_color(255, 255, 255, text_color.mV[VALPHA]);
 
     std::pair<EFontGlyphType, S32> bitmap_entry = std::make_pair(EFontGlyphType::Grayscale, -1);
     S32 glyph_count = 0;
@@ -414,7 +414,7 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
                 shadow,
                 S32_MAX, max_pixels,
                 right_x,
-                FALSE,
+                false,
                 use_color);
         gGL.popUIMatrix();
     }
@@ -429,7 +429,7 @@ S32 LLFontGL::render(const LLWString &text, S32 begin_offset, F32 x, F32 y, cons
     return render(text, begin_offset, x, y, color, LEFT, BASELINE, NORMAL, NO_SHADOW);
 }
 
-S32 LLFontGL::renderUTF8(const std::string &text, S32 begin_offset, F32 x, F32 y, const LLColor4 &color, HAlign halign, VAlign valign, U8 style, ShadowType shadow, S32 max_chars, S32 max_pixels, F32* right_x, BOOL use_ellipses, BOOL use_color) const
+S32 LLFontGL::renderUTF8(const std::string &text, S32 begin_offset, F32 x, F32 y, const LLColor4 &color, HAlign halign, VAlign valign, U8 style, ShadowType shadow, S32 max_chars, S32 max_pixels, F32* right_x, bool use_ellipses, bool use_color) const
 {
     return render(utf8str_to_wstring(text), begin_offset, x, y, color, halign, valign, style, shadow, max_chars, max_pixels, right_x, use_ellipses, use_color);
 }
@@ -578,11 +578,11 @@ S32 LLFontGL::maxDrawableChars(const llwchar* wchars, F32 max_pixels, S32 max_ch
     llassert(max_pixels >= 0.f);
     llassert(max_chars >= 0);
 
-    BOOL clip = FALSE;
+    bool clip = false;
     F32 cur_x = 0;
 
     S32 start_of_last_word = 0;
-    BOOL in_word = FALSE;
+    bool in_word = false;
 
     // avoid S32 overflow when max_pixels == S32_MAX by staying in floating point
     F32 scaled_max_pixels = max_pixels * sScaleX;
@@ -607,18 +607,18 @@ S32 LLFontGL::maxDrawableChars(const llwchar* wchars, F32 max_pixels, S32 max_ch
             {
                 if(wch !=(0x00A0))
                 {
-                    in_word = FALSE;
+                    in_word = false;
                 }
             }
             if (iswindividual(wch))
             {
                 if (iswpunct(wchars[i+1]))
                 {
-                    in_word=TRUE;
+                    in_word=true;
                 }
                 else
                 {
-                    in_word=FALSE;
+                    in_word=false;
                     start_of_last_word = i;
                 }
             }
@@ -628,7 +628,7 @@ S32 LLFontGL::maxDrawableChars(const llwchar* wchars, F32 max_pixels, S32 max_ch
             start_of_last_word = i;
             if (!iswspace(wch)||!iswindividual(wch))
             {
-                in_word = TRUE;
+                in_word = true;
             }
         }
 
@@ -654,7 +654,7 @@ S32 LLFontGL::maxDrawableChars(const llwchar* wchars, F32 max_pixels, S32 max_ch
         // clip if current character runs past scaled_max_pixels (using width_padding)
         if (scaled_max_pixels < cur_x + width_padding)
         {
-            clip = TRUE;
+            clip = true;
             break;
         }
 
@@ -752,7 +752,7 @@ S32 LLFontGL::firstDrawableChar(const llwchar* wchars, F32 max_pixels, S32 text_
 
 }
 
-S32 LLFontGL::charFromPixelOffset(const llwchar* wchars, S32 begin_offset, F32 target_x, F32 max_pixels, S32 max_chars, BOOL round) const
+S32 LLFontGL::charFromPixelOffset(const llwchar* wchars, S32 begin_offset, F32 target_x, F32 max_pixels, S32 max_chars, bool round) const
 {
     if (!wchars || !wchars[0] || max_chars == 0)
     {
@@ -1164,7 +1164,7 @@ LLFontGL* LLFontGL::getFontDefault()
 std::string LLFontGL::getFontPathSystem()
 {
 #if LL_DARWIN
-    // HACK for Mac OS X
+    // HACK for macOS
     return "/System/Library/Fonts/";
 
 #elif LL_WINDOWS
diff --git a/indra/llrender/llfontgl.h b/indra/llrender/llfontgl.h
index 81674f4a64..4bb6c55c65 100644
--- a/indra/llrender/llfontgl.h
+++ b/indra/llrender/llfontgl.h
@@ -87,7 +87,7 @@ public:
 
     void destroyGL();
 
-    BOOL loadFace(const std::string& filename, F32 point_size, const F32 vert_dpi, const F32 horz_dpi, bool is_fallback, S32 face_n);
+    bool loadFace(const std::string& filename, F32 point_size, const F32 vert_dpi, const F32 horz_dpi, bool is_fallback, S32 face_n);
 
     S32 getNumFaces(const std::string& filename);
 
@@ -98,8 +98,8 @@ public:
                 U8 style = NORMAL, ShadowType shadow = NO_SHADOW,
                 S32 max_chars = S32_MAX,
                 F32* right_x=NULL,
-                BOOL use_ellipses = FALSE,
-                BOOL use_color = TRUE) const;
+                bool use_ellipses = false,
+                bool use_color = true) const;
 
     S32 render(const LLWString &text, S32 begin_offset,
                 const LLRectf& rect,
@@ -108,8 +108,8 @@ public:
                 U8 style = NORMAL, ShadowType shadow = NO_SHADOW,
                 S32 max_chars = S32_MAX,
                 F32* right_x=NULL,
-                BOOL use_ellipses = FALSE,
-                BOOL use_color = TRUE) const;
+                bool use_ellipses = false,
+                bool use_color = true) const;
 
     S32 render(const LLWString &text, S32 begin_offset,
                 F32 x, F32 y,
@@ -118,13 +118,13 @@ public:
                 U8 style = NORMAL, ShadowType shadow = NO_SHADOW,
                 S32 max_chars = S32_MAX, S32 max_pixels = S32_MAX,
                 F32* right_x=NULL,
-                BOOL use_ellipses = FALSE,
-                BOOL use_color = TRUE) const;
+                bool use_ellipses = false,
+                bool use_color = true) const;
 
     S32 render(const LLWString &text, S32 begin_offset, F32 x, F32 y, const LLColor4 &color) const;
 
     // renderUTF8 does a conversion, so is slower!
-    S32 renderUTF8(const std::string &text, S32 begin_offset, F32 x, F32 y, const LLColor4 &color, HAlign halign,  VAlign valign, U8 style, ShadowType shadow, S32 max_chars = S32_MAX, S32 max_pixels = S32_MAX,  F32* right_x = NULL, BOOL use_ellipses = FALSE, BOOL use_color = TRUE) const;
+    S32 renderUTF8(const std::string &text, S32 begin_offset, F32 x, F32 y, const LLColor4 &color, HAlign halign,  VAlign valign, U8 style, ShadowType shadow, S32 max_chars = S32_MAX, S32 max_pixels = S32_MAX,  F32* right_x = NULL, bool use_ellipses = false, bool use_color = true) const;
     S32 renderUTF8(const std::string &text, S32 begin_offset, S32 x, S32 y, const LLColor4 &color) const;
     S32 renderUTF8(const std::string &text, S32 begin_offset, S32 x, S32 y, const LLColor4 &color, HAlign halign, VAlign valign, U8 style = NORMAL, ShadowType shadow = NO_SHADOW) const;
 
@@ -159,7 +159,7 @@ public:
     S32 firstDrawableChar(const llwchar* wchars, F32 max_pixels, S32 text_len, S32 start_pos=S32_MAX, S32 max_chars = S32_MAX) const;
 
     // Returns the index of the character closest to pixel position x (ignoring text to the right of max_pixels and max_chars)
-    S32 charFromPixelOffset(const llwchar* wchars, S32 char_offset, F32 x, F32 max_pixels=F32_MAX, S32 max_chars = S32_MAX, BOOL round = TRUE) const;
+    S32 charFromPixelOffset(const llwchar* wchars, S32 char_offset, F32 x, F32 max_pixels=F32_MAX, S32 max_chars = S32_MAX, bool round = true) const;
 
     const LLFontDescriptor& getFontDesc() const;
 
@@ -192,7 +192,7 @@ public:
     static std::string nameFromVAlign(LLFontGL::VAlign align);
     static LLFontGL::VAlign vAlignFromName(const std::string& name);
 
-    static void setFontDisplay(BOOL flag) { sDisplayFont = flag; }
+    static void setFontDisplay(bool flag) { sDisplayFont = flag; }
 
     static LLFontGL* getFontEmojiSmall();
     static LLFontGL* getFontEmojiMedium();
@@ -224,7 +224,7 @@ public:
     static F32 sHorizDPI;
     static F32 sScaleX;
     static F32 sScaleY;
-    static BOOL sDisplayFont ;
+    static bool sDisplayFont ;
     static std::string sAppDir;         // For loading fonts
 
 private:
diff --git a/indra/llrender/llfontregistry.cpp b/indra/llrender/llfontregistry.cpp
index 546211aac8..62f4f35e3d 100644
--- a/indra/llrender/llfontregistry.cpp
+++ b/indra/llrender/llfontregistry.cpp
@@ -297,7 +297,7 @@ bool font_desc_init_from_xml(LLXMLNodePtr node, LLFontDescriptor& desc)
 
             if (child->hasAttribute("load_collection"))
             {
-                BOOL col = FALSE;
+                bool col = false;
                 child->getAttributeBOOL("load_collection", col);
                 if (col)
                 {
@@ -475,7 +475,7 @@ LLFontGL *LLFontRegistry::createFont(const LLFontDescriptor& desc)
 
     // The first font will get pulled will be the "head" font, set to non-fallback.
     // Rest will consitute the fallback list.
-    BOOL is_first_found = TRUE;
+    bool is_first_found = true;
 
     string_vec_t font_search_paths;
     font_search_paths.push_back(LLFontGL::getFontPathLocal());
@@ -499,7 +499,7 @@ LLFontGL *LLFontRegistry::createFont(const LLFontDescriptor& desc)
 
         // *HACK: Fallback fonts don't render, so we can use that to suppress
         // creation of OpenGL textures for test apps. JC
-        BOOL is_fallback = !is_first_found || !mCreateGLTextures;
+        bool is_fallback = !is_first_found || !mCreateGLTextures;
         F32 extra_scale = (is_fallback)?fallback_scale:1.0;
         F32 point_size_scale = extra_scale * point_size;
         bool is_font_loaded = false;
diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index c592d7d3e2..2a7cc3d141 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -64,12 +64,12 @@ extern LLControlGroup gSavedSettings;
 #endif
 
 
-BOOL gDebugSession = FALSE;
-BOOL gDebugGLSession = FALSE;
-BOOL gClothRipple = FALSE;
-BOOL gHeadlessClient = FALSE;
-BOOL gNonInteractive = FALSE;
-BOOL gGLActive = FALSE;
+bool gDebugSession = false;
+bool gDebugGLSession = false;
+bool gClothRipple = false;
+bool gHeadlessClient = false;
+bool gNonInteractive = false;
+bool gGLActive = false;
 
 static const std::string HEADLESS_VENDOR_STRING("Linden Lab");
 static const std::string HEADLESS_RENDERER_STRING("Headless");
@@ -991,22 +991,22 @@ PFNGLPOLYGONOFFSETCLAMPPROC              glPolygonOffsetClamp = nullptr;
 LLGLManager gGLManager;
 
 LLGLManager::LLGLManager() :
-    mInited(FALSE),
-    mIsDisabled(FALSE),
+    mInited(false),
+    mIsDisabled(false),
     mMaxSamples(0),
     mNumTextureImageUnits(1),
     mMaxSampleMaskWords(0),
     mMaxColorTextureSamples(0),
     mMaxDepthTextureSamples(0),
     mMaxIntegerSamples(0),
-    mIsAMD(FALSE),
-    mIsNVIDIA(FALSE),
-    mIsIntel(FALSE),
-    mIsApple(FALSE),
+    mIsAMD(false),
+    mIsNVIDIA(false),
+    mIsIntel(false),
+    mIsApple(false),
 #if LL_DARWIN
-    mIsMobileGF(FALSE),
+    mIsMobileGF(false),
 #endif
-    mHasRequirements(TRUE),
+    mHasRequirements(true),
     mDriverVersionMajor(1),
     mDriverVersionMinor(0),
     mDriverVersionRelease(0),
@@ -1158,12 +1158,12 @@ bool LLGLManager::initGL()
     {
         mGLVendorShort = "AMD";
         // *TODO: Fix this?
-        mIsAMD = TRUE;
+        mIsAMD = true;
     }
     else if (mGLVendor.find("NVIDIA ") != std::string::npos)
     {
         mGLVendorShort = "NVIDIA";
-        mIsNVIDIA = TRUE;
+        mIsNVIDIA = true;
     }
     else if (mGLVendor.find("INTEL") != std::string::npos
 #if LL_LINUX || __FreeBSD__
@@ -1174,7 +1174,7 @@ bool LLGLManager::initGL()
          )
     {
         mGLVendorShort = "INTEL";
-        mIsIntel = TRUE;
+        mIsIntel = true;
     }
     else if(mGLVendor.find("APPLE") != std::string::npos)
     {
@@ -1189,7 +1189,7 @@ bool LLGLManager::initGL()
     // This is called here because it depends on the setting of mIsGF2or4MX, and sets up mHasMultitexture.
     initExtensions();
 
-    S32 old_vram = mVRAM;
+    U32 old_vram = mVRAM;
     mVRAM = 0;
 
 #if LL_WINDOWS
@@ -1231,7 +1231,7 @@ bool LLGLManager::initGL()
         // 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.
-        S32 mem = LLDXHardware::getMBVideoMemoryViaWMI();
+        U32 mem = LLDXHardware::getMBVideoMemoryViaWMI();
         if (mem != 0)
         {
             mVRAM = mem;
@@ -1256,6 +1256,11 @@ bool LLGLManager::initGL()
     glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &mMaxSampleMaskWords);
 #endif
     glGetIntegerv(GL_MAX_SAMPLES, &mMaxSamples);
+    glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &mMaxUniformBlockSize);
+
+    // sanity clamp max uniform block size to 64k just in case
+    // there's some implementation that reports a crazy value
+    mMaxUniformBlockSize = llmin(mMaxUniformBlockSize, 65536);
 
     if (mGLVersion >= 4.59f)
     {
@@ -1375,7 +1380,7 @@ void LLGLManager::asLLSD(LLSD& info)
     info["gpu_version"] = mDriverVersionVendorString;
     info["opengl_version"] = mGLVersionString;
 
-    info["vram"] = mVRAM;
+    info["vram"] = LLSD::Integer(mVRAM);
 
     // OpenGL limits
     info["max_samples"] = mMaxSamples;
@@ -1403,12 +1408,12 @@ void LLGLManager::shutdownGL()
     {
         glFinish();
         stop_glerror();
-        mInited = FALSE;
+        mInited = false;
     }
 }
 
 // these are used to turn software blending on. They appear in the Debug/Avatar menu
-// presence of vertex skinning/blending or vertex programs will set these to FALSE by default.
+// presence of vertex skinning/blending or vertex programs will set these to false by default.
 
 void LLGLManager::initExtensions()
 {
@@ -1443,7 +1448,7 @@ void LLGLManager::initExtensions()
     glGetIntegerv(GL_MAX_ELEMENTS_INDICES, (GLint*) &mGLMaxIndexRange);
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*) &mGLMaxTextureSize);
 
-    mInited = TRUE;
+    mInited = true;
 
 /*
 #if LL_WINDOWS
@@ -2332,10 +2337,10 @@ void do_assert_glerror()
     //  Create or update texture to be used with this data
     GLenum error;
     error = glGetError();
-    BOOL quit = FALSE;
+    bool quit = false;
     if (LL_UNLIKELY(error))
     {
-        quit = TRUE;
+        quit = true;
 #if GLU_VERSION_1_1
         GLubyte const * gl_error_msg = gluErrorString(error);
         if (NULL != gl_error_msg)
@@ -2461,7 +2466,7 @@ void LLGLState::dumpStates()
     for (boost::unordered_map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
          iter != sStateMap.end(); ++iter)
     {
-        LL_INFOS("RenderState") << llformat(" 0x%04x : %s",(S32)iter->first,iter->second?"TRUE":"FALSE") << LL_ENDL;
+        LL_INFOS("RenderState") << llformat(" 0x%04x : %s",(S32)iter->first,iter->second?"true":"false") << LL_ENDL;
     }
 }
 
@@ -2504,7 +2509,7 @@ void LLGLState::checkStates(GLboolean writeAlpha)
 ///////////////////////////////////////////////////////////////////////
 
 LLGLState::LLGLState(LLGLenum state, S32 enabled) :
-    mState(state), mWasEnabled(FALSE), mIsEnabled(FALSE)
+    mState(state), mWasEnabled(false), mIsEnabled(false)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
 
@@ -2523,15 +2528,15 @@ void LLGLState::setEnabled(S32 enabled)
     }
     if (enabled == CURRENT_STATE)
     {
-        enabled = sStateMap[mState] == GL_TRUE ? TRUE : FALSE;
+        enabled = sStateMap[mState] == GL_TRUE ? ENABLED_STATE : DISABLED_STATE;
     }
-    else if (enabled == TRUE && sStateMap[mState] != GL_TRUE)
+    else if (enabled == ENABLED_STATE && sStateMap[mState] != GL_TRUE)
     {
         gGL.flush();
         glEnable(mState);
         sStateMap[mState] = GL_TRUE;
     }
-    else if (enabled == FALSE && sStateMap[mState] != GL_FALSE)
+    else if (enabled == DISABLED_STATE && sStateMap[mState] != GL_FALSE)
     {
         gGL.flush();
         glDisable(mState);
@@ -2786,7 +2791,7 @@ LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, G
     { // always disable depth writes if depth testing is disabled
       // GL spec defines this as a requirement, but some implementations allow depth writes with testing disabled
       // The proper way to write to depth buffer with testing disabled is to enable testing and use a depth_func of GL_ALWAYS
-        write_enabled = FALSE;
+        write_enabled = GL_FALSE;
     }
 
     if (depth_enabled != sDepthEnabled)
@@ -2839,7 +2844,7 @@ void LLGLDepthTest::checkState()
     if (gDebugGL)
     {
         GLint func = 0;
-        GLboolean mask = FALSE;
+        GLboolean mask = GL_FALSE;
 
         glGetIntegerv(GL_DEPTH_FUNC, &func);
         glGetBooleanv(GL_DEPTH_WRITEMASK, &mask);
diff --git a/indra/llrender/llgl.h b/indra/llrender/llgl.h
index e4b106c999..a3d87e001c 100644
--- a/indra/llrender/llgl.h
+++ b/indra/llrender/llgl.h
@@ -45,9 +45,9 @@
 #include "llglheaders.h"
 #include "glh/glh_linear.h"
 
-extern BOOL gDebugGL;
-extern BOOL gDebugSession;
-extern BOOL gDebugGLSession;
+extern bool gDebugGL;
+extern bool gDebugSession;
+extern bool gDebugGLSession;
 extern llofstream gFailLog;
 
 #define LL_GL_ERRS LL_ERRS("RenderState")
@@ -73,8 +73,8 @@ public:
 
     std::string getRawGLString(); // For sending to simulator
 
-    BOOL mInited;
-    BOOL mIsDisabled;
+    bool mInited;
+    bool mIsDisabled;
 
     // OpenGL limits
     S32 mMaxSamples;
@@ -87,6 +87,7 @@ public:
     S32 mGLMaxIndexRange;
     S32 mGLMaxTextureSize;
     F32 mMaxAnisotropy = 0.f;
+    S32 mMaxUniformBlockSize = 0;
 
     // GL 4.x capabilities
     bool mHasCubeMapArray = false;
@@ -97,18 +98,18 @@ public:
     // Vendor-specific extensions
     bool mHasAMDAssociations = false;
 
-    BOOL mIsAMD;
-    BOOL mIsNVIDIA;
-    BOOL mIsIntel;
-    BOOL mIsApple;
+    bool mIsAMD;
+    bool mIsNVIDIA;
+    bool mIsIntel;
+    bool mIsApple;
 
 #if LL_DARWIN
     // Needed to distinguish problem cards on older Macs that break with Materials
-    BOOL mIsMobileGF;
+    bool mIsMobileGF;
 #endif
 
     // Whether this version of GL is good enough for SL to use
-    BOOL mHasRequirements;
+    bool mHasRequirements;
 
     S32 mDriverVersionMajor;
     S32 mDriverVersionMinor;
@@ -119,9 +120,7 @@ public:
     std::string mDriverVersionVendorString;
     std::string mGLVersionString;
 
-    S32 mVRAM; // VRAM in MB
-
-    void getPixelFormat(); // Get the best pixel format
+    U32 mVRAM; // VRAM in MB
 
     std::string getGLInfoString();
     void printGLInfoString();
@@ -139,7 +138,6 @@ public:
 private:
     void initExtensions();
     void initGLStates();
-    void initGLImages();
 };
 
 extern LLGLManager gGLManager;
@@ -156,13 +154,18 @@ void assert_glerror();
 
 void clear_glerror();
 
-//#if LL_DEBUG
+
 # define stop_glerror() assert_glerror()
 # define llglassertok() assert_glerror()
-//#else
-//# define stop_glerror()
-//# define llglassertok()
-//#endif
+
+// stop_glerror is still needed on OS X but has performance implications
+// use macro below to conditionally add stop_glerror to non-release builds
+// on OS X
+#if LL_DARWIN && !LL_RELEASE_FOR_DOWNLOAD
+#define STOP_GLERROR stop_glerror()
+#else
+#define STOP_GLERROR
+#endif
 
 #define llglassertok_always() assert_glerror()
 
@@ -242,16 +245,16 @@ protected:
     static boost::unordered_map<LLGLenum, LLGLboolean> sStateMap;
 
 public:
-    enum { CURRENT_STATE = -2 };
+    enum { CURRENT_STATE = -2, DISABLED_STATE = 0, ENABLED_STATE = 1 };
     LLGLState(LLGLenum state, S32 enabled = CURRENT_STATE);
     ~LLGLState();
     void setEnabled(S32 enabled);
-    void enable() { setEnabled(TRUE); }
-    void disable() { setEnabled(FALSE); }
+    void enable() { setEnabled(ENABLED_STATE); }
+    void disable() { setEnabled(DISABLED_STATE); }
 protected:
     LLGLenum mState;
-    BOOL mWasEnabled;
-    BOOL mIsEnabled;
+    bool mWasEnabled;
+    bool mIsEnabled;
 };
 
 // New LLGLState class wrappers that don't depend on actual GL flags.
@@ -285,14 +288,14 @@ public:
 class LLGLEnable : public LLGLState
 {
 public:
-    LLGLEnable(LLGLenum state) : LLGLState(state, TRUE) {}
+    LLGLEnable(LLGLenum state) : LLGLState(state, ENABLED_STATE) {}
 };
 
 /// TODO: Being deprecated.
 class LLGLDisable : public LLGLState
 {
 public:
-    LLGLDisable(LLGLenum state) : LLGLState(state, FALSE) {}
+    LLGLDisable(LLGLenum state) : LLGLState(state, DISABLED_STATE) {}
 };
 
 /*
@@ -352,9 +355,9 @@ public:
 
     static std::list<LLGLUpdate*> sGLQ;
 
-    BOOL mInQ;
+    bool mInQ;
     LLGLUpdate()
-        : mInQ(FALSE)
+        : mInQ(false)
     {
     }
     virtual ~LLGLUpdate()
@@ -406,10 +409,10 @@ void init_glstates();
 
 void parse_gl_version( S32* major, S32* minor, S32* release, std::string* vendor_specific, std::string* version_string );
 
-extern BOOL gClothRipple;
-extern BOOL gHeadlessClient;
-extern BOOL gNonInteractive;
-extern BOOL gGLActive;
+extern bool gClothRipple;
+extern bool gHeadlessClient;
+extern bool gNonInteractive;
+extern bool gGLActive;
 
 // Deal with changing glext.h definitions for newer SDK versions, specifically
 // with MAC OSX 10.5 -> 10.6
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 0c1519824c..880b491253 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -54,6 +54,8 @@ using std::string;
 GLuint LLGLSLShader::sCurBoundShader = 0;
 LLGLSLShader* LLGLSLShader::sCurBoundShaderPtr = NULL;
 S32 LLGLSLShader::sIndexedTextureChannels = 0;
+U32 LLGLSLShader::sMaxGLTFMaterials = 0;
+U32 LLGLSLShader::sMaxGLTFNodes = 0;
 bool LLGLSLShader::sProfileEnabled = false;
 std::set<LLGLSLShader*> LLGLSLShader::sInstances;
 LLGLSLShader::defines_map_t LLGLSLShader::sGlobalDefines;
@@ -81,7 +83,7 @@ const std::string gShaderConstsVal[LLGLSLShader::NUM_SHADER_CONSTS] =
 };
 
 
-BOOL shouldChange(const LLVector4& v1, const LLVector4& v2)
+bool shouldChange(const LLVector4& v1, const LLVector4& v2)
 {
     return v1 != v2;
 }
@@ -339,7 +341,7 @@ LLGLSLShader::LLGLSLShader()
     mShaderLevel(0),
     mShaderGroup(SG_DEFAULT),
     mFeatures(),
-    mUniformsDirty(FALSE),
+    mUniformsDirty(false),
     mTimerQuery(0),
     mSamplesQuery(0),
     mPrimitivesQuery(0)
@@ -411,10 +413,7 @@ void LLGLSLShader::unloadInternal()
     stop_glerror();
 }
 
-BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString>* attributes,
-    std::vector<LLStaticHashedString>* uniforms,
-    U32 varying_count,
-    const char** varyings)
+bool LLGLSLShader::createShader()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SHADER;
 
@@ -445,10 +444,10 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString>* attributes,
         // Shouldn't happen if shader related extensions, like ARB_vertex_shader, exist.
         LL_SHADER_LOADING_WARNS() << "Failed to create handle for shader: " << mName << LL_ENDL;
         unloadInternal();
-        return FALSE;
+        return false;
     }
 
-    BOOL success = TRUE;
+    bool success = true;
 
     mUsingBinaryProgram =  LLShaderMgr::instance()->loadCachedProgramBinary(this);
 
@@ -470,7 +469,7 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString>* attributes,
             }
             else
             {
-                success = FALSE;
+                success = false;
             }
         }
     }
@@ -479,16 +478,16 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString>* attributes,
     if (!LLShaderMgr::instance()->attachShaderFeatures(this))
     {
         unloadInternal();
-        return FALSE;
+        return false;
     }
     // Map attributes and uniforms
     if (success)
     {
-        success = mapAttributes(attributes);
+        success = mapAttributes();
     }
     if (success)
     {
-        success = mapUniforms(uniforms);
+        success = mapUniforms();
     }
     if (!success)
     {
@@ -499,7 +498,7 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString>* attributes,
         {
             LL_SHADER_LOADING_WARNS() << "Failed to link using shader level " << mShaderLevel << " trying again using shader level " << (mShaderLevel - 1) << LL_ENDL;
             mShaderLevel--;
-            return createShader(attributes, uniforms);
+            return createShader();
         }
         else
         {
@@ -509,6 +508,7 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString>* attributes,
     }
     else if (mFeatures.mIndexedTextureChannels > 0)
     { //override texture channels for indexed texture rendering
+        llassert(mFeatures.mIndexedTextureChannels == LLGLSLShader::sIndexedTextureChannels); // these numbers must always match
         bind();
         S32 channel_count = mFeatures.mIndexedTextureChannels;
 
@@ -518,19 +518,41 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString>* attributes,
             uniform1i(uniName, i);
         }
 
-        S32 cur_tex = channel_count; //adjust any texture channels that might have been overwritten
+        //adjust any texture channels that might have been overwritten
         for (U32 i = 0; i < mTexture.size(); i++)
         {
-            if (mTexture[i] > -1 && mTexture[i] < channel_count)
+            if (mTexture[i] > -1)
             {
-                llassert(cur_tex < gGLManager.mNumTextureImageUnits);
-                uniform1i(i, cur_tex);
-                mTexture[i] = cur_tex++;
+                S32 new_tex = mTexture[i] + channel_count;
+                uniform1i(i, new_tex);
+                mTexture[i] = new_tex;
             }
         }
+
+        // get the true number of active texture channels
+        mActiveTextureChannels = channel_count;
+        for (auto& tex : mTexture)
+        {
+            mActiveTextureChannels = llmax(mActiveTextureChannels, tex + 1);
+        }
+
+        // when indexed texture channels are used, enforce an upper limit of 16
+        // this should act as a canary in the coal mine for adding textures
+        // and breaking machines that are limited to 16 texture channels
+        llassert(mActiveTextureChannels <= 16);
         unbind();
     }
 
+    LL_DEBUGS("GLSLTextureChannels") << mName << " has " << mActiveTextureChannels << " active texture channels" << LL_ENDL;
+
+    for (U32 i = 0; i < mTexture.size(); i++)
+    {
+        if (mTexture[i] > -1)
+        {
+            LL_DEBUGS("GLSLTextureChannels") << "Texture " << LLShaderMgr::instance()->mReservedUniforms[i] << " assigned to channel " << mTexture[i] << LL_ENDL;
+        }
+    }
+
 #ifdef LL_PROFILER_ENABLE_RENDER_DOC
     setLabel(mName.c_str());
 #endif
@@ -559,7 +581,7 @@ void dumpAttachObject(const char* func_name, GLuint program_object, const std::s
 }
 #endif // DEBUG_SHADER_INCLUDES
 
-BOOL LLGLSLShader::attachVertexObject(std::string object_path)
+bool LLGLSLShader::attachVertexObject(std::string object_path)
 {
     if (LLShaderMgr::instance()->mVertexShaderObjects.count(object_path) > 0)
     {
@@ -569,19 +591,19 @@ BOOL LLGLSLShader::attachVertexObject(std::string object_path)
         dumpAttachObject("attachVertexObject", mProgramObject, object_path);
 #endif // DEBUG_SHADER_INCLUDES
         stop_glerror();
-        return TRUE;
+        return true;
     }
     else
     {
         LL_SHADER_LOADING_WARNS() << "Attempting to attach shader object: '" << object_path << "' that hasn't been compiled." << LL_ENDL;
-        return FALSE;
+        return false;
     }
 }
 
-BOOL LLGLSLShader::attachFragmentObject(std::string object_path)
+bool LLGLSLShader::attachFragmentObject(std::string object_path)
 {
     if(mUsingBinaryProgram)
-        return TRUE;
+        return true;
 
     if (LLShaderMgr::instance()->mFragmentShaderObjects.count(object_path) > 0)
     {
@@ -591,12 +613,12 @@ BOOL LLGLSLShader::attachFragmentObject(std::string object_path)
         dumpAttachObject("attachFragmentObject", mProgramObject, object_path);
 #endif // DEBUG_SHADER_INCLUDES
         stop_glerror();
-        return TRUE;
+        return true;
     }
     else
     {
         LL_SHADER_LOADING_WARNS() << "Attempting to attach shader object: '" << object_path << "' that hasn't been compiled." << LL_ENDL;
-        return FALSE;
+        return false;
     }
 }
 
@@ -632,11 +654,11 @@ void LLGLSLShader::attachObjects(GLuint* objects, S32 count)
     }
 }
 
-BOOL LLGLSLShader::mapAttributes(const std::vector<LLStaticHashedString>* attributes)
+bool LLGLSLShader::mapAttributes()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SHADER;
 
-    BOOL res = TRUE;
+    bool res = true;
     if (!mUsingBinaryProgram)
     {
         //before linking, make sure reserved attributes always have consistent locations
@@ -651,11 +673,10 @@ BOOL LLGLSLShader::mapAttributes(const std::vector<LLStaticHashedString>* attrib
     }
 
     mAttribute.clear();
-    U32 numAttributes = (attributes == NULL) ? 0 : attributes->size();
 #if LL_RELEASE_WITH_DEBUG_INFO
-    mAttribute.resize(LLShaderMgr::instance()->mReservedAttribs.size() + numAttributes, { -1, NULL });
+    mAttribute.resize(LLShaderMgr::instance()->mReservedAttribs.size(), { -1, NULL });
 #else
-    mAttribute.resize(LLShaderMgr::instance()->mReservedAttribs.size() + numAttributes, -1);
+    mAttribute.resize(LLShaderMgr::instance()->mReservedAttribs.size(), -1);
 #endif
 
     if (res)
@@ -679,27 +700,14 @@ BOOL LLGLSLShader::mapAttributes(const std::vector<LLStaticHashedString>* attrib
                 LL_DEBUGS("ShaderUniform") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
             }
         }
-        if (attributes != NULL)
-        {
-            for (U32 i = 0; i < numAttributes; i++)
-            {
-                const char* name = (*attributes)[i].String().c_str();
-                S32 index = glGetAttribLocation(mProgramObject, name);
-                if (index != -1)
-                {
-                    mAttribute[LLShaderMgr::instance()->mReservedAttribs.size() + i] = index;
-                    LL_DEBUGS("ShaderUniform") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
-                }
-            }
-        }
 
-        return TRUE;
+        return true;
     }
 
-    return FALSE;
+    return false;
 }
 
-void LLGLSLShader::mapUniform(GLint index, const vector<LLStaticHashedString>* uniforms)
+void LLGLSLShader::mapUniform(GLint index)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SHADER;
 
@@ -789,22 +797,11 @@ void LLGLSLShader::mapUniform(GLint index, const vector<LLStaticHashedString>* u
                 //found it
                 mUniform[i] = location;
                 mTexture[i] = mapUniformTextureChannel(location, type, size);
-                return;
-            }
-        }
-
-        if (uniforms != NULL)
-        {
-            for (U32 i = 0; i < uniforms->size(); i++)
-            {
-                if ((mUniform[i + LLShaderMgr::instance()->mReservedUniforms.size()] == -1)
-                    && ((*uniforms)[i].String() == name))
+                if (mTexture[i] != -1)
                 {
-                    //found it
-                    mUniform[i + LLShaderMgr::instance()->mReservedUniforms.size()] = location;
-                    mTexture[i + LLShaderMgr::instance()->mReservedUniforms.size()] = mapUniformTextureChannel(location, type, size);
-                    return;
+                    LL_DEBUGS("GLSLTextureChannels") << name << " assigned to texture channel " << mTexture[i] << LL_ENDL;
                 }
+                return;
             }
         }
     }
@@ -845,35 +842,31 @@ GLint LLGLSLShader::mapUniformTextureChannel(GLint location, GLenum type, GLint
         if (size == 1)
         {
             glUniform1i(location, mActiveTextureChannels);
-            LL_DEBUGS("ShaderUniform") << "Assigned to texture channel " << mActiveTextureChannels << LL_ENDL;
             mActiveTextureChannels++;
         }
         else
         {
             //is array of textures, make sequential after this texture
-            GLint channel[32]; // <=== only support up to 32 texture channels
-            llassert(size <= 32);
-            size = llmin(size, 32);
+            GLint channel[16]; // <=== only support up to 16 texture channels
+            llassert(size <= 16);
+            size = llmin(size, 16);
             for (int i = 0; i < size; ++i)
             {
                 channel[i] = mActiveTextureChannels++;
             }
             glUniform1iv(location, size, channel);
-            LL_DEBUGS("ShaderUniform") << "Assigned to texture channel " <<
-                (mActiveTextureChannels - size) << " through " << (mActiveTextureChannels - 1) << LL_ENDL;
         }
 
-        llassert(mActiveTextureChannels <= 32); // too many textures (probably)
         return ret;
     }
     return -1;
 }
 
-BOOL LLGLSLShader::mapUniforms(const vector<LLStaticHashedString>* uniforms)
+bool LLGLSLShader::mapUniforms()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SHADER;
 
-    BOOL res = TRUE;
+    bool res = true;
 
     mTotalUniformSize = 0;
     mActiveTextureChannels = 0;
@@ -882,9 +875,8 @@ BOOL LLGLSLShader::mapUniforms(const vector<LLStaticHashedString>* uniforms)
     mTexture.clear();
     mValue.clear();
     //initialize arrays
-    U32 numUniforms = (uniforms == NULL) ? 0 : uniforms->size();
-    mUniform.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
-    mTexture.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
+    mUniform.resize(LLShaderMgr::instance()->mReservedUniforms.size(), -1);
+    mTexture.resize(LLShaderMgr::instance()->mReservedUniforms.size(), -1);
 
     bind();
 
@@ -985,26 +977,26 @@ BOOL LLGLSLShader::mapUniforms(const vector<LLStaticHashedString>* uniforms)
 
         if (specularDiff || bumpLessDiff || envLessDiff || refLessDiff)
         {
-            mapUniform(diffuseMap, uniforms);
+            mapUniform(diffuseMap);
             skip_index.insert(diffuseMap);
 
             if (-1 != specularMap) {
-                mapUniform(specularMap, uniforms);
+                mapUniform(specularMap);
                 skip_index.insert(specularMap);
             }
 
             if (-1 != bumpMap) {
-                mapUniform(bumpMap, uniforms);
+                mapUniform(bumpMap);
                 skip_index.insert(bumpMap);
             }
 
             if (-1 != environmentMap) {
-                mapUniform(environmentMap, uniforms);
+                mapUniform(environmentMap);
                 skip_index.insert(environmentMap);
             }
 
             if (-1 != reflectionMap) {
-                mapUniform(reflectionMap, uniforms);
+                mapUniform(reflectionMap);
                 skip_index.insert(reflectionMap);
             }
         }
@@ -1018,21 +1010,31 @@ BOOL LLGLSLShader::mapUniforms(const vector<LLStaticHashedString>* uniforms)
         if (skip_index.end() != skip_index.find(i)) continue;
         //........................................................................................
 
-        mapUniform(i, uniforms);
+        mapUniform(i);
     }
     //........................................................................................................................................
 
-    if (mFeatures.hasReflectionProbes) // Set up block binding, in a way supported by Apple (rather than binding = 1 in .glsl).
-    {   // See slide 35 and more of https://docs.huihoo.com/apple/wwdc/2011/session_420__advances_in_opengl_for_mac_os_x_lion.pdf
-        static const GLuint BLOCKBINDING = 1; //picked by us
-        //Get the index, similar to a uniform location
-        GLuint UBOBlockIndex = glGetUniformBlockIndex(mProgramObject, "ReflectionProbes");
+    // Set up block binding, in a way supported by Apple (rather than binding = 1 in .glsl).
+    // See slide 35 and more of https://docs.huihoo.com/apple/wwdc/2011/session_420__advances_in_opengl_for_mac_os_x_lion.pdf
+    const char* ubo_names[] =
+    {
+        "ReflectionProbes", // UB_REFLECTION_PROBES
+        "GLTFJoints",       // UB_GLTF_JOINTS
+        "GLTFNodes",        // UB_GLTF_NODES
+        "GLTFMaterials",    // UB_GLTF_MATERIALS
+    };
+
+    llassert(LL_ARRAY_SIZE(ubo_names) == NUM_UNIFORM_BLOCKS);
+
+    for (U32 i = 0; i < NUM_UNIFORM_BLOCKS; ++i)
+    {
+        GLuint UBOBlockIndex = glGetUniformBlockIndex(mProgramObject, ubo_names[i]);
         if (UBOBlockIndex != GL_INVALID_INDEX)
         {
-            //Set this index to a binding index
-            glUniformBlockBinding(mProgramObject, UBOBlockIndex, BLOCKBINDING);
+            glUniformBlockBinding(mProgramObject, UBOBlockIndex, i);
         }
     }
+
     unbind();
 
     LL_DEBUGS("ShaderUniform") << "Total Uniform Size: " << mTotalUniformSize << LL_ENDL;
@@ -1040,11 +1042,11 @@ BOOL LLGLSLShader::mapUniforms(const vector<LLStaticHashedString>* uniforms)
 }
 
 
-BOOL LLGLSLShader::link(BOOL suppress_errors)
+bool LLGLSLShader::link(bool suppress_errors)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SHADER;
 
-    BOOL success = LLShaderMgr::instance()->linkProgramObject(mProgramObject, suppress_errors);
+    bool success = LLShaderMgr::instance()->linkProgramObject(mProgramObject, suppress_errors);
 
     if (!success && !suppress_errors)
     {
@@ -1084,10 +1086,17 @@ void LLGLSLShader::bind()
     if (mUniformsDirty)
     {
         LLShaderMgr::instance()->updateShaderUniforms(this);
-        mUniformsDirty = FALSE;
+        mUniformsDirty = false;
     }
 }
 
+void LLGLSLShader::bind(U8 variant)
+{
+    llassert(mGLTFVariants.size() == LLGLSLShader::NUM_GLTF_VARIANTS);
+    llassert(variant < LLGLSLShader::NUM_GLTF_VARIANTS);
+    mGLTFVariants[variant].bind();
+}
+
 void LLGLSLShader::bind(bool rigged)
 {
     if (rigged)
@@ -1133,7 +1142,8 @@ S32 LLGLSLShader::bindTexture(S32 uniform, LLTexture* texture, LLTexUnit::eTextu
 
     if (uniform < 0 || uniform >= (S32)mTexture.size())
     {
-        LL_SHADER_UNIFORM_ERRS() << "Uniform out of range: " << uniform << LL_ENDL;
+        LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << uniform << LL_ENDL;
+        llassert(false);
         return -1;
     }
 
@@ -1154,6 +1164,8 @@ S32 LLGLSLShader::bindTexture(S32 uniform, LLRenderTarget* texture, bool depth,
 
     if (uniform < 0 || uniform >= (S32)mTexture.size())
     {
+        LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << uniform << LL_ENDL;
+        llassert(false);
         return -1;
     }
 
@@ -1201,7 +1213,8 @@ S32 LLGLSLShader::unbindTexture(S32 uniform, LLTexUnit::eTextureType mode)
 
     if (uniform < 0 || uniform >= (S32)mTexture.size())
     {
-        LL_SHADER_UNIFORM_ERRS() << "Uniform out of range: " << uniform << LL_ENDL;
+        LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << uniform << LL_ENDL;
+        llassert(false);
         return -1;
     }
 
@@ -1226,7 +1239,8 @@ S32 LLGLSLShader::enableTexture(S32 uniform, LLTexUnit::eTextureType mode, LLTex
 
     if (uniform < 0 || uniform >= (S32)mTexture.size())
     {
-        LL_SHADER_UNIFORM_ERRS() << "Uniform out of range: " << uniform << LL_ENDL;
+        LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << uniform << LL_ENDL;
+        llassert(false);
         return -1;
     }
 
@@ -1247,7 +1261,8 @@ S32 LLGLSLShader::disableTexture(S32 uniform, LLTexUnit::eTextureType mode, LLTe
 
     if (uniform < 0 || uniform >= (S32)mTexture.size())
     {
-        LL_SHADER_UNIFORM_ERRS() << "Uniform out of range: " << uniform << LL_ENDL;
+        LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << uniform << LL_ENDL;
+        llassert(false);
         return -1;
     }
     S32 index = mTexture[uniform];
@@ -1278,7 +1293,8 @@ void LLGLSLShader::uniform1i(U32 index, GLint x)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1303,7 +1319,8 @@ void LLGLSLShader::uniform1f(U32 index, GLfloat x)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1338,7 +1355,8 @@ void LLGLSLShader::uniform2f(U32 index, GLfloat x, GLfloat y)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1364,7 +1382,8 @@ void LLGLSLShader::uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1390,7 +1409,8 @@ void LLGLSLShader::uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1416,7 +1436,8 @@ void LLGLSLShader::uniform1iv(U32 index, U32 count, const GLint* v)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1442,7 +1463,8 @@ void LLGLSLShader::uniform4iv(U32 index, U32 count, const GLint* v)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1469,7 +1491,8 @@ void LLGLSLShader::uniform1fv(U32 index, U32 count, const GLfloat* v)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1495,7 +1518,8 @@ void LLGLSLShader::uniform2fv(U32 index, U32 count, const GLfloat* v)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1521,7 +1545,8 @@ void LLGLSLShader::uniform3fv(U32 index, U32 count, const GLfloat* v)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1547,7 +1572,8 @@ void LLGLSLShader::uniform4fv(U32 index, U32 count, const GLfloat* v)
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1574,7 +1600,8 @@ void LLGLSLShader::uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, c
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1594,7 +1621,8 @@ void LLGLSLShader::uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, c
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1614,7 +1642,8 @@ void LLGLSLShader::uniformMatrix3x4fv(U32 index, U32 count, GLboolean transpose,
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
@@ -1634,7 +1663,8 @@ void LLGLSLShader::uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, c
     {
         if (mUniform.size() <= index)
         {
-            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            LL_WARNS_ONCE("Shader") << "Uniform index out of bounds. Size: " << (S32)mUniform.size() << " index: " << index << LL_ENDL;
+            llassert(false);
             return;
         }
 
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index d7741c51bb..86e5625dca 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -44,6 +44,7 @@ public:
     bool hasTransport = false; // implies no lighting (it's possible to have neither though)
     bool hasSkinning = false;
     bool hasObjectSkinning = false;
+    bool mGLTF = false;
     bool hasAtmospherics = false;
     bool hasGamma = false;
     bool hasShadows = false;
@@ -51,7 +52,6 @@ public:
     bool hasSrgb = false;
     bool isDeferred = false;
     bool hasScreenSpaceReflections = false;
-    bool disableTextureIndex = false;
     bool hasAlphaMask = false;
     bool hasReflectionProbes = false;
     bool attachNothing = false;
@@ -69,8 +69,8 @@ public:
     template<typename T>
     struct UniformSetting
     {
-        S32 mUniform;
-        T mValue;
+        S32 mUniform{ 0 };
+        T mValue{};
     };
 
     typedef UniformSetting<S32> IntSetting;
@@ -145,6 +145,16 @@ public:
         SG_COUNT
     } eGroup;
 
+    enum UniformBlock : GLuint
+    {
+        UB_REFLECTION_PROBES,   // "ReflectionProbes"
+        UB_GLTF_JOINTS,         // "GLTFJoints"
+        UB_GLTF_NODES,          // "GLTFNodes"
+        UB_GLTF_MATERIALS,      // "GLTFMaterials"
+        NUM_UNIFORM_BLOCKS
+    };
+
+
     static std::set<LLGLSLShader*> sInstances;
     static bool sProfileEnabled;
 
@@ -155,6 +165,9 @@ public:
     static LLGLSLShader* sCurBoundShaderPtr;
     static S32 sIndexedTextureChannels;
 
+    static U32 sMaxGLTFMaterials;
+    static U32 sMaxGLTFNodes;
+
     static void initProfile();
     static void finishProfile(bool emit_report = true);
 
@@ -175,17 +188,14 @@ public:
     // If force_read is true, will force an immediate readback (severe performance penalty)
     bool readProfileQuery(bool for_runtime = false, bool force_read = false);
 
-    BOOL createShader(std::vector<LLStaticHashedString>* attributes,
-        std::vector<LLStaticHashedString>* uniforms,
-        U32 varying_count = 0,
-        const char** varyings = NULL);
-    BOOL attachFragmentObject(std::string object);
-    BOOL attachVertexObject(std::string object);
+    bool createShader();
+    bool attachFragmentObject(std::string object);
+    bool attachVertexObject(std::string object);
     void attachObject(GLuint object);
     void attachObjects(GLuint* objects = NULL, S32 count = 0);
-    BOOL mapAttributes(const std::vector<LLStaticHashedString>* attributes);
-    BOOL mapUniforms(const std::vector<LLStaticHashedString>*);
-    void mapUniform(GLint index, const std::vector<LLStaticHashedString>*);
+    bool mapAttributes();
+    bool mapUniforms();
+    void mapUniform(GLint index);
     void uniform1i(U32 index, GLint i);
     void uniform1f(U32 index, GLfloat v);
     void fastUniform1f(U32 index, GLfloat v);
@@ -252,7 +262,7 @@ public:
     S32 unbindTexture(const std::string& uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
     S32 unbindTexture(S32 uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
 
-    BOOL link(BOOL suppress_errors = FALSE);
+    bool link(bool suppress_errors = false);
     void bind();
     //helper to conditionally bind mRiggedVariant instead of this
     void bind(bool rigged);
@@ -290,7 +300,7 @@ public:
     S32 mActiveTextureChannels;
     S32 mShaderLevel;
     S32 mShaderGroup; // see LLGLSLShader::eGroup
-    BOOL mUniformsDirty;
+    bool mUniformsDirty;
     LLShaderFeatures mFeatures;
     std::vector< std::pair< std::string, GLenum > > mShaderFiles;
     std::string mName;
@@ -318,6 +328,26 @@ public:
     // this pointer should be set to whichever shader represents this shader's rigged variant
     LLGLSLShader* mRiggedVariant = nullptr;
 
+    // variants for use by GLTF renderer
+    // bit 0 = alpha mode blend (1) or opaque (0)
+    // bit 1 = rigged (1) or static (0)
+    // bit 2 = unlit (1) or lit (0)
+    // bit 3 = single (0) or multi (1) uv coordinates
+    struct GLTFVariant
+    {
+        constexpr static U8 ALPHA_BLEND = 1;
+        constexpr static U8 RIGGED = 2;
+        constexpr static U8 UNLIT = 4;
+        constexpr static U8 MULTI_UV = 8;
+    };
+
+    constexpr static U8 NUM_GLTF_VARIANTS = 16;
+
+    std::vector<LLGLSLShader> mGLTFVariants;
+
+    //helper to bind GLTF variant
+    void bind(U8 variant);
+
     // hacky flag used for optimization in LLDrawPoolAlpha
     bool mCanBindFast = false;
 
diff --git a/indra/llrender/llgltexture.cpp b/indra/llrender/llgltexture.cpp
index 104976fcc6..e614f45986 100644
--- a/indra/llrender/llgltexture.cpp
+++ b/indra/llrender/llgltexture.cpp
@@ -27,13 +27,13 @@
 #include "llgltexture.h"
 
 
-LLGLTexture::LLGLTexture(BOOL usemipmaps)
+LLGLTexture::LLGLTexture(bool usemipmaps)
 {
     init();
     mUseMipMaps = usemipmaps;
 }
 
-LLGLTexture::LLGLTexture(const U32 width, const U32 height, const U8 components, BOOL usemipmaps)
+LLGLTexture::LLGLTexture(const U32 width, const U32 height, const U8 components, bool usemipmaps)
 {
     init();
     mFullWidth = width ;
@@ -43,14 +43,14 @@ LLGLTexture::LLGLTexture(const U32 width, const U32 height, const U8 components,
     setTexelsPerImage();
 }
 
-LLGLTexture::LLGLTexture(const LLImageRaw* raw, BOOL usemipmaps)
+LLGLTexture::LLGLTexture(const LLImageRaw* raw, bool usemipmaps)
 {
     init();
     mUseMipMaps = usemipmaps ;
     // Create an empty image of the specified size and width
     mGLTexturep = new LLImageGL(raw, usemipmaps) ;
-    mFullWidth = mGLTexturep->getCurrentWidth();
-    mFullHeight = mGLTexturep->getCurrentHeight();
+    mFullWidth = mGLTexturep->getWidth();
+    mFullHeight = mGLTexturep->getHeight();
     mComponents = mGLTexturep->getComponents();
     setTexelsPerImage();
 }
@@ -67,12 +67,12 @@ void LLGLTexture::init()
     mFullWidth = 0;
     mFullHeight = 0;
     mTexelsPerImage = 0 ;
-    mUseMipMaps = FALSE ;
+    mUseMipMaps = false ;
     mComponents = 0 ;
 
     mTextureState = NO_DELETE ;
-    mDontDiscard = FALSE;
-    mNeedsGLTexture = FALSE ;
+    mDontDiscard = false;
+    mNeedsGLTexture = false ;
 }
 
 void LLGLTexture::cleanup()
@@ -141,7 +141,7 @@ LLImageGL* LLGLTexture::getGLTexture() const
     return mGLTexturep ;
 }
 
-BOOL LLGLTexture::createGLTexture()
+bool LLGLTexture::createGLTexture()
 {
     if(mGLTexturep.isNull())
     {
@@ -151,11 +151,11 @@ BOOL LLGLTexture::createGLTexture()
     return mGLTexturep->createGLTexture() ;
 }
 
-BOOL LLGLTexture::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename, BOOL to_create, S32 category, bool defer_copy, LLGLuint* tex_name)
+bool LLGLTexture::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename, bool to_create, S32 category, bool defer_copy, LLGLuint* tex_name)
 {
     llassert(mGLTexturep.notNull());
 
-    BOOL ret = mGLTexturep->createGLTexture(discard_level, imageraw, usename, to_create, category, defer_copy, tex_name) ;
+    bool ret = mGLTexturep->createGLTexture(discard_level, imageraw, usename, to_create, category, defer_copy, tex_name) ;
 
     if(ret)
     {
@@ -168,7 +168,7 @@ BOOL LLGLTexture::createGLTexture(S32 discard_level, const LLImageRaw* imageraw,
     return ret ;
 }
 
-void LLGLTexture::setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format, BOOL swap_bytes)
+void LLGLTexture::setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format, bool swap_bytes)
 {
     llassert(mGLTexturep.notNull()) ;
 
@@ -223,22 +223,22 @@ LLGLuint LLGLTexture::getTexName() const
     return mGLTexturep->getTexName() ;
 }
 
-BOOL LLGLTexture::hasGLTexture() const
+bool LLGLTexture::hasGLTexture() const
 {
     if(mGLTexturep.notNull())
     {
         return mGLTexturep->getHasGLTexture() ;
     }
-    return FALSE ;
+    return false ;
 }
 
-BOOL LLGLTexture::getBoundRecently() const
+bool LLGLTexture::getBoundRecently() const
 {
     if(mGLTexturep.notNull())
     {
         return mGLTexturep->getBoundRecently() ;
     }
-    return FALSE ;
+    return false ;
 }
 
 LLTexUnit::eTextureType LLGLTexture::getTarget(void) const
@@ -247,7 +247,7 @@ LLTexUnit::eTextureType LLGLTexture::getTarget(void) const
     return mGLTexturep->getTarget() ;
 }
 
-BOOL LLGLTexture::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, LLGLuint use_name)
+bool LLGLTexture::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, LLGLuint use_name)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     llassert(mGLTexturep.notNull()) ;
@@ -255,7 +255,7 @@ BOOL LLGLTexture::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos,
     return mGLTexturep->setSubImage(imageraw, x_pos, y_pos, width, height, 0, use_name) ;
 }
 
-BOOL LLGLTexture::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, LLGLuint use_name)
+bool LLGLTexture::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, LLGLuint use_name)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     llassert(mGLTexturep.notNull()) ;
@@ -310,14 +310,14 @@ LLGLenum LLGLTexture::getPrimaryFormat() const
     return mGLTexturep->getPrimaryFormat() ;
 }
 
-BOOL LLGLTexture::getIsAlphaMask() const
+bool LLGLTexture::getIsAlphaMask() const
 {
     llassert(mGLTexturep.notNull()) ;
 
     return mGLTexturep->getIsAlphaMask() ;
 }
 
-BOOL LLGLTexture::getMask(const LLVector2 &tc)
+bool LLGLTexture::getMask(const LLVector2 &tc)
 {
     llassert(mGLTexturep.notNull()) ;
 
@@ -330,14 +330,14 @@ F32 LLGLTexture::getTimePassedSinceLastBound()
 
     return mGLTexturep->getTimePassedSinceLastBound() ;
 }
-BOOL LLGLTexture::getMissed() const
+bool LLGLTexture::getMissed() const
 {
     llassert(mGLTexturep.notNull()) ;
 
     return mGLTexturep->getMissed() ;
 }
 
-BOOL LLGLTexture::isJustBound() const
+bool LLGLTexture::isJustBound() const
 {
     llassert(mGLTexturep.notNull()) ;
 
@@ -365,7 +365,7 @@ U32 LLGLTexture::getTexelsInGLTexture() const
     return mGLTexturep->getTexelsInGLTexture() ;
 }
 
-BOOL LLGLTexture::isGLTextureCreated() const
+bool LLGLTexture::isGLTextureCreated() const
 {
     llassert(mGLTexturep.notNull()) ;
 
diff --git a/indra/llrender/llgltexture.h b/indra/llrender/llgltexture.h
index f5bef0e291..0901243f8f 100644
--- a/indra/llrender/llgltexture.h
+++ b/indra/llrender/llgltexture.h
@@ -94,9 +94,9 @@ protected:
     LOG_CLASS(LLGLTexture);
 
 public:
-    LLGLTexture(BOOL usemipmaps = TRUE);
-    LLGLTexture(const LLImageRaw* raw, BOOL usemipmaps) ;
-    LLGLTexture(const U32 width, const U32 height, const U8 components, BOOL usemipmaps) ;
+    LLGLTexture(bool usemipmaps = true);
+    LLGLTexture(const LLImageRaw* raw, bool usemipmaps) ;
+    LLGLTexture(const U32 width, const U32 height, const U8 components, bool usemipmaps) ;
 
     virtual void dump();    // debug info to LL_INFOS()
 
@@ -117,25 +117,25 @@ public:
     /*virtual*/S32         getWidth(S32 discard_level = -1) const;
     /*virtual*/S32         getHeight(S32 discard_level = -1) const;
 
-    BOOL       hasGLTexture() const ;
+    bool       hasGLTexture() const ;
     LLGLuint   getTexName() const ;
-    BOOL       createGLTexture() ;
+    bool       createGLTexture() ;
 
     // Create a GL Texture from an image raw
     // discard_level - mip level, 0 for highest resultion mip
     // imageraw - the image to copy from
     // usename - explicit GL name override
-    // to_create - set to FALSE to force gl texture to not be created
+    // to_create - set to false to force gl texture to not be created
     // category - LLGLTexture category for this LLGLTexture
     // defer_copy - set to true to allocate GL texture but NOT initialize with imageraw data
     // tex_name - if not null, will be set to the GL name of the texture created
-    BOOL       createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0, BOOL to_create = TRUE, S32 category = LLGLTexture::OTHER, bool defer_copy = false, LLGLuint* tex_name = nullptr);
+    bool       createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0, bool to_create = true, S32 category = LLGLTexture::OTHER, bool defer_copy = false, LLGLuint* tex_name = nullptr);
 
     void       setFilteringOption(LLTexUnit::eTextureFilterOptions option);
-    void       setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, BOOL swap_bytes = FALSE);
+    void       setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, bool swap_bytes = false);
     void       setAddressMode(LLTexUnit::eTextureAddressMode mode);
-    BOOL       setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, LLGLuint use_name = 0);
-    BOOL       setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, LLGLuint use_name = 0);
+    bool       setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, LLGLuint use_name = 0);
+    bool       setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, LLGLuint use_name = 0);
     void       setGLTextureCreated (bool initialized);
     void       setCategory(S32 category) ;
     void       setTexName(LLGLuint); // for forcing w/ externally created textures only
@@ -145,20 +145,20 @@ public:
     S32        getMaxDiscardLevel() const;
     S32        getDiscardLevel() const;
     S8         getComponents() const;
-    BOOL       getBoundRecently() const;
+    bool       getBoundRecently() const;
     S32Bytes   getTextureMemory() const ;
     LLGLenum   getPrimaryFormat() const;
-    BOOL       getIsAlphaMask() const ;
+    bool       getIsAlphaMask() const ;
     LLTexUnit::eTextureType getTarget(void) const ;
-    BOOL       getMask(const LLVector2 &tc);
+    bool       getMask(const LLVector2 &tc);
     F32        getTimePassedSinceLastBound();
-    BOOL       getMissed() const ;
-    BOOL       isJustBound()const ;
+    bool       getMissed() const ;
+    bool       isJustBound()const ;
     void       forceUpdateBindStats(void) const;
 
     U32        getTexelsInAtlas() const ;
     U32        getTexelsInGLTexture() const ;
-    BOOL       isGLTextureCreated() const ;
+    bool       isGLTextureCreated() const ;
     S32        getDiscardLevelInAtlas() const ;
     LLGLTextureState getTextureState() const { return mTextureState; }
 
@@ -171,7 +171,7 @@ public:
     void forceActive() ;
     void setNoDelete() ;
     void dontDiscard() { mDontDiscard = 1; mTextureState = NO_DELETE; }
-    BOOL getDontDiscard() const { return mDontDiscard; }
+    bool getDontDiscard() const { return mDontDiscard; }
     //-----------------
 
 private:
@@ -188,7 +188,7 @@ protected:
     S32 mBoostLevel;                // enum describing priority level
     U32 mFullWidth;
     U32 mFullHeight;
-    BOOL mUseMipMaps;
+    bool mUseMipMaps;
     S8  mComponents;
     U32 mTexelsPerImage;            // Texels per image.
     mutable S8  mNeedsGLTexture;
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index c713a2b3a9..fb02c72338 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -56,14 +56,14 @@ const F32 MIN_TEXTURE_LIFETIME = 10.f;
 U32 wpo2(U32 i);
 
 
-// texture memory accounting (for OS X)
+// texture memory accounting (for macOS)
 static LLMutex sTexMemMutex;
 static std::unordered_map<U32, U64> sTextureAllocs;
 static U64 sTextureBytes = 0;
 
 // track a texture alloc on the currently bound texture.
 // asserts that no currently tracked alloc exists
-static void alloc_tex_image(U32 width, U32 height, U32 pixformat)
+void LLImageGLMemory::alloc_tex_image(U32 width, U32 height, U32 pixformat)
 {
     U32 texUnit = gGL.getCurrentTexUnitIndex();
     U32 texName = gGL.getTexUnit(texUnit)->getCurrTexture();
@@ -81,7 +81,7 @@ static void alloc_tex_image(U32 width, U32 height, U32 pixformat)
 }
 
 // track texture free on given texName
-static void free_tex_image(U32 texName)
+void LLImageGLMemory::free_tex_image(U32 texName)
 {
     sTexMemMutex.lock();
     auto iter = sTextureAllocs.find(texName);
@@ -98,22 +98,24 @@ static void free_tex_image(U32 texName)
 }
 
 // track texture free on given texNames
-static void free_tex_images(U32 count, const U32* texNames)
+void LLImageGLMemory::free_tex_images(U32 count, const U32* texNames)
 {
-    for (int i = 0; i < count; ++i)
+    for (U32 i = 0; i < count; ++i)
     {
         free_tex_image(texNames[i]);
     }
 }
 
 // track texture free on currently bound texture
-static void free_cur_tex_image()
+void LLImageGLMemory::free_cur_tex_image()
 {
     U32 texUnit = gGL.getCurrentTexUnitIndex();
     U32 texName = gGL.getTexUnit(texUnit)->getCurrTexture();
     free_tex_image(texName);
 }
 
+using namespace LLImageGLMemory;
+
 // static
 U64 LLImageGL::getTextureBytesAllocated()
 {
@@ -126,9 +128,9 @@ U32 LLImageGL::sUniqueCount             = 0;
 U32 LLImageGL::sBindCount               = 0;
 S32 LLImageGL::sCount                   = 0;
 
-BOOL LLImageGL::sGlobalUseAnisotropic   = FALSE;
+bool LLImageGL::sGlobalUseAnisotropic   = false;
 F32 LLImageGL::sLastFrameTime           = 0.f;
-BOOL LLImageGL::sAllowReadBackRaw       = FALSE ;
+bool LLImageGL::sAllowReadBackRaw       = false ;
 LLImageGL* LLImageGL::sDefaultGLTexture = NULL ;
 bool LLImageGL::sCompressTextures = false;
 std::set<LLImageGL*> LLImageGL::sImageList;
@@ -147,7 +149,7 @@ S32 LLImageGL::sCurTexPickSize = -1 ;
 S32 LLImageGL::sMaxCategories = 1 ;
 
 //optimization for when we don't need to calculate mIsMask
-BOOL LLImageGL::sSkipAnalyzeAlpha;
+bool LLImageGL::sSkipAnalyzeAlpha;
 
 //------------------------
 //****************************************************************************************************
@@ -185,12 +187,12 @@ void LLImageGL::checkTexSize(bool forced) const
 
         GLint texname;
         glGetIntegerv(GL_TEXTURE_BINDING_2D, &texname);
-        BOOL error = FALSE;
+        bool error = false;
         if (texname != mTexName)
         {
             LL_INFOS() << "Bound: " << texname << " Should bind: " << mTexName << " Default: " << LLImageGL::sDefaultGLTexture->getTexName() << LL_ENDL;
 
-            error = TRUE;
+            error = true;
             if (gDebugSession)
             {
                 gFailLog << "Invalid texture bound!" << std::endl;
@@ -213,7 +215,7 @@ void LLImageGL::checkTexSize(bool forced) const
         }
         if(x != (mWidth >> mCurrentDiscardLevel) || y != (mHeight >> mCurrentDiscardLevel))
         {
-            error = TRUE;
+            error = true;
             if (gDebugSession)
             {
                 gFailLog << "wrong texture size and discard level!" <<
@@ -236,7 +238,7 @@ void LLImageGL::checkTexSize(bool forced) const
 //**************************************************************************************
 
 //----------------------------------------------------------------------------
-BOOL is_little_endian()
+bool is_little_endian()
 {
     S32 a = 0x12345678;
     U8 *c = (U8*)(&a);
@@ -245,7 +247,7 @@ BOOL is_little_endian()
 }
 
 //static
-void LLImageGL::initClass(LLWindow* window, S32 num_catagories, BOOL skip_analyze_alpha /* = false */, bool thread_texture_loads /* = false */, bool thread_media_updates /* = false */)
+void LLImageGL::initClass(LLWindow* window, S32 num_catagories, bool skip_analyze_alpha /* = false */, bool thread_texture_loads /* = false */, bool thread_media_updates /* = false */)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     sSkipAnalyzeAlpha = skip_analyze_alpha;
@@ -297,6 +299,8 @@ S32 LLImageGL::dataFormatBits(S32 dataformat)
     case GL_BGRA:                                   return 32;      // Used for QuickTime media textures on the Mac
 #endif
     case GL_DEPTH_COMPONENT:                        return 24;
+    case GL_RGB16F:                                 return 48;
+    case GL_RGBA16F:                                return 64;
     default:
         LL_ERRS() << "LLImageGL::Unknown format: " << dataformat << LL_ENDL;
         return 0;
@@ -375,7 +379,7 @@ void LLImageGL::updateStats(F32 current_time)
 //----------------------------------------------------------------------------
 
 //static
-void LLImageGL::destroyGL(BOOL save_state)
+void LLImageGL::destroyGL(bool save_state)
 {
     for (S32 stage = 0; stage < gGLManager.mNumTextureImageUnits; stage++)
     {
@@ -420,7 +424,7 @@ void LLImageGL::restoreGL()
         {
             if (glimage->getComponents() && glimage->mSaveData->getComponents())
             {
-                glimage->createGLTexture(glimage->mCurrentDiscardLevel, glimage->mSaveData, 0, TRUE, glimage->getCategory());
+                glimage->createGLTexture(glimage->mCurrentDiscardLevel, glimage->mSaveData, 0, true, glimage->getCategory());
                 stop_glerror();
             }
             glimage->mSaveData = NULL; // deletes data
@@ -444,30 +448,30 @@ void LLImageGL::dirtyTexOptions()
 
 //for server side use only.
 //static
-BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, BOOL usemipmaps)
+bool LLImageGL::create(LLPointer<LLImageGL>& dest, bool usemipmaps)
 {
     dest = new LLImageGL(usemipmaps);
-    return TRUE;
+    return true;
 }
 
 //for server side use only.
-BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, U32 width, U32 height, U8 components, BOOL usemipmaps)
+bool LLImageGL::create(LLPointer<LLImageGL>& dest, U32 width, U32 height, U8 components, bool usemipmaps)
 {
     dest = new LLImageGL(width, height, components, usemipmaps);
-    return TRUE;
+    return true;
 }
 
 //for server side use only.
-BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, BOOL usemipmaps)
+bool LLImageGL::create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, bool usemipmaps)
 {
     dest = new LLImageGL(imageraw, usemipmaps);
-    return TRUE;
+    return true;
 }
 
 //----------------------------------------------------------------------------
 
-LLImageGL::LLImageGL(BOOL usemipmaps)
-:   mSaveData(0), mExternalTexture(FALSE)
+LLImageGL::LLImageGL(bool usemipmaps)
+:   mSaveData(0), mExternalTexture(false)
 {
     init(usemipmaps);
     setSize(0, 0, 0);
@@ -475,8 +479,8 @@ LLImageGL::LLImageGL(BOOL usemipmaps)
     sCount++;
 }
 
-LLImageGL::LLImageGL(U32 width, U32 height, U8 components, BOOL usemipmaps)
-:   mSaveData(0), mExternalTexture(FALSE)
+LLImageGL::LLImageGL(U32 width, U32 height, U8 components, bool usemipmaps)
+:   mSaveData(0), mExternalTexture(false)
 {
     llassert( components <= 4 );
     init(usemipmaps);
@@ -485,8 +489,8 @@ LLImageGL::LLImageGL(U32 width, U32 height, U8 components, BOOL usemipmaps)
     sCount++;
 }
 
-LLImageGL::LLImageGL(const LLImageRaw* imageraw, BOOL usemipmaps)
-:   mSaveData(0), mExternalTexture(FALSE)
+LLImageGL::LLImageGL(const LLImageRaw* imageraw, bool usemipmaps)
+:   mSaveData(0), mExternalTexture(false)
 {
     init(usemipmaps);
     setSize(0, 0, 0);
@@ -527,7 +531,7 @@ LLImageGL::~LLImageGL()
     }
 }
 
-void LLImageGL::init(BOOL usemipmaps)
+void LLImageGL::init(bool usemipmaps)
 {
 #if LL_IMAGEGL_THREAD_CHECK
     mActiveThread = LLThread::currentID();
@@ -544,14 +548,14 @@ void LLImageGL::init(BOOL usemipmaps)
     mPickMaskWidth = 0;
     mPickMaskHeight = 0;
     mUseMipMaps = usemipmaps;
-    mHasExplicitFormat = FALSE;
+    mHasExplicitFormat = false;
 
-    mIsMask = FALSE;
-    mNeedsAlphaAndPickMask = TRUE ;
+    mIsMask = false;
+    mNeedsAlphaAndPickMask = true ;
     mAlphaStride = 0 ;
     mAlphaOffset = 0 ;
 
-    mGLTextureCreated = FALSE ;
+    mGLTextureCreated = false ;
     mTexName = 0;
     mWidth = 0;
     mHeight = 0;
@@ -580,10 +584,10 @@ void LLImageGL::init(BOOL usemipmaps)
     mFormatInternal = -1;
     mFormatPrimary = (LLGLenum) 0;
     mFormatType = GL_UNSIGNED_BYTE;
-    mFormatSwapBytes = FALSE;
+    mFormatSwapBytes = false;
 
 #ifdef DEBUG_MISS
-    mMissed = FALSE;
+    mMissed = false;
 #endif
 
     mCategory = -1;
@@ -701,12 +705,12 @@ void LLImageGL::forceUpdateBindStats(void) const
     mLastBindTime = sLastFrameTime;
 }
 
-BOOL LLImageGL::updateBindStats() const
+bool LLImageGL::updateBindStats() const
 {
     if (mTexName != 0)
     {
 #ifdef DEBUG_MISS
-        mMissed = ! getIsResident(TRUE);
+        mMissed = ! getIsResident(true);
 #endif
         sBindCount++;
         if (mLastBindTime != sLastFrameTime)
@@ -715,10 +719,10 @@ BOOL LLImageGL::updateBindStats() const
             sUniqueCount++;
             mLastBindTime = sLastFrameTime;
 
-            return TRUE ;
+            return true ;
         }
     }
-    return FALSE ;
+    return false ;
 }
 
 F32 LLImageGL::getTimePassedSinceLastBound()
@@ -726,11 +730,11 @@ F32 LLImageGL::getTimePassedSinceLastBound()
     return sLastFrameTime - mLastBindTime ;
 }
 
-void LLImageGL::setExplicitFormat( LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format, BOOL swap_bytes )
+void LLImageGL::setExplicitFormat( LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format, bool swap_bytes )
 {
     // Note: must be called before createTexture()
     // Note: it's up to the caller to ensure that the format matches the number of components.
-    mHasExplicitFormat = TRUE;
+    mHasExplicitFormat = true;
     mFormatInternal = internal_format;
     mFormatPrimary = primary_format;
     if(type_format == 0)
@@ -751,10 +755,10 @@ void LLImageGL::setImage(const LLImageRaw* imageraw)
              (imageraw->getHeight() == getHeight(mCurrentDiscardLevel)) &&
              (imageraw->getComponents() == getComponents()));
     const U8* rawdata = imageraw->getData();
-    setImage(rawdata, FALSE);
+    setImage(rawdata, false);
 }
 
-BOOL LLImageGL::setImage(const U8* data_in, BOOL data_hasmips /* = FALSE */, S32 usename /* = 0 */)
+bool LLImageGL::setImage(const U8* data_in, bool data_hasmips /* = false */, S32 usename /* = 0 */)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 
@@ -946,7 +950,7 @@ BOOL LLImageGL::setImage(const U8* data_in, BOOL data_hasmips /* = FALSE */, S32
                             }
 
                             mGLTextureCreated = false;
-                            return FALSE;
+                            return false;
                         }
                         else
                         {
@@ -1055,10 +1059,10 @@ BOOL LLImageGL::setImage(const U8* data_in, BOOL data_hasmips /* = FALSE */, S32
     }
     stop_glerror();
     mGLTextureCreated = true;
-    return TRUE;
+    return true;
 }
 
-BOOL LLImageGL::preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image)
+bool LLImageGL::preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image)
 {
     //not compatible with core GL profile
     llassert(!LLRender::sGLCoreProfile);
@@ -1066,7 +1070,7 @@ BOOL LLImageGL::preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image)
     if (gGLManager.mIsDisabled)
     {
         LL_WARNS() << "Trying to create a texture while GL is disabled!" << LL_ENDL;
-        return FALSE;
+        return false;
     }
     llassert(gGLManager.mInited);
     stop_glerror();
@@ -1085,7 +1089,7 @@ BOOL LLImageGL::preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image)
     if (!setSize(w, h, raw_image->getComponents(), discard_level))
     {
         LL_WARNS() << "Trying to create a texture with incorrect dimensions!" << LL_ENDL;
-        return FALSE;
+        return false;
     }
 
     if (!mHasExplicitFormat)
@@ -1140,7 +1144,7 @@ BOOL LLImageGL::preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image)
     }
 #endif
 
-    return TRUE ;
+    return true ;
 }
 
 void LLImageGL::postAddToAtlas()
@@ -1214,31 +1218,31 @@ void sub_image_lines(U32 target, S32 miplevel, S32 x_offset, S32 y_offset, S32 w
     }
 }
 
-BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update /* = FALSE */, LLGLuint use_name)
+bool LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, bool force_fast_update /* = false */, LLGLuint use_name)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     if (!width || !height)
     {
-        return TRUE;
+        return true;
     }
     LLGLuint tex_name = use_name != 0 ? use_name : mTexName;
     if (0 == tex_name)
     {
         // *TODO: Re-enable warning?  Ran into thread locking issues? DK 2011-02-18
         //LL_WARNS() << "Setting subimage on image without GL texture" << LL_ENDL;
-        return FALSE;
+        return false;
     }
     if (datap == NULL)
     {
         // *TODO: Re-enable warning?  Ran into thread locking issues? DK 2011-02-18
         //LL_WARNS() << "Setting subimage on image with NULL datap" << LL_ENDL;
-        return FALSE;
+        return false;
     }
 
     // HACK: allow the caller to explicitly force the fast path (i.e. using glTexSubImage2D here instead of calling setImage) even when updating the full texture.
     if (!force_fast_update && x_pos == 0 && y_pos == 0 && width == getWidth() && height == getHeight() && data_width == width && data_height == height)
     {
-        setImage(datap, FALSE, tex_name);
+        setImage(datap, false, tex_name);
     }
     else
     {
@@ -1292,7 +1296,7 @@ BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S3
 
         const U8* sub_datap = datap + (y_pos * data_width + x_pos) * getComponents();
         // Update the GL texture
-        BOOL res = gGL.getTexUnit(0)->bindManual(mBindTarget, tex_name);
+        bool res = gGL.getTexUnit(0)->bindManual(mBindTarget, tex_name);
         if (!res) LL_ERRS() << "LLImageGL::setSubImage(): bindTexture failed" << LL_ENDL;
         stop_glerror();
 
@@ -1324,28 +1328,28 @@ BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S3
         stop_glerror();
         mGLTextureCreated = true;
     }
-    return TRUE;
+    return true;
 }
 
-BOOL LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update /* = FALSE */, LLGLuint use_name)
+bool LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, bool force_fast_update /* = false */, LLGLuint use_name)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     return setSubImage(imageraw->getData(), imageraw->getWidth(), imageraw->getHeight(), x_pos, y_pos, width, height, force_fast_update, use_name);
 }
 
 // Copy sub image from frame buffer
-BOOL LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height)
+bool LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height)
 {
     if (gGL.getTexUnit(0)->bind(this, false, true))
     {
         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, fb_x, fb_y, x_pos, y_pos, width, height);
         mGLTextureCreated = true;
         stop_glerror();
-        return TRUE;
+        return true;
     }
     else
     {
-        return FALSE;
+        return false;
     }
 }
 
@@ -1365,7 +1369,7 @@ void LLImageGL::generateTextures(S32 numTextures, U32 *textures)
         name_count = pool_size;
     }
 
-    if (numTextures <= name_count)
+    if ((U32)numTextures <= name_count)
     {
         //copy teture names off the end of the pool
         memcpy(textures, name_pool + name_count - numTextures, sizeof(U32) * numTextures);
@@ -1584,7 +1588,7 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt
 
 //create an empty GL texture: just create a texture name
 //the texture is assiciate with some image by calling glTexImage outside LLImageGL
-BOOL LLImageGL::createGLTexture()
+bool LLImageGL::createGLTexture()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     checkActiveThread();
@@ -1592,7 +1596,7 @@ BOOL LLImageGL::createGLTexture()
     if (gGLManager.mIsDisabled)
     {
         LL_WARNS() << "Trying to create a texture while GL is disabled!" << LL_ENDL;
-        return FALSE;
+        return false;
     }
 
     mGLTextureCreated = false ; //do not save this texture when gl is destroyed.
@@ -1612,13 +1616,13 @@ BOOL LLImageGL::createGLTexture()
     if (!mTexName)
     {
         LL_WARNS() << "LLImageGL::createGLTexture failed to make an empty texture" << LL_ENDL;
-        return FALSE;
+        return false;
     }
 
-    return TRUE ;
+    return true ;
 }
 
-BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/, BOOL to_create, S32 category, bool defer_copy, LLGLuint* tex_name)
+bool LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/, bool to_create, S32 category, bool defer_copy, LLGLuint* tex_name)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     checkActiveThread();
@@ -1626,7 +1630,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
     if (gGLManager.mIsDisabled)
     {
         LL_WARNS() << "Trying to create a texture while GL is disabled!" << LL_ENDL;
-        return FALSE;
+        return false;
     }
 
     llassert(gGLManager.mInited);
@@ -1636,7 +1640,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
     {
         LL_WARNS() << "Trying to create a texture from invalid image data" << LL_ENDL;
         mGLTextureCreated = false;
-        return FALSE;
+        return false;
     }
 
     if (discard_level < 0)
@@ -1657,7 +1661,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
     {
         LL_WARNS() << "Trying to create a texture with incorrect dimensions!" << LL_ENDL;
         mGLTextureCreated = false;
-        return FALSE;
+        return false;
     }
 
     if (mHasExplicitFormat &&
@@ -1666,7 +1670,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
 
     {
         LL_WARNS()  << "Incorrect format: " << std::hex << mFormatPrimary << " components: " << (U32)mComponents <<  LL_ENDL;
-        mHasExplicitFormat = FALSE;
+        mHasExplicitFormat = false;
     }
 
     if( !mHasExplicitFormat )
@@ -1716,15 +1720,15 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
         mCurrentDiscardLevel = discard_level;
         mLastBindTime = sLastFrameTime;
         mGLTextureCreated = false;
-        return TRUE ;
+        return true ;
     }
 
     setCategory(category);
     const U8* rawdata = imageraw->getData();
-    return createGLTexture(discard_level, rawdata, FALSE, usename, defer_copy, tex_name);
+    return createGLTexture(discard_level, rawdata, false, usename, defer_copy, tex_name);
 }
 
-BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_hasmips, S32 usename, bool defer_copy, LLGLuint* tex_name)
+bool LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, bool data_hasmips, S32 usename, bool defer_copy, LLGLuint* tex_name)
 // Call with void data, vmem is allocated but unitialized
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
@@ -1797,7 +1801,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
         LL_PROFILE_ZONE_NAMED("cglt - late setImage");
         if (!setImage(data_in, data_hasmips, new_texname))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -1835,7 +1839,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
     mLastBindTime = sLastFrameTime;
 
     checkActiveThread();
-    return TRUE;
+    return true;
 }
 
 void LLImageGL::syncToMainThread(LLGLuint new_tex_name)
@@ -1905,7 +1909,7 @@ void LLImageGL::syncTexName(LLGLuint texname)
     }
 }
 
-BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok) const
+bool LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok) const
 {
     llassert_always(sAllowReadBackRaw) ;
     //LL_ERRS() << "should not call this function!" << LL_ENDL ;
@@ -1917,7 +1921,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
 
     if (mTexName == 0 || discard_level < mCurrentDiscardLevel || discard_level > mMaxDiscardLevel )
     {
-        return FALSE;
+        return false;
     }
 
     S32 gl_discard = discard_level - mCurrentDiscardLevel;
@@ -1934,7 +1938,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
     if (glwidth == 0)
     {
         // No mip data smaller than current discard level
-        return FALSE;
+        return false;
     }
 
     S32 width = getWidth(discard_level);
@@ -1942,14 +1946,14 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
     S32 ncomponents = getComponents();
     if (ncomponents == 0)
     {
-        return FALSE;
+        return false;
     }
     if(width < glwidth)
     {
         LL_WARNS() << "texture size is smaller than it should be." << LL_ENDL ;
         LL_WARNS() << "width: " << width << " glwidth: " << glwidth << " mWidth: " << mWidth <<
             " mCurrentDiscardLevel: " << (S32)mCurrentDiscardLevel << " discard_level: " << (S32)discard_level << LL_ENDL ;
-        return FALSE ;
+        return false ;
     }
 
     if (width <= 0 || width > 2048 || height <= 0 || height > 2048 || ncomponents < 1 || ncomponents > 4)
@@ -1971,6 +1975,8 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
     }
     //-----------------------------------------------------------------------------------------------
 
+    LLImageDataLock lock(imageraw);
+
 #if GL_VERSION_1_3
     if (is_compressed)
     {
@@ -1980,7 +1986,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
         {
             LL_WARNS() << "Memory allocation failed for reading back texture. Size is: " << glbytes << LL_ENDL ;
             LL_WARNS() << "width: " << width << "height: " << height << "components: " << ncomponents << LL_ENDL ;
-            return FALSE ;
+            return false ;
         }
 
         glGetCompressedTexImage(mTarget, gl_discard, (GLvoid*)(imageraw->getData()));
@@ -1992,7 +1998,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
         {
             LL_WARNS() << "Memory allocation failed for reading back texture." << LL_ENDL ;
             LL_WARNS() << "width: " << width << "height: " << height << "components: " << ncomponents << LL_ENDL ;
-            return FALSE ;
+            return false ;
         }
 
         glGetTexImage(GL_TEXTURE_2D, gl_discard, mFormatPrimary, mFormatType, (GLvoid*)(imageraw->getData()));
@@ -2011,11 +2017,11 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
             LL_WARNS() << "GL Error happens after reading back texture. Error code: " << error << LL_ENDL ;
         }
 
-        return FALSE ;
+        return false ;
     }
     //-----------------------------------------------------------------------------------------------
 
-    return TRUE ;
+    return true ;
 }
 
 void LLImageGL::destroyGLTexture()
@@ -2032,7 +2038,7 @@ void LLImageGL::destroyGLTexture()
         LLImageGL::deleteTextures(1, &mTexName);
         mCurrentDiscardLevel = -1 ; //invalidate mCurrentDiscardLevel.
         mTexName = 0;
-        mGLTextureCreated = FALSE ;
+        mGLTextureCreated = false ;
     }
 }
 
@@ -2083,7 +2089,7 @@ void LLImageGL::setFilteringOption(LLTexUnit::eTextureFilterOptions option)
     }
 }
 
-BOOL LLImageGL::getIsResident(BOOL test_now)
+bool LLImageGL::getIsResident(bool test_now)
 {
     if (test_now)
     {
@@ -2095,7 +2101,7 @@ BOOL LLImageGL::getIsResident(BOOL test_now)
         else
 #endif
         {
-            mIsResident = FALSE;
+            mIsResident = false;
         }
     }
 
@@ -2158,17 +2164,17 @@ S64 LLImageGL::getMipBytes(S32 discard_level) const
     return res;
 }
 
-BOOL LLImageGL::isJustBound() const
+bool LLImageGL::isJustBound() const
 {
-    return (BOOL)(sLastFrameTime - mLastBindTime < 0.5f);
+    return sLastFrameTime - mLastBindTime < 0.5f;
 }
 
-BOOL LLImageGL::getBoundRecently() const
+bool LLImageGL::getBoundRecently() const
 {
-    return (BOOL)(sLastFrameTime - mLastBindTime < MIN_TEXTURE_LIFETIME);
+    return (bool)(sLastFrameTime - mLastBindTime < MIN_TEXTURE_LIFETIME);
 }
 
-BOOL LLImageGL::getIsAlphaMask() const
+bool LLImageGL::getIsAlphaMask() const
 {
     llassert_always(!sSkipAnalyzeAlpha);
     return mIsMask;
@@ -2181,7 +2187,7 @@ void LLImageGL::setTarget(const LLGLenum target, const LLTexUnit::eTextureType b
 }
 
 const S8 INVALID_OFFSET = -99 ;
-void LLImageGL::setNeedsAlphaAndPickMask(BOOL need_mask)
+void LLImageGL::setNeedsAlphaAndPickMask(bool need_mask)
 {
     if(mNeedsAlphaAndPickMask != need_mask)
     {
@@ -2194,7 +2200,7 @@ void LLImageGL::setNeedsAlphaAndPickMask(BOOL need_mask)
         else //do not need alpha mask
         {
             mAlphaOffset = INVALID_OFFSET ;
-            mIsMask = FALSE;
+            mIsMask = false;
         }
     }
 }
@@ -2219,8 +2225,8 @@ void LLImageGL::calcAlphaChannelOffsetAndStride()
     case GL_RED:
     case GL_RGB:
     case GL_SRGB:
-        mNeedsAlphaAndPickMask = FALSE;
-        mIsMask = FALSE;
+        mNeedsAlphaAndPickMask = false;
+        mIsMask = false;
         return; //no alpha channel.
     case GL_RGBA:
 #if GL_VERSION_2_1
@@ -2277,8 +2283,8 @@ void LLImageGL::calcAlphaChannelOffsetAndStride()
     {
         LL_WARNS() << "Cannot analyze alpha for image with format type " << std::hex << mFormatType << std::dec << LL_ENDL;
 
-        mNeedsAlphaAndPickMask = FALSE ;
-        mIsMask = FALSE;
+        mNeedsAlphaAndPickMask = false ;
+        mIsMask = false;
     }
 }
 
@@ -2375,11 +2381,11 @@ void LLImageGL::analyzeAlpha(const void* data_in, U32 w, U32 h)
         (lowerhalftotal == length && alphatotal != 0) || // all close to transparent but not all totally transparent, or
         (upperhalftotal == length && alphatotal != 255*length)) // all close to opaque but not all totally opaque
     {
-        mIsMask = FALSE; // not suitable for masking
+        mIsMask = false; // not suitable for masking
     }
     else
     {
-        mIsMask = TRUE;
+        mIsMask = true;
     }
 }
 
@@ -2485,9 +2491,9 @@ void LLImageGL::updatePickMask(S32 width, S32 height, const U8* data_in)
     }
 }
 
-BOOL LLImageGL::getMask(const LLVector2 &tc)
+bool LLImageGL::getMask(const LLVector2 &tc)
 {
-    BOOL res = TRUE;
+    bool res = true;
 
     if (mPickMask)
     {
@@ -2531,13 +2537,13 @@ BOOL LLImageGL::getMask(const LLVector2 &tc)
         S32 idx = y*mPickMaskWidth+x;
         S32 offset = idx%8;
 
-        res = mPickMask[idx/8] & (1 << offset) ? TRUE : FALSE;
+        res = (mPickMask[idx/8] & (1 << offset)) != 0;
     }
 
     return res;
 }
 
-void LLImageGL::setCurTexSizebar(S32 index, BOOL set_pick_size)
+void LLImageGL::setCurTexSizebar(S32 index, bool set_pick_size)
 {
     sCurTexSizeBar = index ;
 
diff --git a/indra/llrender/llimagegl.h b/indra/llrender/llimagegl.h
index 89e35d2226..5c7a5ce821 100644
--- a/indra/llrender/llimagegl.h
+++ b/indra/llrender/llimagegl.h
@@ -47,6 +47,14 @@ class LLWindow;
 #define BYTES_TO_MEGA_BYTES(x) ((x) >> 20)
 #define MEGA_BYTES_TO_BYTES(x) ((x) << 20)
 
+namespace LLImageGLMemory
+{
+    void alloc_tex_image(U32 width, U32 height, U32 pixformat);
+    void free_tex_image(U32 texName);
+    void free_tex_images(U32 count, const U32* texNames);
+    void free_cur_tex_image();
+}
+
 //============================================================================
 class LLImageGL : public LLRefCount
 {
@@ -68,7 +76,7 @@ public:
     static S64 dataFormatBytes(S32 dataformat, S32 width, S32 height);
     static S32 dataFormatComponents(S32 dataformat);
 
-    BOOL updateBindStats() const ;
+    bool updateBindStats() const ;
     F32 getTimePassedSinceLastBound();
     void forceUpdateBindStats(void) const;
 
@@ -76,7 +84,7 @@ public:
     static void updateStats(F32 current_time);
 
     // Save off / restore GL textures
-    static void destroyGL(BOOL save_state = TRUE);
+    static void destroyGL(bool save_state = true);
     static void restoreGL();
     static void dirtyTexOptions();
 
@@ -85,14 +93,14 @@ public:
     //for server side use only.
     // Not currently necessary for LLImageGL, but required in some derived classes,
     // so include for compatability
-    static BOOL create(LLPointer<LLImageGL>& dest, BOOL usemipmaps = TRUE);
-    static BOOL create(LLPointer<LLImageGL>& dest, U32 width, U32 height, U8 components, BOOL usemipmaps = TRUE);
-    static BOOL create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, BOOL usemipmaps = TRUE);
+    static bool create(LLPointer<LLImageGL>& dest, bool usemipmaps = true);
+    static bool create(LLPointer<LLImageGL>& dest, U32 width, U32 height, U8 components, bool usemipmaps = true);
+    static bool create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, bool usemipmaps = true);
 
 public:
-    LLImageGL(BOOL usemipmaps = TRUE);
-    LLImageGL(U32 width, U32 height, U8 components, BOOL usemipmaps = TRUE);
-    LLImageGL(const LLImageRaw* imageraw, BOOL usemipmaps = TRUE);
+    LLImageGL(bool usemipmaps = true);
+    LLImageGL(U32 width, U32 height, U8 components, bool usemipmaps = true);
+    LLImageGL(const LLImageRaw* imageraw, bool usemipmaps = true);
 
     // For wrapping textures created via GL elsewhere with our API only. Use with caution.
     LLImageGL(LLGLuint mTexName, U32 components, LLGLenum target, LLGLint  formatInternal, LLGLenum formatPrimary, LLGLenum formatType, LLTexUnit::eTextureAddressMode addressMode);
@@ -112,29 +120,29 @@ public:
 
     static void setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels, bool allow_compression = true);
 
-    BOOL createGLTexture() ;
-    BOOL createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0, BOOL to_create = TRUE,
+    bool createGLTexture() ;
+    bool createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0, bool to_create = true,
         S32 category = sMaxCategories-1, bool defer_copy = false, LLGLuint* tex_name = nullptr);
-    BOOL createGLTexture(S32 discard_level, const U8* data, BOOL data_hasmips = FALSE, S32 usename = 0, bool defer_copy = false, LLGLuint* tex_name = nullptr);
+    bool createGLTexture(S32 discard_level, const U8* data, bool data_hasmips = false, S32 usename = 0, bool defer_copy = false, LLGLuint* tex_name = nullptr);
     void setImage(const LLImageRaw* imageraw);
-    BOOL setImage(const U8* data_in, BOOL data_hasmips = FALSE, S32 usename = 0);
+    bool setImage(const U8* data_in, bool data_hasmips = false, S32 usename = 0);
     // *TODO: This function may not work if the textures is compressed (i.e.
     // RenderCompressTextures is 0). Partial image updates do not work on
     // compressed textures.
-    BOOL setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update = FALSE, LLGLuint use_name = 0);
-    BOOL setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update = FALSE, LLGLuint use_name = 0);
-    BOOL setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height);
+    bool setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, bool force_fast_update = false, LLGLuint use_name = 0);
+    bool setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, bool force_fast_update = false, LLGLuint use_name = 0);
+    bool setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height);
 
     // wait for gl commands to finish on current thread and push
     // a lambda to main thread to swap mNewTexName and mTexName
     void syncToMainThread(LLGLuint new_tex_name);
 
     // Read back a raw image for this discard level, if it exists
-    BOOL readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok) const;
+    bool readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok) const;
     void destroyGLTexture();
     void forceToInvalidateGLTexture();
 
-    void setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, BOOL swap_bytes = FALSE);
+    void setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, bool swap_bytes = false);
     void setComponents(S8 ncomponents) { mComponents = ncomponents; }
 
     S32  getDiscardLevel() const        { return mCurrentDiscardLevel; }
@@ -147,18 +155,18 @@ public:
     U8   getComponents() const { return mComponents; }
     S64  getBytes(S32 discard_level = -1) const;
     S64  getMipBytes(S32 discard_level = -1) const;
-    BOOL getBoundRecently() const;
-    BOOL isJustBound() const;
-    BOOL getHasExplicitFormat() const { return mHasExplicitFormat; }
+    bool getBoundRecently() const;
+    bool isJustBound() const;
+    bool getHasExplicitFormat() const { return mHasExplicitFormat; }
     LLGLenum getPrimaryFormat() const { return mFormatPrimary; }
     LLGLenum getFormatType() const { return mFormatType; }
 
-    BOOL getHasGLTexture() const { return mTexName != 0; }
+    bool getHasGLTexture() const { return mTexName != 0; }
     LLGLuint getTexName() const { return mTexName; }
 
-    BOOL getIsAlphaMask() const;
+    bool getIsAlphaMask() const;
 
-    BOOL getIsResident(BOOL test_now = FALSE); // not const
+    bool getIsResident(bool test_now = false); // not const
 
     void setTarget(const LLGLenum target, const LLTexUnit::eTextureType bind_target);
 
@@ -166,11 +174,11 @@ public:
     bool isGLTextureCreated(void) const { return mGLTextureCreated ; }
     void setGLTextureCreated (bool initialized) { mGLTextureCreated = initialized; }
 
-    BOOL getUseMipMaps() const { return mUseMipMaps; }
-    void setUseMipMaps(BOOL usemips) { mUseMipMaps = usemips; }
-    void setHasMipMaps(BOOL hasmips) { mHasMipMaps = hasmips; }
+    bool getUseMipMaps() const { return mUseMipMaps; }
+    void setUseMipMaps(bool usemips) { mUseMipMaps = usemips; }
+    void setHasMipMaps(bool hasmips) { mHasMipMaps = hasmips; }
     void updatePickMask(S32 width, S32 height, const U8* data_in);
-    BOOL getMask(const LLVector2 &tc);
+    bool getMask(const LLVector2 &tc);
 
     void checkTexSize(bool forced = false) const ;
 
@@ -192,12 +200,12 @@ public:
     U32      getTexelsInGLTexture()const {return mTexelsInGLTexture;}
 
 
-    void init(BOOL usemipmaps);
+    void init(bool usemipmaps);
     virtual void cleanup(); // Clean up the LLImageGL so it can be reinitialized.  Be careful when using this in derived class destructors
 
-    void setNeedsAlphaAndPickMask(BOOL need_mask);
+    void setNeedsAlphaAndPickMask(bool need_mask);
 
-    BOOL preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image);
+    bool preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image);
     void postAddToAtlas() ;
 
 #if LL_IMAGEGL_THREAD_CHECK
@@ -222,11 +230,11 @@ private:
     U16 mPickMaskWidth;
     U16 mPickMaskHeight;
     S8 mUseMipMaps;
-    BOOL mHasExplicitFormat; // If false (default), GL format is f(mComponents)
+    bool mHasExplicitFormat; // If false (default), GL format is f(mComponents)
     bool mAutoGenMips = false;
 
-    BOOL mIsMask;
-    BOOL mNeedsAlphaAndPickMask;
+    bool mIsMask;
+    bool mNeedsAlphaAndPickMask;
     S8   mAlphaStride ;
     S8   mAlphaOffset ;
 
@@ -261,9 +269,9 @@ protected:
     LLGLint  mFormatInternal; // = GL internalformat
     LLGLenum mFormatPrimary;  // = GL format (pixel data format)
     LLGLenum mFormatType;
-    BOOL     mFormatSwapBytes;// if true, use glPixelStorei(GL_UNPACK_SWAP_BYTES, 1)
+    bool     mFormatSwapBytes;// if true, use glPixelStorei(GL_UNPACK_SWAP_BYTES, 1)
 
-    BOOL mExternalTexture;
+    bool mExternalTexture;
 
     // STATICS
 public:
@@ -275,28 +283,28 @@ public:
     // Global memory statistics
     static U32 sBindCount;                  // Tracks number of texture binds for current frame
     static U32 sUniqueCount;                // Tracks number of unique texture binds for current frame
-    static BOOL sGlobalUseAnisotropic;
+    static bool sGlobalUseAnisotropic;
     static LLImageGL* sDefaultGLTexture ;
-    static BOOL sAutomatedTest;
+    static bool sAutomatedTest;
     static bool sCompressTextures;          //use GL texture compression
 #if DEBUG_MISS
-    BOOL mMissed; // Missed on last bind?
-    BOOL getMissed() const { return mMissed; };
+    bool mMissed; // Missed on last bind?
+    bool getMissed() const { return mMissed; };
 #else
-    BOOL getMissed() const { return FALSE; };
+    bool getMissed() const { return false; };
 #endif
 
 public:
-    static void initClass(LLWindow* window, S32 num_catagories, BOOL skip_analyze_alpha = false, bool thread_texture_loads = false, bool thread_media_updates = false);
+    static void initClass(LLWindow* window, S32 num_catagories, bool skip_analyze_alpha = false, bool thread_texture_loads = false, bool thread_media_updates = false);
     static void cleanupClass() ;
 
 private:
     static S32 sMaxCategories;
-    static BOOL sSkipAnalyzeAlpha;
+    static bool sSkipAnalyzeAlpha;
 
     //the flag to allow to call readBackRaw(...).
     //can be removed if we do not use that function at all.
-    static BOOL sAllowReadBackRaw ;
+    static bool sAllowReadBackRaw ;
 //
 //****************************************************************************************************
 //The below for texture auditing use only
@@ -317,7 +325,7 @@ public:
     static S32 sCurTexSizeBar ;
     static S32 sCurTexPickSize ;
 
-    static void setCurTexSizebar(S32 index, BOOL set_pick_size = TRUE) ;
+    static void setCurTexSizebar(S32 index, bool set_pick_size = true) ;
     static void resetCurTexSizebar();
 
 //****************************************************************************************************
diff --git a/indra/llrender/llpostprocess.cpp b/indra/llrender/llpostprocess.cpp
index aa092e5215..29ec1408d5 100644
--- a/indra/llrender/llpostprocess.cpp
+++ b/indra/llrender/llpostprocess.cpp
@@ -165,7 +165,7 @@ void LLPostProcess::invalidate()
     mSceneRenderTexture = NULL ;
     mNoiseTexture = NULL ;
     mTempBloomTexture = NULL ;
-    initialized = FALSE ;
+    initialized = false ;
 }
 
 void LLPostProcess::apply(unsigned int width, unsigned int height)
@@ -373,7 +373,7 @@ void LLPostProcess::createTexture(LLPointer<LLImageGL>& texture, unsigned int wi
 {
     std::vector<GLubyte> data(width * height * 4, 0) ;
 
-    texture = new LLImageGL(FALSE) ;
+    texture = new LLImageGL(false) ;
     if(texture->createGLTexture())
     {
         gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture->getTexName());
@@ -395,7 +395,7 @@ void LLPostProcess::createNoiseTexture(LLPointer<LLImageGL>& texture)
         }
     }
 
-    texture = new LLImageGL(FALSE) ;
+    texture = new LLImageGL(false) ;
     if(texture->createGLTexture())
     {
         gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture->getTexName());
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index 0a522c88d7..1037fbbfe3 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -1008,6 +1008,9 @@ void LLRender::syncLightState()
 
 void LLRender::syncMatrices()
 {
+    STOP_GLERROR;
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_DISPLAY;
+
     static const U32 name[] =
     {
         LLShaderMgr::MODELVIEW_MATRIX,
@@ -1030,8 +1033,6 @@ void LLRender::syncMatrices()
 
     if (shader)
     {
-        //llassert(shader);
-
         bool mvp_done = false;
 
         U32 i = MM_MODELVIEW;
@@ -1105,7 +1106,7 @@ void LLRender::syncMatrices()
             if (shader->getUniformLocation(LLShaderMgr::INVERSE_PROJECTION_MATRIX))
             {
                 glh::matrix4f inv_proj = mat.inverse();
-                shader->uniformMatrix4fv(LLShaderMgr::INVERSE_PROJECTION_MATRIX, 1, FALSE, inv_proj.m);
+                shader->uniformMatrix4fv(LLShaderMgr::INVERSE_PROJECTION_MATRIX, 1, false, inv_proj.m);
             }
 
             // Used by some full screen effects - such as full screen lights, glow, etc.
@@ -1152,6 +1153,7 @@ void LLRender::syncMatrices()
             syncLightState();
         }
     }
+    STOP_GLERROR;
 }
 
 void LLRender::translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
@@ -1602,6 +1604,7 @@ void LLRender::end()
 }
 void LLRender::flush()
 {
+    STOP_GLERROR;
     if (mCount > 0)
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
diff --git a/indra/llrender/llrender.h b/indra/llrender/llrender.h
index 1eace546a2..5852201c94 100644
--- a/indra/llrender/llrender.h
+++ b/indra/llrender/llrender.h
@@ -555,6 +555,5 @@ glh::matrix4f gl_perspective(GLfloat fovy, GLfloat aspect, GLfloat zNear, GLfloa
 glh::matrix4f gl_lookat(LLVector3 eye, LLVector3 center, LLVector3 up);
 
 #define LL_SHADER_LOADING_WARNS(...) LL_WARNS()
-#define LL_SHADER_UNIFORM_ERRS(...)  LL_ERRS("Shader")
 
 #endif
diff --git a/indra/llrender/llrender2dutils.cpp b/indra/llrender/llrender2dutils.cpp
index c04b571798..97e9875afb 100644
--- a/indra/llrender/llrender2dutils.cpp
+++ b/indra/llrender/llrender2dutils.cpp
@@ -51,11 +51,11 @@ const LLColor4 UI_VERTEX_COLOR(1.f, 1.f, 1.f, 1.f);
 // Functions
 //
 
-BOOL ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom)
+bool ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom)
 {
-    if (x < left || right < x) return FALSE;
-    if (y < bottom || top < y) return FALSE;
-    return TRUE;
+    if (x < left || right < x) return false;
+    if (y < bottom || top < y) return false;
+    return true;
 }
 
 
@@ -91,13 +91,13 @@ void gl_draw_x(const LLRect& rect, const LLColor4& color)
 }
 
 
-void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset, BOOL filled)
+void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset, bool filled)
 {
     gGL.color4fv(color.mV);
     gl_rect_2d_offset_local(left, top, right, bottom, pixel_offset, filled);
 }
 
-void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset, BOOL filled)
+void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset, bool filled)
 {
     gGL.pushUIMatrix();
     left += LLFontGL::sCurOrigin.mX;
@@ -115,7 +115,7 @@ void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixe
 }
 
 
-void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, BOOL filled )
+void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, bool filled )
 {
     gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 
@@ -147,14 +147,14 @@ void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, BOOL filled )
     }
 }
 
-void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, BOOL filled )
+void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, bool filled )
 {
     gGL.color4fv( color.mV );
     gl_rect_2d( left, top, right, bottom, filled );
 }
 
 
-void gl_rect_2d( const LLRect& rect, const LLColor4& color, BOOL filled )
+void gl_rect_2d( const LLRect& rect, const LLColor4& color, bool filled )
 {
     gGL.color4fv( color.mV );
     gl_rect_2d( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, filled );
@@ -269,7 +269,7 @@ void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2, const LLColor4 &color )
     gGL.end();
 }
 
-void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, BOOL filled)
+void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, bool filled)
 {
     gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 
@@ -348,7 +348,7 @@ void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLTexture* image,
     gl_draw_scaled_rotated_image( x, y, width, height, 0.f, image, color, uv_rect );
 }
 
-void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4& color, BOOL solid_color, const LLRectf& uv_rect, bool scale_inner)
+void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4& color, bool solid_color, const LLRectf& uv_rect, bool scale_inner)
 {
     if (NULL == image)
     {
@@ -364,7 +364,7 @@ void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border
     gl_draw_scaled_image_with_border(x, y, width, height, image, color, solid_color, uv_rect, scale_rect, scale_inner);
 }
 
-void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color, BOOL solid_color, const LLRectf& uv_outer_rect, const LLRectf& center_rect, bool scale_inner)
+void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color, bool solid_color, const LLRectf& uv_outer_rect, const LLRectf& center_rect, bool scale_inner)
 {
     stop_glerror();
 
@@ -841,7 +841,7 @@ void gl_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& c
     LLRender2D::getInstance()->setLineWidth(1.f);
 }
 
-void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F32 start_angle, F32 end_angle)
+void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, bool filled, F32 start_angle, F32 end_angle)
 {
     if (end_angle < start_angle)
     {
@@ -884,7 +884,7 @@ void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F
     gGL.popUIMatrix();
 }
 
-void gl_circle_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled)
+void gl_circle_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, bool filled)
 {
     gGL.pushUIMatrix();
     {
@@ -945,7 +945,7 @@ void gl_deep_circle( F32 radius, F32 depth, S32 steps )
     gGL.end();
 }
 
-void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, BOOL render_center )
+void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, bool render_center )
 {
     gGL.pushUIMatrix();
     {
diff --git a/indra/llrender/llrender2dutils.h b/indra/llrender/llrender2dutils.h
index c3c6d66b8e..0d3efc38d6 100644
--- a/indra/llrender/llrender2dutils.h
+++ b/indra/llrender/llrender2dutils.h
@@ -43,30 +43,30 @@ class LLUUID;
 
 extern const LLColor4 UI_VERTEX_COLOR;
 
-BOOL ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom);
+bool ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom);
 void gl_state_for_2d(S32 width, S32 height);
 
 void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2);
 void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2, const LLColor4 &color );
-void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, BOOL filled);
+void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, bool filled);
 void gl_rect_2d_simple( S32 width, S32 height );
 
 void gl_draw_x(const LLRect& rect, const LLColor4& color);
 
-void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, BOOL filled = TRUE );
-void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, BOOL filled = TRUE );
-void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset = 0, BOOL filled = TRUE );
-void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset = 0, BOOL filled = TRUE );
-void gl_rect_2d(const LLRect& rect, BOOL filled = TRUE );
-void gl_rect_2d(const LLRect& rect, const LLColor4& color, BOOL filled = TRUE );
+void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, bool filled = true );
+void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, bool filled = true );
+void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset = 0, bool filled = true );
+void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset = 0, bool filled = true );
+void gl_rect_2d(const LLRect& rect, bool filled = true );
+void gl_rect_2d(const LLRect& rect, const LLColor4& color, bool filled = true );
 void gl_rect_2d_checkerboard(const LLRect& rect, GLfloat alpha = 1.0f);
 
 void gl_drop_shadow(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &start_color, S32 lines);
 
-void gl_circle_2d(F32 x, F32 y, F32 radius, S32 steps, BOOL filled);
-void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F32 start_angle, F32 end_angle);
+void gl_circle_2d(F32 x, F32 y, F32 radius, S32 steps, bool filled);
+void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, bool filled, F32 start_angle, F32 end_angle);
 void gl_deep_circle( F32 radius, F32 depth );
-void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, BOOL render_center );
+void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, bool render_center );
 void gl_corners_2d(S32 left, S32 top, S32 right, S32 bottom, S32 length, F32 max_frac);
 void gl_washer_2d(F32 outer_radius, F32 inner_radius, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color);
 void gl_washer_segment_2d(F32 outer_radius, F32 inner_radius, F32 start_radians, F32 end_radians, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color);
@@ -76,8 +76,8 @@ void gl_draw_scaled_target(S32 x, S32 y, S32 width, S32 height, LLRenderTarget*
 void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
 void gl_draw_rotated_image(S32 x, S32 y, F32 degrees, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
 void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degrees, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), LLRenderTarget* target = NULL);
-void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), bool scale_inner = true);
-void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), const LLRectf& scale_rect = LLRectf(0.f, 1.f, 1.f, 0.f), bool scale_inner = true);
+void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4 &color, bool solid_color = false, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), bool scale_inner = true);
+void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4 &color, bool solid_color = false, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), const LLRectf& scale_rect = LLRectf(0.f, 1.f, 1.f, 0.f), bool scale_inner = true);
 
 void gl_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& color);
 
@@ -110,12 +110,12 @@ void gl_segmented_rect_2d_tex(const S32 left, const S32 top, const S32 right, co
 void gl_segmented_rect_2d_fragment_tex(const LLRect& rect, const S32 texture_width, const S32 texture_height, const S32 border_size, const F32 start_fragment, const F32 end_fragment, const U32 edges = ROUNDED_RECT_ALL);
 void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv_rect, const LLRectf& center_draw_rect, const LLVector3& width_vec, const LLVector3& height_vec);
 
-inline void gl_rect_2d( const LLRect& rect, BOOL filled )
+inline void gl_rect_2d( const LLRect& rect, bool filled )
 {
     gl_rect_2d( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, filled );
 }
 
-inline void gl_rect_2d_offset_local( const LLRect& rect, S32 pixel_offset, BOOL filled)
+inline void gl_rect_2d_offset_local( const LLRect& rect, S32 pixel_offset, bool filled)
 {
     gl_rect_2d_offset_local( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, pixel_offset, filled );
 }
diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp
index aa5bcd0864..dcc81a8874 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);
@@ -208,7 +208,7 @@ bool LLRenderTarget::addColorAttachment(U32 color_fmt)
         return true;
     }
 
-    U32 offset = mTex.size();
+    U32 offset = static_cast<U32>(mTex.size());
 
     if( offset >= 4 )
     {
@@ -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;
@@ -378,11 +378,11 @@ void LLRenderTarget::release()
     if (mFBO && (mTex.size() > 1))
     {
         glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-        S32 z;
+        size_t z;
         for (z = mTex.size() - 1; z >= 1; z--)
         {
             sBytesAllocated -= mResX*mResY*4;
-            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+z, LLTexUnit::getInternalType(mUsage), 0, 0);
+            glFramebufferTexture2D(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0+z), LLTexUnit::getInternalType(mUsage), 0, 0);
             LLImageGL::deleteTextures(1, &mTex[z]);
         }
         glBindFramebuffer(GL_FRAMEBUFFER, sCurFBO);
@@ -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;
 
@@ -426,8 +426,8 @@ void LLRenderTarget::bindTarget()
                             GL_COLOR_ATTACHMENT1,
                             GL_COLOR_ATTACHMENT2,
                             GL_COLOR_ATTACHMENT3};
-    glDrawBuffers(mTex.size(), drawbuffers);
-            
+    glDrawBuffers(static_cast<GLsizei>(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)
     {
@@ -486,7 +486,7 @@ U32 LLRenderTarget::getTexture(U32 attachment) const
 
 U32 LLRenderTarget::getNumTextures() const
 {
-    return mTex.size();
+    return static_cast<U32>(mTex.size());
 }
 
 void LLRenderTarget::bindTexture(U32 index, S32 channel, LLTexUnit::eTextureFilterOptions filter_options)
@@ -548,7 +548,7 @@ void LLRenderTarget::flush()
 
 bool LLRenderTarget::isComplete() const
 {
-    return (!mTex.empty() || mDepth) ? true : false;
+    return !mTex.empty() || mDepth;
 }
 
 void LLRenderTarget::getViewport(S32* viewport)
@@ -563,7 +563,7 @@ bool LLRenderTarget::isBoundInStack() const
 {
     LLRenderTarget* cur = sBoundTarget;
     while (cur && cur != this)
-    { 
+    {
         cur = cur->mPreviousRT;
     }
 
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 0f3716bc18..a8e9f20b40 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -66,14 +66,14 @@ LLShaderMgr * LLShaderMgr::instance()
     return sInstance;
 }
 
-BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
+bool LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 {
     llassert_always(shader != NULL);
     LLShaderFeatures *features = & shader->mFeatures;
 
     if (features->attachNothing)
     {
-        return TRUE;
+        return true;
     }
     //////////////////////////////////////
     // Attach Vertex Shader Features First
@@ -84,7 +84,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachVertexObject("windlight/atmosphericsVarsV.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -92,7 +92,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachVertexObject("windlight/atmosphericsHelpersV.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -102,40 +102,40 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
         {
             if (!shader->attachVertexObject("lighting/lightFuncSpecularV.glsl"))
             {
-                return FALSE;
+                return false;
             }
 
             if (!features->isAlphaLighting)
             {
                 if (!shader->attachVertexObject("lighting/sumLightsSpecularV.glsl"))
                 {
-                    return FALSE;
+                    return false;
                 }
             }
 
             if (!shader->attachVertexObject("lighting/lightSpecularV.glsl"))
             {
-                return FALSE;
+                return false;
             }
         }
         else
         {
             if (!shader->attachVertexObject("lighting/lightFuncV.glsl"))
             {
-                return FALSE;
+                return false;
             }
 
             if (!features->isAlphaLighting)
             {
                 if (!shader->attachVertexObject("lighting/sumLightsV.glsl"))
                 {
-                    return FALSE;
+                    return false;
                 }
             }
 
             if (!shader->attachVertexObject("lighting/lightV.glsl"))
             {
-                return FALSE;
+                return false;
             }
         }
     }
@@ -145,16 +145,16 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachVertexObject("environment/srgbF.glsl")) // NOTE -- "F" suffix is superfluous here, there is nothing fragment specific in srgbF
         {
-            return FALSE;
+            return false;
         }
 
         if (!shader->attachVertexObject("windlight/atmosphericsFuncs.glsl")) {
-            return FALSE;
+            return false;
         }
 
         if (!shader->attachVertexObject("windlight/atmosphericsV.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -162,7 +162,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachVertexObject("avatar/avatarSkinV.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -171,13 +171,13 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
         shader->mRiggedVariant = shader;
         if (!shader->attachVertexObject("avatar/objectSkinV.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
     if (!shader->attachVertexObject("deferred/textureUtilV.glsl"))
     {
-        return FALSE;
+        return false;
     }
 
     ///////////////////////////////////////
@@ -188,14 +188,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
     if (!shader->attachFragmentObject("deferred/globalF.glsl"))
     {
-        return FALSE;
+        return false;
     }
 
     if (features->hasSrgb || features->hasAtmospherics || features->calculatesAtmospherics || features->isDeferred)
     {
         if (!shader->attachFragmentObject("environment/srgbF.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -203,7 +203,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("windlight/atmosphericsVarsF.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -211,7 +211,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("windlight/atmosphericsHelpersF.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -220,7 +220,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("deferred/deferredUtil.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -228,7 +228,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("deferred/screenSpaceReflUtil.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -236,7 +236,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("deferred/shadowUtil.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -244,7 +244,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("deferred/reflectionProbeF.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -252,7 +252,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("deferred/aoUtil.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -260,19 +260,19 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("windlight/gammaF.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
     if (features->hasAtmospherics || features->isDeferred)
     {
         if (!shader->attachFragmentObject("windlight/atmosphericsFuncs.glsl")) {
-            return FALSE;
+            return false;
         }
 
         if (!shader->attachFragmentObject("windlight/atmosphericsF.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -280,7 +280,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("deferred/pbrterrainUtilF.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
@@ -289,26 +289,26 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachFragmentObject("environment/waterFogF.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
     if (features->hasLighting)
     {
-        if (features->disableTextureIndex)
+        if (features->mIndexedTextureChannels <= 1)
         {
             if (features->hasAlphaMask)
             {
                 if (!shader->attachFragmentObject("lighting/lightAlphaMaskNonIndexedF.glsl"))
                 {
-                    return FALSE;
+                    return false;
                 }
             }
             else
             {
                 if (!shader->attachFragmentObject("lighting/lightNonIndexedF.glsl"))
                 {
-                    return FALSE;
+                    return false;
                 }
             }
         }
@@ -318,14 +318,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
             {
                 if (!shader->attachFragmentObject("lighting/lightAlphaMaskF.glsl"))
                 {
-                    return FALSE;
+                    return false;
                 }
             }
             else
             {
                 if (!shader->attachFragmentObject("lighting/lightF.glsl"))
                 {
-                    return FALSE;
+                    return false;
                 }
             }
             shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels, 1);
@@ -336,18 +336,18 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     {
         if (!shader->attachVertexObject("objects/nonindexedTextureV.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
     else
     {
         if (!shader->attachVertexObject("objects/indexedTextureV.glsl"))
         {
-            return FALSE;
+            return false;
         }
     }
 
-    return TRUE;
+    return true;
 }
 
 //============================================================================
@@ -421,7 +421,7 @@ void LLShaderMgr::dumpShaderSource(U32 shader_code_count, GLchar** shader_code_t
     LL_CONT << LL_ENDL;
 }
 
-void LLShaderMgr::dumpObjectLog(GLuint ret, BOOL warns, const std::string& filename)
+void LLShaderMgr::dumpObjectLog(GLuint ret, bool warns, const std::string& filename)
 {
     std::string log;
     log = get_object_log(ret);
@@ -689,7 +689,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
         {  //switches are supported in GLSL 1.30 and later
             if (gGLManager.mIsNVIDIA)
             { //switches are unreliable on some NVIDIA drivers
-                for (U32 i = 0; i < texture_index_channels; ++i)
+                for (S32 i = 0; i < texture_index_channels; ++i)
                 {
                     std::string if_string = llformat("\t%sif (vary_texture_index == %d) { return texture(tex%d, texcoord); }\n", i > 0 ? "else " : "", i, i);
                     extra_code_text[extra_code_count++] = strdup(if_string.c_str());
@@ -877,7 +877,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
         {
             //an error occured, print log
             LL_WARNS("ShaderLoading") << "GLSL Compilation Error:" << LL_ENDL;
-            dumpObjectLog(ret, TRUE, open_file_name);
+            dumpObjectLog(ret, true, open_file_name);
             dumpShaderSource(shader_code_count, shader_code_text);
             glDeleteShader(ret); //no longer need handle
             ret = 0;
@@ -919,7 +919,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev
     return ret;
 }
 
-BOOL LLShaderMgr::linkProgramObject(GLuint obj, BOOL suppress_errors)
+bool LLShaderMgr::linkProgramObject(GLuint obj, bool suppress_errors)
 {
     //check for errors
     {
@@ -936,7 +936,7 @@ BOOL LLShaderMgr::linkProgramObject(GLuint obj, BOOL suppress_errors)
         {
             //an error occured, print log
             LL_SHADER_LOADING_WARNS() << "GLSL Linker Error:" << LL_ENDL;
-            dumpObjectLog(obj, TRUE, "linker");
+            dumpObjectLog(obj, true, "linker");
             return success;
         }
     }
@@ -947,12 +947,12 @@ BOOL LLShaderMgr::linkProgramObject(GLuint obj, BOOL suppress_errors)
     {
         LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
         success = GL_FALSE;
-        suppress_errors = FALSE;
+        suppress_errors = false;
     }
     return success;
 }
 
-BOOL LLShaderMgr::validateProgramObject(GLuint obj)
+bool LLShaderMgr::validateProgramObject(GLuint obj)
 {
     //check program validity against current GL
     glValidateProgram(obj);
@@ -965,7 +965,7 @@ BOOL LLShaderMgr::validateProgramObject(GLuint obj)
     }
     else
     {
-        dumpObjectLog(obj, FALSE);
+        dumpObjectLog(obj, false);
     }
 
     return success;
@@ -1120,7 +1120,7 @@ bool LLShaderMgr::saveCachedProgramBinary(LLGLSLShader* shader)
         program_binary.resize(binary_info.mBinaryLength);
 
         GLenum error = glGetError(); // Clear current error
-        glGetProgramBinary(shader->mProgramObject, program_binary.size() * sizeof(U8), nullptr, &binary_info.mBinaryFormat, program_binary.data());
+        glGetProgramBinary(shader->mProgramObject, static_cast<GLsizei>(program_binary.size() * sizeof(U8)), nullptr, &binary_info.mBinaryFormat, program_binary.data());
         error = glGetError();
         if (error == GL_NO_ERROR)
         {
@@ -1157,6 +1157,7 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedAttribs.push_back("weight");
     mReservedAttribs.push_back("weight4");
     mReservedAttribs.push_back("clothing");
+    mReservedAttribs.push_back("joint");
     mReservedAttribs.push_back("texture_index");
 
     //matrix state
@@ -1177,9 +1178,19 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("texture_base_color_transform"); // (GLTF)
     mReservedUniforms.push_back("texture_normal_transform"); // (GLTF)
     mReservedUniforms.push_back("texture_metallic_roughness_transform"); // (GLTF)
+    mReservedUniforms.push_back("texture_occlusion_transform"); // (GLTF)
     mReservedUniforms.push_back("texture_emissive_transform"); // (GLTF)
+    mReservedUniforms.push_back("base_color_texcoord"); // (GLTF)
+    mReservedUniforms.push_back("emissive_texcoord"); // (GLTF)
+    mReservedUniforms.push_back("normal_texcoord"); // (GLTF)
+    mReservedUniforms.push_back("metallic_roughness_texcoord"); // (GLTF)
+    mReservedUniforms.push_back("occlusion_texcoord"); // (GLTF)
+    mReservedUniforms.push_back("gltf_node_id"); // (GLTF)
+    mReservedUniforms.push_back("gltf_material_id"); // (GLTF)
+
+    mReservedUniforms.push_back("terrain_texture_transforms"); // (GLTF)
 
-    llassert(mReservedUniforms.size() == LLShaderMgr::TEXTURE_EMISSIVE_TRANSFORM+1);
+    llassert(mReservedUniforms.size() == LLShaderMgr::TERRAIN_TEXTURE_TRANSFORMS +1);
 
     mReservedUniforms.push_back("viewport");
 
@@ -1223,6 +1234,9 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("diffuseMap");
     mReservedUniforms.push_back("altDiffuseMap");
     mReservedUniforms.push_back("specularMap");
+    mReservedUniforms.push_back("metallicRoughnessMap");
+    mReservedUniforms.push_back("normalMap");
+    mReservedUniforms.push_back("occlusionMap");
     mReservedUniforms.push_back("emissiveMap");
     mReservedUniforms.push_back("bumpMap");
     mReservedUniforms.push_back("bumpMap2");
@@ -1234,7 +1248,6 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("heroProbes");
     mReservedUniforms.push_back("cloud_noise_texture");
     mReservedUniforms.push_back("cloud_noise_texture_next");
-    mReservedUniforms.push_back("fullbright");
     mReservedUniforms.push_back("lightnorm");
     mReservedUniforms.push_back("sunlight_color");
     mReservedUniforms.push_back("ambient_color");
@@ -1346,7 +1359,6 @@ void LLShaderMgr::initAttribsAndUniforms()
 
     llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_SHADOW5+1);
 
-    mReservedUniforms.push_back("normalMap");
     mReservedUniforms.push_back("positionMap");
     mReservedUniforms.push_back("diffuseRect");
     mReservedUniforms.push_back("specularRect");
@@ -1359,7 +1371,6 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("bloomMap");
     mReservedUniforms.push_back("projectionMap");
     mReservedUniforms.push_back("norm_mat");
-    mReservedUniforms.push_back("texture_gamma");
 
     mReservedUniforms.push_back("specular_color");
     mReservedUniforms.push_back("env_intensity");
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index 8b13e822d5..fe6137c448 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -56,7 +56,17 @@ public:
         TEXTURE_BASE_COLOR_TRANSFORM,         //  "texture_base_color_transform" (GLTF)
         TEXTURE_NORMAL_TRANSFORM,             //  "texture_normal_transform" (GLTF)
         TEXTURE_METALLIC_ROUGHNESS_TRANSFORM, //  "texture_metallic_roughness_transform" (GLTF)
+        TEXTURE_OCCLUSION_TRANSFORM,          //  "texture_occlusion_transform" (GLTF)
         TEXTURE_EMISSIVE_TRANSFORM,           //  "texture_emissive_transform" (GLTF)
+        BASE_COLOR_TEXCOORD,                  //  "base_color_texcoord" (GLTF)
+        EMISSIVE_TEXCOORD,                    //  "emissive_texcoord" (GLTF)
+        NORMAL_TEXCOORD,                      //  "normal_texcoord" (GLTF)
+        METALLIC_ROUGHNESS_TEXCOORD,          //  "metallic_roughness_texcoord" (GLTF)
+        OCCLUSION_TEXCOORD,                   //  "occlusion_texcoord" (GLTF)
+        GLTF_NODE_ID,                         //  "gltf_node_id" (GLTF)
+        GLTF_MATERIAL_ID,                     //  "gltf_material_id" (GLTF)
+
+        TERRAIN_TEXTURE_TRANSFORMS,           //  "terrain_texture_transforms" (GLTF)
 
         VIEWPORT,                           //  "viewport"
         LIGHT_POSITION,                     //  "light_position"
@@ -91,6 +101,9 @@ public:
         DIFFUSE_MAP,                        //  "diffuseMap"
         ALTERNATE_DIFFUSE_MAP,              //  "altDiffuseMap"
         SPECULAR_MAP,                       //  "specularMap"
+        METALLIC_ROUGHNESS_MAP,             //  "metallicRoughnessMap"
+        NORMAL_MAP,                         //  "normalMap"
+        OCCLUSION_MAP,                      //  "occlusionMap"
         EMISSIVE_MAP,                       //  "emissiveMap"
         BUMP_MAP,                           //  "bumpMap"
         BUMP_MAP2,                          //  "bumpMap2"
@@ -102,7 +115,6 @@ public:
         HERO_PROBE,                         //  "heroProbes"
         CLOUD_NOISE_MAP,                    //  "cloud_noise_texture"
         CLOUD_NOISE_MAP_NEXT,               //  "cloud_noise_texture_next"
-        FULLBRIGHT,                         //  "fullbright"
         LIGHTNORM,                          //  "lightnorm"
         SUNLIGHT_COLOR,                     //  "sunlight_color"
         AMBIENT,                            //  "ambient_color"
@@ -200,7 +212,6 @@ public:
         DEFERRED_SHADOW3,                   //  "shadowMap3"
         DEFERRED_SHADOW4,                   //  "shadowMap4"
         DEFERRED_SHADOW5,                   //  "shadowMap5"
-        DEFERRED_NORMAL,                    //  "normalMap"
         DEFERRED_POSITION,                  //  "positionMap"
         DEFERRED_DIFFUSE,                   //  "diffuseRect"
         DEFERRED_SPECULAR,                  //  "specularRect"
@@ -213,7 +224,6 @@ public:
         DEFERRED_BLOOM,                     //  "bloomMap"
         DEFERRED_PROJECTION,                //  "projectionMap"
         DEFERRED_NORM_MATRIX,               //  "norm_mat"
-        TEXTURE_GAMMA,                      //  "texture_gamma"
         SPECULAR_COLOR,                     //  "specular_color"
         ENVIRONMENT_INTENSITY,              //  "env_intensity"
 
@@ -328,11 +338,11 @@ public:
 
     virtual void initAttribsAndUniforms(void);
 
-    BOOL attachShaderFeatures(LLGLSLShader * shader);
-    void dumpObjectLog(GLuint ret, BOOL warns = TRUE, const std::string& filename = "");
+    bool attachShaderFeatures(LLGLSLShader * shader);
+    void dumpObjectLog(GLuint ret, bool warns = true, const std::string& filename = "");
     void dumpShaderSource(U32 shader_code_count, GLchar** shader_code_text);
-    BOOL    linkProgramObject(GLuint obj, BOOL suppress_errors = FALSE);
-    BOOL    validateProgramObject(GLuint obj);
+    bool    linkProgramObject(GLuint obj, bool suppress_errors = false);
+    bool    validateProgramObject(GLuint obj);
     GLuint loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, std::map<std::string, std::string>* defines = NULL, S32 texture_index_channels = -1);
 
     // Implemented in the application to actually point to the shader directory.
diff --git a/indra/llrender/lltexturemanagerbridge.h b/indra/llrender/lltexturemanagerbridge.h
index 0b76ee4de8..e742324e4a 100644
--- a/indra/llrender/lltexturemanagerbridge.h
+++ b/indra/llrender/lltexturemanagerbridge.h
@@ -36,8 +36,8 @@ class LLTextureManagerBridge
 public:
     virtual ~LLTextureManagerBridge() {}
 
-    virtual LLPointer<LLGLTexture> getLocalTexture(BOOL usemipmaps = TRUE, BOOL generate_gl_tex = TRUE) = 0;
-    virtual LLPointer<LLGLTexture> getLocalTexture(const U32 width, const U32 height, const U8 components, BOOL usemipmaps, BOOL generate_gl_tex = TRUE) = 0;
+    virtual LLPointer<LLGLTexture> getLocalTexture(bool usemipmaps = true, bool generate_gl_tex = true) = 0;
+    virtual LLPointer<LLGLTexture> getLocalTexture(const U32 width, const U32 height, const U8 components, bool usemipmaps, bool generate_gl_tex = true) = 0;
     virtual LLGLTexture* getFetchedTexture(const LLUUID &image_id) = 0;
 };
 
diff --git a/indra/llrender/lluiimage.inl b/indra/llrender/lluiimage.inl
index a69616c0c1..dff1fcdfcc 100644
--- a/indra/llrender/lluiimage.inl
+++ b/indra/llrender/lluiimage.inl
@@ -36,7 +36,7 @@ void LLUIImage::draw(S32 x, S32 y, S32 width, S32 height, const LLColor4& color)
         width, height,
         mImage,
         color,
-        FALSE,
+        false,
         mClipRegion,
         mScaleRegion,
         mScaleStyle == SCALE_INNER);
@@ -49,7 +49,7 @@ void LLUIImage::drawSolid(S32 x, S32 y, S32 width, S32 height, const LLColor4& c
         width, height,
         mImage,
         color,
-        TRUE,
+        true,
         mClipRegion,
         mScaleRegion,
         mScaleStyle == SCALE_INNER);
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index db881efd2b..b522eb5218 100644
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -294,6 +294,62 @@ static GLuint gen_buffer()
 
 #define ANALYZE_VBO_POOL 0
 
+#if 0 // LL_DARWIN
+
+// experimental -- disable VBO pooling on OS X and use glMapBuffer
+class LLVBOPool
+{
+public:
+    U64 mAllocated = 0;
+
+    U64 getVramBytesUsed()
+    {
+        return mAllocated;
+    }
+
+    void allocate(GLenum type, U32 size, GLuint& name, U8*& data)
+    {
+        LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
+        STOP_GLERROR;
+        llassert(type == GL_ARRAY_BUFFER || type == GL_ELEMENT_ARRAY_BUFFER);
+        llassert(name == 0); // non zero name indicates a gl name that wasn't freed
+        llassert(data == nullptr);  // non null data indicates a buffer that wasn't freed
+        llassert(size >= 2);  // any buffer size smaller than a single index is nonsensical
+
+        mAllocated += size;
+
+        { //allocate a new buffer
+            LL_PROFILE_GPU_ZONE("vbo alloc");
+            // ON OS X, we don't allocate a VBO until the last possible moment
+            // in unmapBuffer
+            data = (U8*) ll_aligned_malloc_16(size);
+            STOP_GLERROR;
+        }
+    }
+
+    void free(GLenum type, U32 size, GLuint name, U8* data)
+    {
+        LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
+        llassert(type == GL_ARRAY_BUFFER || type == GL_ELEMENT_ARRAY_BUFFER);
+        llassert(size >= 2);
+
+        if (data)
+        {
+            ll_aligned_free_16(data);
+        }
+
+        mAllocated -= size;
+        STOP_GLERROR;
+        if (name)
+        {
+            glDeleteBuffers(1, &name);
+        }
+        STOP_GLERROR;
+    }
+};
+
+#else
+
 class LLVBOPool
 {
 public:
@@ -557,9 +613,8 @@ public:
         mIBOPool.clear();
         mVBOPool.clear();
     }
-
-
 };
+#endif
 
 static LLVBOPool* sVBOPool = nullptr;
 
@@ -594,6 +649,7 @@ const U32 LLVertexBuffer::sTypeSize[LLVertexBuffer::TYPE_MAX] =
     sizeof(F32),       // TYPE_WEIGHT,
     sizeof(LLVector4), // TYPE_WEIGHT4,
     sizeof(LLVector4), // TYPE_CLOTHWEIGHT,
+    sizeof(U64),       // TYPE_JOINT,
     sizeof(LLVector4), // TYPE_TEXTURE_INDEX (actually exists as position.w), no extra data, but stride is 16 bytes
 };
 
@@ -611,6 +667,7 @@ static const std::string vb_type_name[] =
     "TYPE_WEIGHT",
     "TYPE_WEIGHT4",
     "TYPE_CLOTHWEIGHT",
+    "TYPE_JOINT"
     "TYPE_TEXTURE_INDEX",
     "TYPE_MAX",
     "TYPE_INDEX",
@@ -678,6 +735,8 @@ void LLVertexBuffer::drawElements(U32 mode, const LLVector4a* pos, const LLVecto
     LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
     llassert(LLGLSLShader::sCurBoundShaderPtr != NULL);
 
+    STOP_GLERROR;
+
     gGL.syncMatrices();
 
     U32 mask = LLVertexBuffer::MAP_VERTEX;
@@ -734,6 +793,45 @@ bool LLVertexBuffer::validateRange(U32 start, U32 end, U32 count, U32 indices_of
     }
 
     {
+#if 0  // not a reliable test for VBOs that are not backed by a CPU buffer
+        U16* idx = (U16*) mMappedIndexData+indices_offset;
+        for (U32 i = 0; i < count; ++i)
+        {
+            llassert(idx[i] >= start);
+            llassert(idx[i] <= end);
+
+            if (idx[i] < start || idx[i] > end)
+            {
+                LL_ERRS() << "Index out of range: " << idx[i] << " not in [" << start << ", " << end << "]" << LL_ENDL;
+            }
+        }
+
+        LLVector4a* v = (LLVector4a*)mMappedData;
+
+        for (U32 i = start; i <= end; ++i)
+        {
+            if (!v[i].isFinite3())
+            {
+                LL_ERRS() << "Non-finite vertex position data detected." << LL_ENDL;
+            }
+        }
+
+        LLGLSLShader* shader = LLGLSLShader::sCurBoundShaderPtr;
+
+        if (shader && shader->mFeatures.mIndexedTextureChannels > 1)
+        {
+            LLVector4a* v = (LLVector4a*) mMappedData;
+
+            for (U32 i = start; i < end; i++)
+            {
+                U32 idx = (U32) (v[i][3]+0.25f);
+                if (idx >= (U32)shader->mFeatures.mIndexedTextureChannels)
+                {
+                    LL_ERRS() << "Bad texture index found in vertex data stream." << LL_ENDL;
+                }
+            }
+        }
+#endif
     }
 
     return true;
@@ -751,8 +849,10 @@ void LLVertexBuffer::drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indi
     llassert(mGLBuffer == sGLRenderBuffer);
     llassert(mGLIndices == sGLRenderIndices);
     gGL.syncMatrices();
+    STOP_GLERROR;
     glDrawRangeElements(sGLMode[mode], start, end, count, mIndicesType,
         (GLvoid*) (indices_offset * (size_t) mIndicesStride));
+    STOP_GLERROR;
 }
 
 void LLVertexBuffer::drawRangeFast(U32 mode, U32 start, U32 end, U32 count, U32 indices_offset) const
@@ -775,7 +875,9 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
     llassert(mGLIndices == sGLRenderIndices);
 
     gGL.syncMatrices();
+    STOP_GLERROR;
     glDrawArrays(sGLMode[mode], first, count);
+    STOP_GLERROR;
 }
 
 //static
@@ -801,9 +903,10 @@ void LLVertexBuffer::initClass(LLWindow* window)
 //static
 void LLVertexBuffer::unbind()
 {
+    STOP_GLERROR;
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
+    STOP_GLERROR;
     sGLRenderBuffer = 0;
     sGLRenderIndices = 0;
 }
@@ -1200,6 +1303,7 @@ void LLVertexBuffer::flush_vbo(GLenum target, U32 start, U32 end, void* data, U8
 
 void LLVertexBuffer::unmapBuffer()
 {
+    STOP_GLERROR;
     struct SortMappedRegion
     {
         bool operator()(const MappedRegion& lhs, const MappedRegion& rhs)
@@ -1479,12 +1583,15 @@ void LLVertexBuffer::setBuffer()
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGLIndices);
         sGLRenderIndices = mGLIndices;
     }
+
+    STOP_GLERROR;
 }
 
 
 // virtual (default)
 void LLVertexBuffer::setupVertexBuffer()
 {
+    STOP_GLERROR;
     U8* base = nullptr;
 
     U32 data_mask = LLGLSLShader::sCurBoundShaderPtr->mAttributeMask;
@@ -1556,6 +1663,12 @@ void LLVertexBuffer::setupVertexBuffer()
         void* ptr = (void*)(base + mOffsets[TYPE_WEIGHT4]);
         glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_WEIGHT4], ptr);
     }
+    if (data_mask & MAP_JOINT)
+    {
+        AttributeType loc = TYPE_JOINT;
+        void* ptr = (void*)(base + mOffsets[TYPE_JOINT]);
+        glVertexAttribIPointer(loc, 4, GL_UNSIGNED_SHORT, LLVertexBuffer::sTypeSize[TYPE_JOINT], ptr);
+    }
     if (data_mask & MAP_CLOTHWEIGHT)
     {
         AttributeType loc = TYPE_CLOTHWEIGHT;
@@ -1574,6 +1687,7 @@ void LLVertexBuffer::setupVertexBuffer()
         void* ptr = (void*)(base + mOffsets[TYPE_VERTEX]);
         glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_VERTEX], ptr);
     }
+    STOP_GLERROR;
 }
 
 void LLVertexBuffer::setPositionData(const LLVector4a* data)
@@ -1611,12 +1725,10 @@ void LLVertexBuffer::setWeight4Data(const LLVector4a* data)
     flush_vbo(GL_ARRAY_BUFFER, mOffsets[TYPE_WEIGHT4], mOffsets[TYPE_WEIGHT4] + sTypeSize[TYPE_WEIGHT4] * getNumVerts() - 1, (U8*) data, mMappedData);
 }
 
-/*
 void LLVertexBuffer::setJointData(const U64* data)
 {
     flush_vbo(GL_ARRAY_BUFFER, mOffsets[TYPE_JOINT], mOffsets[TYPE_JOINT] + sTypeSize[TYPE_JOINT] * getNumVerts() - 1, (U8*) data, mMappedData);
 }
-*/
 
 void LLVertexBuffer::setIndexData(const U16* data)
 {
@@ -1669,12 +1781,10 @@ void LLVertexBuffer::setWeight4Data(const LLVector4a* data, U32 offset, U32 coun
     flush_vbo(GL_ARRAY_BUFFER, mOffsets[TYPE_WEIGHT4] + offset * sTypeSize[TYPE_WEIGHT4], mOffsets[TYPE_WEIGHT4] + (offset + count) * sTypeSize[TYPE_WEIGHT4] - 1, (U8*)data, mMappedData);
 }
 
-/*
 void LLVertexBuffer::setJointData(const U64* data, U32 offset, U32 count)
 {
     flush_vbo(GL_ARRAY_BUFFER, mOffsets[TYPE_JOINT] + offset * sTypeSize[TYPE_JOINT], mOffsets[TYPE_JOINT] + (offset + count) * sTypeSize[TYPE_JOINT] - 1, (U8*)data, mMappedData);
 }
-*/
 
 void LLVertexBuffer::setIndexData(const U16* data, U32 offset, U32 count)
 {
diff --git a/indra/llrender/llvertexbuffer.h b/indra/llrender/llvertexbuffer.h
index 9d7a0bae2c..4dd375a4af 100644
--- a/indra/llrender/llvertexbuffer.h
+++ b/indra/llrender/llvertexbuffer.h
@@ -110,6 +110,7 @@ public:
         TYPE_WEIGHT,            //  "weight"
         TYPE_WEIGHT4,           //  "weight4"
         TYPE_CLOTHWEIGHT,       //  "clothing"
+        TYPE_JOINT,             //  "joint"
         TYPE_TEXTURE_INDEX,     //  "texture_index"
         TYPE_MAX,   // TYPE_MAX is the size/boundary marker for attributes that go in the vertex buffer
         TYPE_INDEX, // TYPE_INDEX is beyond _MAX because it lives in a separate (index) buffer
@@ -129,6 +130,7 @@ public:
         MAP_WEIGHT = (1<<TYPE_WEIGHT),
         MAP_WEIGHT4 = (1<<TYPE_WEIGHT4),
         MAP_CLOTHWEIGHT = (1<<TYPE_CLOTHWEIGHT),
+        MAP_JOINT = (1<<TYPE_JOINT),
         MAP_TEXTURE_INDEX = (1<<TYPE_TEXTURE_INDEX),
     };
 
@@ -193,7 +195,7 @@ public:
     void setNormalData(const LLVector4a* data);
     void setTangentData(const LLVector4a* data);
     void setWeight4Data(const LLVector4a* data);
-    void setTexCoordData(const LLVector2* data);
+    void setJointData(const U64* data);
     void setTexCoord0Data(const LLVector2* data);
     void setTexCoord1Data(const LLVector2* data);
     void setColorData(const LLColor4U* data);
@@ -204,7 +206,7 @@ public:
     void setNormalData(const LLVector4a* data, U32 offset, U32 count);
     void setTangentData(const LLVector4a* data, U32 offset, U32 count);
     void setWeight4Data(const LLVector4a* data, U32 offset, U32 count);
-    //void setJointData(const U64* data, U32 offset, U32 count);
+    void setJointData(const U64* data, U32 offset, U32 count);
     void setTexCoord0Data(const LLVector2* data, U32 offset, U32 count);
     void setTexCoord1Data(const LLVector2* data, U32 offset, U32 count);
     void setColorData(const LLColor4U* data, U32 offset, U32 count);
@@ -276,7 +278,7 @@ private:
         : LLVertexBuffer(typemask)
     {}
 
-    bool    allocateBuffer(S32 nverts, S32 nindices, BOOL create) { return allocateBuffer(nverts, nindices); }
+    bool    allocateBuffer(S32 nverts, S32 nindices, bool create) { return allocateBuffer(nverts, nindices); }
 
 public: