Optimisations and experimental HDR display support on mac

This commit completes the previous ones for performance optimisations,
and adds HDR display support on mac

28 files changed, 794 insertions, 272 deletions

diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index 42af68c276..9ff483b92b 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -357,7 +357,9 @@ S32 LLImageGL::dataFormatBits(S32 dataformat)
     case GL_BGRA:                                   return 32;      // Used for QuickTime media textures on the Mac
 #endif
     case GL_DEPTH_COMPONENT:                        return 24;
+    case GL_DEPTH_COMPONENT16:                      return 16;
     case GL_DEPTH_COMPONENT24:                      return 24;
+    case GL_DEPTH_COMPONENT32:                      return 32;
     case GL_RGBA16:                                 return 64;
     case GL_R16F:                                   return 16;
     case GL_RG16F:                                  return 32;
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index d0e268f08c..5d26a69d7b 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -530,7 +530,9 @@ void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions optio
     {
         if (LLImageGL::sGlobalUseAnisotropic && option == TFO_ANISOTROPIC)
         {
-            glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, gGLManager.mMaxAnisotropy);
+            //glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, gGLManager.mMaxAnisotropy);
+            //We plan to add a setting. For now we stick to a low value.
+            glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, 4.0);
         }
         else
         {
@@ -1592,7 +1594,6 @@ void LLRender::end(std::string comment_)
 
 void LLRender::flush(std::string comment_)
 {
-    LOG_GLERROR("LLRender::flush() begin " + comment_);
     if (mCount > 0)
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
@@ -1661,9 +1662,9 @@ void LLRender::flush(std::string comment_)
         }
 
         resetStriders(count);
-    }
 
-    LOG_GLERROR("LLRender::flush() end " + comment_);
+        LOG_GLERROR("LLRender::flush() end " + comment_);
+    }
 }
 
 LLVertexBuffer* LLRender::bufferfromCache(U32 attribute_mask, U32 count)
@@ -1760,9 +1761,11 @@ LLVertexBuffer* LLRender::genBuffer(U32 attribute_mask, S32 count)
         vb->setColorData(mColorsp.get());
     }
 
-#if LL_DARWIN
-    vb->unmapBuffer();
-#endif
+    if(gGLManager.mIsApple && LLVertexBuffer::getVertexBufferMode() == 0)
+    {
+        vb->unmapBuffer();
+    }
+
     vb->unbind();
 
     return vb;
diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp
index 957c85b606..4fd32620e1 100644
--- a/indra/llrender/llrendertarget.cpp
+++ b/indra/llrender/llrendertarget.cpp
@@ -368,7 +368,7 @@ bool LLRenderTarget::allocateDepth()
 
     U32 internal_type = LLTexUnit::getInternalType(mUsage);
 
-    LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT24, mResX, mResY, GL_DEPTH_COMPONENT, GL_FLOAT, NULL, false);
+    LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT24, mResX, mResY, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL, false);
     gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
 
     sBytesAllocated += mResX*mResY*4;
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 3bc71a7413..fa1c686e8e 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -1512,6 +1512,8 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("bloomExtractORM");
     mReservedUniforms.push_back("bloomExtractMetal");
     mReservedUniforms.push_back("bloomExtractNonMetal");
+    mReservedUniforms.push_back("bloomClampValue");
+    mReservedUniforms.push_back("mpHDRBoost");
 
     llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);
 
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index 8b0bfc6bbe..19416066a5 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -352,6 +352,8 @@ public:
         BLOOM_EXTRACT_ORM,                  //  "bloomExtractORM"
         BLOOM_EXTRACT_METAL,                //  "bloomExtractMetal"
         BLOOM_EXTRACT_NONMETAL,             //  "bloomExtractNonMetal"
+        BLOOM_CLAMP,                        //  "bloomClampValue"
+        MP_HDR_BOOST,                       //  "mpHDRBoost"
 
         END_RESERVED_UNIFORMS
     } eGLSLReservedUniforms;
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index 2a0acab05a..040dde7317 100644
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -29,7 +29,6 @@
 #include "llfasttimer.h"
 #include "llsys.h"
 #include "llvertexbuffer.h"
-// #include "llrender.h"
 #include "llglheaders.h"
 #include "llrender.h"
 #include "llvector4a.h"
