Merge branch 'develop' into rlva/base

19 files changed, 1065 insertions, 1461 deletions

diff --git a/indra/llrender/CMakeLists.txt b/indra/llrender/CMakeLists.txt
index ccff7c7a8c..26a8ff070f 100644
--- a/indra/llrender/CMakeLists.txt
+++ b/indra/llrender/CMakeLists.txt
@@ -23,7 +23,6 @@ set(llrender_SOURCE_FILES
     llglslshader.cpp
     llgltexture.cpp
     llimagegl.cpp
-    llpostprocess.cpp
     llrender.cpp
     llrender2dutils.cpp
     llrendernavprim.cpp
@@ -56,7 +55,6 @@ set(llrender_HEADER_FILES
     llgltexture.h
     llgltypes.h
     llimagegl.h
-    llpostprocess.h
     llrender.h
     llrender2dutils.h
     llrendernavprim.h
diff --git a/indra/llrender/llfontfreetype.cpp b/indra/llrender/llfontfreetype.cpp
index 6128e03fa7..fa76669258 100644
--- a/indra/llrender/llfontfreetype.cpp
+++ b/indra/llrender/llfontfreetype.cpp
@@ -52,7 +52,9 @@
 #include "llfontbitmapcache.h"
 #include "llgl.h"
 
-#define ENABLE_OT_SVG_SUPPORT
+#if !defined(LL_NO_OTSVG)
+    #define ENABLE_OT_SVG_SUPPORT
+#endif
 
 FT_Render_Mode gFontRenderMode = FT_RENDER_MODE_NORMAL;
 
@@ -87,7 +89,7 @@ LLFontManager::LLFontManager()
         FT_Done_FreeType(gFTLibrary);
     }
 
-#ifdef ENABLE_OT_SVG_SUPPORT
+#if defined(ENABLE_OT_SVG_SUPPORT)
     SVG_RendererHooks hooks = {
         LLFontFreeTypeSvgRenderer::OnInit,
         LLFontFreeTypeSvgRenderer::OnFree,
@@ -483,8 +485,8 @@ LLFontGlyphInfo* LLFontFreetype::addGlyph(llwchar wch, EFontGlyphType glyph_type
                     continue;
                 }
                 glyph_index = FT_Get_Char_Index(pair.first->mFTFace, wch);
-                if (glyph_index)
-                {
+            if (glyph_index)
+            {
                     return addGlyphFromFont(pair.first, wch, glyph_index,
                                             glyph_type);
                 }
diff --git a/indra/llrender/llfontfreetypesvg.cpp b/indra/llrender/llfontfreetypesvg.cpp
index 71f751329e..15251fe1b1 100644
--- a/indra/llrender/llfontfreetypesvg.cpp
+++ b/indra/llrender/llfontfreetypesvg.cpp
@@ -80,6 +80,7 @@ void LLFontFreeTypeSvgRenderer::OnDataFinalizer(void* objectp)
 //static
 FT_Error LLFontFreeTypeSvgRenderer::OnPresetGlypthSlot(FT_GlyphSlot glyph_slot, FT_Bool cache, FT_Pointer*)
 {
+#ifndef LL_NO_OTSVG
     FT_SVG_Document document = static_cast<FT_SVG_Document>(glyph_slot->other);
 
     llassert(!glyph_slot->generic.data || !cache || glyph_slot->glyph_index == ((LLSvgRenderData*)glyph_slot->generic.data)->GlyphIndex);
@@ -166,6 +167,9 @@ FT_Error LLFontFreeTypeSvgRenderer::OnPresetGlypthSlot(FT_GlyphSlot glyph_slot,
     }
 
     return FT_Err_Ok;
+#else
+    return FT_Err_Unimplemented_Feature;
+#endif
 }
 
 // static
diff --git a/indra/llrender/llfontfreetypesvg.h b/indra/llrender/llfontfreetypesvg.h
index 4170cab273..94b83d5fff 100644
--- a/indra/llrender/llfontfreetypesvg.h
+++ b/indra/llrender/llfontfreetypesvg.h
@@ -29,7 +29,11 @@
 #include <ft2build.h>
 #include FT_TYPES_H
 #include FT_MODULE_H
-#include FT_OTSVG_H
+#ifdef FT_OTSVG_H
+    #include FT_OTSVG_H
+#else
+   #define LL_NO_OTSVG
+#endif
 
  // See https://freetype.org/freetype2/docs/reference/ft2-svg_fonts.html
 class LLFontFreeTypeSvgRenderer
diff --git a/indra/llrender/llfontgl.cpp b/indra/llrender/llfontgl.cpp
index 9721b020c7..a012d57b5a 100644
--- a/indra/llrender/llfontgl.cpp
+++ b/indra/llrender/llfontgl.cpp
@@ -270,10 +270,10 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
 
     const LLFontGlyphInfo* next_glyph = NULL;
 
-    static constexpr S32 GLYPH_BATCH_SIZE = 30;
-    static thread_local LLVector3 vertices[GLYPH_BATCH_SIZE * 4];
-    static thread_local LLVector2 uvs[GLYPH_BATCH_SIZE * 4];
-    static thread_local LLColor4U colors[GLYPH_BATCH_SIZE * 4];
+    static constexpr U32 GLYPH_BATCH_SIZE = 30;
+    static thread_local LLVector4a vertices[GLYPH_BATCH_SIZE * 6];
+    static thread_local LLVector2 uvs[GLYPH_BATCH_SIZE * 6];
+    static thread_local LLColor4U colors[GLYPH_BATCH_SIZE * 6];
 
     LLColor4U text_color(color);
     // Preserve the transparency to render fading emojis in fading text (e.g.
@@ -281,7 +281,7 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
     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;
+    U32 glyph_count = 0;
     for (i = begin_offset; i < begin_offset + length; i++)
     {
         llwchar wch = wstr[i];
@@ -305,9 +305,9 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
             // otherwise the queued glyphs will be taken from wrong textures.
             if (glyph_count > 0)
             {
-                gGL.begin(LLRender::QUADS);
+                gGL.begin(LLRender::TRIANGLES);
                 {
-                    gGL.vertexBatchPreTransformed(vertices, uvs, colors, glyph_count * 4);
+                    gGL.vertexBatchPreTransformed(vertices, uvs, colors, glyph_count * 6);
                 }
                 gGL.end();
                 glyph_count = 0;
@@ -338,9 +338,9 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
 
         if (glyph_count >= GLYPH_BATCH_SIZE)
         {
-            gGL.begin(LLRender::QUADS);
+            gGL.begin(LLRender::TRIANGLES);
             {
-                gGL.vertexBatchPreTransformed(vertices, uvs, colors, glyph_count * 4);
+                gGL.vertexBatchPreTransformed(vertices, uvs, colors, glyph_count * 6);
             }
             gGL.end();
 
@@ -376,9 +376,9 @@ S32 LLFontGL::render(const LLWString &wstr, S32 begin_offset, F32 x, F32 y, cons
         cur_render_y = cur_y;
     }
 
-    gGL.begin(LLRender::QUADS);
+    gGL.begin(LLRender::TRIANGLES);
     {
-        gGL.vertexBatchPreTransformed(vertices, uvs, colors, glyph_count * 4);
+        gGL.vertexBatchPreTransformed(vertices, uvs, colors, glyph_count * 6);
     }
     gGL.end();
 
@@ -1227,31 +1227,42 @@ LLFontGL &LLFontGL::operator=(const LLFontGL &source)
     return *this;
 }
 
-void LLFontGL::renderQuad(LLVector3* vertex_out, LLVector2* uv_out, LLColor4U* colors_out, const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4U& color, F32 slant_amt) const
+void LLFontGL::renderTriangle(LLVector4a* vertex_out, LLVector2* uv_out, LLColor4U* colors_out, const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4U& color, F32 slant_amt) const
 {
     S32 index = 0;
 
-    vertex_out[index] = LLVector3(screen_rect.mRight, screen_rect.mTop, 0.f);
-    uv_out[index] = LLVector2(uv_rect.mRight, uv_rect.mTop);
+    vertex_out[index].set(screen_rect.mRight, screen_rect.mTop, 0.f);
+    uv_out[index].set(uv_rect.mRight, uv_rect.mTop);
     colors_out[index] = color;
     index++;
 
-    vertex_out[index] = LLVector3(screen_rect.mLeft, screen_rect.mTop, 0.f);
-    uv_out[index] = LLVector2(uv_rect.mLeft, uv_rect.mTop);
+    vertex_out[index].set(screen_rect.mLeft, screen_rect.mTop, 0.f);
+    uv_out[index].set(uv_rect.mLeft, uv_rect.mTop);
     colors_out[index] = color;
     index++;
 
-    vertex_out[index] = LLVector3(screen_rect.mLeft, screen_rect.mBottom, 0.f);
-    uv_out[index] = LLVector2(uv_rect.mLeft, uv_rect.mBottom);
+    vertex_out[index].set(screen_rect.mLeft, screen_rect.mBottom, 0.f);
+    uv_out[index].set(uv_rect.mLeft, uv_rect.mBottom);
     colors_out[index] = color;
     index++;
 
-    vertex_out[index] = LLVector3(screen_rect.mRight, screen_rect.mBottom, 0.f);
-    uv_out[index] = LLVector2(uv_rect.mRight, uv_rect.mBottom);
+
+    vertex_out[index].set(screen_rect.mRight, screen_rect.mTop, 0.f);
+    uv_out[index].set(uv_rect.mRight, uv_rect.mTop);
+    colors_out[index] = color;
+    index++;
+
+    vertex_out[index].set(screen_rect.mLeft, screen_rect.mBottom, 0.f);
+    uv_out[index].set(uv_rect.mLeft, uv_rect.mBottom);
+    colors_out[index] = color;
+    index++;
+
+    vertex_out[index].set(screen_rect.mRight, screen_rect.mBottom, 0.f);
+    uv_out[index].set(uv_rect.mRight, uv_rect.mBottom);
     colors_out[index] = color;
 }
 
-void LLFontGL::drawGlyph(S32& glyph_count, LLVector3* vertex_out, LLVector2* uv_out, LLColor4U* colors_out, const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4U& color, U8 style, ShadowType shadow, F32 drop_shadow_strength) const
+void LLFontGL::drawGlyph(U32& glyph_count, LLVector4a* vertex_out, LLVector2* uv_out, LLColor4U* colors_out, const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4U& color, U8 style, ShadowType shadow, F32 drop_shadow_strength) const
 {
     F32 slant_offset;
     slant_offset = ((style & ITALIC) ? ( -mFontFreetype->getAscenderHeight() * 0.2f) : 0.f);
@@ -1265,7 +1276,7 @@ void LLFontGL::drawGlyph(S32& glyph_count, LLVector3* vertex_out, LLVector2* uv_
             LLRectf screen_rect_offset = screen_rect;
 
             screen_rect_offset.translate((F32)(pass * BOLD_OFFSET), 0.f);
-            renderQuad(&vertex_out[glyph_count * 4], &uv_out[glyph_count * 4], &colors_out[glyph_count * 4], screen_rect_offset, uv_rect, color, slant_offset);
+            renderTriangle(&vertex_out[glyph_count * 6], &uv_out[glyph_count * 6], &colors_out[glyph_count * 6], screen_rect_offset, uv_rect, color, slant_offset);
             glyph_count++;
         }
     }
@@ -1296,10 +1307,10 @@ void LLFontGL::drawGlyph(S32& glyph_count, LLVector3* vertex_out, LLVector2* uv_
                 break;
             }
 
-            renderQuad(&vertex_out[glyph_count * 4], &uv_out[glyph_count * 4], &colors_out[glyph_count * 4], screen_rect_offset, uv_rect, shadow_color, slant_offset);
+            renderTriangle(&vertex_out[glyph_count * 6], &uv_out[glyph_count * 6], &colors_out[glyph_count * 6], screen_rect_offset, uv_rect, shadow_color, slant_offset);
             glyph_count++;
         }
-        renderQuad(&vertex_out[glyph_count * 4], &uv_out[glyph_count * 4], &colors_out[glyph_count * 4], screen_rect, uv_rect, color, slant_offset);
+        renderTriangle(&vertex_out[glyph_count * 6], &uv_out[glyph_count * 6], &colors_out[glyph_count * 6], screen_rect, uv_rect, color, slant_offset);
         glyph_count++;
     }
     else if (shadow == DROP_SHADOW)
@@ -1308,14 +1319,14 @@ void LLFontGL::drawGlyph(S32& glyph_count, LLVector3* vertex_out, LLVector2* uv_
         shadow_color.mV[VALPHA] = U8(color.mV[VALPHA] * drop_shadow_strength);
         LLRectf screen_rect_shadow = screen_rect;
         screen_rect_shadow.translate(1.f, -1.f);
-        renderQuad(&vertex_out[glyph_count * 4], &uv_out[glyph_count * 4], &colors_out[glyph_count * 4], screen_rect_shadow, uv_rect, shadow_color, slant_offset);
+        renderTriangle(&vertex_out[glyph_count * 6], &uv_out[glyph_count * 6], &colors_out[glyph_count * 6], screen_rect_shadow, uv_rect, shadow_color, slant_offset);
         glyph_count++;
-        renderQuad(&vertex_out[glyph_count * 4], &uv_out[glyph_count * 4], &colors_out[glyph_count * 4], screen_rect, uv_rect, color, slant_offset);
+        renderTriangle(&vertex_out[glyph_count * 6], &uv_out[glyph_count * 6], &colors_out[glyph_count * 6], screen_rect, uv_rect, color, slant_offset);
         glyph_count++;
     }
     else // normal rendering
     {
-        renderQuad(&vertex_out[glyph_count * 4], &uv_out[glyph_count * 4], &colors_out[glyph_count * 4], screen_rect, uv_rect, color, slant_offset);
+        renderTriangle(&vertex_out[glyph_count * 6], &uv_out[glyph_count * 6], &colors_out[glyph_count * 6], screen_rect, uv_rect, color, slant_offset);
         glyph_count++;
     }
 }
diff --git a/indra/llrender/llfontgl.h b/indra/llrender/llfontgl.h
index de7529a583..a257d94512 100644
--- a/indra/llrender/llfontgl.h
+++ b/indra/llrender/llfontgl.h
@@ -238,8 +238,8 @@ private:
     LLFontDescriptor mFontDescriptor;
     LLPointer<LLFontFreetype> mFontFreetype;
 
-    void renderQuad(LLVector3* vertex_out, LLVector2* uv_out, LLColor4U* colors_out, const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4U& color, F32 slant_amt) const;
-    void drawGlyph(S32& glyph_count, LLVector3* vertex_out, LLVector2* uv_out, LLColor4U* colors_out, const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4U& color, U8 style, ShadowType shadow, F32 drop_shadow_fade) const;
+    void renderTriangle(LLVector4a* vertex_out, LLVector2* uv_out, LLColor4U* colors_out, const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4U& color, F32 slant_amt) const;
+    void drawGlyph(U32& glyph_count, LLVector4a* vertex_out, LLVector2* uv_out, LLColor4U* colors_out, const LLRectf& screen_rect, const LLRectf& uv_rect, const LLColor4U& color, U8 style, ShadowType shadow, F32 drop_shadow_fade) const;
 
     // Registry holds all instantiated fonts.
     static LLFontRegistry* sFontRegistry;
diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index c62cacdce6..15fb289de3 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -215,8 +215,6 @@ LLMatrix4 gGLObliqueProjectionInverse;
 
 std::list<LLGLUpdate*> LLGLUpdate::sGLQ;
 
-#if (LL_WINDOWS || LL_LINUX)  && !LL_MESA_HEADLESS
-
 #if LL_WINDOWS
 // WGL_ARB_create_context
 PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = nullptr;
@@ -236,8 +234,6 @@ PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC             wglBlitContextFramebufferAMD = n
 PFNWGLSWAPINTERVALEXTPROC    wglSwapIntervalEXT = nullptr;
 PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT = nullptr;
 
-#endif
-
 // GL_VERSION_1_2
 //PFNGLDRAWRANGEELEMENTSPROC  glDrawRangeElements = nullptr;
 //PFNGLTEXIMAGE3DPROC         glTexImage3D = nullptr;
@@ -1170,6 +1166,11 @@ bool LLGLManager::initGL()
         mGLVendorShort = "INTEL";
         mIsIntel = true;
     }
+    else if (mGLVendor.find("APPLE") != std::string::npos)
+    {
+        mGLVendorShort = "APPLE";
+        mIsApple = true;
+    }
     else
     {
         mGLVendorShort = "MISC";
@@ -1402,6 +1403,9 @@ void LLGLManager::shutdownGL()
 
 void LLGLManager::initExtensions()
 {
+#if LL_LINUX
+    glh_init_extensions("");
+#endif
 #if LL_DARWIN
     GLint num_extensions = 0;
     std::string all_extensions{""};
@@ -1432,10 +1436,9 @@ void LLGLManager::initExtensions()
 
     mInited = true;
 
-#if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
+#if LL_WINDOWS
     LL_DEBUGS("RenderInit") << "GL Probe: Getting symbols" << LL_ENDL;
 
-#if LL_WINDOWS
     // WGL_AMD_gpu_association
     wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)GLH_EXT_GET_PROC_ADDRESS("wglGetGPUIDsAMD");
     wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)GLH_EXT_GET_PROC_ADDRESS("wglGetGPUInfoAMD");
@@ -1453,8 +1456,6 @@ void LLGLManager::initExtensions()
 
     // WGL_ARB_create_context
     wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)GLH_EXT_GET_PROC_ADDRESS("wglCreateContextAttribsARB");
-#endif
-
 
     // Load entire OpenGL API through GetProcAddress, leaving sections beyond mGLVersion unloaded
 
