1 files changed, 40 insertions, 74 deletions

diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index 2f2c58ce73..ac66faaf5a 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -50,10 +50,9 @@
 #include "llglheaders.h"
 #include "llglslshader.h"
 
-#include "llvertexbuffer.h"
-#include "llcontrol.h"
-extern LLControlGroup gSavedSettings;
-
+#include "glm/glm.hpp"
+#include <glm/gtc/matrix_access.hpp>
+#include "glm/gtc/type_ptr.hpp"
 
 #if LL_WINDOWS
 #include "lldxhardware.h"
@@ -239,8 +238,6 @@ PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC             wglBlitContextFramebufferAMD = n
 PFNWGLSWAPINTERVALEXTPROC    wglSwapIntervalEXT = nullptr;
 PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT = nullptr;
 
-/*
-
 // GL_VERSION_1_2
 //PFNGLDRAWRANGEELEMENTSPROC  glDrawRangeElements = nullptr;
 //PFNGLTEXIMAGE3DPROC         glTexImage3D = nullptr;
@@ -985,7 +982,6 @@ PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC    glMultiDrawArraysIndirectCount = nullpt
 PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC  glMultiDrawElementsIndirectCount = nullptr;
 PFNGLPOLYGONOFFSETCLAMPPROC              glPolygonOffsetClamp = nullptr;
 
-*/
 #endif
 
 LLGLManager gGLManager;
@@ -1002,7 +998,6 @@ LLGLManager::LLGLManager() :
     mIsAMD(false),
     mIsNVIDIA(false),
     mIsIntel(false),
-    mIsApple(false),
 #if LL_DARWIN
     mIsMobileGF(false),
 #endif
@@ -1177,10 +1172,10 @@ bool LLGLManager::initGL()
         mGLVendorShort = "INTEL";
         mIsIntel = true;
     }
-    else if(mGLVendor.find("APPLE") != std::string::npos)
+    else if (mGLVendor.find("APPLE") != std::string::npos)
     {
         mGLVendorShort = "APPLE";
-        mIsApple = TRUE;
+        mIsApple = true;
     }
     else
     {
@@ -1235,28 +1230,9 @@ bool LLGLManager::initGL()
     }
 #endif
 
-#if LL_WINDOWS
-    if (mVRAM < 256)
-    {
-        // Something likely went wrong using the above extensions
-        // try WMI first and fall back to old method (from dxdiag) if all else fails
-        // Function will check all GPUs WMI knows of and will pick up the one with most
-        // memory. We need to check all GPUs because system can switch active GPU to
-        // weaker one, to preserve power when not under load.
-        U32 mem = LLDXHardware::getMBVideoMemoryViaWMI();
-        if (mem != 0)
-        {
-            mVRAM = mem;
-            LL_WARNS("RenderInit") << "VRAM Detected (WMI):" << mVRAM<< LL_ENDL;
-        }
-    }
-#endif
-
     if (mVRAM < 256 && old_vram > 0)
     {
         // fall back to old method
-        // Note: on Windows value will be from LLDXHardware.
-        // Either received via dxdiag or via WMI by id from dxdiag.
         mVRAM = old_vram;
     }
 
@@ -1268,31 +1244,20 @@ bool LLGLManager::initGL()
     glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &mMaxSampleMaskWords);
 #endif
     glGetIntegerv(GL_MAX_SAMPLES, &mMaxSamples);
+    glGetIntegerv(GL_MAX_VARYING_VECTORS, &mMaxVaryingVectors);
     glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &mMaxUniformBlockSize);
 
     // sanity clamp max uniform block size to 64k just in case
     // there's some implementation that reports a crazy value
     mMaxUniformBlockSize = llmin(mMaxUniformBlockSize, 65536);
 
-    if (mGLVersion >= 4.59f)
+    if (mHasAnisotropic)
     {
         glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &mMaxAnisotropy);
     }
 
     initGLStates();
 