@@ -272,13 +271,13 @@ static GLuint gen_buffer()
     {
         LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("gen buffer");
         sIndex = pool_size;
-#if !LL_DARWIN
+//#if !LL_DARWIN
         if (!gGLManager.mIsAMD)
         {
             glGenBuffers(pool_size, sNamePool);
         }
         else
-#endif
+//#endif
         { // work around for AMD driver bug
             for (U32 i = 0; i < pool_size; ++i)
             {
@@ -615,6 +614,8 @@ public:
 
 static LLVBOPool* sVBOPool = nullptr;
 
+static U32 sMPVertexBufferMode = 0;
+
 void LLVertexBufferData::drawWithMatrix()
 {
     if (!mVB)
@@ -946,11 +947,13 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
 }
 
 //static
-void LLVertexBuffer::initClass(LLWindow* window)
+void LLVertexBuffer::initClass(LLWindow* window, U32 mode_)
 {
     llassert(sVBOPool == nullptr);
 
-    if (gGLManager.mIsApple)
+    sMPVertexBufferMode = mode_;
+
+    if (mode_ == 0 && gGLManager.mIsApple)
     {
         LL_INFOS() << "VBO Pooling Disabled" << LL_ENDL;
         sVBOPool = new LLAppleVBOPool();
@@ -973,6 +976,12 @@ void LLVertexBuffer::initClass(LLWindow* window)
 }
 
 //static
+U32 LLVertexBuffer::getVertexBufferMode()
+{
+    return sMPVertexBufferMode;
+}
+
+//static
 void LLVertexBuffer::unbind()
 {
     glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -1291,7 +1300,7 @@ U8* LLVertexBuffer::mapVertexBuffer(LLVertexBuffer::AttributeType type, U32 inde
         count = mNumVerts - index;
     }
 
-    if (!gGLManager.mIsApple)
+    if (!gGLManager.mIsApple || sMPVertexBufferMode == 1)
     {
         U32 start = mOffsets[type] + sTypeSize[type] * index;
         U32 end = start + sTypeSize[type] * count-1;
@@ -1328,7 +1337,7 @@ U8* LLVertexBuffer::mapIndexBuffer(U32 index, S32 count)
         count = mNumIndices-index;
     }
 
-    if (!gGLManager.mIsApple)
+    if (!gGLManager.mIsApple || sMPVertexBufferMode == 1)
     {
         U32 start = sizeof(U16) * index;
         U32 end = start + sizeof(U16) * count-1;
@@ -1365,13 +1374,35 @@ void LLVertexBuffer::flush_vbo(GLenum target, U32 start, U32 end, void* data, U8
 {
     if (gGLManager.mIsApple)
     {
-        // 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");
-        //LOG_GLERROR("LLVertexBuffer::flush_vbo()");
-        // copy into mapped buffer
-        memcpy(dst+start, data, end-start+1);
+        if(sMPVertexBufferMode == 1)
+        {
+            //LL_WARNS() << "flush_vbo mode 1" << LL_ENDL;
+
+            U32 MapBits = GL_MAP_WRITE_BIT;
+            //U32 MapBits = GL_MAP_READ_BIT;
+            U32 buffer_size = end-start+1;
+
+            U8 * mptr = NULL;
+            mptr = (U8*) glMapBufferRange( target, start, end-start+1, MapBits);
+
+            if (mptr)
+            {
+                std::memcpy(mptr, (U8*) data, buffer_size);
+                if(!glUnmapBuffer(target)) LL_WARNS() << "glUnmapBuffer() failed" << LL_ENDL;
+            }
+            else LL_WARNS() << "glMapBufferRange() returned NULL" << LL_ENDL;
+
+        }
+        else
+        {
+            //LL_WARNS() << "flush_vbo mode 0" << LL_ENDL;
+            // 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");
+            // copy into mapped buffer
+            memcpy(dst+start, data, end-start+1);
+        }
     }
     else
     {
@@ -1428,7 +1459,7 @@ void LLVertexBuffer::_unmapBuffer()
         }
     };
 
-    if (gGLManager.mIsApple)
+    if (gGLManager.mIsApple && sMPVertexBufferMode == 0)
     {
         LOG_GLERROR("LLVertexBuffer::_unmapBuffer() - apple 1");
         if (mMappedData)
diff --git a/indra/llrender/llvertexbuffer.h b/indra/llrender/llvertexbuffer.h
index 375ad76fb8..4239477b8d 100644
--- a/indra/llrender/llvertexbuffer.h
+++ b/indra/llrender/llvertexbuffer.h
@@ -109,7 +109,7 @@ public:
         return *this;
     }
 
-    static void initClass(LLWindow* window);
+    static void initClass(LLWindow* window, U32 mode_ = 0);
     static void cleanupClass();
     static void setupClientArrays(U32 data_mask);
     static void drawArrays(U32 mode, const std::vector<LLVector3>& pos);
@@ -128,6 +128,9 @@ public:
     // flush any pending mapped buffers
     static void flushBuffers();
 
+    static U32 getVertexBufferMode();
+
+
     //WARNING -- when updating these enums you MUST
     // 1 - update LLVertexBuffer::sTypeSize
     // 2 - update LLVertexBuffer::vb_type_name
diff --git a/indra/llwindow/llopenglview-objc.h b/indra/llwindow/llopenglview-objc.h
index 97f4125484..fabce18b6a 100644
--- a/indra/llwindow/llopenglview-objc.h
+++ b/indra/llwindow/llopenglview-objc.h
@@ -43,6 +43,8 @@
     bool mMarkedTextAllowed;
     bool mSimulatedRightClick;
     bool mOldResize;
+
+    bool mHDRDisplay;
 }
 - (id) initWithSamples:(NSUInteger)samples;
 - (id) initWithSamples:(NSUInteger)samples andVsync:(BOOL)vsync;
diff --git a/indra/llwindow/llopenglview-objc.mm b/indra/llwindow/llopenglview-objc.mm
index 3cb6686c02..577311bf49 100644
--- a/indra/llwindow/llopenglview-objc.mm
+++ b/indra/llwindow/llopenglview-objc.mm
@@ -29,6 +29,7 @@
 #import "llappdelegate-objc.h"
 
 extern BOOL gHiDPISupport;
+extern BOOL gHDRDisplaySupport;
 
 #pragma mark local functions
 
@@ -157,6 +158,12 @@ attributedStringInfo getSegments(NSAttributedString *str)
 	return (unsigned long)vram_megabytes; // return value is in megabytes.
 }
 
+- (void)viewWillMoveToWindow:(nullable NSWindow *)newWindow
+{
+    if(mHDRDisplay) self.wantsExtendedDynamicRangeOpenGLSurface = YES;
+    //else self.wantsExtendedDynamicRangeOpenGLSurface = NO;
+}
+
 - (void)viewDidMoveToWindow
 {
 	[[NSNotificationCenter defaultCenter] addObserver:self
@@ -250,22 +257,47 @@ attributedStringInfo getSegments(NSAttributedString *str)
 	// Initialize with a default "safe" pixel format that will work with versions dating back to OS X 10.6.
 	// Any specialized pixel formats, i.e. a core profile pixel format, should be initialized through rebuildContextWithFormat.
 	// 10.7 and 10.8 don't really care if we're defining a profile or not.  If we don't explicitly request a core or legacy profile, it'll always assume a legacy profile (for compatibility reasons).
-	NSOpenGLPixelFormatAttribute attrs[] = {
-        NSOpenGLPFANoRecovery,
-		NSOpenGLPFADoubleBuffer,
-		NSOpenGLPFAClosestPolicy,
-		NSOpenGLPFAAccelerated,
-		NSOpenGLPFASampleBuffers, 0,
-		NSOpenGLPFASamples, 0,
-		NSOpenGLPFAStencilSize, 8,
-		NSOpenGLPFADepthSize, 24,
-		NSOpenGLPFAAlphaSize, 8,
-		NSOpenGLPFAColorSize, 24,
-		NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion4_1Core,
-		0
-    };
-
-	NSOpenGLPixelFormat *pixelFormat = [[[NSOpenGLPixelFormat alloc] initWithAttributes:attrs] autorelease];
+    NSOpenGLPixelFormatAttribute SDRAttrs[] = {
+    NSOpenGLPFADoubleBuffer,
+    NSOpenGLPFASampleBuffers, 0,
+    NSOpenGLPFASamples, 0,
+    NSOpenGLPFAStencilSize, 8,
+    NSOpenGLPFADepthSize, 24,
+    NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion4_1Core,
+    0};
+
+    NSOpenGLPixelFormatAttribute HDRAttrs[] = {
+    NSOpenGLPFADoubleBuffer,
+    NSOpenGLPFASampleBuffers, 0,
+    NSOpenGLPFASamples, 0,
+    NSOpenGLPFAStencilSize, 8,
+    NSOpenGLPFAColorFloat,
+    NSOpenGLPFAColorSize, 64,
+    NSOpenGLPFADepthSize, 24,
+    NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion4_1Core,
+    0};
+
+	NSOpenGLPixelFormat *pixelFormat = nil;
+
+    mHDRDisplay = NO;
+
+    if(gHDRDisplaySupport)
+    {
+        pixelFormat = [[[NSOpenGLPixelFormat alloc] initWithAttributes:HDRAttrs] autorelease];
+        if (pixelFormat == nil)
+        {
+            NSLog(@"Failed to create pixel format for HDR Display!", nil);
+            pixelFormat = [[[NSOpenGLPixelFormat alloc] initWithAttributes:SDRAttrs] autorelease];
+        }
+        else
+        {
+            mHDRDisplay = YES;
+        }
+    }
+    else
+    {
+        pixelFormat = [[[NSOpenGLPixelFormat alloc] initWithAttributes:SDRAttrs] autorelease];
+    }
 
 	if (pixelFormat == nil)
 	{
@@ -283,6 +315,17 @@ attributedStringInfo getSegments(NSAttributedString *str)
 
 	[self setPixelFormat:pixelFormat];
 
+    if(mHDRDisplay)
+    {
+        CGColorSpaceRef color_space = [self.window.colorSpace CGColorSpace];
+        CGColorSpaceRef color_space_extended = CGColorSpaceCreateExtended(color_space);
+        NSColorSpace* extended_ns_color_space
+                    = [[NSColorSpace alloc] initWithCGColorSpace:color_space_extended];
+
+        self.window.colorSpace = extended_ns_color_space;
+        CGColorSpaceRelease(color_space_extended);
+    }
+
 	//for retina support
 	[self setWantsBestResolutionOpenGLSurface:gHiDPISupport];
 
diff --git a/indra/llwindow/llwindowmacosx.cpp b/indra/llwindow/llwindowmacosx.cpp
index c97e014e46..febb43a49b 100644
--- a/indra/llwindow/llwindowmacosx.cpp
+++ b/indra/llwindow/llwindowmacosx.cpp
@@ -53,6 +53,7 @@
 
 extern bool gDebugWindowProc;
 bool gHiDPISupport = true;
+bool gHDRDisplaySupport = false;
 
 const S32   BITS_PER_PIXEL = 32;
 const S32   MAX_NUM_RESOLUTIONS = 32;
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index a614884cea..297ef0e011 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -14352,16 +14352,72 @@
 
 
     <!-- megapahit settings -->
-    <key>MPLowColorPrecision</key>
+
+    <key>MPVertexBufferMode</key>
+    <map>
+      <key>Comment</key>
+      <string>Vertex Buffer Mode for Mac (0=LL, 1=MP)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>U32</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
+    <key>MPHDRDisplay</key>
     <map>
       <key>Comment</key>
-      <string>Enable / Disable lower precision buffers encoding</string>
+      <string>Enable / Disable HDR Display Support (Mac)</string>
       <key>Persist</key>
       <integer>1</integer>
       <key>Type</key>
       <string>Boolean</string>
       <key>Value</key>
+      <integer>0</integer>
+    </map>
+    <key>MPHDRBoost</key>
+    <map>
+      <key>Comment</key>
+      <string>HDR Boost</string>
+      <key>Persist</key>
       <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <integer>1.5</integer>
+    </map>
+    <key>MPHDRGamma</key>
+    <map>
+      <key>Comment</key>
+      <string>HDR Gamma</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <integer>2.4</integer>
+    </map>
+    <key>MPHDRUIBoost</key>
+    <map>
+      <key>Comment</key>
+      <string>HDR UI Boost</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <integer>1.5</integer>
+    </map>
+    <key>MPColorPrecision</key>
+    <map>
+      <key>Comment</key>
+      <string>Color buffers precision</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>U32</string>
+      <key>Value</key>
+      <integer>0</integer>
     </map>
     <key>MPNoGLDebug</key>
     <map>
@@ -14438,28 +14494,6 @@
       <key>Value</key>
       <integer>0</integer>
     </map>
-    <key>MPDumbCopy</key>
-    <map>
-      <key>Comment</key>
-      <string>Add a useless copy in pipeline::renderFinalize()</string>
-      <key>Persist</key>
-      <integer>1</integer>
-      <key>Type</key>
-      <string>Boolean</string>
-      <key>Value</key>
-      <real>0</real>
-    </map>
-    <key>MPRenderShadowOpti</key>
-    <map>
-      <key>Comment</key>
-      <string>Shadows Optimisations</string>
-      <key>Persist</key>
-      <integer>1</integer>
-      <key>Type</key>
-      <string>U32</string>
-      <key>Value</key>
-      <integer>0</integer>
-    </map>
     <key>MPRenderShadowMaxDist</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/app_settings/shaders/class1/deferred/MPHDRDisplayGammaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/MPHDRDisplayGammaF.glsl
new file mode 100644
index 0000000000..7107cfcbce
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/MPHDRDisplayGammaF.glsl
@@ -0,0 +1,55 @@
+/**
+ * @file postDeferredGammaCorrect.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2007, 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$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+out vec4 frag_color;
+
+uniform sampler2D diffuseRect;
+
+uniform float gamma = 2.2;
+uniform float mpHDRBoost;
+
+in vec2 vary_fragcoord;
+
+vec3 clampHDRRange(vec3 color);
+
+vec3 HDRDisplayGamma(vec3 linearRGB)
+{
+    bvec3 cutoff = lessThan(linearRGB, vec3(0.0031308));
+    vec3 higher = vec3(1.055)*pow(linearRGB, vec3(1.0/gamma)) - vec3(0.055);
+    vec3 lower = linearRGB * vec3(12.92);
+
+    return mix(higher, lower, cutoff);
+}
+
+void main()
+{
+    vec4 diff = texture(diffuseRect, vary_fragcoord);
+    diff.rgb = mpHDRBoost * HDRDisplayGamma(diff.rgb);
+    diff.rgb = clampHDRRange(diff.rgb);
+    frag_color = diff;
+}
+
diff --git a/indra/newview/app_settings/shaders/class1/deferred/SMAA.glsl b/indra/newview/app_settings/shaders/class1/deferred/SMAA.glsl
index 60a8300352..fdb77cce6e 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/SMAA.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/SMAA.glsl
@@ -1351,10 +1351,6 @@ float4 SMAABlendingWeightCalculationPS(float2 texcoord,
 //-----------------------------------------------------------------------------
 // Neighborhood Blending Pixel Shader (Third Pass)
 
-vec3 srgb_to_linear(vec3 cs);
-vec4 srgb_to_linear4(vec4 cs);
-vec3 linear_to_srgb(vec3 cl);
-
 float4 SMAANeighborhoodBlendingPS(float2 texcoord,
                                   float4 offset,
                                   SMAATexture2D(colorTex),
@@ -1373,7 +1369,6 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord,
     SMAA_BRANCH
     if (dot(a, float4(1.0, 1.0, 1.0, 1.0)) < 1e-5) {
         float4 color = SMAASampleLevelZero(colorTex, texcoord);
-        color.rgb = srgb_to_linear(color.rgb);
 
         #if SMAA_REPROJECTION
         float2 velocity = SMAA_DECODE_VELOCITY(SMAASampleLevelZero(velocityTex, texcoord));
@@ -1382,8 +1377,6 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord,
         color.a = sqrt(5.0 * length(velocity));
         #endif
 
-        color.rgb = linear_to_srgb(color.rgb);
-
         return color;
     } else {
         bool h = max(a.x, a.z) > max(a.y, a.w); // max(horizontal) > max(vertical)
@@ -1400,15 +1393,8 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord,
 
         // We exploit bilinear filtering to mix current pixel with the chosen
         // neighbor:
-        //float4 color = blendingWeight.x * SMAASampleLevelZero(colorTex, blendingCoord.xy);
-        //color += blendingWeight.y * SMAASampleLevelZero(colorTex, blendingCoord.zw);
-        float4 color = SMAASampleLevelZero(colorTex, blendingCoord.xy);
-        color.rgb = srgb_to_linear(color.rgb);
-        color = blendingWeight.x * color;
-
-        float4 color2 = SMAASampleLevelZero(colorTex, blendingCoord.zw);
-        color2.rgb = srgb_to_linear(color2.rgb);
-        color += blendingWeight.y * color2;
+        float4 color = blendingWeight.x * SMAASampleLevelZero(colorTex, blendingCoord.xy);
+        color += blendingWeight.y * SMAASampleLevelZero(colorTex, blendingCoord.zw);
 
         #if SMAA_REPROJECTION
         // Antialias velocity for proper reprojection in a later stage:
@@ -1419,7 +1405,6 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord,
         color.a = sqrt(5.0 * length(velocity));
         #endif
 
-        color.rgb = linear_to_srgb(color.rgb);
         return color;
     }
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
index 4ccc6f54a8..197ce48a45 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
@@ -30,7 +30,7 @@ out vec4 frag_color;
 uniform sampler2D diffuseRect;
 
 uniform float gamma;
-uniform vec2 screen_res;
+//uniform vec2 screen_res;
 in vec2 vary_fragcoord;
 
 vec3 linear_to_srgb(vec3 cl);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl
index c05b4eed7a..8ee53e3ae4 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl
@@ -79,6 +79,7 @@ void main()
     vec4 diff = texture(diffuseRect, vary_fragcoord.xy);
 
 #ifdef HAS_NOISE
+
     vec2 tc = vary_fragcoord.xy*screen_res*4.0;
     vec3 seed = (diff.rgb+vec3(1.0))*vec3(tc.xy, tc.x+tc.y);
     vec3 nz = vec3(noise(seed.rg), noise(seed.gb), noise(seed.rb));
diff --git a/indra/newview/app_settings/shaders/class1/effects/bloomCombineF.glsl b/indra/newview/app_settings/shaders/class1/effects/bloomCombineF.glsl
index 31a6e10fa4..40cfdd6bff 100644
--- a/indra/newview/app_settings/shaders/class1/effects/bloomCombineF.glsl
+++ b/indra/newview/app_settings/shaders/class1/effects/bloomCombineF.glsl
@@ -6,18 +6,16 @@ uniform sampler2D diffuseMap;
 uniform sampler2D bloomBlurredMap;
 
 uniform float bloomStrength;
+uniform float bloomClampValue;
 
 void main()
 {
     vec4 hdrColor = texture(diffuseMap, vary_texcoord0);
-    vec3 bloomColor = texture(bloomBlurredMap, vary_texcoord0).rgb;
-    vec4 result = vec4(0.0);
+    vec4 bloomColor = texture(bloomBlurredMap, vary_texcoord0);
+    vec4 result = hdrColor;
 
-    result.r = min(hdrColor.r + bloomStrength * bloomColor.r, 1.0);
-    result.g = min(hdrColor.g + bloomStrength * bloomColor.g, 1.0);
-    result.b = min(hdrColor.b + bloomStrength * bloomColor.b, 1.0);
-    result.a = hdrColor.a;
+    result.rgb += bloomStrength * bloomColor.rgb;
+    result.rgb = clamp(result.rgb, vec3(0.0), vec3(bloomClampValue));
 
-    //bloomColor += hdrColor.rgb;
     frag_color = result;
 }
\ No newline at end of file
diff --git a/indra/newview/app_settings/shaders/class1/effects/bloomExtractF.glsl b/indra/newview/app_settings/shaders/class1/effects/bloomExtractF.glsl
index 8fb10d8698..d878ab053e 100644
--- a/indra/newview/app_settings/shaders/class1/effects/bloomExtractF.glsl
+++ b/indra/newview/app_settings/shaders/class1/effects/bloomExtractF.glsl
@@ -56,7 +56,7 @@ void main()
     if(orm.b < 0.15)
     {
         // non metal
-        if(orm.g > bloomExtractNonMetal)
+        if(orm.g >= bloomExtractNonMetal)
         {
             discard;
             return;
@@ -65,7 +65,7 @@ void main()
     else if(orm.b > 0.8)
     {
         // metal
-        if(orm.g > bloomExtractMetal)
+        if(orm.g >= bloomExtractMetal)
         {
             discard;
             return;
diff --git a/indra/newview/app_settings/shaders/class1/interface/uiF.glsl b/indra/newview/app_settings/shaders/class1/interface/uiF.glsl
index 83fe1c505f..42cc333829 100644
--- a/indra/newview/app_settings/shaders/class1/interface/uiF.glsl
+++ b/indra/newview/app_settings/shaders/class1/interface/uiF.glsl
@@ -27,10 +27,12 @@ out vec4 frag_color;
 
 uniform sampler2D diffuseMap;
 
+uniform float mpHDRBoost = 1.0;
+
 in vec2 vary_texcoord0;
 in vec4 vertex_color;
 
 void main()
 {
-    frag_color = vertex_color*texture(diffuseMap, vary_texcoord0.xy);
+    frag_color = mpHDRBoost * vertex_color*texture(diffuseMap, vary_texcoord0.xy);
 }
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 5d107e69db..dfffdbf482 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -305,6 +305,7 @@ extern bool gDebugGL;
 
 #if LL_DARWIN
 extern bool gHiDPISupport;
+extern bool gHDRDisplaySupport;
 #endif
 
 ////////////////////////////////////////////////////////////
@@ -581,6 +582,7 @@ static void settings_to_globals()
     LLWindowMacOSX::sUseMultGL = gSavedSettings.getBOOL("RenderAppleUseMultGL");
 #endif // LL_SDL
     gHiDPISupport = gSavedSettings.getBOOL("RenderHiDPI");
+    gHDRDisplaySupport = gSavedSettings.getBOOL("MPHDRDisplay");
 #endif
 }
 
@@ -1297,11 +1299,15 @@ void LLAppViewer::initMaxHeapSize()
     //------------------------------------------------------------------------------------------
     //currently SL is built under 32-bit setting, we set its max heap size no more than 1.6 GB.
 
- #ifndef LL_X86_64
+/*
+#ifndef LL_X86_64
     F32Gigabytes max_heap_size_gb = (F32Gigabytes)gSavedSettings.getF32("MaxHeapSize") ;
 #else
-    F32Gigabytes max_heap_size_gb = (F32Gigabytes)gSavedSettings.getF32("MaxHeapSize64");
+*/
+F32Gigabytes max_heap_size_gb = (F32Gigabytes)gSavedSettings.getF32("MaxHeapSize64");
+/*
 #endif
+*/
 
     LLMemory::initMaxHeapSizeGB(max_heap_size_gb);
 }
diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp
index 334f9cb692..d0d5305b0c 100644
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@@ -2647,6 +2647,9 @@ void LLPanelPreferenceGraphics3::onMPRecommanded()
     gSavedSettings.setU32("RenderFSAAType", 2);
     gSavedSettings.setU32("RenderFSAASamples", 2);
 
+    gSavedSettings.setBOOL("RenderAnisotropic", false);
+
+
     // Shadows
 
     gSavedSettings.setS32("RenderShadowDetail", 0);
@@ -2658,8 +2661,8 @@ void LLPanelPreferenceGraphics3::onMPRecommanded()
     // Bloom
 
     gSavedSettings.setU32("MPRenderBloom", 0);
-    gSavedSettings.setF32("MPBloomBlurRadius", 1.0);
-    gSavedSettings.setF32("MPBloomBlurRadiusAdd", 0.6);
+    gSavedSettings.setF32("MPBloomBlurRadius", 1.2);
+    gSavedSettings.setF32("MPBloomBlurRadiusAdd", 1.2);
     gSavedSettings.setF32("MPBloomExtractBrightness", 0.1);
     gSavedSettings.setF32("MPBloomStrength", 1.0);
 
@@ -2681,11 +2684,18 @@ void LLPanelPreferenceGraphics3::onMPRecommanded()
 
     gSavedSettings.setBOOL("RenderDisableVintageMode", true);
     gSavedSettings.setBOOL("RenderTransparentWater", true);
-    gSavedSettings.setBOOL("MPLowColorPrecision", true);
+    gSavedSettings.setU32("MPColorPrecision", 0);
+
+    gSavedSettings.setU32("RenderResolutionDivisor", 1.0);
 
     gSavedSettings.setBOOL("RenderGLMultiThreadedTextures", false);
     gSavedSettings.setBOOL("RenderAppleUseMultGL", false);
     gSavedSettings.setBOOL("MPNoGLDebug", true);
+
+    gSavedSettings.setBOOL("MPHDRDisplay", false);
+    gSavedSettings.setF32("MPHDRBoost", 1.0);
+    gSavedSettings.setF32("MPHDRUIBoost", 1.0);
+    gSavedSettings.setF32("MPHDRGamma", 2.4);
 }
 
 //------------------------LLPanelPreferenceControls--------------------------------
diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp
index 9f8a21694f..68a849714c 100644
--- a/indra/newview/llreflectionmapmanager.cpp
+++ b/indra/newview/llreflectionmapmanager.cpp
@@ -297,8 +297,8 @@ void LLReflectionMapManager::update()
 
     U32 color_fmt = render_hdr ? GL_R11F_G11F_B10F : GL_RGB8;
 
-    static LLCachedControl<bool> MPLowColorPrecision(gSavedSettings, "MPLowColorPrecision", 0);
-    if(MPLowColorPrecision)
+    static LLCachedControl<U32> MPColorPrecision(gSavedSettings, "MPColorPrecision", 0);
+    if(MPColorPrecision == 1)
     {
         color_fmt = GL_RGB8;
     }
@@ -566,12 +566,10 @@ void LLReflectionMapManager::update()
 
             if(probe->mCompletedCount < 2)
             {
-                LL_WARNS() << "we program a short delay for this probe" << LL_ENDL;
                 probe->mNextUpdateTime = gFrameTimeSeconds + fmax( ((F32)sMPUpdatePeriod / 2.0), 0.25);
             }
             else
             {
-                LL_WARNS() << "we program a long delay for this probe" << LL_ENDL;
                 probe->mNextUpdateTime = gFrameTimeSeconds + fmax( (F32)sMPUpdatePeriod, 0.25);
             }
 
@@ -826,7 +824,6 @@ void LLReflectionMapManager::doProbeUpdate()
             mUpdatingProbe->mCompletedCount++;
             mUpdatingProbe = nullptr;
             mRadiancePass = false;
-            LL_WARNS() << "probe updated !" << LL_ENDL;
         }
         else
         {
@@ -1033,7 +1030,6 @@ void LLReflectionMapManager::updateProbeIrradiance(LLReflectionMap* probe)
 
     static LLStaticHashedString sSourceIdx("sourceIdx");
 
-    LL_WARNS() << "IRRADIANCE 1" << LL_ENDL;
 
     mMipChain[0].bindTarget("irradiance", 0);
     mMipChain[0].clear(0);
@@ -1110,7 +1106,6 @@ void LLReflectionMapManager::updateProbeRadiance(LLReflectionMap* probe)
 
     static LLStaticHashedString sSourceIdx("sourceIdx");
 
-    LL_WARNS() << "RADIANCE" << LL_ENDL;
     //LL_RECORD_BLOCK_TIME(FTM_RENDER_RADIANCE);
 
     mMipChain[0].bindTarget("radiance", 0);
@@ -1799,7 +1794,6 @@ void LLReflectionMapManager::initReflectionMaps()
 
         touch_default_probe(mDefaultProbe);
 
-        LL_WARNS() << "====== END initReflectionMaps() =======" << LL_ENDL;
     }
 
     if (mVertexBuffer.isNull())
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index fb060307cd..bd1fc46f5d 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -1690,6 +1690,10 @@ void render_ui_3d()
     gUIProgram.bind();
     gGL.color4f(1.f, 1.f, 1.f, 1.f);
 
+    static LLCachedControl<bool> hdrDisplay(gSavedSettings, "MPHDRDisplay");
+    static LLCachedControl<F32> hdrUIBoost(gSavedSettings, "MPHDRUIBoost");
+    if(hdrDisplay) gUIProgram.uniform1f(LLShaderMgr::MP_HDR_BOOST, (GLfloat)hdrUIBoost);
+
     // Coordinate axes
     static LLCachedControl<bool> show_axes(gSavedSettings, "ShowAxes");
     if (show_axes())
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 4d62adf3e2..18407b5b43 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -202,6 +202,7 @@ LLGLSLShader            gDeferredPostTonemapProgram;
 LLGLSLShader            gNoPostTonemapProgram;
 LLGLSLShader            gDeferredPostGammaCorrectProgram;
 LLGLSLShader            gLegacyPostGammaCorrectProgram;
+LLGLSLShader            gHDRGammaCorrectProgram;
 LLGLSLShader            gExposureProgram;
 LLGLSLShader            gExposureProgramNoFade;
 LLGLSLShader            gLuminanceProgram;
@@ -449,6 +450,7 @@ void LLViewerShaderMgr::finalizeShaderList()
     mShaderList.push_back(&gNoPostTonemapProgram);
     mShaderList.push_back(&gDeferredPostGammaCorrectProgram); // for gamma
     mShaderList.push_back(&gLegacyPostGammaCorrectProgram);
+    mShaderList.push_back(&gHDRGammaCorrectProgram);
     mShaderList.push_back(&gDeferredDiffuseProgram);
     mShaderList.push_back(&gDeferredBumpProgram);
     mShaderList.push_back(&gDeferredPBROpaqueProgram);
@@ -802,13 +804,16 @@ std::string LLViewerShaderMgr::loadBasicShaders()
 
     S32 probe_level = llclamp(gSavedSettings.getS32("RenderReflectionProbeLevel"), 0, 3);
 
-    S32 shadow_detail            = gSavedSettings.getS32("RenderShadowDetail");
+    S32 shadow_detail = gSavedSettings.getS32("RenderShadowDetail");
 
     if (shadow_detail >= 1)
     {
-    attribs["SUN_SHADOW"] = "1";
+        if(shadow_detail < 3)
+        {
+            attribs["SUN_SHADOW"] = "1";
+        }
 
-        if (shadow_detail >= 2)
+        if (shadow_detail > 1)
         {
             attribs["SPOT_SHADOW"] = "1";
         }
@@ -908,7 +913,7 @@ bool LLViewerShaderMgr::loadShadersWater()
 
     S32 shadow_detail = gSavedSettings.getS32("RenderShadowDetail");
     bool use_sun_shadow = mShaderLevel[SHADER_DEFERRED] > 1 &&
-        shadow_detail > 0;
+        shadow_detail > 0 && shadow_detail < 3;
 
     if (mShaderLevel[SHADER_WATER] == 0)
     {
@@ -1158,6 +1163,7 @@ bool LLViewerShaderMgr::loadShadersDeferred()
         gLuminanceProgram.unload();
         gDeferredPostGammaCorrectProgram.unload();
         gLegacyPostGammaCorrectProgram.unload();
+        gHDRGammaCorrectProgram.unload();
         gDeferredPostTonemapProgram.unload();
         gNoPostTonemapProgram.unload();
         for (auto i = 0; i < 4; ++i)
@@ -2501,6 +2507,21 @@ bool LLViewerShaderMgr::loadShadersDeferred()
 
     if (success)
     {
+        gHDRGammaCorrectProgram.mName = "HDR Gamma Correction Post Process";
+        gHDRGammaCorrectProgram.mFeatures.hasSrgb = true;
+        gHDRGammaCorrectProgram.mFeatures.isDeferred = true;
+        gHDRGammaCorrectProgram.mShaderFiles.clear();
+        gHDRGammaCorrectProgram.clearPermutations();
+        //gHDRGammaCorrectProgram.addPermutation("HDR_GAMMA", "1");
+        gHDRGammaCorrectProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
+        gHDRGammaCorrectProgram.mShaderFiles.push_back(make_pair("deferred/MPHDRDisplayGammaF.glsl", GL_FRAGMENT_SHADER));
+        gHDRGammaCorrectProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gHDRGammaCorrectProgram.createShader();
+        llassert(success);
+    }
+
+    if (success)
+    {
         gDeferredPostTonemapProgram.mName = "Deferred Tonemap Post Process";
         gDeferredPostTonemapProgram.mFeatures.hasSrgb = true;
         gDeferredPostTonemapProgram.mFeatures.isDeferred = true;
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index 89c4bb5605..62ed963749 100644
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -254,6 +254,7 @@
  extern LLGLSLShader         gDeferredPostNoDoFNoiseProgram;
  extern LLGLSLShader         gDeferredPostGammaCorrectProgram;
  extern LLGLSLShader         gLegacyPostGammaCorrectProgram;
+ extern LLGLSLShader         gHDRGammaCorrectProgram;
  extern LLGLSLShader         gDeferredPostTonemapProgram;
  extern LLGLSLShader         gNoPostTonemapProgram;
  extern LLGLSLShader         gExposureProgram;
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 9e52ed9a12..82246b564c 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -1966,8 +1966,10 @@ LLViewerWindow::LLViewerWindow(const Params& p)
     //
     LL_DEBUGS("Window") << "Loading feature tables." << LL_ENDL;
 
+
     // Initialize OpenGL Renderer
-    LLVertexBuffer::initClass(mWindow);
+    LLVertexBuffer::initClass(mWindow, gSavedSettings.getU32("MPVertexBufferMode"));
+
     LL_INFOS("RenderInit") << "LLVertexBuffer initialization done." << LL_ENDL ;
     if (!gGL.init(true))
     {
@@ -5177,7 +5179,7 @@ bool LLViewerWindow::rawSnapshot(LLImageRaw *raw, S32 image_width, S32 image_hei
                             glReadPixels(
                                          subimage_x_offset, out_y + subimage_y_offset,
                                          read_width, 1,
-                                         GL_DEPTH_COMPONENT, GL_FLOAT,
+                                         GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
                                          depth_line_buffer->getData()// current output pixel is beginning of buffer...
                                          );
 
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 924efde89b..996221fdba 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -144,7 +144,6 @@ U32 LLPipeline::RenderFSAAType;
 F32 LLPipeline::RenderResolutionDivisor;
 bool LLPipeline::RenderUIBuffer;
 S32 LLPipeline::RenderShadowDetail;
-S32 LLPipeline::MPRenderShadowOpti;
 S32 LLPipeline::RenderShadowSplits;
 bool LLPipeline::RenderDeferredSSAO;
 F32 LLPipeline::RenderShadowResolutionScale;
@@ -354,13 +353,13 @@ bool addDeferredAttachments(LLRenderTarget& target, bool for_impostor = false)
     U32 norm = GL_RGBA16F;
     U32 emissive = GL_RGB16F;
 
-    static LLCachedControl<bool> MPLowColorPrecision(gSavedSettings, "MPLowColorPrecision", 0);
-
     static LLCachedControl<bool> has_emissive(gSavedSettings, "RenderEnableEmissiveBuffer", false);
     static LLCachedControl<bool> has_hdr(gSavedSettings, "RenderHDREnabled", true);
+    static LLCachedControl<U32> MPColorPrecision(gSavedSettings, "MPColorPrecision", 0);
+
     bool hdr = has_hdr() && gGLManager.mGLVersion > 4.05f;
 
-    if (!hdr || MPLowColorPrecision)
+    if (!hdr || MPColorPrecision < 2)
     {
         norm = GL_RGB10_A2;
         emissive = GL_RGB8;
@@ -485,6 +484,10 @@ void LLPipeline::init()
         gSavedSettings.setBOOL("RenderPerformanceTest", true);
     }
 
+#if LL_DARWIN
+    mHDRDisplay = gSavedSettings.getBOOL("MPHDRDisplay");
+#endif
+
     mOldRenderDebugMask = mRenderDebugMask;
 
     mBackfaceCull = true;
@@ -533,7 +536,6 @@ void LLPipeline::init()
     connectRefreshCachedSettingsSafe("RenderResolutionDivisor");
     connectRefreshCachedSettingsSafe("RenderUIBuffer");
     connectRefreshCachedSettingsSafe("RenderShadowDetail");
-    connectRefreshCachedSettingsSafe("MPRenderShadowOpti");
     connectRefreshCachedSettingsSafe("RenderShadowSplits");
     connectRefreshCachedSettingsSafe("RenderDeferredSSAO");
     connectRefreshCachedSettingsSafe("RenderShadowResolutionScale");
@@ -819,13 +821,15 @@ LLPipeline::eFBOStatus LLPipeline::doAllocateScreenBuffer(U32 resX, U32 resY)
     return ret;
 }
 
-bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY)
+bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY, U32 type_)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DISPLAY;
 
     static LLCachedControl<bool> has_hdr(gSavedSettings, "RenderHDREnabled", true);
     bool hdr = gGLManager.mGLVersion > 4.05f && has_hdr();
 
+    static LLCachedControl<U32> MPColorPrecision(gSavedSettings, "MPColorPrecision", 0);
+
     if (mRT == &mMainRT)
     { // hacky -- allocate auxillary buffer
 
@@ -838,14 +842,14 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY)
 
         mRT = &mAuxillaryRT;
         U32 res = mReflectionMapManager.mProbeResolution * 4;  //multiply by 4 because probes will be 16x super sampled
-        allocateScreenBufferInternal(res, res);
+        allocateScreenBufferInternal(res, res, 1);
 
         if (RenderMirrors)
         {
             mHeroProbeManager.initReflectionMaps();
             res = mHeroProbeManager.mProbeResolution;  // We also scale the hero probe RT to the probe res since we don't super sample it.
             mRT = &mHeroProbeRT;
-            allocateScreenBufferInternal(res, res);
+            allocateScreenBufferInternal(res, res, 2);
         }
 
         mRT = &mMainRT;
@@ -858,25 +862,27 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY)
 
     F32 res_mod = fmin(RenderResolutionDivisor, 4.0);
 
-    LL_WARNS() << "res_mod=" << res_mod << " resX=" << resX << " resY=" << resY << LL_ENDL;
-
     if (res_mod >= 0.5 && res_mod <= 4.0)
     {
         resX = (U32)(floor((F32)resX / res_mod));
         resY = (U32)(floor((F32)resY / res_mod));
-        LL_WARNS() << "res_mod=" << res_mod << " resX=" << resX << " resY=" << resY << LL_ENDL;
     }
 
     S32 shadow_detail = RenderShadowDetail;
     bool ssao = RenderDeferredSSAO;
 
     //allocate deferred rendering color buffers
-    if (!mRT->deferredScreen.allocate(resX, resY, GL_RGBA8, true)) return false;
+
+    GLuint deferredScreenFormat = GL_RGBA8;
+    if((hdr || mHDRDisplay) && MPColorPrecision == 2) deferredScreenFormat = GL_RGBA16F;
+
+    if (!mRT->deferredScreen.allocate(resX, resY, deferredScreenFormat, true)) return false;
     if (!addDeferredAttachments(mRT->deferredScreen)) return false;
 
-    GLuint screenFormat = hdr ? GL_RGBA16F : GL_RGBA8;
+    GLuint screenFormat = GL_RGBA8;
+    if(hdr || mHDRDisplay) screenFormat = GL_RGBA16F;
 
-    if (!mRT->screen.allocate(resX, resY, screenFormat)) return false;
+    if (!mRT->screen.allocate(resX, resY, GL_RGBA16F)) return false;
 
     mRT->deferredScreen.shareDepthBuffer(mRT->screen);
 
@@ -890,13 +896,16 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY)
     }
 
     //allocateShadowBuffer(resX, resY);
-    allocateShadowBuffer(SHADOWS_RESX, SHADOWS_RESY);
+    if(type_ == 0) allocateShadowBuffer(SHADOWS_RESX, SHADOWS_RESY);
 
     if (!gCubeSnapshot) // hack to not re-allocate various targets for cube snapshots
     {
+        GLuint UIFormat = GL_RGBA8;
+        if(mHDRDisplay && MPColorPrecision == 2) UIFormat = GL_RGBA16F;
+
         if (RenderUIBuffer)
         {
-            if (!mUIScreen.allocate(resX, resY, GL_RGBA8))
+            if (!mUIScreen.allocate(resX, resY, UIFormat))
             {
                 return false;
             }
@@ -904,10 +913,13 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY)
 
         if (RenderFSAAType > 0)
         {
-            if (!mFXAAMap.allocate(resX, resY, GL_RGBA8)) return false;
+            GLuint AAFormat = GL_RGBA8;
+            if(mHDRDisplay && MPColorPrecision == 2) AAFormat = GL_RGBA16F;
+
+            if (!mFXAAMap.allocate(resX, resY, AAFormat)) return false;
             if (RenderFSAAType == 2)
             {
-                if (!mSMAABlendBuffer.allocate(resX, resY, GL_RGBA8, false)) return false;
+                if (!mSMAABlendBuffer.allocate(resX, resY, AAFormat, false)) return false;
             }
         }
         else
@@ -921,17 +933,25 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY)
 
         if(RenderScreenSpaceReflections)
         {
-            mSceneMap.allocate(resX, resY, screenFormat, true);
+            //mSceneMap.allocate(resX, resY, screenFormat, true);
+            //We plan a setting. For now e go with a reasonable value
+            mSceneMap.allocate(512, 512, screenFormat, true);
         }
         else
         {
             mSceneMap.release();
         }
 
-        //mPostMaps[0].allocate(resX, resY, screenFormat);
-        //mPostMaps[1].allocate(resX, resY, screenFormat);
-        mPostMaps[0].allocate(resX, resY, GL_RGBA);
-        mPostMaps[1].allocate(resX, resY, GL_RGBA);
+        if((hdr && MPColorPrecision == 2) || mHDRDisplay)
+        {
+            mPostMaps[0].allocate(resX, resY, screenFormat);
+            mPostMaps[1].allocate(resX, resY, screenFormat);
+        }
+        else
+        {
+            mPostMaps[0].allocate(resX, resY, GL_RGBA);
+            mPostMaps[1].allocate(resX, resY, GL_RGBA);
+        }
 
         // The water exclusion mask needs its own depth buffer so we can take care of the problem of multiple water planes.
         // Should we ever make water not just a plane, it also aids with that as well as the water planes will be rendered into the mask.
@@ -975,7 +995,7 @@ bool LLPipeline::allocateShadowBuffer(U32 resX, U32 resY)
     U32 sun_shadow_map_width = resX * scale;
     U32 sun_shadow_map_height = resY * scale;
 
-    if (shadow_detail > 0)
+    if (shadow_detail > 0 && shadow_detail < 3)
     { //allocate 4 sun shadow maps
         for (U32 i = 0; i < 4; i++)
         {
@@ -1311,17 +1331,21 @@ void LLPipeline::createGLBuffers()
     // allocate screen space glow buffers
     const U32 glow_res = llmax(1, llmin(512, 1 << gSavedSettings.getS32("RenderGlowResolutionPow")));
     const bool glow_hdr = gSavedSettings.getBOOL("RenderGlowHDR");
-    const U32 glow_color_fmt = glow_hdr ? GL_RGBA16F : GL_RGBA8;
+    static LLCachedControl<U32> MPColorPrecision(gSavedSettings, "MPColorPrecision", 0);
+
+    U32 glow_color_fmt = glow_hdr ? GL_RGBA16F : GL_RGBA8;
+    if(MPColorPrecision == 2) glow_color_fmt = GL_RGBA16F;
+
     for (U32 i = 0; i < 3; i++)
     {
         mGlow[i].allocate(512, glow_res, glow_color_fmt);
     }
 
-    mBloomMap.allocate(resX/2.0, resY/2.0, glow_color_fmt);
+    mBloomMap.allocate(512, 256, glow_color_fmt);
 
     for (U32 i = 0; i < 2; i++)
     {
-        mBloomBlur[i].allocate(resX/2.0, resY/2.0, glow_color_fmt);
+        mBloomBlur[i].allocate(512, 256, glow_color_fmt);
     }
 
     allocateScreenBuffer(resX, resY);
@@ -3867,6 +3891,10 @@ void render_hud_elements()
     gGL.color4f(1, 1, 1, 1);
     LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 
+    static LLCachedControl<bool> HDRDisplay(gSavedSettings, "MPHDRDisplay");
+    static LLCachedControl<F32> hdrUIBoost(gSavedSettings, "MPHDRUIBoost");
+    if(HDRDisplay) gUIProgram.uniform1f(LLShaderMgr::MP_HDR_BOOST, (GLfloat)hdrUIBoost);
+
     if (!LLPipeline::sReflectionRender && gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
     {
         gViewerWindow->renderSelections(false, false, false); // For HUD version in render_ui_3d()
@@ -5798,19 +5826,22 @@ void LLPipeline::setupHWLights()
         mSunDiffuse.setVec(psky->getSunlightColor());
         mMoonDiffuse.setVec(psky->getMoonlightColor());
 
-        F32 max_color = llmax(mSunDiffuse.mV[0], mSunDiffuse.mV[1], mSunDiffuse.mV[2]);
-        if (max_color > 1.f)
+        if(!mHDRDisplay)
         {
-            mSunDiffuse *= 1.f/max_color;
-        }
-        mSunDiffuse.clamp();
+            F32 max_color = llmax(mSunDiffuse.mV[0], mSunDiffuse.mV[1], mSunDiffuse.mV[2]);
+            if (max_color > 1.f)
+            {
+                mSunDiffuse *= 1.f/max_color;
+            }
+            mSunDiffuse.clamp();
 
-        max_color = llmax(mMoonDiffuse.mV[0], mMoonDiffuse.mV[1], mMoonDiffuse.mV[2]);
-        if (max_color > 1.f)
-        {
-            mMoonDiffuse *= 1.f/max_color;
+            max_color = llmax(mMoonDiffuse.mV[0], mMoonDiffuse.mV[1], mMoonDiffuse.mV[2]);
+            if (max_color > 1.f)
+            {
+                mMoonDiffuse *= 1.f/max_color;
+            }
+            mMoonDiffuse.clamp();
         }
-        mMoonDiffuse.clamp();
 
         // prevent underlighting from having neither lightsource facing us
         if (!sun_up && !moon_up)
@@ -7073,9 +7104,8 @@ static LLTrace::BlockTimerStatHandle FTM_RENDER_BLOOM("Post processing");
 void LLPipeline::visualizeBuffers(LLRenderTarget* src, LLRenderTarget* dst, U32 bufferIndex)
 {
     dst->bindTarget("visualizeBuffers", 1);
-    dst->clear();
     gDeferredBufferVisualProgram.bind();
-    gDeferredBufferVisualProgram.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_BILINEAR, bufferIndex);
+    gDeferredBufferVisualProgram.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_POINT, bufferIndex);
 
     static LLStaticHashedString mipLevel("mipLevel");
     if (RenderBufferVisualization != 4)
@@ -7153,7 +7183,7 @@ void LLPipeline::generateExposure(LLRenderTarget* src, LLRenderTarget* dst, bool
         }
 
         dst->bindTarget("generateExposure", 1);
-        //dst->clear();
+        dst->clear();
 
         LLGLDepthTest depth(GL_FALSE, GL_FALSE);
 
@@ -7321,9 +7351,20 @@ void LLPipeline::gammaCorrect(LLRenderTarget* src, LLRenderTarget* dst)
         LLGLSLShader& shader = psky->getReflectionProbeAmbiance(should_auto_adjust) == 0.f ? gLegacyPostGammaCorrectProgram :
             gDeferredPostGammaCorrectProgram;
 
+        static LLCachedControl<F32> mp_hdr_boost(gSavedSettings, "MPHDRBoost", false);
+        static LLCachedControl<F32> mp_hdr_gamma(gSavedSettings, "MPHDRGamma", false);
+        if(mHDRDisplay) shader = gHDRGammaCorrectProgram;
+
         shader.bind();
         shader.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_POINT);
-        shader.uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, (GLfloat)src->getWidth(), (GLfloat)src->getHeight());
+        //screensize isn't a uniform int he shader, we comment out for now
+        //shader.uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, (GLfloat)src->getWidth(), (GLfloat)src->getHeight());
+
+        if(mHDRDisplay)
+        {
+            shader.uniform1f(LLShaderMgr::GAMMA, (GLfloat)mp_hdr_gamma);
+            shader.uniform1f(LLShaderMgr::MP_HDR_BOOST, (GLfloat)mp_hdr_boost);
+        }
 
         renderTriangle();
 
@@ -7527,7 +7568,6 @@ bool LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst)
     S32 width = dst->getWidth();
     S32 height = dst->getHeight();
 
-    //LL_WARNS() << "dst width=" << width << LL_ENDL;
 
     // bake out texture2D with RGBL for FXAA shader
     mFXAAMap.bindTarget("applyFXAA", 1);
@@ -8040,6 +8080,9 @@ bool LLPipeline::renderBloom(LLRenderTarget* src, LLRenderTarget* dst)
     static LLCachedControl<F32> mp_bloom_metal(gSavedSettings, "MPBloomExtractMetal", 0.2);
     static LLCachedControl<F32> mp_bloom_nonmetal(gSavedSettings, "MPBloomExtractNonMetal", 0.2);
 
+    F32 clampValue = 1.0;
+    if(mHDRDisplay) clampValue = 11.0;
+
     LLGLDepthTest depth(GL_FALSE, GL_FALSE);
     LLGLDisable blend(GL_BLEND);
 
@@ -8049,7 +8092,7 @@ bool LLPipeline::renderBloom(LLRenderTarget* src, LLRenderTarget* dst)
     mBloomMap.clear();
 
     gBloomExtractProgram.bind();
-    gBloomExtractProgram.bindTexture(LLShaderMgr::DIFFUSE_MAP, src);
+    gBloomExtractProgram.bindTexture(LLShaderMgr::DIFFUSE_MAP, &mRT->screen);
     gBloomExtractProgram.bindTexture(LLShaderMgr::BLOOM_EXTRACT_ORM, &mRT->deferredScreen, false, LLTexUnit::TFO_POINT, 1);
     gBloomExtractProgram.bindTexture(LLShaderMgr::BLOOM_EXTRACT_EMISSIVE, &mGlow[1], false, LLTexUnit::TFO_POINT, 0);
     gBloomExtractProgram.bindTexture(LLShaderMgr::BLOOM_EXTRACT_EMISSIVE2, &mRT->deferredScreen, false, LLTexUnit::TFO_POINT, 3);
@@ -8132,6 +8175,7 @@ bool LLPipeline::renderBloom(LLRenderTarget* src, LLRenderTarget* dst)
     gBloomCombineProgram.bindTexture(LLShaderMgr::DIFFUSE_MAP, src);
     gBloomCombineProgram.bindTexture(LLShaderMgr::BLOOM_BMAP, &mBloomBlur[1]);
     gBloomCombineProgram.uniform1f(LLShaderMgr::BLOOM_STRENGTH, mp_bloom_strength);
+    gBloomCombineProgram.uniform1f(LLShaderMgr::BLOOM_CLAMP, clampValue);
 
     renderTriangle();
 
@@ -8177,36 +8221,41 @@ void LLPipeline::renderFinalize()
     {
         copyScreenSpaceReflections(&mRT->screen, &mSceneMap);
 
-        generateLuminance(&mRT->screen, &mLuminanceMap);
+        if(!mHDRDisplay)
+        {
+            generateLuminance(&mRT->screen, &mLuminanceMap);
+            generateExposure(&mLuminanceMap, &mExposureMap);
 
-        generateExposure(&mLuminanceMap, &mExposureMap);
+            tonemap(&mRT->screen, &mRT->deferredLight);
+            postHDRBuffer = &mRT->deferredLight;
+        }
+    }
 
-        tonemap(&mRT->screen, &mRT->deferredLight);
+    gammaCorrect(postHDRBuffer, &mPostMaps[activeRT]);
 
-        postHDRBuffer = &mRT->deferredLight;
 
+    if(hdr)
+    {
+        generateGlow(&mPostMaps[activeRT]);
     }
 
-    gammaCorrect(postHDRBuffer, &mPostMaps[0]);
-
-    generateGlow(&mPostMaps[0]);
-
     LLVertexBuffer::unbind();
 
-    if(renderBloom(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]))
+    if(hdr)
     {
-        activeRT = 1 - activeRT;
+        if(renderBloom(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]))
+        {
+            activeRT = 1 - activeRT;
+        }
     }
 
-    combineGlow(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]);
-    activeRT = 1 - activeRT;
-
-    if(applyFXAA(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]))
+    if(hdr)
     {
+        combineGlow(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]);
         activeRT = 1 - activeRT;
     }
 