@@ -2582,6 +2583,7 @@ void parse_gl_version( S32* major, S32* minor, S32* release, std::string* vendor
     {
         return;
     }
+    LL_INFOS() << "GL: "  << version << LL_ENDL;
 
     version_string->assign(version);
 
@@ -2957,5 +2959,3 @@ extern "C"
     __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif
-
-
diff --git a/indra/llrender/llgl.h b/indra/llrender/llgl.h
index 17f825bd71..f5b1e8d786 100644
--- a/indra/llrender/llgl.h
+++ b/indra/llrender/llgl.h
@@ -102,6 +102,7 @@ public:
     bool mIsAMD;
     bool mIsNVIDIA;
     bool mIsIntel;
+    bool mIsApple = false;
 
     // hints to the render pipe
     U32 mDownScaleMethod = 0; // see settings.xml RenderDownScaleMethod
diff --git a/indra/llrender/llglheaders.h b/indra/llrender/llglheaders.h
index 3d4dc5e698..921adc0f8c 100644
--- a/indra/llrender/llglheaders.h
+++ b/indra/llrender/llglheaders.h
@@ -41,6 +41,22 @@
 # include "GL/glh_extensions.h"
 # undef __APPLE__
 
+#elif LL_LINUX
+#define GL_GLEXT_PROTOTYPES
+#define GLX_GLEXT_PROTOTYPES
+
+#include "GL/gl.h"
+#include "GL/glext.h"
+#include "GL/glu.h"
+
+// The __APPLE__ kludge is to make glh_extensions.h not symbol-clash horribly
+# define __APPLE__
+# include "GL/glh_extensions.h"
+# undef __APPLE__
+
+# include "GL/glx.h"
+# include "GL/glxext.h"
+
 #elif LL_WINDOWS
 //----------------------------------------------------------------------------
 // LL_WINDOWS
@@ -1029,6 +1045,25 @@ extern void glGetBufferPointervARB (GLenum, GLenum, GLvoid* *);
 
 #include <OpenGL/gl.h>
 
+#elif LL_LINUX
+
+#define GL_GLEXT_PROTOTYPES
+#define GLX_GLEXT_PROTOTYPES
+
+#include "GL/gl.h"
+#include "GL/glu.h"
+#include "GL/glext.h"
+#include "GL/glx.h"
+
+// The __APPLE__ kludge is to make glh_extensions.h not symbol-clash horribly
+# define __APPLE__
+# include "GL/glh_extensions.h"
+# undef __APPLE__
+
+// #include <X11/Xlib.h>
+// #include <X11/Xutil.h>
+#include "GL/glh_extensions.h"
+
 #endif // LL_MESA / LL_WINDOWS / LL_DARWIN
 
 // Even when GL_ARB_depth_clamp is available in the driver, the (correct)
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index a157bfee21..6ba5463acd 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -63,6 +63,7 @@ U64 LLGLSLShader::sTotalTimeElapsed = 0;
 U32 LLGLSLShader::sTotalTrianglesDrawn = 0;
 U64 LLGLSLShader::sTotalSamplesDrawn = 0;
 U32 LLGLSLShader::sTotalBinds = 0;
+boost::json::value LLGLSLShader::sDefaultStats;
 
 //UI shader -- declared here so llui_libtest will link properly
 LLGLSLShader    gUIProgram;
@@ -101,9 +102,9 @@ void LLGLSLShader::initProfile()
     sTotalSamplesDrawn = 0;
     sTotalBinds = 0;
 
-    for (std::set<LLGLSLShader*>::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
+    for (auto ptr : sInstances)
     {
-        (*iter)->clearStats();
+        ptr->clearStats();
     }
 }
 
@@ -117,45 +118,57 @@ struct LLGLSLShaderCompareTimeElapsed
 };
 
 //static
-void LLGLSLShader::finishProfile(bool emit_report)
+void LLGLSLShader::finishProfile(boost::json::value& statsv)
 {
     sProfileEnabled = false;
 
-    if (emit_report)
+    if (! statsv.is_null())
     {
-        std::vector<LLGLSLShader*> sorted;
-
-        for (std::set<LLGLSLShader*>::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
-        {
-            sorted.push_back(*iter);
-        }
-
+        std::vector<LLGLSLShader*> sorted(sInstances.begin(), sInstances.end());
         std::sort(sorted.begin(), sorted.end(), LLGLSLShaderCompareTimeElapsed());
 
+        auto& stats = statsv.as_object();
+        auto shadersit = stats.emplace("shaders", boost::json::array_kind).first;
+        auto& shaders = shadersit->value().as_array();
         bool unbound = false;
-        for (std::vector<LLGLSLShader*>::iterator iter = sorted.begin(); iter != sorted.end(); ++iter)
+        for (auto ptr : sorted)
         {
-            (*iter)->dumpStats();
-            if ((*iter)->mBinds == 0)
+            if (ptr->mBinds == 0)
             {
                 unbound = true;
             }
+            else
+            {
+                auto& shaderit = shaders.emplace_back(boost::json::object_kind);
+                ptr->dumpStats(shaderit.as_object());
+            }
         }
 
+        constexpr float mega = 1'000'000.f;
+        float totalTimeMs = sTotalTimeElapsed / mega;
         LL_INFOS() << "-----------------------------------" << LL_ENDL;
-        LL_INFOS() << "Total rendering time: " << llformat("%.4f ms", sTotalTimeElapsed / 1000000.f) << LL_ENDL;
-        LL_INFOS() << "Total samples drawn: " << llformat("%.4f million", sTotalSamplesDrawn / 1000000.f) << LL_ENDL;
-        LL_INFOS() << "Total triangles drawn: " << llformat("%.3f million", sTotalTrianglesDrawn / 1000000.f) << LL_ENDL;
+        LL_INFOS() << "Total rendering time: " << llformat("%.4f ms", totalTimeMs) << LL_ENDL;
+        LL_INFOS() << "Total samples drawn: " << llformat("%.4f million", sTotalSamplesDrawn / mega) << LL_ENDL;
+        LL_INFOS() << "Total triangles drawn: " << llformat("%.3f million", sTotalTrianglesDrawn / mega) << LL_ENDL;
         LL_INFOS() << "-----------------------------------" << LL_ENDL;
-
+        auto totalsit = stats.emplace("totals", boost::json::object_kind).first;
+        auto& totals = totalsit->value().as_object();
+        totals.emplace("time", totalTimeMs / 1000.0);
+        totals.emplace("binds", sTotalBinds);
+        totals.emplace("samples", sTotalSamplesDrawn);
+        totals.emplace("triangles", sTotalTrianglesDrawn);
+
+        auto unusedit = stats.emplace("unused", boost::json::array_kind).first;
+        auto& unused = unusedit->value().as_array();
         if (unbound)
         {
             LL_INFOS() << "The following shaders were unused: " << LL_ENDL;
-            for (std::vector<LLGLSLShader*>::iterator iter = sorted.begin(); iter != sorted.end(); ++iter)
+            for (auto ptr : sorted)
             {
-                if ((*iter)->mBinds == 0)
+                if (ptr->mBinds == 0)
                 {
-                    LL_INFOS() << (*iter)->mName << LL_ENDL;
+                    LL_INFOS() << ptr->mName << LL_ENDL;
+                    unused.emplace_back(ptr->mName);
                 }
             }
         }
@@ -170,36 +183,43 @@ void LLGLSLShader::clearStats()
     mBinds = 0;
 }
 
-void LLGLSLShader::dumpStats()
+void LLGLSLShader::dumpStats(boost::json::object& stats)
 {
-    if (mBinds > 0)
+    stats.emplace("name", mName);
+    auto filesit = stats.emplace("files", boost::json::array_kind).first;
+    auto& files = filesit->value().as_array();
+    LL_INFOS() << "=============================================" << LL_ENDL;
+    LL_INFOS() << mName << LL_ENDL;
+    for (U32 i = 0; i < mShaderFiles.size(); ++i)
     {
-        LL_INFOS() << "=============================================" << LL_ENDL;
-        LL_INFOS() << mName << LL_ENDL;
-        for (U32 i = 0; i < mShaderFiles.size(); ++i)
-        {
-            LL_INFOS() << mShaderFiles[i].first << LL_ENDL;
-        }
-        LL_INFOS() << "=============================================" << LL_ENDL;
+        LL_INFOS() << mShaderFiles[i].first << LL_ENDL;
+        files.emplace_back(mShaderFiles[i].first);
+    }
+    LL_INFOS() << "=============================================" << LL_ENDL;
 
-        F32 ms = mTimeElapsed / 1000000.f;
-        F32 seconds = ms / 1000.f;
+    constexpr float  mega = 1'000'000.f;
+    constexpr double giga = 1'000'000'000.0;
+    F32 ms = mTimeElapsed / mega;
+    F32 seconds = ms / 1000.f;
 
-        F32 pct_tris = (F32)mTrianglesDrawn / (F32)sTotalTrianglesDrawn * 100.f;
-        F32 tris_sec = (F32)(mTrianglesDrawn / 1000000.0);
-        tris_sec /= seconds;
+    F32 pct_tris = (F32)mTrianglesDrawn / (F32)sTotalTrianglesDrawn * 100.f;
+    F32 tris_sec = (F32)(mTrianglesDrawn / mega);
+    tris_sec /= seconds;
 
-        F32 pct_samples = (F32)((F64)mSamplesDrawn / (F64)sTotalSamplesDrawn) * 100.f;
-        F32 samples_sec = (F32)(mSamplesDrawn / 1000000000.0);
-        samples_sec /= seconds;
+    F32 pct_samples = (F32)((F64)mSamplesDrawn / (F64)sTotalSamplesDrawn) * 100.f;
+    F32 samples_sec = (F32)(mSamplesDrawn / giga);
+    samples_sec /= seconds;
 
-        F32 pct_binds = (F32)mBinds / (F32)sTotalBinds * 100.f;
+    F32 pct_binds = (F32)mBinds / (F32)sTotalBinds * 100.f;
 
-        LL_INFOS() << "Triangles Drawn: " << mTrianglesDrawn << " " << llformat("(%.2f pct of total, %.3f million/sec)", pct_tris, tris_sec) << LL_ENDL;
-        LL_INFOS() << "Binds: " << mBinds << " " << llformat("(%.2f pct of total)", pct_binds) << LL_ENDL;
-        LL_INFOS() << "SamplesDrawn: " << mSamplesDrawn << " " << llformat("(%.2f pct of total, %.3f billion/sec)", pct_samples, samples_sec) << LL_ENDL;
-        LL_INFOS() << "Time Elapsed: " << mTimeElapsed << " " << llformat("(%.2f pct of total, %.5f ms)\n", (F32)((F64)mTimeElapsed / (F64)sTotalTimeElapsed) * 100.f, ms) << LL_ENDL;
-    }
+    LL_INFOS() << "Triangles Drawn: " << mTrianglesDrawn << " " << llformat("(%.2f pct of total, %.3f million/sec)", pct_tris, tris_sec) << LL_ENDL;
+    LL_INFOS() << "Binds: " << mBinds << " " << llformat("(%.2f pct of total)", pct_binds) << LL_ENDL;
+    LL_INFOS() << "SamplesDrawn: " << mSamplesDrawn << " " << llformat("(%.2f pct of total, %.3f billion/sec)", pct_samples, samples_sec) << LL_ENDL;
+    LL_INFOS() << "Time Elapsed: " << mTimeElapsed << " " << llformat("(%.2f pct of total, %.5f ms)\n", (F32)((F64)mTimeElapsed / (F64)sTotalTimeElapsed) * 100.f, ms) << LL_ENDL;
+    stats.emplace("time", seconds);
+    stats.emplace("binds", mBinds);
+    stats.emplace("samples", mSamplesDrawn);
+    stats.emplace("triangles", mTrianglesDrawn);
 }
 
 //static
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 27c8f0b7d0..2d669c70a9 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -30,6 +30,7 @@
 #include "llgl.h"
 #include "llrender.h"
 #include "llstaticstringtable.h"
+#include <boost/json.hpp>
 #include <unordered_map>
 
 class LLShaderFeatures
@@ -169,14 +170,14 @@ public:
     static U32 sMaxGLTFNodes;
 
     static void initProfile();
-    static void finishProfile(bool emit_report = true);
+    static void finishProfile(boost::json::value& stats=sDefaultStats);
 
     static void startProfile();
     static void stopProfile();
 
     void unload();
     void clearStats();
-    void dumpStats();
+    void dumpStats(boost::json::object& stats);
 
     // place query objects for profiling if profiling is enabled
     // if for_runtime is true, will place timer query only whether or not profiling is enabled
@@ -363,6 +364,11 @@ public:
 
 private:
     void unloadInternal();
+    // This must be static because finishProfile() is called at least once
+    // within a __try block. If we default its stats parameter to a temporary
+    // json::value, that temporary must be destroyed when the stack is
+    // unwound, which __try forbids.
+    static boost::json::value sDefaultStats;
 };
 
 //UI shader (declared here so llui_libtest will link properly)