-    U32 MPVBufferOptiMode = gSavedSettings.getU32("MPVBufferOptiMode");
-    if (MPVBufferOptiMode == 0)
-    {
-        if(mIsApple) MPVBufferOptiMode = 2;
-        else MPVBufferOptiMode = 1;
-        gSavedSettings.setU32("MPVBufferOptiMode",MPVBufferOptiMode);
-    }
-    LLVertexBuffer::sMappingMode = MPVBufferOptiMode;
-    //LLRender::sMappingMode = MPVBufferOptiMode;
-
-    LL_INFOS() << "milo init sMappingMode " << MPVBufferOptiMode << LL_ENDL;
-
     return true;
 }
 
@@ -1409,7 +1374,6 @@ void LLGLManager::asLLSD(LLSD& info)
     info["is_ati"] = mIsAMD;  // note, do not rename is_ati to is_amd without coordinating with DW
     info["is_nvidia"] = mIsNVIDIA;
     info["is_intel"] = mIsIntel;
-    info["is_apple"] = mIsApple;
 
     info["gl_renderer"] = mGLRenderer;
 }
@@ -1454,6 +1418,11 @@ void LLGLManager::initExtensions()
     mHasCubeMapArray = mGLVersion >= 3.99f;
     mHasTransformFeedback = mGLVersion >= 3.99f;
     mHasDebugOutput = mGLVersion >= 4.29f;
+    mHasAnisotropic = mGLVersion >= 4.59f;
+    if(!mHasAnisotropic && gGLHExts.mSysExts)
+    {
+        mHasAnisotropic = ExtensionExists("GL_EXT_texture_filter_anisotropic", gGLHExts.mSysExts);
+    }
 
     // Misc
     glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, (GLint*) &mGLMaxVertexRange);
@@ -1462,7 +1431,6 @@ void LLGLManager::initExtensions()
 
     mInited = true;
 
-/*
 #if LL_WINDOWS
     LL_DEBUGS("RenderInit") << "GL Probe: Getting symbols" << LL_ENDL;
 
@@ -2300,7 +2268,6 @@ void LLGLManager::initExtensions()
     glPolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC)GLH_EXT_GET_PROC_ADDRESS("glPolygonOffsetClamp");
 
 #endif
-*/
 }
 
 void rotate_quat(LLQuaternion& rotation)
@@ -2489,12 +2456,15 @@ void LLGLState::checkStates(GLboolean writeAlpha)
         return;
     }
 
-    GLint src;
-    GLint dst;
-    glGetIntegerv(GL_BLEND_SRC, &src);
-    glGetIntegerv(GL_BLEND_DST, &dst);
-    llassert_always(src == GL_SRC_ALPHA);
-    llassert_always(dst == GL_ONE_MINUS_SRC_ALPHA);
+    GLint srcRGB, dstRGB, srcAlpha, dstAlpha;
+    glGetIntegerv(GL_BLEND_SRC_RGB, &srcRGB);
+    glGetIntegerv(GL_BLEND_DST_RGB, &dstRGB);
+    glGetIntegerv(GL_BLEND_SRC_ALPHA, &srcAlpha);
+    glGetIntegerv(GL_BLEND_DST_ALPHA, &dstAlpha);
+    llassert_always(srcRGB == GL_SRC_ALPHA);
+    llassert_always(srcAlpha == GL_SRC_ALPHA);
+    llassert_always(dstRGB == GL_ONE_MINUS_SRC_ALPHA);
+    llassert_always(dstAlpha == GL_ONE_MINUS_SRC_ALPHA);
 
     // disable for now until usage is consistent
     //GLboolean colorMask[4];
@@ -2736,7 +2706,7 @@ void parse_glsl_version(S32& major, S32& minor)
     LLStringUtil::convertToS32(minor_str, minor);
 }
 