-    if(applyCAS(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]))
+    if(applyFXAA(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]))
     {
         activeRT = 1 - activeRT;
     }
@@ -8216,6 +8265,14 @@ void LLPipeline::renderFinalize()
         activeRT = 1 - activeRT;
     }
 
+    if(!mHDRDisplay)
+    {
+        //CAS breaks the hdr colors for now.
+        if(applyCAS(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]))
+        {
+            activeRT = 1 - activeRT;
+        }
+    }
 
     if(renderDoF(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]))
     {
@@ -8274,6 +8331,15 @@ void LLPipeline::renderFinalize()
         case 13:
             visualizeBuffers(&mSceneMap, finalBuffer, 0);
             break;
+        case 14:
+            visualizeBuffers(&mRT->screen, finalBuffer, 0);
+            break;
+        case 15:
+            visualizeBuffers(&mRT->deferredLight, finalBuffer, 0);
+            break;
+        case 16:
+            visualizeBuffers(&mPostMaps[1-activeRT], finalBuffer, 0);
+            break;
         default:
             break;
         }
@@ -8693,7 +8759,7 @@ void LLPipeline::renderDeferredLighting()
         tc_moon = mat * tc_moon;
         mTransformedMoonDir.set(tc_moon);
 
-        if ((RenderDeferredSSAO && !gCubeSnapshot) || RenderShadowDetail > 0)
+        if ((RenderDeferredSSAO && !gCubeSnapshot) || (RenderShadowDetail > 0 && RenderShadowDetail < 4))
         {
             LL_PROFILE_GPU_ZONE("sun program");
             deferred_light_target->bindTarget("sun_shader", 1);
@@ -9772,67 +9838,69 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa
         renderGeomShadow(shadow_cam);
     }
 