diff --git a/indra/llrender/llpostprocess.cpp b/indra/llrender/llpostprocess.cpp
deleted file mode 100644
index eef7193c92..0000000000
--- a/indra/llrender/llpostprocess.cpp
+++ /dev/null
@@ -1,454 +0,0 @@
-/**
- * @file llpostprocess.cpp
- * @brief LLPostProcess class implementation
- *
- * $LicenseInfo:firstyear=2007&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$
- */
-
-#include "linden_common.h"
-
-#include "llpostprocess.h"
-#include "llglslshader.h"
-#include "llsdserialize.h"
-#include "llrender.h"
-
-static LLStaticHashedString sRenderTexture("RenderTexture");
-static LLStaticHashedString sBrightness("brightness");
-static LLStaticHashedString sContrast("contrast");
-static LLStaticHashedString sContrastBase("contrastBase");
-static LLStaticHashedString sSaturation("saturation");
-static LLStaticHashedString sLumWeights("lumWeights");
-static LLStaticHashedString sNoiseTexture("NoiseTexture");
-static LLStaticHashedString sBrightMult("brightMult");
-static LLStaticHashedString sNoiseStrength("noiseStrength");
-static LLStaticHashedString sExtractLow("extractLow");
-static LLStaticHashedString sExtractHigh("extractHigh");
-static LLStaticHashedString sBloomStrength("bloomStrength");
-static LLStaticHashedString sTexelSize("texelSize");
-static LLStaticHashedString sBlurDirection("blurDirection");
-static LLStaticHashedString sBlurWidth("blurWidth");
-
-LLPostProcess * gPostProcess = NULL;
-
-static const unsigned int NOISE_SIZE = 512;
-
-LLPostProcess::LLPostProcess(void) :
-                    initialized(false),
-                    mAllEffects(LLSD::emptyMap()),
-                    screenW(1), screenH(1)
-{
-    mSceneRenderTexture = NULL ;
-    mNoiseTexture = NULL ;
-    mTempBloomTexture = NULL ;
-
-    noiseTextureScale = 1.0f;
-
-    /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
-    std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
-    LL_DEBUGS("AppInit", "Shaders") << "Loading PostProcess Effects settings from " << pathName << LL_ENDL;
-
-    llifstream effectsXML(pathName);
-
-    if (effectsXML)
-    {
-        LLPointer<LLSDParser> parser = new LLSDXMLParser();
-
-        parser->parse(effectsXML, mAllEffects, LLSDSerialize::SIZE_UNLIMITED);
-    }
-
-    if (!mAllEffects.has("default"))
-    {
-        LLSD & defaultEffect = (mAllEffects["default"] = LLSD::emptyMap());
-
-        defaultEffect["enable_night_vision"] = LLSD::Boolean(false);
-        defaultEffect["enable_bloom"] = LLSD::Boolean(false);
-        defaultEffect["enable_color_filter"] = LLSD::Boolean(false);
-
-        /// NVG Defaults
-        defaultEffect["brightness_multiplier"] = 3.0;
-        defaultEffect["noise_size"] = 25.0;
-        defaultEffect["noise_strength"] = 0.4;
-
-        // TODO BTest potentially add this to tweaks?
-        noiseTextureScale = 1.0f;
-
-        /// Bloom Defaults
-        defaultEffect["extract_low"] = 0.95;
-        defaultEffect["extract_high"] = 1.0;
-        defaultEffect["bloom_width"] = 2.25;
-        defaultEffect["bloom_strength"] = 1.5;
-
-        /// Color Filter Defaults
-        defaultEffect["brightness"] = 1.0;
-        defaultEffect["contrast"] = 1.0;
-        defaultEffect["saturation"] = 1.0;
-
-        LLSD& contrastBase = (defaultEffect["contrast_base"] = LLSD::emptyArray());
-        contrastBase.append(1.0);
-        contrastBase.append(1.0);
-        contrastBase.append(1.0);
-        contrastBase.append(0.5);
-    }
-
-    setSelectedEffect("default");
-    */
-}
-
-LLPostProcess::~LLPostProcess(void)
-{
-    invalidate() ;
-}
-
-// static
-void LLPostProcess::initClass(void)
-{
-    //this will cause system to crash at second time login
-    //if first time login fails due to network connection --- bao
-    //***llassert_always(gPostProcess == NULL);
-    //replaced by the following line:
-    if(gPostProcess)
-        return ;
-
-
-    gPostProcess = new LLPostProcess();
-}
-
-// static
-void LLPostProcess::cleanupClass()
-{
-    delete gPostProcess;
-    gPostProcess = NULL;
-}
-
-void LLPostProcess::setSelectedEffect(std::string const & effectName)
-{
-    mSelectedEffectName = effectName;
-    static_cast<LLSD &>(tweaks) = mAllEffects[effectName];
-}
-
-void LLPostProcess::saveEffect(std::string const & effectName)
-{
-    /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
-    mAllEffects[effectName] = tweaks;
-
-    std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
-    //LL_INFOS() << "Saving PostProcess Effects settings to " << pathName << LL_ENDL;
-
-    llofstream effectsXML(pathName);
-
-    LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
-
-    formatter->format(mAllEffects, effectsXML);
-    */
-}
-void LLPostProcess::invalidate()
-{
-    mSceneRenderTexture = NULL ;
-    mNoiseTexture = NULL ;
-    mTempBloomTexture = NULL ;
-    initialized = false ;
-}
-
-void LLPostProcess::apply(unsigned int width, unsigned int height)
-{
-    if (!initialized || width != screenW || height != screenH){
-        initialize(width, height);
-    }
-    if (shadersEnabled()){
-        doEffects();
-    }
-}
-
-void LLPostProcess::initialize(unsigned int width, unsigned int height)
-{
-    screenW = width;
-    screenH = height;
-    createTexture(mSceneRenderTexture, screenW, screenH);
-    initialized = true;
-
-    checkError();
-    createNightVisionShader();
-    createBloomShader();
-    createColorFilterShader();
-    checkError();
-}
-
-inline bool LLPostProcess::shadersEnabled(void)
-{
-    return (tweaks.useColorFilter().asBoolean() ||
-            tweaks.useNightVisionShader().asBoolean() ||
-            tweaks.useBloomShader().asBoolean() );
-
-}
-
-void LLPostProcess::applyShaders(void)
-{
-    if (tweaks.useColorFilter()){
-        applyColorFilterShader();
-        checkError();
-    }
-    if (tweaks.useNightVisionShader()){
-        /// If any of the above shaders have been called update the frame buffer;
-        if (tweaks.useColorFilter())
-        {
-            U32 tex = mSceneRenderTexture->getTexName() ;
-            copyFrameBuffer(tex, screenW, screenH);
-        }
-        applyNightVisionShader();
-        checkError();
-    }
-    if (tweaks.useBloomShader()){
-        /// If any of the above shaders have been called update the frame buffer;
-        if (tweaks.useColorFilter().asBoolean() || tweaks.useNightVisionShader().asBoolean())
-        {
-            U32 tex = mSceneRenderTexture->getTexName() ;
-            copyFrameBuffer(tex, screenW, screenH);
-        }
-        applyBloomShader();
-        checkError();
-    }
-}
-
-void LLPostProcess::applyColorFilterShader(void)
-{
-
-}
-
-void LLPostProcess::createColorFilterShader(void)
-{
-    /// Define uniform names
-    colorFilterUniforms[sRenderTexture] = 0;
-    colorFilterUniforms[sBrightness] = 0;
-    colorFilterUniforms[sContrast] = 0;
-    colorFilterUniforms[sContrastBase] = 0;
-    colorFilterUniforms[sSaturation] = 0;
-    colorFilterUniforms[sLumWeights] = 0;
-}
-
-void LLPostProcess::applyNightVisionShader(void)
-{
-
-}
-
-void LLPostProcess::createNightVisionShader(void)
-{
-    /// Define uniform names
-    nightVisionUniforms[sRenderTexture] = 0;
-    nightVisionUniforms[sNoiseTexture] = 0;
-    nightVisionUniforms[sBrightMult] = 0;
-    nightVisionUniforms[sNoiseStrength] = 0;
-    nightVisionUniforms[sLumWeights] = 0;
-
-    createNoiseTexture(mNoiseTexture);
-}
-
-void LLPostProcess::applyBloomShader(void)
-{
-
-}
-
-void LLPostProcess::createBloomShader(void)
-{
-    createTexture(mTempBloomTexture, unsigned(screenW * 0.5), unsigned(screenH * 0.5));
-
-    /// Create Bloom Extract Shader
-    bloomExtractUniforms[sRenderTexture] = 0;
-    bloomExtractUniforms[sExtractLow] = 0;
-    bloomExtractUniforms[sExtractHigh] = 0;
-    bloomExtractUniforms[sLumWeights] = 0;
-
-    /// Create Bloom Blur Shader
-    bloomBlurUniforms[sRenderTexture] = 0;
-    bloomBlurUniforms[sBloomStrength] = 0;
-    bloomBlurUniforms[sTexelSize] = 0;
-    bloomBlurUniforms[sBlurDirection] = 0;
-    bloomBlurUniforms[sBlurWidth] = 0;
-}
-
-void LLPostProcess::getShaderUniforms(glslUniforms & uniforms, GLuint & prog)
-{
-    /// Find uniform locations and insert into map
-    glslUniforms::iterator i;
-    for (i  = uniforms.begin(); i != uniforms.end(); ++i){
-        i->second = glGetUniformLocation(prog, i->first.String().c_str());
-    }
-}
-
-void LLPostProcess::doEffects(void)
-{
-    /// Save GL State
-    glPushAttrib(GL_ALL_ATTRIB_BITS);
-    glPushClientAttrib(GL_ALL_ATTRIB_BITS);
-
-    /// Copy the screen buffer to the render texture
-    {
-        U32 tex = mSceneRenderTexture->getTexName() ;
-        copyFrameBuffer(tex, screenW, screenH);
-    }
-
-    /// Clear the frame buffer.
-    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-    glClear(GL_COLOR_BUFFER_BIT);
-
-    /// Change to an orthogonal view
-    viewOrthogonal(screenW, screenH);
-
-    checkError();
-    applyShaders();
-
-    LLGLSLShader::unbind();
-    checkError();
-
-    /// Change to a perspective view
-    viewPerspective();
-
-    /// Reset GL State
-    glPopClientAttrib();
-    glPopAttrib();
-    checkError();
-}
-
-void LLPostProcess::copyFrameBuffer(U32 & texture, unsigned int width, unsigned int height)
-{
-    gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture);
-    glCopyTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_RGBA, 0, 0, width, height, 0);
-}
-
-void LLPostProcess::drawOrthoQuad(unsigned int width, unsigned int height, QuadType type)
-{
-
-}
-
-void LLPostProcess::viewOrthogonal(unsigned int width, unsigned int height)
-{
-    gGL.matrixMode(LLRender::MM_PROJECTION);
-    gGL.pushMatrix();
-    gGL.loadIdentity();
-    gGL.ortho( 0.f, (GLfloat) width , (GLfloat) height , 0.f, -1.f, 1.f );
-    gGL.matrixMode(LLRender::MM_MODELVIEW);
-    gGL.pushMatrix();
-    gGL.loadIdentity();
-}
-
-void LLPostProcess::viewPerspective(void)
-{
-    gGL.matrixMode(LLRender::MM_PROJECTION);
-    gGL.popMatrix();
-    gGL.matrixMode(LLRender::MM_MODELVIEW);
-    gGL.popMatrix();
-}
-
-void LLPostProcess::changeOrthogonal(unsigned int width, unsigned int height)
-{
-    viewPerspective();
-    viewOrthogonal(width, height);
-}
-
-void LLPostProcess::createTexture(LLPointer<LLImageGL>& texture, unsigned int width, unsigned int height)
-{
-    std::vector<GLubyte> data(width * height * 4, 0) ;
-
-    texture = new LLImageGL(false) ;
-    if(texture->createGLTexture())
-    {
-        gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture->getTexName());
-        glTexImage2D(GL_TEXTURE_RECTANGLE, 0, 4, width, height, 0,
-            GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
-        gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
-        gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
-    }
-}
-
-void LLPostProcess::createNoiseTexture(LLPointer<LLImageGL>& texture)
-{
-    std::vector<GLubyte> buffer(NOISE_SIZE * NOISE_SIZE);
-    for (unsigned int i = 0; i < NOISE_SIZE; i++){
-        for (unsigned int k = 0; k < NOISE_SIZE; k++){
-            buffer[(i * NOISE_SIZE) + k] = (GLubyte)((double) rand() / ((double) RAND_MAX + 1.f) * 255.f);
-        }
-    }
-
-    texture = new LLImageGL(false) ;
-    if(texture->createGLTexture())
-    {
-        gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture->getTexName());
-        LLImageGL::setManualImage(GL_TEXTURE_2D, 0, GL_LUMINANCE, NOISE_SIZE, NOISE_SIZE, GL_LUMINANCE, GL_UNSIGNED_BYTE, &buffer[0]);
-        gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
-        gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_WRAP);
-    }
-}
-
-bool LLPostProcess::checkError(void)
-{
-    GLenum glErr;
-    bool    retCode = false;
-
-    glErr = glGetError();
-    while (glErr != GL_NO_ERROR)
-    {
-        // shaderErrorLog << (const char *) gluErrorString(glErr) << std::endl;
-        char const * err_str_raw = (const char *) gluErrorString(glErr);
-
-        if(err_str_raw == NULL)
-        {
-            std::ostringstream err_builder;
-            err_builder << "unknown error number " << glErr;
-            mShaderErrorString = err_builder.str();
-        }
-        else
-        {
-            mShaderErrorString = err_str_raw;
-        }
-
-        retCode = true;
-        glErr = glGetError();
-    }
-    return retCode;
-}
-
-void LLPostProcess::checkShaderError(GLuint shader)
-{
-    GLint infologLength = 0;
-    GLint charsWritten  = 0;
-    GLchar *infoLog;
-
-    checkError();  // Check for OpenGL errors
-
-    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infologLength);
-
-    checkError();  // Check for OpenGL errors
-
-    if (infologLength > 0)
-    {
-        infoLog = (GLchar *)malloc(infologLength);
-        if (infoLog == NULL)
-        {
-            /// Could not allocate infolog buffer
-            return;
-        }
-       glGetProgramInfoLog(shader, infologLength, &charsWritten, infoLog);
-        // shaderErrorLog << (char *) infoLog << std::endl;
-        mShaderErrorString = (char *) infoLog;
-        free(infoLog);
-    }
-    checkError();  // Check for OpenGL errors
-}
diff --git a/indra/llrender/llpostprocess.h b/indra/llrender/llpostprocess.h
deleted file mode 100644
index b5b7549efb..0000000000
--- a/indra/llrender/llpostprocess.h
+++ /dev/null
@@ -1,267 +0,0 @@
-/**
- * @file llpostprocess.h
- * @brief LLPostProcess class definition
- *
- * $LicenseInfo:firstyear=2007&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$
- */
-
-#ifndef LL_POSTPROCESS_H
-#define LL_POSTPROCESS_H
-
-#include <map>
-#include <fstream>
-#include "llgl.h"
-#include "llglheaders.h"
-#include "llstaticstringtable.h"
-
-class LLPostProcess
-{
-public:
-
-    typedef enum _QuadType {
-        QUAD_NORMAL,
-        QUAD_NOISE,
-        QUAD_BLOOM_EXTRACT,
-        QUAD_BLOOM_COMBINE
-    } QuadType;
-
-    /// GLSL Shader Encapsulation Struct
-    typedef LLStaticStringTable<GLuint> glslUniforms;
-
-    struct PostProcessTweaks : public LLSD {
-        inline PostProcessTweaks() : LLSD(LLSD::emptyMap())
-        {
-        }
-
-        inline LLSD & brightMult() {
-            return (*this)["brightness_multiplier"];
-        }
-
-        inline LLSD & noiseStrength() {
-            return (*this)["noise_strength"];
-        }
-
-        inline LLSD & noiseSize() {
-            return (*this)["noise_size"];
-        }
-
-        inline LLSD & extractLow() {
-            return (*this)["extract_low"];
-        }
-
-        inline LLSD & extractHigh() {
-            return (*this)["extract_high"];
-        }
-
-        inline LLSD & bloomWidth() {
-            return (*this)["bloom_width"];
-        }
-
-        inline LLSD & bloomStrength() {
-            return (*this)["bloom_strength"];
-        }
-
-        inline LLSD & brightness() {
-            return (*this)["brightness"];
-        }
-
-        inline LLSD & contrast() {
-            return (*this)["contrast"];
-        }
-
-        inline LLSD & contrastBaseR() {
-            return (*this)["contrast_base"][0];
-        }
-
-        inline LLSD & contrastBaseG() {
-            return (*this)["contrast_base"][1];
-        }
-
-        inline LLSD & contrastBaseB() {
-            return (*this)["contrast_base"][2];
-        }
-
-        inline LLSD & contrastBaseIntensity() {
-            return (*this)["contrast_base"][3];
-        }
-
-        inline LLSD & saturation() {
-            return (*this)["saturation"];
-        }
-
-        inline LLSD & useNightVisionShader() {
-            return (*this)["enable_night_vision"];
-        }
-
-        inline LLSD & useBloomShader() {
-            return (*this)["enable_bloom"];
-        }
-
-        inline LLSD & useColorFilter() {
-            return (*this)["enable_color_filter"];
-        }
-
-
-        inline F32 getBrightMult() const {
-            return F32((*this)["brightness_multiplier"].asReal());
-        }
-
-        inline F32 getNoiseStrength() const {
-            return F32((*this)["noise_strength"].asReal());
-        }
-
-        inline F32 getNoiseSize() const {
-            return F32((*this)["noise_size"].asReal());
-        }
-
-        inline F32 getExtractLow() const {
-            return F32((*this)["extract_low"].asReal());
-        }
-
-        inline F32 getExtractHigh() const {
-            return F32((*this)["extract_high"].asReal());
-        }
-
-        inline F32 getBloomWidth() const {
-            return F32((*this)["bloom_width"].asReal());
-        }
-
-        inline F32 getBloomStrength() const {
-            return F32((*this)["bloom_strength"].asReal());
-        }
-
-        inline F32 getBrightness() const {
-            return F32((*this)["brightness"].asReal());
-        }
-
-        inline F32 getContrast() const {
-            return F32((*this)["contrast"].asReal());
-        }
-
-        inline F32 getContrastBaseR() const {
-            return F32((*this)["contrast_base"][0].asReal());
-        }
-
-        inline F32 getContrastBaseG() const {
-            return F32((*this)["contrast_base"][1].asReal());
-        }
-
-        inline F32 getContrastBaseB() const {
-            return F32((*this)["contrast_base"][2].asReal());
-        }
-
-        inline F32 getContrastBaseIntensity() const {
-            return F32((*this)["contrast_base"][3].asReal());
-        }
-
-        inline F32 getSaturation() const {
-            return F32((*this)["saturation"].asReal());
-        }
-
-    };
-
-    bool initialized;
-    PostProcessTweaks tweaks;
-
-    // the map of all availible effects
-    LLSD mAllEffects;
-
-private:
-    LLPointer<LLImageGL> mSceneRenderTexture ;
-    LLPointer<LLImageGL> mNoiseTexture ;
-    LLPointer<LLImageGL> mTempBloomTexture ;
-
-public:
-    LLPostProcess(void);
-
-    ~LLPostProcess(void);
-
-    void apply(unsigned int width, unsigned int height);
-    void invalidate() ;
-
-    /// Perform global initialization for this class.
-    static void initClass(void);
-
-    // Cleanup of global data that's only inited once per class.
-    static void cleanupClass();
-
-    void setSelectedEffect(std::string const & effectName);
-
-    inline std::string const & getSelectedEffect(void) const {
-        return mSelectedEffectName;
-    }
-
-    void saveEffect(std::string const & effectName);
-
-private:
-        /// read in from file
-    std::string mShaderErrorString;
-    unsigned int screenW;
-    unsigned int screenH;
-
-    float noiseTextureScale;
-
-    /// Shader Uniforms
-    glslUniforms nightVisionUniforms;
-    glslUniforms bloomExtractUniforms;
-    glslUniforms bloomBlurUniforms;
-    glslUniforms colorFilterUniforms;
-
-    // the name of currently selected effect in mAllEffects
-    // invariant: tweaks == mAllEffects[mSelectedEffectName]
-    std::string mSelectedEffectName;
-
-    /// General functions
-    void initialize(unsigned int width, unsigned int height);
-    void doEffects(void);
-    void applyShaders(void);
-    bool shadersEnabled(void);
-
-    /// Night Vision Functions
-    void createNightVisionShader(void);
-    void applyNightVisionShader(void);
-
-    /// Bloom Functions
-    void createBloomShader(void);
-    void applyBloomShader(void);
-
-    /// Color Filter Functions
-    void createColorFilterShader(void);
-    void applyColorFilterShader(void);
-
-    /// OpenGL Helper Functions
-    void getShaderUniforms(glslUniforms & uniforms, GLuint & prog);
-    void createTexture(LLPointer<LLImageGL>& texture, unsigned int width, unsigned int height);
-    void copyFrameBuffer(U32 & texture, unsigned int width, unsigned int height);
-    void createNoiseTexture(LLPointer<LLImageGL>& texture);
-    bool checkError(void);
-    void checkShaderError(GLuint shader);
-    void drawOrthoQuad(unsigned int width, unsigned int height, QuadType type);
-    void viewOrthogonal(unsigned int width, unsigned int height);
-    void changeOrthogonal(unsigned int width, unsigned int height);
-    void viewPerspective(void);
-};
-
-extern LLPostProcess * gPostProcess;
-
-
-#endif // LL_POSTPROCESS_H
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index 16a8309a9a..565071ff0d 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -151,7 +151,8 @@ void LLTexUnit::refreshState(void)
 
 void LLTexUnit::activate(void)
 {
-    if (mIndex < 0) return;
+    if (mIndex < 0)
+        return;
 
     if ((S32)gGL.mCurrTextureUnitIndex != mIndex || gGL.mDirty)
     {
@@ -163,7 +164,8 @@ void LLTexUnit::activate(void)
 
 void LLTexUnit::enable(eTextureType type)
 {
-    if (mIndex < 0) return;
+    if (mIndex < 0)
+        return;
 
     if ( (mCurrTexType != type || gGL.mDirty) && (type != TT_NONE) )
     {
@@ -180,7 +182,8 @@ void LLTexUnit::enable(eTextureType type)
 
 void LLTexUnit::disable(void)
 {
-    if (mIndex < 0) return;
+    if (mIndex < 0)
+        return;
 
     if (mCurrTexType != TT_NONE)
     {
@@ -216,7 +219,7 @@ bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
     {
         gGL.flush();
 
-        LLImageGL* gl_tex = NULL ;
+        LLImageGL* gl_tex = NULL;
 
         if (texture != NULL && (gl_tex = texture->getGLTexture()))
         {
@@ -231,8 +234,8 @@ bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
                     glBindTexture(sGLTextureType[gl_tex->getTarget()], mCurrTexture);
                     if(gl_tex->updateBindStats())
                     {
-                        texture->setActive() ;
-                        texture->updateBindStatsForTester() ;
+                        texture->setActive();
+                        texture->updateBindStatsForTester();
                     }
                     mHasMipMaps = gl_tex->mHasMipMaps;
                     if (gl_tex->mTexOptionsDirty)
@@ -246,9 +249,9 @@ bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
             else
             {
                 //if deleted, will re-generate it immediately
-                texture->forceImmediateUpdate() ;
+                texture->forceImmediateUpdate();
 
-                gl_tex->forceUpdateBindStats() ;
+                gl_tex->forceUpdateBindStats();
                 return texture->bindDefaultImage(mIndex);
             }
         }
@@ -276,24 +279,27 @@ bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
 bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind, S32 usename)
 {
     stop_glerror();
-    if (mIndex < 0) return false;
+    if (mIndex < 0)
+    {
+        return false;
+    }
 
     U32 texname = usename ? usename : texture->getTexName();
 
-    if(!texture)
+    if (!texture)
     {
         LL_DEBUGS() << "NULL LLTexUnit::bind texture" << LL_ENDL;
         return false;
     }
 
-    if(!texname)
+    if (!texname)
     {
         if(LLImageGL::sDefaultGLTexture && LLImageGL::sDefaultGLTexture->getTexName())
         {
-            return bind(LLImageGL::sDefaultGLTexture) ;
+            return bind(LLImageGL::sDefaultGLTexture);
         }
         stop_glerror();
-        return false ;
+        return false;
     }
 
     if ((mCurrTexture != texname) || forceBind)
@@ -326,7 +332,10 @@ bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind, S32
 
 bool LLTexUnit::bind(LLCubeMap* cubeMap)
 {
-    if (mIndex < 0) return false;
+    if (mIndex < 0)
+    {
+        return false;
+    }
 
     gGL.flush();
 
@@ -366,7 +375,10 @@ bool LLTexUnit::bind(LLCubeMap* cubeMap)
 // LLRenderTarget is unavailible on the mapserver since it uses FBOs.
 bool LLTexUnit::bind(LLRenderTarget* renderTarget, bool bindDepth)
 {
-    if (mIndex < 0) return false;
+    if (mIndex < 0)
+    {
+        return false;
+    }
 
     gGL.flush();
 
@@ -391,7 +403,7 @@ bool LLTexUnit::bindManual(eTextureType type, U32 texture, bool hasMips)
         return false;
     }
 
-    if(mCurrTexture != texture)
+    if (mCurrTexture != texture)
     {
         gGL.flush();
 
@@ -401,6 +413,7 @@ bool LLTexUnit::bindManual(eTextureType type, U32 texture, bool hasMips)
         glBindTexture(sGLTextureType[type], texture);
         mHasMipMaps = hasMips;
     }
+
     return true;
 }
 
@@ -408,7 +421,8 @@ void LLTexUnit::unbind(eTextureType type)
 {
     stop_glerror();
 
-    if (mIndex < 0) return;
+    if (mIndex < 0)
+        return;
 
     //always flush and activate for consistency
     //   some code paths assume unbind always flushes and sets the active texture
@@ -454,7 +468,8 @@ void LLTexUnit::unbindFast(eTextureType type)
 
 void LLTexUnit::setTextureAddressMode(eTextureAddressMode mode)
 {
-    if (mIndex < 0 || mCurrTexture == 0) return;
+    if (mIndex < 0 || mCurrTexture == 0)
+        return;
 
     gGL.flush();
 
@@ -470,7 +485,8 @@ void LLTexUnit::setTextureAddressMode(eTextureAddressMode mode)
 
 void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions option)
 {
-    if (mIndex < 0 || mCurrTexture == 0 || mCurrTexType == LLTexUnit::TT_MULTISAMPLE_TEXTURE) return;
+    if (mIndex < 0 || mCurrTexture == 0 || mCurrTexType == LLTexUnit::TT_MULTISAMPLE_TEXTURE)
+        return;
 
     gGL.flush();
 
@@ -525,7 +541,7 @@ void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions optio
 
 GLint LLTexUnit::getTextureSource(eTextureBlendSrc src)
 {
-    switch(src)
+    switch (src)
     {
         // All four cases should return the same value.
         case TBS_PREV_COLOR:
@@ -563,14 +579,14 @@ GLint LLTexUnit::getTextureSource(eTextureBlendSrc src)
 
 GLint LLTexUnit::getTextureSourceType(eTextureBlendSrc src, bool isAlpha)
 {
-    switch(src)
+    switch (src)
     {
         // All four cases should return the same value.
         case TBS_PREV_COLOR:
         case TBS_TEX_COLOR:
         case TBS_VERT_COLOR:
         case TBS_CONST_COLOR:
-            return (isAlpha) ? GL_SRC_ALPHA: GL_SRC_COLOR;
+            return isAlpha ? GL_SRC_ALPHA : GL_SRC_COLOR;
 
         // All four cases should return the same value.
         case TBS_PREV_ALPHA:
@@ -584,7 +600,7 @@ GLint LLTexUnit::getTextureSourceType(eTextureBlendSrc src, bool isAlpha)
         case TBS_ONE_MINUS_TEX_COLOR:
         case TBS_ONE_MINUS_VERT_COLOR:
         case TBS_ONE_MINUS_CONST_COLOR:
-            return (isAlpha) ? GL_ONE_MINUS_SRC_ALPHA : GL_ONE_MINUS_SRC_COLOR;
+            return isAlpha ? GL_ONE_MINUS_SRC_ALPHA : GL_ONE_MINUS_SRC_COLOR;
 
         // All four cases should return the same value.
         case TBS_ONE_MINUS_PREV_ALPHA:
@@ -595,7 +611,7 @@ GLint LLTexUnit::getTextureSourceType(eTextureBlendSrc src, bool isAlpha)
 
         default:
             LL_WARNS() << "Unknown eTextureBlendSrc: " << src << ".  Using Source Color or Alpha instead." << LL_ENDL;
-            return (isAlpha) ? GL_SRC_ALPHA: GL_SRC_COLOR;
+            return isAlpha ? GL_SRC_ALPHA : GL_SRC_COLOR;
     }
 }
 
@@ -605,7 +621,7 @@ void LLTexUnit::setColorScale(S32 scale)
     {
         mCurrColorScale = scale;
         gGL.flush();
-        glTexEnvi( GL_TEXTURE_ENV, GL_RGB_SCALE, scale );
+        glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE, scale);
     }
 }
 
@@ -615,7 +631,7 @@ void LLTexUnit::setAlphaScale(S32 scale)
     {
         mCurrAlphaScale = scale;
         gGL.flush();
-        glTexEnvi( GL_TEXTURE_ENV, GL_ALPHA_SCALE, scale );
+        glTexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE, scale);
     }
 }
 
@@ -623,7 +639,8 @@ void LLTexUnit::setAlphaScale(S32 scale)
 // texture unit based on the currently set active texture in opengl.
 void LLTexUnit::debugTextureUnit(void)
 {
-    if (mIndex < 0) return;
+    if (mIndex < 0)
+        return;
 
     GLint activeTexture;
     glGetIntegerv(GL_ACTIVE_TEXTURE, &activeTexture);
@@ -645,16 +662,16 @@ LLLightState::LLLightState(S32 index)
 {
     if (mIndex == 0)
     {
-        mDiffuse.set(1,1,1,1);
-        mDiffuseB.set(0,0,0,0);
-        mSpecular.set(1,1,1,1);
+        mDiffuse.set(1, 1, 1, 1);
+        mDiffuseB.set(0, 0, 0, 0);
+        mSpecular.set(1, 1, 1, 1);
     }
 
     mSunIsPrimary = true;
 
-    mAmbient.set(0,0,0,1);
-    mPosition.set(0,0,1,0);
-    mSpotDirection.set(0,0,-1);
+    mAmbient.set(0, 0, 0, 1);
+    mPosition.set(0, 0, 1, 0);
+    mSpotDirection.set(0, 0, -1);
 }
 
 void LLLightState::enable()
@@ -803,7 +820,6 @@ void LLLightState::setSpotDirection(const LLVector3& direction)
 LLRender::LLRender()
   : mDirty(false),
     mCount(0),
-    mQuadCycle(0),
     mMode(LLRender::TRIANGLES),
     mCurrTextureUnitIndex(0)
 {
@@ -887,6 +903,7 @@ bool LLRender::init(bool needs_vertex_buffer)
     {
         initVertexBuffer();
     }
+
     return true;
 }
 
@@ -1120,7 +1137,6 @@ void LLRender::syncMatrices()
             }
         }
 
-
         if (shader->mFeatures.hasLighting || shader->mFeatures.calculatesLighting || shader->mFeatures.calculatesAtmospherics)
         { //also sync light state
             syncLightState();
@@ -1133,91 +1149,78 @@ void LLRender::translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
 {
     flush();
 
-    {
-        mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::translate(mMatrix[mMatrixMode][mMatIdx[mMatrixMode]], glm::vec3(x, y, z));
-        mMatHash[mMatrixMode]++;
-    }
+    mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::translate(mMatrix[mMatrixMode][mMatIdx[mMatrixMode]], glm::vec3(x, y, z));
+    mMatHash[mMatrixMode]++;
 }
 
 void LLRender::scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
 {
     flush();
 
-    {
-        mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::scale(mMatrix[mMatrixMode][mMatIdx[mMatrixMode]], glm::vec3(x, y, z));
-        mMatHash[mMatrixMode]++;
-    }
+    mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::scale(mMatrix[mMatrixMode][mMatIdx[mMatrixMode]], glm::vec3(x, y, z));
+    mMatHash[mMatrixMode]++;
 }
 
 void LLRender::ortho(F32 left, F32 right, F32 bottom, F32 top, F32 zNear, F32 zFar)
 {
     flush();
 
-    {
-        mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] *= glm::ortho(left, right, bottom, top, zNear, zFar);
-        mMatHash[mMatrixMode]++;
-    }
+    mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] *= glm::ortho(left, right, bottom, top, zNear, zFar);
+    mMatHash[mMatrixMode]++;
 }
 
 void LLRender::rotatef(const GLfloat& a, const GLfloat& x, const GLfloat& y, const GLfloat& z)
 {
     flush();
 
-    {
-        mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::rotate(mMatrix[mMatrixMode][mMatIdx[mMatrixMode]], glm::radians(a), glm::vec3(x,y,z));
-        mMatHash[mMatrixMode]++;
-    }
+    mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::rotate(mMatrix[mMatrixMode][mMatIdx[mMatrixMode]], glm::radians(a), glm::vec3(x,y,z));
+    mMatHash[mMatrixMode]++;
 }
 
 void LLRender::pushMatrix()
 {
     flush();
 
+    if (mMatIdx[mMatrixMode] < LL_MATRIX_STACK_DEPTH-1)
     {
-        if (mMatIdx[mMatrixMode] < LL_MATRIX_STACK_DEPTH-1)
-        {
-            mMatrix[mMatrixMode][mMatIdx[mMatrixMode]+1] = mMatrix[mMatrixMode][mMatIdx[mMatrixMode]];
-            ++mMatIdx[mMatrixMode];
-        }
-        else
-        {
-            LL_WARNS() << "Matrix stack overflow." << LL_ENDL;
-        }
+        mMatrix[mMatrixMode][mMatIdx[mMatrixMode]+1] = mMatrix[mMatrixMode][mMatIdx[mMatrixMode]];
+        ++mMatIdx[mMatrixMode];
+    }
+    else
+    {
+        LL_WARNS() << "Matrix stack overflow." << LL_ENDL;
     }
 }
 
 void LLRender::popMatrix()
 {
     flush();
+
+    if (mMatIdx[mMatrixMode] > 0)
     {
-        if (mMatIdx[mMatrixMode] > 0)
-        {
-            --mMatIdx[mMatrixMode];
-            mMatHash[mMatrixMode]++;
-        }
-        else
-        {
-            LL_WARNS() << "Matrix stack underflow." << LL_ENDL;
-        }
+        --mMatIdx[mMatrixMode];
+        mMatHash[mMatrixMode]++;
+    }
+    else
+    {
+        LL_WARNS() << "Matrix stack underflow." << LL_ENDL;
     }
 }
 
 void LLRender::loadMatrix(const GLfloat* m)
 {
     flush();
-    {
-        mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::make_mat4((GLfloat*) m);
-        mMatHash[mMatrixMode]++;
-    }
+
+    mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::make_mat4((GLfloat*) m);
+    mMatHash[mMatrixMode]++;
 }
 
 void LLRender::multMatrix(const GLfloat* m)
 {
     flush();
-    {
-        mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] *= glm::make_mat4(m);
-        mMatHash[mMatrixMode]++;
-    }
+
+    mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] *= glm::make_mat4(m);
+    mMatHash[mMatrixMode]++;
 }
 
 void LLRender::matrixMode(eMatrixMode mode)
@@ -1255,12 +1258,10 @@ void LLRender::loadIdentity()
 {
     flush();
 
-    {
-        llassert_always(mMatrixMode < NUM_MATRIX_MODES) ;
+    llassert_always(mMatrixMode < NUM_MATRIX_MODES);
 
-        mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::identity<glm::mat4>();
-        mMatHash[mMatrixMode]++;
-    }
+    mMatrix[mMatrixMode][mMatIdx[mMatrixMode]] = glm::identity<glm::mat4>();
+    mMatHash[mMatrixMode]++;
 }
 
 const glm::mat4& LLRender::getModelviewMatrix()
@@ -1280,9 +1281,7 @@ void LLRender::translateUI(F32 x, F32 y, F32 z)
         LL_ERRS() << "Need to push a UI translation frame before offsetting" << LL_ENDL;
     }
 
-    mUIOffset.back().mV[0] += x;
-    mUIOffset.back().mV[1] += y;
-    mUIOffset.back().mV[2] += z;
+    mUIOffset.back().add(LLVector4a(x, y, z));
 }
 
 void LLRender::scaleUI(F32 x, F32 y, F32 z)
@@ -1292,14 +1291,14 @@ void LLRender::scaleUI(F32 x, F32 y, F32 z)
         LL_ERRS() << "Need to push a UI transformation frame before scaling." << LL_ENDL;
     }
 