-LLGLUserClipPlane::LLGLUserClipPlane(const LLPlane& p, const glh::matrix4f& modelview, const glh::matrix4f& projection, bool apply)
+LLGLUserClipPlane::LLGLUserClipPlane(const LLPlane& p, const glm::mat4& modelview, const glm::mat4& projection, bool apply)
 {
     mApply = apply;
 
@@ -2763,13 +2733,12 @@ void LLGLUserClipPlane::disable()
 
 void LLGLUserClipPlane::setPlane(F32 a, F32 b, F32 c, F32 d)
 {
-    glh::matrix4f& P = mProjection;
-    glh::matrix4f& M = mModelview;
+    const glm::mat4& P = mProjection;
+    const glm::mat4& M = mModelview;
 
-    glh::matrix4f invtrans_MVP = (P * M).inverse().transpose();
-    glh::vec4f oplane(a,b,c,d);
-    glh::vec4f cplane;
-    invtrans_MVP.mult_matrix_vec(oplane, cplane);
+    glm::mat4 invtrans_MVP = glm::transpose(glm::inverse(P*M));
+    glm::vec4 oplane(a,b,c,d);
+    glm::vec4 cplane = invtrans_MVP * oplane;
 
     cplane /= fabs(cplane[2]); // normalize such that depth is not scaled
     cplane[3] -= 1;
@@ -2777,13 +2746,13 @@ void LLGLUserClipPlane::setPlane(F32 a, F32 b, F32 c, F32 d)
     if(cplane[2] < 0)
         cplane *= -1;
 
-    glh::matrix4f suffix;
-    suffix.set_row(2, cplane);
-    glh::matrix4f newP = suffix * P;
+    glm::mat4 suffix;
+    suffix = glm::row(suffix, 2, cplane);
+    glm::mat4 newP = suffix * P;
     gGL.matrixMode(LLRender::MM_PROJECTION);
     gGL.pushMatrix();
-    gGL.loadMatrix(newP.m);
-    gGLObliqueProjectionInverse = LLMatrix4(newP.inverse().transpose().m);
+    gGL.loadMatrix(glm::value_ptr(newP));
+    gGLObliqueProjectionInverse = LLMatrix4(glm::value_ptr(glm::transpose(glm::inverse(newP))));
     gGL.matrixMode(LLRender::MM_MODELVIEW);
 }
 
@@ -2796,7 +2765,7 @@ LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, G
 : mPrevDepthEnabled(sDepthEnabled), mPrevDepthFunc(sDepthFunc), mPrevWriteEnabled(sWriteEnabled)
 {
     stop_glerror();
-
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
     checkState();
 
     if (!depth_enabled)
@@ -2829,6 +2798,7 @@ LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, G
 
 LLGLDepthTest::~LLGLDepthTest()
 {
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
     checkState();
     if (sDepthEnabled != mPrevDepthEnabled )
     {
@@ -2879,31 +2849,27 @@ void LLGLDepthTest::checkState()
 
 LLGLSquashToFarClip::LLGLSquashToFarClip()
 {
-    glh::matrix4f proj = get_current_projection();
+    glm::mat4 proj = get_current_projection();
     setProjectionMatrix(proj, 0);
 }
 
-LLGLSquashToFarClip::LLGLSquashToFarClip(glh::matrix4f& P, U32 layer)
+LLGLSquashToFarClip::LLGLSquashToFarClip(const glm::mat4& P, U32 layer)
 {
     setProjectionMatrix(P, layer);
 }
 
-
-void LLGLSquashToFarClip::setProjectionMatrix(glh::matrix4f& projection, U32 layer)
+void LLGLSquashToFarClip::setProjectionMatrix(glm::mat4 projection, U32 layer)
 {
-
     F32 depth = 0.99999f - 0.0001f * layer;
 
-    for (U32 i = 0; i < 4; i++)
-    {
-        projection.element(2, i) = projection.element(3, i) * depth;
-    }
+    glm::vec4 P_row_3 = glm::row(projection, 3) * depth;
+    projection = glm::row(projection, 2, P_row_3);
 
     LLRender::eMatrixMode last_matrix_mode = gGL.getMatrixMode();
 
     gGL.matrixMode(LLRender::MM_PROJECTION);
     gGL.pushMatrix();
-    gGL.loadMatrix(projection.m);
+    gGL.loadMatrix(glm::value_ptr(projection));
 
     gGL.matrixMode(last_matrix_mode);
 }