-    LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha");
-    LL_PROFILE_GPU_ZONE("shadow alpha");
-    LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA);
-
-    const S32 sun_up = LLEnvironment::instance().getIsSunUp() ? 1 : 0;
-    U32 target_width = LLRenderTarget::sCurResX;
-
-    for (int i = 0; i < 2; ++i)
     {
-        bool rigged = i == 1;
+        LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha");
+        LL_PROFILE_GPU_ZONE("shadow alpha");
+        LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA);
 
-        {
-            LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha masked");
-            LL_PROFILE_GPU_ZONE("shadow alpha masked");
-            LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_MASKED);
-            gDeferredShadowAlphaMaskProgram.bind(rigged);
-            LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up);
-            LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH, (float)target_width);
-            renderMaskedObjects(LLRenderPass::PASS_ALPHA_MASK, true, true, rigged);
-        }
-
-        {
-            LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha blend");
-            LL_PROFILE_GPU_ZONE("shadow alpha blend");
-            LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_BLEND);
-            renderAlphaObjects(rigged);
-        }
+        const S32 sun_up = LLEnvironment::instance().getIsSunUp() ? 1 : 0;
+        U32 target_width = LLRenderTarget::sCurResX;
 
+        for (int i = 0; i < 2; ++i)
         {
-            LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow fullbright alpha masked");
-            LL_PROFILE_GPU_ZONE("shadow alpha masked");
-            LL_RECORD_BLOCK_TIME(FTM_SHADOW_FULLBRIGHT_ALPHA_MASKED);
-
-            gDeferredShadowFullbrightAlphaMaskProgram.bind(rigged);
-            LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up);
-            LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH, (float)target_width);
-            renderFullbrightMaskedObjects(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, true, true, rigged);
-        }
+            bool rigged = i == 1;
 