-    mUIScale.back().scaleVec(LLVector3(x,y,z));
+    mUIScale.back().mul(LLVector4a(x, y, z));
 }
 
 void LLRender::pushUIMatrix()
 {
     if (mUIOffset.empty())
     {
-        mUIOffset.push_back(LLVector3(0,0,0));
+        mUIOffset.emplace_back(0.f);
     }
     else
     {
@@ -1308,7 +1307,7 @@ void LLRender::pushUIMatrix()
 
     if (mUIScale.empty())
     {
-        mUIScale.push_back(LLVector3(1,1,1));
+        mUIScale.emplace_back(1.f);
     }
     else
     {
@@ -1330,18 +1329,20 @@ LLVector3 LLRender::getUITranslation()
 {
     if (mUIOffset.empty())
     {
-        return LLVector3(0,0,0);
+        return LLVector3::zero;
     }
-    return mUIOffset.back();
+
+    return LLVector3(mUIOffset.back().getF32ptr());
 }
 
 LLVector3 LLRender::getUIScale()
 {
     if (mUIScale.empty())
     {
-        return LLVector3(1,1,1);
+        return LLVector3::all_one;
     }
-    return mUIScale.back();
+
+    return LLVector3(mUIScale.back().getF32ptr());
 }
 
 
@@ -1351,8 +1352,9 @@ void LLRender::loadUIIdentity()
     {
         LL_ERRS() << "Need to push UI translation frame before clearing offset." << LL_ENDL;
     }
-    mUIOffset.back().setVec(0,0,0);
-    mUIScale.back().setVec(1,1,1);
+
+    mUIOffset.back().clear();
+    mUIScale.back().splat(1);
 }
 
 void LLRender::setColorMask(bool writeColor, bool writeAlpha)
@@ -1446,7 +1448,7 @@ void LLRender::blendFunc(eBlendFactor color_sfactor, eBlendFactor color_dfactor,
         flush();
 
         glBlendFuncSeparate(sGLBlendFactor[color_sfactor], sGLBlendFactor[color_dfactor],
-                           sGLBlendFactor[alpha_sfactor], sGLBlendFactor[alpha_dfactor]);
+                            sGLBlendFactor[alpha_sfactor], sGLBlendFactor[alpha_dfactor]);
     }
 }
 
@@ -1456,11 +1458,9 @@ LLTexUnit* LLRender::getTexUnit(U32 index)
     {
         return &mTexUnits[index];
     }
-    else
-    {
-        LL_DEBUGS() << "Non-existing texture unit layer requested: " << index << LL_ENDL;
-        return &mDummyTexUnit;
-    }
+
+    LL_DEBUGS() << "Non-existing texture unit layer requested: " << index << LL_ENDL;
+    return &mDummyTexUnit;
 }
 
 LLLightState* LLRender::getLight(U32 index)
@@ -1489,11 +1489,9 @@ bool LLRender::verifyTexUnitActive(U32 unitToVerify)
     {
         return true;
     }
-    else
-    {
-        LL_WARNS() << "TexUnit currently active: " << mCurrTextureUnitIndex << " (expecting " << unitToVerify << ")" << LL_ENDL;
-        return false;
-    }
+
+    LL_WARNS() << "TexUnit currently active: " << mCurrTextureUnitIndex << " (expecting " << unitToVerify << ")" << LL_ENDL;
+    return false;
 }
 
 void LLRender::clearErrors()
@@ -1510,6 +1508,7 @@ void LLRender::beginList(std::list<LLVertexBufferData> *list)
     {
         LL_ERRS() << "beginList called while another list is open." << LL_ENDL;
     }
+
     llassert(LLGLSLShader::sCurBoundShaderPtr == &gUIProgram);
     flush();
     sBufferDataList = list;