-        {
-            LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha grass");
-            LL_PROFILE_GPU_ZONE("shadow alpha grass");
-            LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_GRASS);
+            {
+                LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha masked");
+                LL_PROFILE_GPU_ZONE("shadow alpha masked");
+                LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_MASKED);
+                gDeferredShadowAlphaMaskProgram.bind(rigged);
+                LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up);
+                LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH, (float)target_width);
+                renderMaskedObjects(LLRenderPass::PASS_ALPHA_MASK, true, true, rigged);
+            }
 
-            gDeferredTreeShadowProgram.bind(rigged);
-            LLGLSLShader::sCurBoundShaderPtr->setMinimumAlpha(ALPHA_BLEND_CUTOFF);
+            {
+                LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha blend");
+                LL_PROFILE_GPU_ZONE("shadow alpha blend");
+                LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_BLEND);
+                renderAlphaObjects(rigged);
+            }
 
-            if (i == 0)
             {
-                renderObjects(LLRenderPass::PASS_GRASS, true);
+                LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow fullbright alpha masked");
+                LL_PROFILE_GPU_ZONE("shadow alpha masked");
+                LL_RECORD_BLOCK_TIME(FTM_SHADOW_FULLBRIGHT_ALPHA_MASKED);
+
+                gDeferredShadowFullbrightAlphaMaskProgram.bind(rigged);
+                LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up);
+                LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH, (float)target_width);
+                renderFullbrightMaskedObjects(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, true, true, rigged);
             }
 
             {
-                LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha material");
-                LL_PROFILE_GPU_ZONE("shadow alpha material");
-                LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_MATERIAL);
+                LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha grass");
+                LL_PROFILE_GPU_ZONE("shadow alpha grass");
+                LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_GRASS);
+
+                gDeferredTreeShadowProgram.bind(rigged);
+                LLGLSLShader::sCurBoundShaderPtr->setMinimumAlpha(ALPHA_BLEND_CUTOFF);
 
-                renderMaskedObjects(LLRenderPass::PASS_NORMSPEC_MASK, true, false, rigged);
-                renderMaskedObjects(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, true, false, rigged);
-                renderMaskedObjects(LLRenderPass::PASS_SPECMAP_MASK, true, false, rigged);
-                renderMaskedObjects(LLRenderPass::PASS_NORMMAP_MASK, true, false, rigged);
+                if (i == 0)
+                {
+                    renderObjects(LLRenderPass::PASS_GRASS, true);
+                }
+
+                {
+                    LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha material");
+                    LL_PROFILE_GPU_ZONE("shadow alpha material");
+                    LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_MATERIAL);
+
+                    renderMaskedObjects(LLRenderPass::PASS_NORMSPEC_MASK, true, false, rigged);
+                    renderMaskedObjects(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, true, false, rigged);
+                    renderMaskedObjects(LLRenderPass::PASS_SPECMAP_MASK, true, false, rigged);
+                    renderMaskedObjects(LLRenderPass::PASS_NORMMAP_MASK, true, false, rigged);
+                }
             }
         }
 
@@ -10348,7 +10416,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
     // convenience array of 4 near clip plane distances
     F32 dist[] = { near_clip, mSunClipPlanes.mV[0], mSunClipPlanes.mV[1], mSunClipPlanes.mV[2], mSunClipPlanes.mV[3] };
 