@@ -1532,13 +1531,7 @@ void LLRender::begin(const GLuint& mode)
 {
     if (mode != mMode)
     {
-        if (mode == LLRender::QUADS)
-        {
-            mQuadCycle = 1;
-        }
-
-        if (mMode == LLRender::QUADS ||
-            mMode == LLRender::LINES ||
+        if (mMode == LLRender::LINES ||
             mMode == LLRender::TRIANGLES ||
             mMode == LLRender::POINTS)
         {
@@ -1561,8 +1554,7 @@ void LLRender::end()
         //IMM_ERRS << "GL begin and end called with no vertices specified." << LL_ENDL;
     }
 
-    if ((mMode != LLRender::QUADS &&
-        mMode != LLRender::LINES &&
+    if ((mMode != LLRender::LINES &&
         mMode != LLRender::TRIANGLES &&
         mMode != LLRender::POINTS) ||
         mCount > 2048)
@@ -1587,28 +1579,19 @@ void LLRender::flush()
         //store mCount in a local variable to avoid re-entrance (drawArrays may call flush)
         U32 count = mCount;
 
-            if (mMode == LLRender::QUADS && !sGLCoreProfile)
-            {
-                if (mCount%4 != 0)
-                {
-                count -= (mCount % 4);
-                LL_WARNS() << "Incomplete quad requested." << LL_ENDL;
-                }
-            }
-
-            if (mMode == LLRender::TRIANGLES)
+        if (mMode == LLRender::TRIANGLES)
+        {
+            if (mCount % 3 != 0)
             {
-                if (mCount%3 != 0)
-                {
-                count -= (mCount % 3);
-                LL_WARNS() << "Incomplete triangle requested." << LL_ENDL;
-                }
+            count -= (mCount % 3);
+            LL_WARNS() << "Incomplete triangle requested." << LL_ENDL;
             }
+        }
 
-            if (mMode == LLRender::LINES)
+        if (mMode == LLRender::LINES)
+        {
+            if (mCount % 2 != 0)
             {
-                if (mCount%2 != 0)
-                {
                 count -= (mCount % 2);
                 LL_WARNS() << "Incomplete line requested." << LL_ENDL;
             }
@@ -1618,7 +1601,6 @@ void LLRender::flush()
 
         if (mBuffer)
         {
-
             LLVertexBuffer *vb;
 
             U32 attribute_mask = LLGLSLShader::sCurBoundShaderPtr->mAttributeMask;
@@ -1725,6 +1707,7 @@ LLVertexBuffer* LLRender::bufferfromCache(U32 attribute_mask, U32 count)
             }
         }
     }
+
     return vb;
 }
 
@@ -1735,7 +1718,7 @@ LLVertexBuffer* LLRender::genBuffer(U32 attribute_mask, S32 count)
 
     vb->setBuffer();
 
-    vb->setPositionData((LLVector4a*)mVerticesp.get());
+    vb->setPositionData(mVerticesp.get());
 
     if (attribute_mask & LLVertexBuffer::MAP_TEXCOORD0)
     {
@@ -1758,16 +1741,7 @@ LLVertexBuffer* LLRender::genBuffer(U32 attribute_mask, S32 count)
 void LLRender::drawBuffer(LLVertexBuffer* vb, U32 mode, S32 count)
 {
     vb->setBuffer();
-
-    if (mode == LLRender::QUADS && sGLCoreProfile)
-    {
-        vb->drawArrays(LLRender::TRIANGLES, 0, count);
-        mQuadCycle = 1;
-    }
-    else
-    {
-        vb->drawArrays(mode, 0, count);
-    }
+    vb->drawArrays(mode, 0, count);
 }
 
 void LLRender::resetStriders(S32 count)
@@ -1781,15 +1755,26 @@ void LLRender::resetStriders(S32 count)
 
 void LLRender::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
 {
-    //the range of mVerticesp, mColorsp and mTexcoordsp is [0, 4095]
+    // the range of mVerticesp, mColorsp and mTexcoordsp is [0, 4095]
     if (mCount > 2048)
-    { //break when buffer gets reasonably full to keep GL command buffers happy and avoid overflow below
+    { // break when buffer gets reasonably full to keep GL command buffers happy and avoid overflow below
         switch (mMode)
         {
-            case LLRender::POINTS: flush(); break;
-            case LLRender::TRIANGLES: if (mCount%3==0) flush(); break;
-            case LLRender::QUADS: if(mCount%4 == 0) flush(); break;
-            case LLRender::LINES: if (mCount%2 == 0) flush(); break;
+            case LLRender::POINTS:
+                flush();
+                break;
+            case LLRender::TRIANGLES:
+                if (mCount % 3 == 0)
+                {
+                    flush();
+                }
+                break;
+            case LLRender::LINES:
+                if (mCount % 2 == 0)
+                {
+                    flush();
+                }
+                break;
         }
     }
 
@@ -1799,42 +1784,64 @@ void LLRender::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
         return;
     }
 
-    if (mUIOffset.empty())
+    LLVector4a vert(x, y, z);
+    transform(vert);
+    mVerticesp[mCount] = vert;
+
+    mCount++;
+    mVerticesp[mCount] = vert;
+    mColorsp[mCount] = mColorsp[mCount-1];
+    mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
+}
+
+void LLRender::transform(LLVector3& vert)
+{
+    if (!mUIOffset.empty())
     {
-        mVerticesp[mCount] = LLVector3(x,y,z);
+        vert += LLVector3(mUIOffset.back().getF32ptr());
+        vert *= LLVector3(mUIScale.back().getF32ptr());
     }
-    else
+}
+
+void LLRender::transform(LLVector4a& vert)
+{
+    if (!mUIOffset.empty())
     {
-        LLVector3 vert = (LLVector3(x,y,z)+mUIOffset.back()).scaledVec(mUIScale.back());
-        mVerticesp[mCount] = vert;
+        vert.add(mUIOffset.back());
+        vert.mul(mUIScale.back());
     }
+}
 
-    if (mMode == LLRender::QUADS && LLRender::sGLCoreProfile)
+void LLRender::untransform(LLVector3& vert)
+{
+    if (!mUIOffset.empty())
     {
-        mQuadCycle++;
-        if (mQuadCycle == 4)
-        { //copy two vertices so fourth quad element will add a triangle
-            mQuadCycle = 0;
+        vert /= LLVector3(mUIScale.back().getF32ptr());
+        vert -= LLVector3(mUIOffset.back().getF32ptr());
+    }
+}
 
-            mCount++;
-            mVerticesp[mCount] = mVerticesp[mCount-3];
-            mColorsp[mCount] = mColorsp[mCount-3];
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-3];
+void LLRender::batchTransform(LLVector4a* verts, U32 vert_count)
+{
+    if (!mUIOffset.empty())
+    {
+        const LLVector4a& offset = mUIOffset.back();
+        const LLVector4a& scale = mUIScale.back();
 
-            mCount++;
-            mVerticesp[mCount] = mVerticesp[mCount-2];
-            mColorsp[mCount] = mColorsp[mCount-2];
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-2];
+        for (U32 i = 0; i < vert_count; ++i)
+        {
+            verts[i].add(offset);
+            verts[i].mul(scale);
         }
     }
+}
 
-    mCount++;
-    mVerticesp[mCount] = mVerticesp[mCount-1];
-    mColorsp[mCount] = mColorsp[mCount-1];
-    mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
+void LLRender::vertexBatchPreTransformed(const std::vector<LLVector4a>& verts)
+{
+    vertexBatchPreTransformed(verts.data(), verts.size());
 }
 
-void LLRender::vertexBatchPreTransformed(LLVector3* verts, S32 vert_count)
+void LLRender::vertexBatchPreTransformed(const LLVector4a* verts, std::size_t vert_count)
 {
     if (mCount + vert_count > 4094)
     {
@@ -1842,57 +1849,22 @@ void LLRender::vertexBatchPreTransformed(LLVector3* verts, S32 vert_count)
         return;
     }
 
-    if (sGLCoreProfile && mMode == LLRender::QUADS)
-    { //quads are deprecated, convert to triangle list
-        S32 i = 0;
-
-        while (i < vert_count)
-        {
-            //read first three
-            mVerticesp[mCount++] = verts[i++];
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            mVerticesp[mCount++] = verts[i++];
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            mVerticesp[mCount++] = verts[i++];
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            //copy two
-            mVerticesp[mCount++] = verts[i-3];
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            mVerticesp[mCount++] = verts[i-1];
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            //copy last one
-            mVerticesp[mCount++] = verts[i++];
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-            mColorsp[mCount] = mColorsp[mCount-1];
-        }
-    }
-    else
+    for (S32 i = 0; i < vert_count; i++)
     {
-        for (S32 i = 0; i < vert_count; i++)
-        {
-            mVerticesp[mCount] = verts[i];
+        mVerticesp[mCount] = verts[i];
 
-            mCount++;
-            mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-            mColorsp[mCount] = mColorsp[mCount-1];
-        }
+        mCount++;
+        mTexcoordsp[mCount] = mTexcoordsp[mCount - 1];
+        mColorsp[mCount] = mColorsp[mCount - 1];
     }
 
-    if( mCount > 0 ) // ND: Guard against crashes if mCount is zero, yes it can happen
-        mVerticesp[mCount] = mVerticesp[mCount-1];
+    if (mCount > 0) // ND: Guard against crashes if mCount is zero, yes it can happen
+    {
+        mVerticesp[mCount] = mVerticesp[mCount - 1];
+    }
 }
 
-void LLRender::vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, S32 vert_count)
+void LLRender::vertexBatchPreTransformed(const LLVector4a* verts, const LLVector2* uvs, std::size_t vert_count)
 {
     if (mCount + vert_count > 4094)
     {
@@ -1900,50 +1872,13 @@ void LLRender::vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, S32 v
         return;
     }
 
-    if (sGLCoreProfile && mMode == LLRender::QUADS)
-    { //quads are deprecated, convert to triangle list
-        S32 i = 0;
-
-        while (i < vert_count)
-        {
-            //read first three
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount++] = uvs[i++];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount++] = uvs[i++];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount++] = uvs[i++];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            //copy last two
-            mVerticesp[mCount] = verts[i-3];
-            mTexcoordsp[mCount++] = uvs[i-3];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            mVerticesp[mCount] = verts[i-1];
-            mTexcoordsp[mCount++] = uvs[i-1];
-            mColorsp[mCount] = mColorsp[mCount-1];
-
-            //copy last one
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount++] = uvs[i++];
-            mColorsp[mCount] = mColorsp[mCount-1];
-        }
-    }
-    else
+    for (S32 i = 0; i < vert_count; i++)
     {
-        for (S32 i = 0; i < vert_count; i++)
-        {
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount] = uvs[i];
+        mVerticesp[mCount] = verts[i];
+        mTexcoordsp[mCount] = uvs[i];
 
-            mCount++;
-            mColorsp[mCount] = mColorsp[mCount-1];
-        }
+        mCount++;
+        mColorsp[mCount] = mColorsp[mCount-1];
     }
 
     if (mCount > 0)
@@ -1953,7 +1888,7 @@ void LLRender::vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, S32 v
     }
 }
 
-void LLRender::vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, LLColor4U* colors, S32 vert_count)
+void LLRender::vertexBatchPreTransformed(const LLVector4a* verts, const LLVector2* uvs, const LLColor4U* colors, std::size_t vert_count)
 {
     if (mCount + vert_count > 4094)
     {
@@ -1961,51 +1896,13 @@ void LLRender::vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, LLCol
         return;
     }
 
-
-    if (sGLCoreProfile && mMode == LLRender::QUADS)
-    { //quads are deprecated, convert to triangle list
-        S32 i = 0;
-
-        while (i < vert_count)
-        {
-            //read first three
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount] = uvs[i];
-            mColorsp[mCount++] = colors[i++];
-
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount] = uvs[i];
-            mColorsp[mCount++] = colors[i++];
-
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount] = uvs[i];
-            mColorsp[mCount++] = colors[i++];
-
-            //copy last two
-            mVerticesp[mCount] = verts[i-3];
-            mTexcoordsp[mCount] = uvs[i-3];
-            mColorsp[mCount++] = colors[i-3];
-
-            mVerticesp[mCount] = verts[i-1];
-            mTexcoordsp[mCount] = uvs[i-1];
-            mColorsp[mCount++] = colors[i-1];
-
-            //copy last one
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount] = uvs[i];
-            mColorsp[mCount++] = colors[i++];
-        }
-    }
-    else
+    for (S32 i = 0; i < vert_count; i++)
     {
-        for (S32 i = 0; i < vert_count; i++)
-        {
-            mVerticesp[mCount] = verts[i];
-            mTexcoordsp[mCount] = uvs[i];
-            mColorsp[mCount] = colors[i];
+        mVerticesp[mCount] = verts[i];
+        mTexcoordsp[mCount] = uvs[i];
+        mColorsp[mCount] = colors[i];
 
-            mCount++;
-        }
+        mCount++;
     }
 
     if (mCount > 0)
@@ -2018,27 +1915,27 @@ void LLRender::vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, LLCol
 
 void LLRender::vertex2i(const GLint& x, const GLint& y)
 {
-    vertex3f((GLfloat) x, (GLfloat) y, 0);
+    vertex3f((GLfloat)x, (GLfloat)y, 0);
 }
 
 void LLRender::vertex2f(const GLfloat& x, const GLfloat& y)
 {
-    vertex3f(x,y,0);
+    vertex3f(x, y, 0);
 }
 
 void LLRender::vertex2fv(const GLfloat* v)
 {
-    vertex3f(v[0], v[1], 0);
+    vertex3f(v[VX], v[VY], 0);
 }
 
 void LLRender::vertex3fv(const GLfloat* v)
 {
-    vertex3f(v[0], v[1], v[2]);
+    vertex3f(v[VX], v[VY], v[VZ]);
 }
 
 void LLRender::texCoord2f(const GLfloat& x, const GLfloat& y)
 {
-    mTexcoordsp[mCount] = LLVector2(x,y);
+    mTexcoordsp[mCount].set(x,y);
 }
 
 void LLRender::texCoord2i(const GLint& x, const GLint& y)
@@ -2048,46 +1945,47 @@ void LLRender::texCoord2i(const GLint& x, const GLint& y)
 
 void LLRender::texCoord2fv(const GLfloat* tc)
 {
-    texCoord2f(tc[0], tc[1]);
+    texCoord2f(tc[VX], tc[VY]);
 }
 
 void LLRender::color4ub(const GLubyte& r, const GLubyte& g, const GLubyte& b, const GLubyte& a)
 {
-    if (!LLGLSLShader::sCurBoundShaderPtr || LLGLSLShader::sCurBoundShaderPtr->mAttributeMask & LLVertexBuffer::MAP_COLOR)
+    if (!LLGLSLShader::sCurBoundShaderPtr ||
+        LLGLSLShader::sCurBoundShaderPtr->mAttributeMask & LLVertexBuffer::MAP_COLOR)
     {
-        mColorsp[mCount] = LLColor4U(r,g,b,a);
+        mColorsp[mCount].set(r, g, b, a);
     }
     else
     { //not using shaders or shader reads color from a uniform
-        diffuseColor4ub(r,g,b,a);
+        diffuseColor4ub(r, g, b, a);
     }
 }
 void LLRender::color4ubv(const GLubyte* c)
 {
-    color4ub(c[0], c[1], c[2], c[3]);
+    color4ub(c[VX], c[VY], c[VZ], c[VW]);
 }
 
 void LLRender::color4f(const GLfloat& r, const GLfloat& g, const GLfloat& b, const GLfloat& a)
 {
-    color4ub((GLubyte) (llclamp(r, 0.f, 1.f)*255),
-        (GLubyte) (llclamp(g, 0.f, 1.f)*255),
-        (GLubyte) (llclamp(b, 0.f, 1.f)*255),
-        (GLubyte) (llclamp(a, 0.f, 1.f)*255));
+    color4ub((GLubyte) (llclamp(r, 0.f, 1.f) * 255),
+        (GLubyte) (llclamp(g, 0.f, 1.f) * 255),
+        (GLubyte) (llclamp(b, 0.f, 1.f) * 255),
+        (GLubyte) (llclamp(a, 0.f, 1.f) * 255));
 }
 
 void LLRender::color4fv(const GLfloat* c)
 {
-    color4f(c[0],c[1],c[2],c[3]);
+    color4f(c[VX], c[VY], c[VZ], c[VW]);
 }
 
 void LLRender::color3f(const GLfloat& r, const GLfloat& g, const GLfloat& b)
 {
-    color4f(r,g,b,1);
+    color4f(r, g, b, 1);
 }
 
 void LLRender::color3fv(const GLfloat* c)
 {
-    color4f(c[0],c[1],c[2],1);
+    color4f(c[VX], c[VY], c[VZ], 1);
 }
 
 void LLRender::diffuseColor3f(F32 r, F32 g, F32 b)
@@ -2097,7 +1995,7 @@ void LLRender::diffuseColor3f(F32 r, F32 g, F32 b)
 
     if (shader)
     {
-        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r,g,b,1.f);
+        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r, g, b, 1.f);
     }
 }
 
@@ -2108,7 +2006,7 @@ void LLRender::diffuseColor3fv(const F32* c)
 
     if (shader)
     {
-        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, c[0], c[1], c[2], 1.f);
+        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, c[VX], c[VY], c[VZ], 1.f);
     }
 }
 
@@ -2119,7 +2017,7 @@ void LLRender::diffuseColor4f(F32 r, F32 g, F32 b, F32 a)
 
     if (shader)
     {
-        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r,g,b,a);
+        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r, g, b, a);
     }
 }
 
@@ -2141,7 +2039,7 @@ void LLRender::diffuseColor4ubv(const U8* c)
 
     if (shader)
     {
-        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, c[0]/255.f, c[1]/255.f, c[2]/255.f, c[3]/255.f);
+        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, c[0] / 255.f, c[1] / 255.f, c[2] / 255.f, c[3] / 255.f);
     }
 }
 
@@ -2152,11 +2050,10 @@ void LLRender::diffuseColor4ub(U8 r, U8 g, U8 b, U8 a)
 
     if (shader)
     {
-        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r/255.f, g/255.f, b/255.f, a/255.f);
+        shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r / 255.f, g / 255.f, b / 255.f, a / 255.f);
     }
 }
 
-
 void LLRender::debugTexUnits(void)
 {
     LL_INFOS("TextureUnit") << "Active TexUnit: " << mCurrTextureUnitIndex << LL_ENDL;
@@ -2167,7 +2064,7 @@ void LLRender::debugTexUnits(void)
         {
             if (i == mCurrTextureUnitIndex) active_enabled = "true";
             LL_INFOS("TextureUnit") << "TexUnit: " << i << " Enabled" << LL_ENDL;
-            LL_INFOS("TextureUnit") << "Enabled As: " ;
+            LL_INFOS("TextureUnit") << "Enabled As: ";
             switch (getTexUnit(i)->mCurrTexType)
             {
                 case LLTexUnit::TT_TEXTURE:
@@ -2252,10 +2149,10 @@ glm::vec3 mul_mat4_vec3(const glm::mat4& mat, const glm::vec3& vec)
     y.splat(vec.y);
     z.splat(vec.z);
 
-    s.splat<3>(mat[0].data);
-    t.splat<3>(mat[1].data);
-    p.splat<3>(mat[2].data);
-    q.splat<3>(mat[3].data);
+    s.splat<3>(mat[VX].data);
+    t.splat<3>(mat[VY].data);
+    p.splat<3>(mat[VZ].data);
+    q.splat<3>(mat[VW].data);
 
     s.mul(x);
     t.mul(y);
@@ -2264,12 +2161,12 @@ glm::vec3 mul_mat4_vec3(const glm::mat4& mat, const glm::vec3& vec)
     t.add(p);
     q.add(t);
 
-    x.mul(mat[0].data);
-    y.mul(mat[1].data);
-    z.mul(mat[2].data);
+    x.mul(mat[VX].data);
+    y.mul(mat[VY].data);
+    z.mul(mat[VZ].data);
 
     x.add(y);
-    z.add(mat[3].data);
+    z.add(mat[VW].data);
     LLVector4a res;
     res.load3(glm::value_ptr(vec));
     res.setAdd(x, z);
diff --git a/indra/llrender/llrender.h b/indra/llrender/llrender.h
index 2645597b1a..8c7126420e 100644
--- a/indra/llrender/llrender.h
+++ b/indra/llrender/llrender.h
@@ -46,6 +46,7 @@
 
 #include <array>
 #include <list>
+#include <vector>
 
 class LLVertexBuffer;
 class LLCubeMap;
@@ -319,7 +320,6 @@ public:
         POINTS,
         LINES,
         LINE_STRIP,
-        QUADS,
         LINE_LOOP,
         NUM_MODES
     };
@@ -450,9 +450,16 @@ public:
     void diffuseColor4ubv(const U8* c);
     void diffuseColor4ub(U8 r, U8 g, U8 b, U8 a);
 
-    void vertexBatchPreTransformed(LLVector3* verts, S32 vert_count);
-    void vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, S32 vert_count);
-    void vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, LLColor4U*, S32 vert_count);
+    void transform(LLVector3& vert);
+    void transform(LLVector4a& vert);
+    void untransform(LLVector3& vert);
+
+    void batchTransform(LLVector4a* verts, U32 vert_count);
+
+    void vertexBatchPreTransformed(const std::vector<LLVector4a>& verts);
+    void vertexBatchPreTransformed(const LLVector4a* verts, std::size_t vert_count);
+    void vertexBatchPreTransformed(const LLVector4a* verts, const LLVector2* uvs, std::size_t vert_count);
+    void vertexBatchPreTransformed(const LLVector4a* verts, const LLVector2* uvs, const LLColor4U*, std::size_t vert_count);
 
     void setColorMask(bool writeColor, bool writeAlpha);
     void setColorMask(bool writeColorR, bool writeColorG, bool writeColorB, bool writeAlpha);