-    if (mSunDiffuse == LLColor4::black)
+    if (mSunDiffuse == LLColor4::black || RenderShadowDetail == 3)
     { //sun diffuse is totally black shadows don't matter
         skipRenderingShadows();
     }
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index c56e181d2d..0145a9c397 100644
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -131,7 +131,8 @@ public:
 
     //attempt to allocate screen buffers at resX, resY
     //returns true if allocation successful, false otherwise
-    bool allocateScreenBufferInternal(U32 resX, U32 resY);
+    //type 0 = screen, 1 = probe, 2 = mirror
+    bool allocateScreenBufferInternal(U32 resX, U32 resY, U32 type_ = 0);
     bool allocateShadowBuffer(U32 resX, U32 resY);
 
     // rebuild all LLVOVolume render batches
@@ -820,6 +821,9 @@ public:
     bool                    mShadersLoaded;
 
     U32                     mTransformFeedbackPrimitives; //number of primitives expected to be generated by transform feedback
+
+    bool                    mHDRDisplay;
+
 protected:
     bool                    mRenderTypeEnabled[NUM_RENDER_TYPES];
     std::stack<std::string> mRenderTypeEnableStack;
@@ -1019,7 +1023,6 @@ public:
     static F32 RenderResolutionDivisor;
     static bool RenderUIBuffer;
     static S32 RenderShadowDetail;
-    static S32 MPRenderShadowOpti;
     static S32 RenderShadowSplits;
     static bool RenderDeferredSSAO;
     static F32 RenderShadowResolutionScale;
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_graphics3.xml b/indra/newview/skins/default/xui/en/panel_preferences_graphics3.xml
index 8b76ece106..ddc00915a5 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_graphics3.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_graphics3.xml
@@ -299,6 +299,71 @@ font="SansSerifSmall"
 Beware: SMAA + Sharpness currently causes a slow down on Mac.
 </text>
 