@@ -508,14 +515,13 @@ private:
     LLColor4 mAmbientLightColor;
 
     bool            mDirty;
-    U32             mQuadCycle;
     U32             mCount;
     U32             mMode;
     U32             mCurrTextureUnitIndex;
     bool                mCurrColorMask[4];
 
     LLPointer<LLVertexBuffer>   mBuffer;
-    LLStrider<LLVector3>        mVerticesp;
+    LLStrider<LLVector4a>       mVerticesp;
     LLStrider<LLVector2>        mTexcoordsp;
     LLStrider<LLColor4U>        mColorsp;
     std::array<LLTexUnit, LL_NUM_TEXTURE_LAYERS> mTexUnits;
@@ -527,8 +533,8 @@ private:
     eBlendFactor mCurrBlendAlphaSFactor;
     eBlendFactor mCurrBlendAlphaDFactor;
 
-    std::vector<LLVector3> mUIOffset;
-    std::vector<LLVector3> mUIScale;
+    std::vector<LLVector4a> mUIOffset;
+    std::vector<LLVector4a> mUIScale;
 };
 
 extern F32 gGLModelView[16];
diff --git a/indra/llrender/llrender2dutils.cpp b/indra/llrender/llrender2dutils.cpp
index 428370057e..0cd0c5fe6e 100644
--- a/indra/llrender/llrender2dutils.cpp
+++ b/indra/llrender/llrender2dutils.cpp
@@ -122,10 +122,13 @@ void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, bool filled )
     // Counterclockwise quad will face the viewer
     if( filled )
     {
-        gGL.begin( LLRender::QUADS );
+        gGL.begin( LLRender::TRIANGLES );
             gGL.vertex2i(left, top);
             gGL.vertex2i(left, bottom);
             gGL.vertex2i(right, bottom);
+
+            gGL.vertex2i(left, top);
+            gGL.vertex2i(right, bottom);
             gGL.vertex2i(right, top);
         gGL.end();
     }
@@ -172,50 +175,70 @@ void gl_drop_shadow(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &st
     LLColor4 end_color = start_color;
     end_color.mV[VALPHA] = 0.f;
 
-    gGL.begin(LLRender::QUADS);
+    gGL.begin(LLRender::TRIANGLES);
 
     // Right edge, CCW faces screen
     gGL.color4fv(start_color.mV);
-    gGL.vertex2i(right,     top-lines);
-    gGL.vertex2i(right,     bottom);
+    gGL.vertex2i(right, top - lines);
+    gGL.vertex2i(right, bottom);
+    gGL.color4fv(end_color.mV);
+    gGL.vertex2i(right + lines, bottom);
+    gGL.color4fv(start_color.mV);
+    gGL.vertex2i(right, top - lines);
     gGL.color4fv(end_color.mV);
-    gGL.vertex2i(right+lines, bottom);
-    gGL.vertex2i(right+lines, top-lines);
+    gGL.vertex2i(right + lines, bottom);
+    gGL.vertex2i(right + lines, top - lines);
 
     // Bottom edge, CCW faces screen
     gGL.color4fv(start_color.mV);
-    gGL.vertex2i(right,     bottom);
-    gGL.vertex2i(left+lines,    bottom);
+    gGL.vertex2i(right, bottom);
+    gGL.vertex2i(left + lines, bottom);
+    gGL.color4fv(end_color.mV);
+    gGL.vertex2i(left + lines, bottom - lines);
+    gGL.color4fv(start_color.mV);
+    gGL.vertex2i(right, bottom);
     gGL.color4fv(end_color.mV);
-    gGL.vertex2i(left+lines,    bottom-lines);
-    gGL.vertex2i(right,     bottom-lines);
+    gGL.vertex2i(left + lines, bottom - lines);
+    gGL.vertex2i(right, bottom - lines);
 
     // bottom left Corner
     gGL.color4fv(start_color.mV);
-    gGL.vertex2i(left+lines,    bottom);
+    gGL.vertex2i(left + lines, bottom);
     gGL.color4fv(end_color.mV);
-    gGL.vertex2i(left,      bottom);
+    gGL.vertex2i(left, bottom);
     // make the bottom left corner not sharp
-    gGL.vertex2i(left+1,        bottom-lines+1);
-    gGL.vertex2i(left+lines,    bottom-lines);
+    gGL.vertex2i(left + 1, bottom - lines + 1);
+    gGL.color4fv(start_color.mV);
+    gGL.vertex2i(left + lines, bottom);
+    gGL.color4fv(end_color.mV);
+    gGL.vertex2i(left + 1, bottom - lines + 1);
+    gGL.vertex2i(left + lines, bottom - lines);
 
     // bottom right corner
     gGL.color4fv(start_color.mV);
-    gGL.vertex2i(right,     bottom);
+    gGL.vertex2i(right, bottom);
     gGL.color4fv(end_color.mV);
-    gGL.vertex2i(right,     bottom-lines);
+    gGL.vertex2i(right, bottom - lines);
     // make the rightmost corner not sharp
-    gGL.vertex2i(right+lines-1, bottom-lines+1);
-    gGL.vertex2i(right+lines,   bottom);
+    gGL.vertex2i(right + lines - 1, bottom - lines + 1);
+    gGL.color4fv(start_color.mV);
+    gGL.vertex2i(right, bottom);
+    gGL.color4fv(end_color.mV);
+    gGL.vertex2i(right + lines - 1, bottom - lines + 1);
+    gGL.vertex2i(right + lines, bottom);
 
     // top right corner
     gGL.color4fv(start_color.mV);
-    gGL.vertex2i( right,            top-lines );
+    gGL.vertex2i(right, top - lines);
     gGL.color4fv(end_color.mV);
-    gGL.vertex2i( right+lines,  top-lines );
+    gGL.vertex2i(right + lines, top - lines);
     // make the corner not sharp
-    gGL.vertex2i( right+lines-1,    top-1 );
-    gGL.vertex2i( right,            top );
+    gGL.vertex2i(right + lines - 1, top - 1);
+    gGL.color4fv(start_color.mV);
+    gGL.vertex2i(right, top - lines);
+    gGL.color4fv(end_color.mV);
+    gGL.vertex2i(right + lines - 1, top - 1);
+    gGL.vertex2i(right, top);
 
     gGL.end();
     stop_glerror();
@@ -423,171 +446,251 @@ void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTex
                                 ui_translation.mV[VX] + width * ui_scale.mV[VX],
                                 ui_translation.mV[VY]);
 
-        LLGLSUIDefault gls_ui;
-
         gGL.getTexUnit(0)->bind(image, true);
 
         gGL.color4fv(color.mV);
 
-        const S32 NUM_VERTICES = 9 * 4; // 9 quads
-        LLVector2 uv[NUM_VERTICES];
-        LLVector3 pos[NUM_VERTICES];
+        constexpr U32 NUM_VERTICES = 9 * 2 * 3; // 9 quads, 2 triangles per quad, 3 vertices per triangle
+        static thread_local LLVector2 uv[NUM_VERTICES];
+        static thread_local LLVector4a pos[NUM_VERTICES];
 
         S32 index = 0;
 
-        gGL.begin(LLRender::QUADS);
+        gGL.begin(LLRender::TRIANGLES);
         {
-            // draw bottom left
-            uv[index] = LLVector2(uv_outer_rect.mLeft, uv_outer_rect.mBottom);
-            pos[index] = LLVector3(draw_outer_rect.mLeft, draw_outer_rect.mBottom, 0.f);
+            // draw bottom left triangles
+            // 1
+            uv[index].set(uv_outer_rect.mLeft, uv_outer_rect.mBottom);
+            pos[index].set(draw_outer_rect.mLeft, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mLeft, uv_outer_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
+            // 2
+            uv[index].set(uv_outer_rect.mLeft, uv_outer_rect.mBottom);
+            pos[index].set(draw_outer_rect.mLeft, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            // draw bottom middle
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
+            uv[index].set(uv_outer_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
+            // draw bottom middle triangles
+            uv[index].set(uv_center_rect.mLeft, uv_outer_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mRight, uv_outer_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            // draw bottom right
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mRight, uv_outer_rect.mBottom);
-            pos[index] = LLVector3(draw_outer_rect.mRight, draw_outer_rect.mBottom, 0.f);
+            // 2
+            uv[index].set(uv_center_rect.mLeft, uv_outer_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            // draw left
-            uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
+            // draw bottom right triangles
+            uv[index].set(uv_center_rect.mRight, uv_outer_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
+            uv[index].set(uv_outer_rect.mRight, uv_outer_rect.mBottom);
+            pos[index].set(draw_outer_rect.mRight, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
+            uv[index].set(uv_outer_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
+            // 2
+            uv[index].set(uv_center_rect.mRight, uv_outer_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_outer_rect.mBottom, 0.f);
             index++;
 
-            // draw middle
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
+            uv[index].set(uv_outer_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
+            // draw left triangles
+            uv[index].set(uv_outer_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            // draw right
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mBottom);
-            pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
+            // 2
+            uv[index].set(uv_outer_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_outer_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
+            uv[index].set(uv_outer_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
             index++;
 
-            // draw top left
-            uv[index] = LLVector2(uv_outer_rect.mLeft, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
+            // draw middle triangles
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mLeft, uv_outer_rect.mTop);
-            pos[index] = LLVector3(draw_outer_rect.mLeft, draw_outer_rect.mTop, 0.f);
+            // 2
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mBottom, 0.f);
             index++;
 
-            // draw top middle
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
+            // draw right triangles
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mLeft, uv_outer_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
+            uv[index].set(uv_outer_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_outer_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            // draw top right
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
+            uv[index].set(uv_outer_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mRight, uv_center_rect.mTop);
-            pos[index] = LLVector3(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
+            // 2
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mBottom);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mBottom, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_outer_rect.mRight, uv_outer_rect.mTop);
-            pos[index] = LLVector3(draw_outer_rect.mRight, draw_outer_rect.mTop, 0.f);
+            uv[index].set(uv_outer_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_center_rect.mRight, uv_outer_rect.mTop);
-            pos[index] = LLVector3(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
+            index++;
+
+            // draw top left triangles
+            uv[index].set(uv_outer_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_center_rect.mLeft, uv_outer_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
+            index++;
+
+            // 2
+            uv[index].set(uv_outer_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_outer_rect.mLeft, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_center_rect.mLeft, uv_outer_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_outer_rect.mLeft, uv_outer_rect.mTop);
+            pos[index].set(draw_outer_rect.mLeft, draw_outer_rect.mTop, 0.f);
+            index++;
+
+            // draw top middle triangles
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_center_rect.mRight, uv_outer_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
+            index++;
+
+            // 2
+            uv[index].set(uv_center_rect.mLeft, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_center_rect.mRight, uv_outer_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_center_rect.mLeft, uv_outer_rect.mTop);
+            pos[index].set(draw_center_rect.mLeft, draw_outer_rect.mTop, 0.f);
+            index++;
+
+            // draw top right triangles
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_outer_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_outer_rect.mRight, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_outer_rect.mRight, uv_outer_rect.mTop);
+            pos[index].set(draw_outer_rect.mRight, draw_outer_rect.mTop, 0.f);
+            index++;
+
+            // 2
+            uv[index].set(uv_center_rect.mRight, uv_center_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_center_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_outer_rect.mRight, uv_outer_rect.mTop);
+            pos[index].set(draw_outer_rect.mRight, draw_outer_rect.mTop, 0.f);
+            index++;
+
+            uv[index].set(uv_center_rect.mRight, uv_outer_rect.mTop);
+            pos[index].set(draw_center_rect.mRight, draw_outer_rect.mTop, 0.f);
             index++;
 
             gGL.vertexBatchPreTransformed(pos, uv, NUM_VERTICES);
@@ -614,8 +717,6 @@ void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degre
         return;
     }
 
-    LLGLSUIDefault gls_ui;
-
     if(image != NULL)
     {
         gGL.getTexUnit(0)->bind(image, true);
@@ -629,11 +730,11 @@ void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degre
 
     if (degrees == 0.f)
     {
-        const S32 NUM_VERTICES = 4; // 9 quads
-        LLVector2 uv[NUM_VERTICES];
-        LLVector3 pos[NUM_VERTICES];
+        constexpr S32 NUM_VERTICES = 2 * 3;
+        static thread_local LLVector2 uv[NUM_VERTICES +1];
+        static thread_local LLVector4a pos[NUM_VERTICES +1];
 
-        gGL.begin(LLRender::QUADS);
+        gGL.begin(LLRender::TRIANGLES);
         {
             LLVector3 ui_scale = gGL.getUIScale();
             LLVector3 ui_translation = gGL.getUITranslation();
@@ -644,20 +745,28 @@ void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degre
             S32 scaled_width = ll_round(width * ui_scale.mV[VX]);
             S32 scaled_height = ll_round(height * ui_scale.mV[VY]);
 
-            uv[index] = LLVector2(uv_rect.mRight, uv_rect.mTop);
-            pos[index] = LLVector3(ui_translation.mV[VX] + scaled_width, ui_translation.mV[VY] + scaled_height, 0.f);
+            uv[index].set(uv_rect.mRight, uv_rect.mTop);
+            pos[index].set(ui_translation.mV[VX] + scaled_width, ui_translation.mV[VY] + scaled_height, 0.f);
+            index++;
+
+            uv[index].set(uv_rect.mLeft, uv_rect.mTop);
+            pos[index].set(ui_translation.mV[VX], ui_translation.mV[VY] + scaled_height, 0.f);
+            index++;
+
+            uv[index].set(uv_rect.mLeft, uv_rect.mBottom);
+            pos[index].set(ui_translation.mV[VX], ui_translation.mV[VY], 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_rect.mLeft, uv_rect.mTop);
-            pos[index] = LLVector3(ui_translation.mV[VX], ui_translation.mV[VY] + scaled_height, 0.f);
+            uv[index].set(uv_rect.mRight, uv_rect.mTop);
+            pos[index].set(ui_translation.mV[VX] + scaled_width, ui_translation.mV[VY] + scaled_height, 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_rect.mLeft, uv_rect.mBottom);
-            pos[index] = LLVector3(ui_translation.mV[VX], ui_translation.mV[VY], 0.f);
+            uv[index].set(uv_rect.mLeft, uv_rect.mBottom);
+            pos[index].set(ui_translation.mV[VX], ui_translation.mV[VY], 0.f);
             index++;
 
-            uv[index] = LLVector2(uv_rect.mRight, uv_rect.mBottom);
-            pos[index] = LLVector3(ui_translation.mV[VX] + scaled_width, ui_translation.mV[VY], 0.f);
+            uv[index].set(uv_rect.mRight, uv_rect.mBottom);
+            pos[index].set(ui_translation.mV[VX] + scaled_width, ui_translation.mV[VY], 0.f);
             index++;
 
             gGL.vertexBatchPreTransformed(pos, uv, NUM_VERTICES);
@@ -687,7 +796,7 @@ void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degre
 
         gGL.color4fv(color.mV);
 
-        gGL.begin(LLRender::QUADS);
+        gGL.begin(LLRender::TRIANGLES);
         {
             LLVector3 v;
 
@@ -703,6 +812,14 @@ void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degre
             gGL.texCoord2f(uv_rect.mLeft, uv_rect.mBottom);
             gGL.vertex2f(v.mV[0], v.mV[1] );
 
+            v = LLVector3(offset_x, offset_y, 0.f) * quat;
+            gGL.texCoord2f(uv_rect.mRight, uv_rect.mTop);
+            gGL.vertex2f(v.mV[0], v.mV[1]);
+
+            v = LLVector3(-offset_x, -offset_y, 0.f) * quat;
+            gGL.texCoord2f(uv_rect.mLeft, uv_rect.mBottom);
+            gGL.vertex2f(v.mV[0], v.mV[1]);
+
             v = LLVector3(offset_x, -offset_y, 0.f) * quat;
             gGL.texCoord2f(uv_rect.mRight, uv_rect.mBottom);
             gGL.vertex2f(v.mV[0], v.mV[1] );
@@ -948,7 +1065,7 @@ void gl_washer_segment_2d(F32 outer_radius, F32 inner_radius, F32 start_radians,
 
 void gl_rect_2d_simple_tex( S32 width, S32 height )
 {
-    gGL.begin( LLRender::QUADS );
+    gGL.begin( LLRender::TRIANGLES );
 
         gGL.texCoord2f(1.f, 1.f);
         gGL.vertex2i(width, height);
@@ -959,6 +1076,12 @@ void gl_rect_2d_simple_tex( S32 width, S32 height )
         gGL.texCoord2f(0.f, 0.f);
         gGL.vertex2i(0, 0);
 
+        gGL.texCoord2f(1.f, 1.f);
+        gGL.vertex2i(width, height);
+
+        gGL.texCoord2f(0.f, 0.f);
+        gGL.vertex2i(0, 0);
+
         gGL.texCoord2f(1.f, 0.f);
         gGL.vertex2i(width, 0);
 
@@ -967,10 +1090,13 @@ void gl_rect_2d_simple_tex( S32 width, S32 height )
 
 void gl_rect_2d_simple( S32 width, S32 height )
 {
-    gGL.begin( LLRender::QUADS );
+    gGL.begin( LLRender::TRIANGLES );
         gGL.vertex2i(width, height);
         gGL.vertex2i(0, height);
         gGL.vertex2i(0, 0);
+
+        gGL.vertex2i(width, height);
+        gGL.vertex2i(0, 0);
         gGL.vertex2i(width, 0);
     gGL.end();
 }
@@ -1011,7 +1137,7 @@ void gl_segmented_rect_2d_tex(const S32 left,
     LLVector2 width_vec((F32)width, 0.f);
     LLVector2 height_vec(0.f, (F32)height);
 
-    gGL.begin(LLRender::QUADS);
+    gGL.begin(LLRender::TRIANGLES);
     {
         // draw bottom left
         gGL.texCoord2f(0.f, 0.f);
@@ -1023,6 +1149,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
         gGL.vertex2fv((border_width_left + border_height_bottom).mV);
 
+        gGL.texCoord2f(0.f, 0.f);
+        gGL.vertex2f(0.f, 0.f);
+
+        gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+        gGL.vertex2fv((border_width_left + border_height_bottom).mV);
+
         gGL.texCoord2f(0.f, border_uv_scale.mV[VY]);
         gGL.vertex2fv(border_height_bottom.mV);
 
@@ -1036,6 +1168,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
         gGL.vertex2fv((width_vec - border_width_right + border_height_bottom).mV);
 
+        gGL.texCoord2f(border_uv_scale.mV[VX], 0.f);
+        gGL.vertex2fv(border_width_left.mV);
+
+        gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+        gGL.vertex2fv((width_vec - border_width_right + border_height_bottom).mV);
+
         gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
         gGL.vertex2fv((border_width_left + border_height_bottom).mV);
 
@@ -1049,6 +1187,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(1.f, border_uv_scale.mV[VY]);
         gGL.vertex2fv((width_vec + border_height_bottom).mV);
 
+        gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 0.f);
+        gGL.vertex2fv((width_vec - border_width_right).mV);
+
+        gGL.texCoord2f(1.f, border_uv_scale.mV[VY]);
+        gGL.vertex2fv((width_vec + border_height_bottom).mV);
+
         gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
         gGL.vertex2fv((width_vec - border_width_right + border_height_bottom).mV);
 
@@ -1062,6 +1206,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
         gGL.vertex2fv((border_width_left + height_vec - border_height_top).mV);
 
+        gGL.texCoord2f(0.f, border_uv_scale.mV[VY]);
+        gGL.vertex2fv(border_height_bottom.mV);
+
+        gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+        gGL.vertex2fv((border_width_left + height_vec - border_height_top).mV);
+
         gGL.texCoord2f(0.f, 1.f - border_uv_scale.mV[VY]);
         gGL.vertex2fv((height_vec - border_height_top).mV);
 
@@ -1075,6 +1225,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
         gGL.vertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
 
+        gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+        gGL.vertex2fv((border_width_left + border_height_bottom).mV);
+
+        gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+        gGL.vertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
+
         gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
         gGL.vertex2fv((border_width_left + height_vec - border_height_top).mV);
 
@@ -1088,6 +1244,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(1.f, 1.f - border_uv_scale.mV[VY]);
         gGL.vertex2fv((width_vec + height_vec - border_height_top).mV);
 
+        gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+        gGL.vertex2fv((width_vec - border_width_right + border_height_bottom).mV);
+
+        gGL.texCoord2f(1.f, 1.f - border_uv_scale.mV[VY]);
+        gGL.vertex2fv((width_vec + height_vec - border_height_top).mV);
+
         gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
         gGL.vertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
 
@@ -1101,6 +1263,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(border_uv_scale.mV[VX], 1.f);
         gGL.vertex2fv((border_width_left + height_vec).mV);
 
+        gGL.texCoord2f(0.f, 1.f - border_uv_scale.mV[VY]);
+        gGL.vertex2fv((height_vec - border_height_top).mV);
+
+        gGL.texCoord2f(border_uv_scale.mV[VX], 1.f);
+        gGL.vertex2fv((border_width_left + height_vec).mV);
+
         gGL.texCoord2f(0.f, 1.f);
         gGL.vertex2fv((height_vec).mV);
 
@@ -1114,6 +1282,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
         gGL.vertex2fv((width_vec - border_width_right + height_vec).mV);
 
+        gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+        gGL.vertex2fv((border_width_left + height_vec - border_height_top).mV);
+
+        gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
+        gGL.vertex2fv((width_vec - border_width_right + height_vec).mV);
+
         gGL.texCoord2f(border_uv_scale.mV[VX], 1.f);
         gGL.vertex2fv((border_width_left + height_vec).mV);
 
@@ -1127,6 +1301,12 @@ void gl_segmented_rect_2d_tex(const S32 left,
         gGL.texCoord2f(1.f, 1.f);
         gGL.vertex2fv((width_vec + height_vec).mV);
 
+        gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+        gGL.vertex2fv((width_vec - border_width_right + height_vec - border_height_top).mV);
+
+        gGL.texCoord2f(1.f, 1.f);
+        gGL.vertex2fv((width_vec + height_vec).mV);
+
         gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
         gGL.vertex2fv((width_vec - border_width_right + height_vec).mV);
     }
@@ -1181,7 +1361,7 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
     LLVector2 x_min;
     LLVector2 x_max;
 
-    gGL.begin(LLRender::QUADS);
+    gGL.begin(LLRender::TRIANGLES);
     {
         if (start_fragment < middle_start)
         {
@@ -1200,6 +1380,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(u_max, border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_max + border_height_bottom).mV);
 
+            gGL.texCoord2f(u_min, 0.f);
+            gGL.vertex2fv(x_min.mV);
+
+            gGL.texCoord2f(u_max, border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_max + border_height_bottom).mV);
+
             gGL.texCoord2f(u_min, border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_min + border_height_bottom).mV);
 
@@ -1213,6 +1399,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
 
+            gGL.texCoord2f(u_min, border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_min + border_height_bottom).mV);
+
+            gGL.texCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
+
             gGL.texCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
 
@@ -1226,6 +1418,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(u_max, 1.f);
             gGL.vertex2fv((x_max + height_vec).mV);
 
+            gGL.texCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
+
+            gGL.texCoord2f(u_max, 1.f);
+            gGL.vertex2fv((x_max + height_vec).mV);
+
             gGL.texCoord2f(u_min, 1.f);
             gGL.vertex2fv((x_min + height_vec).mV);
         }
@@ -1245,6 +1443,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_max + border_height_bottom).mV);
 
+            gGL.texCoord2f(border_uv_scale.mV[VX], 0.f);
+            gGL.vertex2fv(x_min.mV);
+
+            gGL.texCoord2f(1.f - border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_max + border_height_bottom).mV);
+
             gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_min + border_height_bottom).mV);
 
@@ -1258,6 +1462,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
 
+            gGL.texCoord2f(border_uv_scale.mV[VX], border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_min + border_height_bottom).mV);
+
+            gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
+
             gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
 
@@ -1271,6 +1481,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
             gGL.vertex2fv((x_max + height_vec).mV);
 
+            gGL.texCoord2f(border_uv_scale.mV[VX], 1.f - border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
+
+            gGL.texCoord2f(1.f - border_uv_scale.mV[VX], 1.f);
+            gGL.vertex2fv((x_max + height_vec).mV);
+
             gGL.texCoord2f(border_uv_scale.mV[VX], 1.f);
             gGL.vertex2fv((x_min + height_vec).mV);
         }
@@ -1292,6 +1508,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(u_max, border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_max + border_height_bottom).mV);
 
+            gGL.texCoord2f(u_min, 0.f);
+            gGL.vertex2fv((x_min).mV);
+
+            gGL.texCoord2f(u_max, border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_max + border_height_bottom).mV);
+
             gGL.texCoord2f(u_min, border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_min + border_height_bottom).mV);
 
@@ -1305,6 +1527,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
 
+            gGL.texCoord2f(u_min, border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_min + border_height_bottom).mV);
+
+            gGL.texCoord2f(u_max, 1.f - border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_max + height_vec - border_height_top).mV);
+
             gGL.texCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
             gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
 
@@ -1318,6 +1546,12 @@ void gl_segmented_rect_2d_fragment_tex(const LLRect& rect,
             gGL.texCoord2f(u_max, 1.f);
             gGL.vertex2fv((x_max + height_vec).mV);
 
+            gGL.texCoord2f(u_min, 1.f - border_uv_scale.mV[VY]);
+            gGL.vertex2fv((x_min + height_vec - border_height_top).mV);
+
+            gGL.texCoord2f(u_max, 1.f);
+            gGL.vertex2fv((x_max + height_vec).mV);
+
             gGL.texCoord2f(u_min, 1.f);
             gGL.vertex2fv((x_min + height_vec).mV);
         }
@@ -1332,7 +1566,7 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
 
-    gGL.begin(LLRender::QUADS);
+    gGL.begin(LLRender::TRIANGLES);
     {
         // draw bottom left
         gGL.texCoord2f(clip_rect.mLeft, clip_rect.mBottom);
@@ -1344,6 +1578,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mBottom);
         gGL.vertex3fv((center_draw_rect.mLeft * width_vec + center_draw_rect.mBottom * height_vec).mV);
 
+        gGL.texCoord2f(clip_rect.mLeft, clip_rect.mBottom);
+        gGL.vertex3f(0.f, 0.f, 0.f);
+
+        gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mBottom);
+        gGL.vertex3fv((center_draw_rect.mLeft * width_vec + center_draw_rect.mBottom * height_vec).mV);
+
         gGL.texCoord2f(clip_rect.mLeft, center_uv_rect.mBottom);
         gGL.vertex3fv((center_draw_rect.mBottom * height_vec).mV);
 
@@ -1357,6 +1597,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mBottom);
         gGL.vertex3fv((center_draw_rect.mRight * width_vec + center_draw_rect.mBottom * height_vec).mV);
 
+        gGL.texCoord2f(center_uv_rect.mLeft, clip_rect.mBottom);
+        gGL.vertex3fv((center_draw_rect.mLeft * width_vec).mV);
+
+        gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mBottom);
+        gGL.vertex3fv((center_draw_rect.mRight * width_vec + center_draw_rect.mBottom * height_vec).mV);
+
         gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mBottom);
         gGL.vertex3fv((center_draw_rect.mLeft * width_vec + center_draw_rect.mBottom * height_vec).mV);
 
@@ -1370,6 +1616,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(clip_rect.mRight, center_uv_rect.mBottom);
         gGL.vertex3fv((width_vec + center_draw_rect.mBottom * height_vec).mV);
 
+        gGL.texCoord2f(center_uv_rect.mRight, clip_rect.mBottom);
+        gGL.vertex3fv((center_draw_rect.mRight * width_vec).mV);
+
+        gGL.texCoord2f(clip_rect.mRight, center_uv_rect.mBottom);
+        gGL.vertex3fv((width_vec + center_draw_rect.mBottom * height_vec).mV);
+
         gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mBottom);
         gGL.vertex3fv((center_draw_rect.mRight * width_vec + center_draw_rect.mBottom * height_vec).mV);
 
@@ -1383,6 +1635,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mLeft * width_vec + center_draw_rect.mTop * height_vec).mV);
 
+        gGL.texCoord2f(clip_rect.mLeft, center_uv_rect.mBottom);
+        gGL.vertex3fv((center_draw_rect.mBottom * height_vec).mV);
+
+        gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mTop);
+        gGL.vertex3fv((center_draw_rect.mLeft * width_vec + center_draw_rect.mTop * height_vec).mV);
+
         gGL.texCoord2f(clip_rect.mLeft, center_uv_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mTop * height_vec).mV);
 
@@ -1396,6 +1654,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mRight * width_vec + center_draw_rect.mTop * height_vec).mV);
 
+        gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mBottom);
+        gGL.vertex3fv((center_draw_rect.mLeft * width_vec + center_draw_rect.mBottom * height_vec).mV);
+
+        gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mTop);
+        gGL.vertex3fv((center_draw_rect.mRight * width_vec + center_draw_rect.mTop * height_vec).mV);
+
         gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mLeft * width_vec + center_draw_rect.mTop * height_vec).mV);
 
@@ -1409,6 +1673,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(clip_rect.mRight, center_uv_rect.mTop);
         gGL.vertex3fv((width_vec + center_draw_rect.mTop * height_vec).mV);
 
+        gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mBottom);
+        gGL.vertex3fv((center_draw_rect.mRight* width_vec + center_draw_rect.mBottom * height_vec).mV);
+
+        gGL.texCoord2f(clip_rect.mRight, center_uv_rect.mTop);
+        gGL.vertex3fv((width_vec + center_draw_rect.mTop * height_vec).mV);
+
         gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mRight * width_vec + center_draw_rect.mTop * height_vec).mV);
 
@@ -1422,6 +1692,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(center_uv_rect.mLeft, clip_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mLeft * width_vec + height_vec).mV);
 
+        gGL.texCoord2f(clip_rect.mLeft, center_uv_rect.mTop);
+        gGL.vertex3fv((center_draw_rect.mTop* height_vec).mV);
+
+        gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mTop);
+        gGL.vertex3fv((center_draw_rect.mLeft* width_vec + center_draw_rect.mTop * height_vec).mV);
+
         gGL.texCoord2f(clip_rect.mLeft, clip_rect.mTop);
         gGL.vertex3fv((height_vec).mV);
 
@@ -1435,6 +1711,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(center_uv_rect.mRight, clip_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mRight * width_vec + height_vec).mV);
 
+        gGL.texCoord2f(center_uv_rect.mLeft, center_uv_rect.mTop);
+        gGL.vertex3fv((center_draw_rect.mLeft* width_vec + center_draw_rect.mTop * height_vec).mV);
+
+        gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mTop);
+        gGL.vertex3fv((center_draw_rect.mRight* width_vec + center_draw_rect.mTop * height_vec).mV);
+
         gGL.texCoord2f(center_uv_rect.mLeft, clip_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mLeft * width_vec + height_vec).mV);
 
@@ -1448,6 +1730,12 @@ void gl_segmented_rect_3d_tex(const LLRectf& clip_rect, const LLRectf& center_uv
         gGL.texCoord2f(clip_rect.mRight, clip_rect.mTop);
         gGL.vertex3fv((width_vec + height_vec).mV);
 
+        gGL.texCoord2f(center_uv_rect.mRight, center_uv_rect.mTop);
+        gGL.vertex3fv((center_draw_rect.mRight* width_vec + center_draw_rect.mTop * height_vec).mV);
+
+        gGL.texCoord2f(clip_rect.mRight, clip_rect.mTop);
+        gGL.vertex3fv((width_vec + height_vec).mV);
+
         gGL.texCoord2f(center_uv_rect.mRight, clip_rect.mTop);
         gGL.vertex3fv((center_draw_rect.mRight * width_vec + height_vec).mV);
     }
diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp
index 38bc5ff331..c72f8fa2ba 100644
--- a/indra/llrender/llrendertarget.cpp
+++ b/indra/llrender/llrendertarget.cpp
@@ -51,6 +51,7 @@ void check_framebuffer_status()
 }
 
 bool LLRenderTarget::sUseFBO = false;
+bool LLRenderTarget::sClearOnInvalidate = false;
 U32 LLRenderTarget::sCurFBO = 0;
 
 
@@ -473,6 +474,13 @@ void LLRenderTarget::clear(U32 mask_in)
     }
 }
 
+void LLRenderTarget::invalidate(U32 mask_in)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_DISPLAY;
+    if (!sClearOnInvalidate) { return; }
+    clear(mask_in);
+}
+
 U32 LLRenderTarget::getTexture(U32 attachment) const
 {
     if (attachment >= mTex.size())
@@ -584,7 +592,6 @@ void LLRenderTarget::swapFBORefs(LLRenderTarget& other)
     llassert(!other.isBoundInStack());
 
     // Must be same type
-    llassert(sUseFBO == other.sUseFBO);
     llassert(mResX == other.mResX);
     llassert(mResY == other.mResY);
     llassert(mInternalFormat == other.mInternalFormat);
diff --git a/indra/llrender/llrendertarget.h b/indra/llrender/llrendertarget.h
index cd3290cf66..f066534cf4 100644
--- a/indra/llrender/llrendertarget.h
+++ b/indra/llrender/llrendertarget.h
@@ -63,6 +63,7 @@ class LLRenderTarget
 public:
     // Whether or not to use FBO implementation
     static bool sUseFBO;
+    static bool sClearOnInvalidate;
     static U32 sBytesAllocated;
     static U32 sCurFBO;
     static U32 sCurResX;
@@ -128,11 +129,17 @@ public:
     //  Asserts that this target is not currently bound in the stack
     void bindTarget();
 
-    //clear render targer, clears depth buffer if present,
+    //clear render target, clears depth buffer if present,
     //uses scissor rect if in copy-to-texture mode
     // asserts that this target is currently bound
     void clear(U32 mask = 0xFFFFFFFF);
 
+    //same as clear, except may be a no-op depending on configuration
+    //useful to indicate the buffer is about to be overwritten and we
+    //don't care about its previous contents
+    //depending on the GPU, one may be more expensive than the other
+    void invalidate(U32 mask = 0xFFFFFFFF);
+
     //get applied viewport
     void getViewport(S32* viewport);
 
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index e9fa369b0c..6f4828397a 100644
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -289,22 +289,58 @@ static GLuint gen_buffer()
     return ret;
 }
 
-#define ANALYZE_VBO_POOL 0
+static void delete_buffers(S32 count, GLuint* buffers)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
+    // wait a few frames before actually deleting the buffers to avoid
+    // synchronization issues with the GPU
+    static std::vector<GLuint> sFreeList[4];
+
+    if (gGLManager.mInited)
+    {
+        U32 idx = LLImageGL::sFrameCount % 4;
 
-#if LL_DARWIN
+        for (S32 i = 0; i < count; ++i)
+        {
+            sFreeList[idx].push_back(buffers[i]);
+        }
+
+        idx = (LLImageGL::sFrameCount + 3) % 4;
 
-// experimental -- disable VBO pooling on OS X and use glMapBuffer
+        if (!sFreeList[idx].empty())
+        {
+            glDeleteBuffers((GLsizei)sFreeList[idx].size(), sFreeList[idx].data());
+            sFreeList[idx].resize(0);
+        }
+    }
+}
+
+
+#define ANALYZE_VBO_POOL 0
+
+// VBO Pool interface
 class LLVBOPool
 {
+    public:
+    virtual ~LLVBOPool() = default;
+    virtual void allocate(GLenum type, U32 size, GLuint& name, U8*& data) = 0;
+    virtual void free(GLenum type, U32 size, GLuint name, U8* data) = 0;
+    virtual U64 getVramBytesUsed() = 0;
+};
+
+// VBO Pool for Apple GPUs (as in M1/M2 etc, not Intel macs)
+// Effectively disables VBO pooling
+class LLAppleVBOPool final: public LLVBOPool
+{
 public:
     U64 mAllocated = 0;
 
-    U64 getVramBytesUsed()
+    U64 getVramBytesUsed() override
     {
         return mAllocated;
     }
 
-    void allocate(GLenum type, U32 size, GLuint& name, U8*& data)
+    void allocate(GLenum type, U32 size, GLuint& name, U8*& data) override
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
         STOP_GLERROR;
@@ -324,7 +360,7 @@ public:
         }
     }
 