+<text
+follows="left|top"
+layout="topleft"
+width="400"
+height="18"
+left="55"
+top_pad="12"
+font="SansSerifSmall"
+>
+Disabling HUDS (Option + Shift + H) fixes the issue.
+</text>
+
+<text
+name="aniso_lbl"
+follows="left|top"
+layout="topleft"
+width="140"
+height="18"
+left="20"
+top_pad="40"
+font="SansSerifSmall"
+text_color="White"
+>
+Texture Filtering
+</text>
+
+<check_box
+name="mp_aniso_ctrl"
+control_name="RenderAnisotropic"
+label="Anisotropic Filtering"
+layout="topleft"
+width="200"
+height="16"
+left="20"
+top_delta="32"
+initial_value="true"
+>
+<check_box.commit_callback
+function="Pref.RenderOptionUpdate" />
+</check_box>
+
+<icon
+name="mp_aniso_bullet"
+tool_tip="Low performance impact on PC/Linux, Medium performance impact on Mac (We are investigating)"
+image_name="mp_yellow_bullet"
+follows="left|top"
+width="16"
+height="16"
+layout="topleft"
+left_pad="5"
+top_delta="-2"
+/>
+
+<icon
+name="mp_aniso_info_bullet"
+tool_tip="Improves textures clarity at certain angles (i.e. ground). This should be on, but on Mac there is an abnormal performance penalty, currently."
+image_name="mp_info_bullet"
+follows="left|top"
+width="16"
+height="16"
+layout="topleft"
+left_pad="5"
+top_delta="0"
+/>
+
 </panel>
 
 <panel
@@ -886,7 +951,7 @@ top_delta="-1"
 increment="0.1"
 initial_value="1.0"
 min_val="0.5"
-max_val="2.0"
+max_val="4.0"
 label_width="2"
 >
 </slider>
@@ -1542,12 +1607,26 @@ name="preferences_visuals_others"
 layout="topleft"
 follows="top|left">
 
+<text
+name="mp_aa_lbl"
+follows="left|top"
+layout="topleft"
+top_pad="20"
+width="400"
+height="18"
+left="20"
+font="SansSerifSmall"
+text_color="White"
+>
+Visual Quality Settings:
+</text>
+
 <check_box
 name="VintageCtrl"
 control_name="RenderDisableVintageMode"
 label="HDR and Emissive"
 layout="topleft"
-width="250"
+width="300"
 height="16"
 left="20"
 top_delta="32"
@@ -1565,7 +1644,7 @@ follows="left|top"
 width="16"
 height="16"
 layout="topleft"
-left_pad="5"
+left_pad="8"
 top_delta="-2"
 />
 
@@ -1586,7 +1665,7 @@ name="mp_transparent_water"
 control_name="RenderTransparentWater"
 label="Transparent Water"
 layout="topleft"
-width="250"
+width="300"
 height="16"
 left="20"
 top_delta="32"
@@ -1604,7 +1683,7 @@ follows="left|top"
 width="16"
 height="16"
 layout="topleft"
-left_pad="5"
+left_pad="8"
 top_delta="-2"
 />
 
@@ -1620,45 +1699,6 @@ left_pad="5"
 top_delta="0"
 />
 
-<check_box
-name="colorPrecisionCtrl"
-control_name="MPLowColorPrecision"
-label="Lower color precision (needs restart)"
-layout="topleft"
-width="250"
-height="16"
-left="20"
-top_delta="32"
-initial_value="false"
->
-<check_box.commit_callback
-function="Pref.RenderOptionUpdate" />
-</check_box>
-
-<icon
-name="mp_lowcolor_bullet"
-tool_tip="Can help performance specially in high resolution"
-image_name="mp_green_bullet"
-follows="left|top"
-width="16"
-height="16"
-layout="topleft"
-left_pad="5"
-top_delta="-2"
-/>
-
-<icon
-name="mp_lowcolor_info_bullet"
-tool_tip="Lowers the internal color precision which can help with performance."
-image_name="mp_info_bullet"
-follows="left|top"
-width="16"
-height="16"
-layout="topleft"
-left_pad="5"
-top_delta="0"
-/>
-
 <text
 name="mp_resdiv_lbl"
 follows="left|top"
@@ -1681,9 +1721,9 @@ height="16"
 left_delta="150"
 top_delta="-1"
 initial_value="1.0"
-increment="0.25"
-min_val="1.0"
-max_val="4.0"
+increment="0.1"
+min_val="0.8"
+max_val="2.0"
 decimal_digits="2"
 label_width="2">
 </slider>
@@ -1696,12 +1736,25 @@ name="preferences_visuals_others"
 layout="topleft"
 follows="top|left">
 
+<text
+follows="left|top"
+layout="topleft"
+top_pad="20"
+width="400"
+height="18"
+left="20"
+font="SansSerifSmall"
+text_color="White"
+>
+Advanced settings:
+</text>
+
 <check_box
 name="MultiTexCtrl"
 control_name="RenderGLMultiThreadedTextures"
 label="Multithreaded Textures"
 layout="topleft"
-width="250"
+width="400"
 height="16"
 left="20"
 top_delta="32"
@@ -1738,7 +1791,7 @@ name="AppleMultGLCtrl"
 control_name="RenderAppleUseMultGL"
 label="Apple Multithreaded OpenGL"
 layout="topleft"
-width="250"
+width="400"
 height="16"
 left="20"
 top_delta="32"
@@ -1770,12 +1823,194 @@ left_pad="5"
 top_delta="0"
 />
 
+<text
+name="color_precision_lbl"
+follows="left|top"
+layout="topleft"
+width="200"
+height="18"
+left="32"
+top_pad="20"
+font="SansSerifSmall"
+>
+Color precision (needs restart):
+</text>
+
+<combo_box
+name="colorPrecisionCtrl"
+control_name="MPColorPrecision"
+layout="topleft"
+width="80"
+height="18"
+left_pad="8"
+top_delta="0"
+>
+<combo_box.item
+label="Low"
+name="low"
+value="1"/>
+<combo_box.item
+label="Default"
+name="default"
+value="0"/>
+<combo_box.item
+label="High"
+name="high"
+value="2"/>
+</combo_box>
+
+<icon
+name="mp_lowcolor_bullet"
+tool_tip="Low setting can help performance specially in high resolution"
+image_name="mp_green_bullet"
+follows="left|top"
+width="16"
+height="16"
+layout="topleft"
+left_pad="104"
+top_delta="-2"
+/>
+
+<icon
+name="mp_lowcolor_info_bullet"
+tool_tip="Sets the internal color resolution. Improves the speed or quality."
+image_name="mp_info_bullet"
+follows="left|top"
+width="16"
+height="16"
+layout="topleft"
+left_pad="5"
+top_delta="0"
+/>
+
+<text
+follows="left|top"
+layout="topleft"
+top_pad="30"
+width="400"
+height="18"
+left="20"
+font="SansSerifSmall"
+text_color="White"
+>
+HDR Display (Experimental - Mac only):
+</text>
+
+<icon
+name="mp_hdrd_bullet"
+tool_tip="You need an Apple hdr/xdr display"
+image_name="mp_info_bullet"
+follows="left|top"
+width="16"
+height="16"
+layout="topleft"
+left_pad="5"
+top_delta="-2"
+/>
+
+<text
+follows="left|top"
+layout="topleft"
+width="400"
+height="18"
+left="20"
+top_pad="12"
+font="SansSerifSmall"
+text_color="White"
+>
+Warning: HDR shows extreme luminosity contrast. Use carefully!
+</text>
+
+<check_box
+name="HDRDisplayCtrl"
+control_name="MPHDRDisplay"
+label="HDR Display (Mac)"
+layout="topleft"
+width="250"
+height="16"
+left="20"
+top_delta="32"
+initial_value="true"
+>
+</check_box>
+
+<text
+name="mp_hdrd_gamma_lbl"
+follows="left|top"
+layout="topleft"
+width="140"
+height="18"
+left="32"
+top_pad="16"
+font="SansSerifSmall"
+>
+Gamma
+</text>
+
+<slider
+control_name="MPHDRGamma"
+follows="left|top"
+layout="topleft"
+width="200"
+height="16"
+left_delta="150"
+top_delta="-1"
+initial_value="2.2"
+increment="0.05"
+min_val="1.8"
+max_val="2.6"
+decimal_digits="2"
+label_width="2">
+</slider>
+
+<text
+name="mp_hdrd_uiboost_lbl"
+follows="left|top"
+layout="topleft"
+width="140"
+height="18"
+left="32"
+top_pad="16"
+font="SansSerifSmall"
+>
+UI Luminosity Boost
+</text>
+
+<slider
+control_name="MPHDRUIBoost"
+follows="left|top"
+layout="topleft"
+width="200"
+height="16"
+left_delta="150"
+top_delta="-1"
+initial_value="1.0"
+increment="0.1"
+min_val="1.0"
+max_val="1.4"
+decimal_digits="2"
+label_width="2">
+</slider>
+
+<text
+follows="left|top"
+layout="topleft"
+top_pad="30"
+width="400"
+height="18"
+left="20"
+font="SansSerifSmall"
+text_color="White"
+>
+Developer settings:
+</text>
+
 <check_box
 name="NoGLDebugCtrl"
 control_name="MPNoGLDebug"
 label="No GL Debug"
 layout="topleft"
-width="250"
+width="400"
 height="16"
 left="20"
 top_delta="32"
@@ -1807,8 +2042,22 @@ left_pad="5"
 top_delta="0"
 />
 
+<check_box
+name="MPAppleVBModeCtrl"
+control_name="MPVertexBufferMode"
+label="Megapahit Vertex Buffer Mode (needs restart)"
+layout="topleft"
+width="400"
+height="16"
+left="20"
+top_delta="32"
+initial_value="false"
+>
+</check_box>
+
 </panel>
 
+
 </tab_container>
 
 </panel>
\ No newline at end of file