-    void free(GLenum type, U32 size, GLuint name, U8* data)
+    void free(GLenum type, U32 size, GLuint name, U8* data) override
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
         llassert(type == GL_ARRAY_BUFFER || type == GL_ELEMENT_ARRAY_BUFFER);
@@ -339,19 +375,17 @@ public:
         STOP_GLERROR;
         if (name)
         {
-            glDeleteBuffers(1, &name);
+            delete_buffers(1, &name);
         }
         STOP_GLERROR;
     }
 };
 
-#else
-
-class LLVBOPool
+// VBO Pool for GPUs that benefit from VBO pooling
+class LLDefaultVBOPool final : public LLVBOPool
 {
 public:
     typedef std::chrono::steady_clock::time_point Time;
-
     struct Entry
     {
         U8* mData;
@@ -359,7 +393,7 @@ public:
         Time mAge;
     };
 
-    ~LLVBOPool()
+    ~LLDefaultVBOPool() override
     {
         clear();
     }
@@ -377,7 +411,7 @@ public:
     U32 mMisses = 0;
     U32 mHits = 0;
 
-    U64 getVramBytesUsed()
+    U64 getVramBytesUsed() override
     {
         return mAllocated + mReserved;
     }
@@ -393,7 +427,7 @@ public:
         size += block_size - (size % block_size);
     }
 
-    void allocate(GLenum type, U32 size, GLuint& name, U8*& data)
+    void allocate(GLenum type, U32 size, GLuint& name, U8*& data) override
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
         llassert(type == GL_ARRAY_BUFFER || type == GL_ELEMENT_ARRAY_BUFFER);
@@ -449,7 +483,7 @@ public:
         clean();
     }
 
-    void free(GLenum type, U32 size, GLuint name, U8* data)
+    void free(GLenum type, U32 size, GLuint name, U8* data) override
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
         llassert(type == GL_ARRAY_BUFFER || type == GL_ELEMENT_ARRAY_BUFFER);
@@ -512,7 +546,7 @@ public:
                     LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("vbo cache timeout");
                     auto& entry = entries.back();
                     ll_aligned_free_16(entry.mData);
-                    glDeleteBuffers(1, &entry.mGLName);
+                    delete_buffers(1, &entry.mGLName);
                     llassert(mReserved >= iter->first);
                     mReserved -= iter->first;
                     entries.pop_back();
@@ -548,7 +582,7 @@ public:
             for (auto& entry : entries.second)
             {
                 ll_aligned_free_16(entry.mData);
-                glDeleteBuffers(1, &entry.mGLName);
+                delete_buffers(1, &entry.mGLName);
             }
         }
 
@@ -557,7 +591,7 @@ public:
             for (auto& entry : entries.second)
             {
                 ll_aligned_free_16(entry.mData);
-                glDeleteBuffers(1, &entry.mGLName);
+                delete_buffers(1, &entry.mGLName);
             }
         }
 
@@ -567,7 +601,6 @@ public:
         mVBOPool.clear();
     }
 };
-#endif
 
 static LLVBOPool* sVBOPool = nullptr;
 
@@ -600,15 +633,7 @@ void LLVertexBufferData::draw()
     gGL.loadMatrix(glm::value_ptr(mTexture0));
 
     mVB->setBuffer();
-
-    if (mMode == LLRender::QUADS && LLRender::sGLCoreProfile)
-    {
-        mVB->drawArrays(LLRender::TRIANGLES, 0, mCount);
-    }
-    else
-    {
-        mVB->drawArrays(mMode, 0, mCount);
-    }
+    mVB->drawArrays(mMode, 0, mCount);
 
     gGL.popMatrix();
     gGL.matrixMode(LLRender::MM_PROJECTION);
@@ -681,7 +706,6 @@ const U32 LLVertexBuffer::sGLMode[LLRender::NUM_MODES] =
     GL_POINTS,
     GL_LINES,
     GL_LINE_STRIP,
-    GL_QUADS,
     GL_LINE_LOOP,
 };
 
@@ -896,7 +920,16 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
 void LLVertexBuffer::initClass(LLWindow* window)
 {
     llassert(sVBOPool == nullptr);
-    sVBOPool = new LLVBOPool();
+    if (gGLManager.mIsApple)
+    {
+        LL_INFOS() << "VBO Pooling Disabled" << LL_ENDL;
+        sVBOPool = new LLAppleVBOPool();
+    }
+    else
+    {
+        LL_INFOS() << "VBO Pooling Enabled" << LL_ENDL;
+        sVBOPool = new LLDefaultVBOPool();
+    }
 
 #if ENABLE_GL_WORK_QUEUE
     sQueue = new GLWorkQueue();
@@ -964,7 +997,6 @@ void LLVertexBuffer::flushBuffers()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX;
     // must only be called from main thread
-    llassert(LLCoros::on_main_thread_main_coro());
     for (auto& buffer : sMappedBuffers)
     {
         buffer->_unmapBuffer();
@@ -1231,28 +1263,29 @@ U8* LLVertexBuffer::mapVertexBuffer(LLVertexBuffer::AttributeType type, U32 inde
         count = mNumVerts - index;
     }
 
-#if !LL_DARWIN
-    U32 start = mOffsets[type] + sTypeSize[type] * index;
-    U32 end = start + sTypeSize[type] * count-1;
-
-    bool flagged = false;
-    // flag region as mapped
-    for (U32 i = 0; i < mMappedVertexRegions.size(); ++i)
+    if (!gGLManager.mIsApple)
     {
-        MappedRegion& region = mMappedVertexRegions[i];
-        if (expand_region(region, start, end))
+        U32 start = mOffsets[type] + sTypeSize[type] * index;
+        U32 end = start + sTypeSize[type] * count-1;
+
+        bool flagged = false;
+        // flag region as mapped
+        for (U32 i = 0; i < mMappedVertexRegions.size(); ++i)
         {
-            flagged = true;
-            break;
+            MappedRegion& region = mMappedVertexRegions[i];
+            if (expand_region(region, start, end))
+            {
+                flagged = true;
+                break;
+            }
         }
-    }
 
-    if (!flagged)
-    {
-        //didn't expand an existing region, make a new one
-        mMappedVertexRegions.push_back({ start, end });
+        if (!flagged)
+        {
+            //didn't expand an existing region, make a new one
+            mMappedVertexRegions.push_back({ start, end });
+        }
     }
-#endif
     return mMappedData+mOffsets[type]+sTypeSize[type]*index;
 }
 
@@ -1267,28 +1300,29 @@ U8* LLVertexBuffer::mapIndexBuffer(U32 index, S32 count)
         count = mNumIndices-index;
     }
 
-#if !LL_DARWIN
-    U32 start = sizeof(U16) * index;
-    U32 end = start + sizeof(U16) * count-1;
-
-    bool flagged = false;
-    // flag region as mapped
-    for (U32 i = 0; i < mMappedIndexRegions.size(); ++i)
+    if (!gGLManager.mIsApple)
     {
-        MappedRegion& region = mMappedIndexRegions[i];
-        if (expand_region(region, start, end))
+        U32 start = sizeof(U16) * index;
+        U32 end = start + sizeof(U16) * count-1;
+
+        bool flagged = false;
+        // flag region as mapped
+        for (U32 i = 0; i < mMappedIndexRegions.size(); ++i)
         {
-            flagged = true;
-            break;
+            MappedRegion& region = mMappedIndexRegions[i];
+            if (expand_region(region, start, end))
+            {
+                flagged = true;
+                break;
+            }
         }
-    }
 
-    if (!flagged)
-    {
-        //didn't expand an existing region, make a new one
-        mMappedIndexRegions.push_back({ start, end });
+        if (!flagged)
+        {
+            //didn't expand an existing region, make a new one
+            mMappedIndexRegions.push_back({ start, end });
+        }
     }
-#endif
 
     return mMappedIndexData + sizeof(U16)*index;
 }
@@ -1301,37 +1335,40 @@ U8* LLVertexBuffer::mapIndexBuffer(U32 index, S32 count)
 //  dst -- mMappedData or mMappedIndexData
 void LLVertexBuffer::flush_vbo(GLenum target, U32 start, U32 end, void* data, U8* dst)
 {
-#if LL_DARWIN
-    // on OS X, flush_vbo doesn't actually write to the GL buffer, so be sure to call
-    // _mapBuffer to tag the buffer for flushing to GL
-    _mapBuffer();
-    LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("vb memcpy");
-    STOP_GLERROR;
-    // copy into mapped buffer
-    memcpy(dst+start, data, end-start+1);
-#else
-    llassert(target == GL_ARRAY_BUFFER ? sGLRenderBuffer == mGLBuffer : sGLRenderIndices == mGLIndices);
-
-    // skip mapped data and stream to GPU via glBufferSubData
-    if (end != 0)
+    if (gGLManager.mIsApple)
     {
-        LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("glBufferSubData");
-        LL_PROFILE_ZONE_NUM(start);
-        LL_PROFILE_ZONE_NUM(end);
-        LL_PROFILE_ZONE_NUM(end-start);
-
-        constexpr U32 block_size = 65536;
+        // on OS X, flush_vbo doesn't actually write to the GL buffer, so be sure to call
+        // _mapBuffer to tag the buffer for flushing to GL
+        _mapBuffer();
+        LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("vb memcpy");
+        STOP_GLERROR;
+        // copy into mapped buffer
+        memcpy(dst+start, data, end-start+1);
+    }
+    else
+    {
+        llassert(target == GL_ARRAY_BUFFER ? sGLRenderBuffer == mGLBuffer : sGLRenderIndices == mGLIndices);
 
-        for (U32 i = start; i <= end; i += block_size)
+        // skip mapped data and stream to GPU via glBufferSubData
+        if (end != 0)
         {
-            //LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("glBufferSubData block");
-            //LL_PROFILE_GPU_ZONE("glBufferSubData");
-            U32 tend = llmin(i + block_size, end);
-            U32 size = tend - i + 1;
-            glBufferSubData(target, i, size, (U8*) data + (i-start));
+            LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("glBufferSubData");
+            LL_PROFILE_ZONE_NUM(start);
+            LL_PROFILE_ZONE_NUM(end);
+            LL_PROFILE_ZONE_NUM(end-start);
+
+            constexpr U32 block_size = 65536;
+
+            for (U32 i = start; i <= end; i += block_size)
+            {
+                //LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("glBufferSubData block");
+                //LL_PROFILE_GPU_ZONE("glBufferSubData");
+                U32 tend = llmin(i + block_size, end);
+                U32 size = tend - i + 1;
+                glBufferSubData(target, i, size, (U8*) data + (i-start));
+            }
         }
     }
-#endif
 }
 
 void LLVertexBuffer::unmapBuffer()
@@ -1364,114 +1401,116 @@ void LLVertexBuffer::_unmapBuffer()
         }
     };
 
-#if LL_DARWIN
-    STOP_GLERROR;
-    if (mMappedData)
-    {
-        if (mGLBuffer)
-        {
-            glDeleteBuffers(1, &mGLBuffer);
-        }
-        mGLBuffer = gen_buffer();
-        glBindBuffer(GL_ARRAY_BUFFER, mGLBuffer);
-        sGLRenderBuffer = mGLBuffer;
-        glBufferData(GL_ARRAY_BUFFER, mSize, mMappedData, GL_STATIC_DRAW);
-    }
-    else if (mGLBuffer != sGLRenderBuffer)
-    {
-        glBindBuffer(GL_ARRAY_BUFFER, mGLBuffer);
-        sGLRenderBuffer = mGLBuffer;
-    }
-    STOP_GLERROR;
-
-    if (mMappedIndexData)
+    if (gGLManager.mIsApple)
     {
-        if (mGLIndices)
+        STOP_GLERROR;
+        if (mMappedData)
         {
-            glDeleteBuffers(1, &mGLIndices);
+            if (mGLBuffer)
+            {
+                delete_buffers(1, &mGLBuffer);
+            }
+            mGLBuffer = gen_buffer();
+            glBindBuffer(GL_ARRAY_BUFFER, mGLBuffer);
+            sGLRenderBuffer = mGLBuffer;
+            glBufferData(GL_ARRAY_BUFFER, mSize, mMappedData, GL_STATIC_DRAW);
         }
-
-        mGLIndices = gen_buffer();
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGLIndices);
-        sGLRenderIndices = mGLIndices;
-
-        glBufferData(GL_ELEMENT_ARRAY_BUFFER, mIndicesSize, mMappedIndexData, GL_STATIC_DRAW);
-    }
-    else if (mGLIndices != sGLRenderIndices)
-    {
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGLIndices);
-        sGLRenderIndices = mGLIndices;
-    }
-    STOP_GLERROR;
-#else
-
-    if (!mMappedVertexRegions.empty())
-    {
-        LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("unmapBuffer - vertex");
-
-        if (sGLRenderBuffer != mGLBuffer)
+        else if (mGLBuffer != sGLRenderBuffer)
         {
             glBindBuffer(GL_ARRAY_BUFFER, mGLBuffer);
             sGLRenderBuffer = mGLBuffer;
         }
+        STOP_GLERROR;
 
-        U32 start = 0;
-        U32 end = 0;
-
-        std::sort(mMappedVertexRegions.begin(), mMappedVertexRegions.end(), SortMappedRegion());
-
-        for (U32 i = 0; i < mMappedVertexRegions.size(); ++i)
+        if (mMappedIndexData)
         {
-            const MappedRegion& region = mMappedVertexRegions[i];
-            if (region.mStart == end + 1)
+            if (mGLIndices)
             {
-                end = region.mEnd;
+                delete_buffers(1, &mGLIndices);
             }
-            else
-            {
-                flush_vbo(GL_ARRAY_BUFFER, start, end, (U8*)mMappedData + start, mMappedData);
-                start = region.mStart;
-                end = region.mEnd;
-            }
-        }
-
-        flush_vbo(GL_ARRAY_BUFFER, start, end, (U8*)mMappedData + start, mMappedData);
-        mMappedVertexRegions.clear();
-    }
 
-    if (!mMappedIndexRegions.empty())
-    {
-        LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("unmapBuffer - index");
+            mGLIndices = gen_buffer();
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGLIndices);
+            sGLRenderIndices = mGLIndices;
 
-        if (mGLIndices != sGLRenderIndices)
+            glBufferData(GL_ELEMENT_ARRAY_BUFFER, mIndicesSize, mMappedIndexData, GL_STATIC_DRAW);
+        }
+        else if (mGLIndices != sGLRenderIndices)
         {
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGLIndices);
             sGLRenderIndices = mGLIndices;
         }
-        U32 start = 0;
-        U32 end = 0;
+        STOP_GLERROR;
+    }
+    else
+    {
+        if (!mMappedVertexRegions.empty())
+        {
+            LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("unmapBuffer - vertex");
 
-        std::sort(mMappedIndexRegions.begin(), mMappedIndexRegions.end(), SortMappedRegion());
+            if (sGLRenderBuffer != mGLBuffer)
+            {
+                glBindBuffer(GL_ARRAY_BUFFER, mGLBuffer);
+                sGLRenderBuffer = mGLBuffer;
+            }
 
-        for (U32 i = 0; i < mMappedIndexRegions.size(); ++i)
+            U32 start = 0;
+            U32 end = 0;
+
+            std::sort(mMappedVertexRegions.begin(), mMappedVertexRegions.end(), SortMappedRegion());
+
+            for (U32 i = 0; i < mMappedVertexRegions.size(); ++i)
+            {
+                const MappedRegion& region = mMappedVertexRegions[i];
+                if (region.mStart == end + 1)
+                {
+                    end = region.mEnd;
+                }
+                else
+                {
+                    flush_vbo(GL_ARRAY_BUFFER, start, end, (U8*)mMappedData + start, mMappedData);
+                    start = region.mStart;
+                    end = region.mEnd;
+                }
+            }
+
+            flush_vbo(GL_ARRAY_BUFFER, start, end, (U8*)mMappedData + start, mMappedData);
+            mMappedVertexRegions.clear();
+        }
+
+        if (!mMappedIndexRegions.empty())
         {
-            const MappedRegion& region = mMappedIndexRegions[i];
-            if (region.mStart == end + 1)
+            LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("unmapBuffer - index");
+
+            if (mGLIndices != sGLRenderIndices)
             {
-                end = region.mEnd;
+                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGLIndices);
+                sGLRenderIndices = mGLIndices;
             }
-            else
+            U32 start = 0;
+            U32 end = 0;
+
+            std::sort(mMappedIndexRegions.begin(), mMappedIndexRegions.end(), SortMappedRegion());
+
+            for (U32 i = 0; i < mMappedIndexRegions.size(); ++i)
             {
-                flush_vbo(GL_ELEMENT_ARRAY_BUFFER, start, end, (U8*)mMappedIndexData + start, mMappedIndexData);
-                start = region.mStart;
-                end = region.mEnd;
+                const MappedRegion& region = mMappedIndexRegions[i];
+                if (region.mStart == end + 1)
+                {
+                    end = region.mEnd;
+                }
+                else
+                {
+                    flush_vbo(GL_ELEMENT_ARRAY_BUFFER, start, end, (U8*)mMappedIndexData + start, mMappedIndexData);
+                    start = region.mStart;
+                    end = region.mEnd;
+                }
             }
-        }
 
-        flush_vbo(GL_ELEMENT_ARRAY_BUFFER, start, end, (U8*)mMappedIndexData + start, mMappedIndexData);
-        mMappedIndexRegions.clear();
+            flush_vbo(GL_ELEMENT_ARRAY_BUFFER, start, end, (U8*)mMappedIndexData + start, mMappedIndexData);
+            mMappedIndexRegions.clear();
+        }
     }
-#endif
 }
 
 //----------------------------------------------------------------------------