#824 Process source files in bulk: replace tabs with spaces, convert CRLF to LF, and trim trailing whitespaces as needed

1 files changed, 795 insertions, 795 deletions

diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index a4a56af981..1b5566a3f7 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -1,30 +1,30 @@
-/** 
+/**
  * @file llgl.cpp
  * @brief LLGL implementation
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 
-// This file sets some global GL parameters, and implements some 
+// This file sets some global GL parameters, and implements some
 // useful functions for GL operations.
 
 #define GLH_EXT_SINGLE_FILE
@@ -172,37 +172,37 @@ void parse_glsl_version(S32& major, S32& minor);
 
 void ll_init_fail_log(std::string filename)
 {
-	gFailLog.open(filename.c_str());
+    gFailLog.open(filename.c_str());
 }
 
 
 void ll_fail(std::string msg)
 {
-	
-	if (gDebugSession)
-	{
-		std::vector<std::string> lines;
 
-		gFailLog << LLError::utcTime() << " " << msg << std::endl;
+    if (gDebugSession)
+    {
+        std::vector<std::string> lines;
 
-		gFailLog << "Stack Trace:" << std::endl;
+        gFailLog << LLError::utcTime() << " " << msg << std::endl;
 
-		ll_get_stack_trace(lines);
-		
-		for(size_t i = 0; i < lines.size(); ++i)
-		{
-			gFailLog << lines[i] << std::endl;
-		}
+        gFailLog << "Stack Trace:" << std::endl;
+
+        ll_get_stack_trace(lines);
+
+        for(size_t i = 0; i < lines.size(); ++i)
+        {
+            gFailLog << lines[i] << std::endl;
+        }
 
-		gFailLog << "End of Stack Trace." << std::endl << std::endl;
+        gFailLog << "End of Stack Trace." << std::endl << std::endl;
 
-		gFailLog.flush();
-	}
+        gFailLog.flush();
+    }
 };
 
 void ll_close_fail_log()
 {
-	gFailLog.close();
+    gFailLog.close();
 }
 
 LLMatrix4 gGLObliqueProjectionInverse;
@@ -983,30 +983,30 @@ PFNGLPOLYGONOFFSETCLAMPPROC              glPolygonOffsetClamp = nullptr;
 LLGLManager gGLManager;
 
 LLGLManager::LLGLManager() :
-	mInited(FALSE),
-	mIsDisabled(FALSE),
-	mMaxSamples(0),
-	mNumTextureImageUnits(1),
-	mMaxSampleMaskWords(0),
-	mMaxColorTextureSamples(0),
-	mMaxDepthTextureSamples(0),
-	mMaxIntegerSamples(0),
-	mIsAMD(FALSE),
-	mIsNVIDIA(FALSE),
-	mIsIntel(FALSE),
+    mInited(FALSE),
+    mIsDisabled(FALSE),
+    mMaxSamples(0),
+    mNumTextureImageUnits(1),
+    mMaxSampleMaskWords(0),
+    mMaxColorTextureSamples(0),
+    mMaxDepthTextureSamples(0),
+    mMaxIntegerSamples(0),
+    mIsAMD(FALSE),
+    mIsNVIDIA(FALSE),
+    mIsIntel(FALSE),
 #if LL_DARWIN
-	mIsMobileGF(FALSE),
+    mIsMobileGF(FALSE),
 #endif
-	mHasRequirements(TRUE),
-	mDriverVersionMajor(1),
-	mDriverVersionMinor(0),
-	mDriverVersionRelease(0),
-	mGLVersion(1.0f),
-	mGLSLVersionMajor(0),
-	mGLSLVersionMinor(0),		
-	mVRAM(0),
-	mGLMaxVertexRange(0),
-	mGLMaxIndexRange(0)
+    mHasRequirements(TRUE),
+    mDriverVersionMajor(1),
+    mDriverVersionMinor(0),
+    mDriverVersionRelease(0),
+    mGLVersion(1.0f),
+    mGLSLVersionMajor(0),
+    mGLSLVersionMinor(0),
+    mVRAM(0),
+    mGLMaxVertexRange(0),
+    mGLMaxIndexRange(0)
 {
 }
 
@@ -1016,227 +1016,227 @@ LLGLManager::LLGLManager() :
 void LLGLManager::initWGL()
 {
 #if LL_WINDOWS && !LL_MESA_HEADLESS
-	if (!glh_init_extensions("WGL_ARB_pixel_format"))
-	{
-		LL_WARNS("RenderInit") << "No ARB pixel format extensions" << LL_ENDL;
-	}
-
-	if (ExtensionExists("WGL_ARB_create_context",gGLHExts.mSysExts))
-	{
-		GLH_EXT_NAME(wglCreateContextAttribsARB) = (PFNWGLCREATECONTEXTATTRIBSARBPROC)GLH_EXT_GET_PROC_ADDRESS("wglCreateContextAttribsARB");
-	}
-	else
-	{
-		LL_WARNS("RenderInit") << "No ARB create context extensions" << LL_ENDL;
-	}
-
-	// For retreiving information per AMD adapter, 
-	// because we can't trust curently selected/default one when there are multiple
-	mHasAMDAssociations = ExtensionExists("WGL_AMD_gpu_association", gGLHExts.mSysExts);
-	if (mHasAMDAssociations)
-	{
-		GLH_EXT_NAME(wglGetGPUIDsAMD) = (PFNWGLGETGPUIDSAMDPROC)GLH_EXT_GET_PROC_ADDRESS("wglGetGPUIDsAMD");
-		GLH_EXT_NAME(wglGetGPUInfoAMD) = (PFNWGLGETGPUINFOAMDPROC)GLH_EXT_GET_PROC_ADDRESS("wglGetGPUInfoAMD");
-	}
-
-	if (ExtensionExists("WGL_EXT_swap_control", gGLHExts.mSysExts))
-	{
+    if (!glh_init_extensions("WGL_ARB_pixel_format"))
+    {
+        LL_WARNS("RenderInit") << "No ARB pixel format extensions" << LL_ENDL;
+    }
+
+    if (ExtensionExists("WGL_ARB_create_context",gGLHExts.mSysExts))
+    {
+        GLH_EXT_NAME(wglCreateContextAttribsARB) = (PFNWGLCREATECONTEXTATTRIBSARBPROC)GLH_EXT_GET_PROC_ADDRESS("wglCreateContextAttribsARB");
+    }
+    else
+    {
+        LL_WARNS("RenderInit") << "No ARB create context extensions" << LL_ENDL;
+    }
+
+    // For retreiving information per AMD adapter,
+    // because we can't trust curently selected/default one when there are multiple
+    mHasAMDAssociations = ExtensionExists("WGL_AMD_gpu_association", gGLHExts.mSysExts);
+    if (mHasAMDAssociations)
+    {
+        GLH_EXT_NAME(wglGetGPUIDsAMD) = (PFNWGLGETGPUIDSAMDPROC)GLH_EXT_GET_PROC_ADDRESS("wglGetGPUIDsAMD");
+        GLH_EXT_NAME(wglGetGPUInfoAMD) = (PFNWGLGETGPUINFOAMDPROC)GLH_EXT_GET_PROC_ADDRESS("wglGetGPUInfoAMD");
+    }
+
+    if (ExtensionExists("WGL_EXT_swap_control", gGLHExts.mSysExts))
+    {
         GLH_EXT_NAME(wglSwapIntervalEXT) = (PFNWGLSWAPINTERVALEXTPROC)GLH_EXT_GET_PROC_ADDRESS("wglSwapIntervalEXT");
-	}
+    }
 
-	if( !glh_init_extensions("WGL_ARB_pbuffer") )
-	{
-		LL_WARNS("RenderInit") << "No ARB WGL PBuffer extensions" << LL_ENDL;
-	}
+    if( !glh_init_extensions("WGL_ARB_pbuffer") )
+    {
+        LL_WARNS("RenderInit") << "No ARB WGL PBuffer extensions" << LL_ENDL;
+    }
 
-	if( !glh_init_extensions("WGL_ARB_render_texture") )
-	{
-		LL_WARNS("RenderInit") << "No ARB WGL render texture extensions" << LL_ENDL;
-	}
+    if( !glh_init_extensions("WGL_ARB_render_texture") )
+    {
+        LL_WARNS("RenderInit") << "No ARB WGL render texture extensions" << LL_ENDL;
+    }
 #endif
 }
 
 // return false if unable (or unwilling due to old drivers) to init GL
 bool LLGLManager::initGL()
 {
-	if (mInited)
-	{
-		LL_ERRS("RenderInit") << "Calling init on LLGLManager after already initialized!" << LL_ENDL;
-	}
+    if (mInited)
+    {
+        LL_ERRS("RenderInit") << "Calling init on LLGLManager after already initialized!" << LL_ENDL;
+    }
 
 #if 0 && LL_WINDOWS
-	if (!glGetStringi)
-	{
-		glGetStringi = (PFNGLGETSTRINGIPROC) GLH_EXT_GET_PROC_ADDRESS("glGetStringi");
-	}
-
-	//reload extensions string (may have changed after using wglCreateContextAttrib)
-	if (glGetStringi)
-	{
-		std::stringstream str;
-
-		GLint count = 0;
-		glGetIntegerv(GL_NUM_EXTENSIONS, &count);
-		for (GLint i = 0; i < count; ++i)
-		{
-			std::string ext = ll_safe_string((const char*) glGetStringi(GL_EXTENSIONS, i));
-			str << ext << " ";
-			LL_DEBUGS("GLExtensions") << ext << LL_ENDL;
-		}
-		
-		{
-			PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = 0;
-			wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB");
-			if(wglGetExtensionsStringARB)
-			{
-				str << (const char*) wglGetExtensionsStringARB(wglGetCurrentDC());
-			}
-		}
-
-		free(gGLHExts.mSysExts);
-		std::string extensions = str.str();
-		gGLHExts.mSysExts = strdup(extensions.c_str());
-	}
+    if (!glGetStringi)
+    {
+        glGetStringi = (PFNGLGETSTRINGIPROC) GLH_EXT_GET_PROC_ADDRESS("glGetStringi");
+    }
+
+    //reload extensions string (may have changed after using wglCreateContextAttrib)
+    if (glGetStringi)
+    {
+        std::stringstream str;
+
+        GLint count = 0;
+        glGetIntegerv(GL_NUM_EXTENSIONS, &count);
+        for (GLint i = 0; i < count; ++i)
+        {
+            std::string ext = ll_safe_string((const char*) glGetStringi(GL_EXTENSIONS, i));
+            str << ext << " ";
+            LL_DEBUGS("GLExtensions") << ext << LL_ENDL;
+        }
+
+        {
+            PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = 0;
+            wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB");
+            if(wglGetExtensionsStringARB)
+            {
+                str << (const char*) wglGetExtensionsStringARB(wglGetCurrentDC());
+            }
+        }
+
+        free(gGLHExts.mSysExts);
+        std::string extensions = str.str();
+        gGLHExts.mSysExts = strdup(extensions.c_str());
+    }
 #endif
-	
-	// Extract video card strings and convert to upper case to
-	// work around driver-to-driver variation in capitalization.
-	mGLVendor = ll_safe_string((const char *)glGetString(GL_VENDOR));
-	LLStringUtil::toUpper(mGLVendor);
 
-	mGLRenderer = ll_safe_string((const char *)glGetString(GL_RENDERER));
-	LLStringUtil::toUpper(mGLRenderer);
+    // Extract video card strings and convert to upper case to
+    // work around driver-to-driver variation in capitalization.
+    mGLVendor = ll_safe_string((const char *)glGetString(GL_VENDOR));
+    LLStringUtil::toUpper(mGLVendor);
 
-	parse_gl_version( &mDriverVersionMajor, 
-		&mDriverVersionMinor, 
-		&mDriverVersionRelease, 
-		&mDriverVersionVendorString,
-		&mGLVersionString);
+    mGLRenderer = ll_safe_string((const char *)glGetString(GL_RENDERER));
+    LLStringUtil::toUpper(mGLRenderer);
 
-	mGLVersion = mDriverVersionMajor + mDriverVersionMinor * .1f;
+    parse_gl_version( &mDriverVersionMajor,
+        &mDriverVersionMinor,
+        &mDriverVersionRelease,
+        &mDriverVersionVendorString,
+        &mGLVersionString);
 
-	if (mGLVersion >= 2.f)
-	{
-		parse_glsl_version(mGLSLVersionMajor, mGLSLVersionMinor);
+    mGLVersion = mDriverVersionMajor + mDriverVersionMinor * .1f;
+
+    if (mGLVersion >= 2.f)
+    {
+        parse_glsl_version(mGLSLVersionMajor, mGLSLVersionMinor);
 
 #if 0 && LL_DARWIN
-		// TODO maybe switch to using a core profile for GL 3.2?
-		// https://stackoverflow.com/a/19868861
-		//never use GLSL greater than 1.20 on OSX
-		if (mGLSLVersionMajor > 1 || mGLSLVersionMinor > 30)
-		{
-			mGLSLVersionMajor = 1;
-			mGLSLVersionMinor = 30;
-		}
+        // TODO maybe switch to using a core profile for GL 3.2?
+        // https://stackoverflow.com/a/19868861
+        //never use GLSL greater than 1.20 on OSX
+        if (mGLSLVersionMajor > 1 || mGLSLVersionMinor > 30)
+        {
+            mGLSLVersionMajor = 1;
+            mGLSLVersionMinor = 30;
+        }
 #endif
-	}
-
-	if (mGLVersion >= 2.1f && LLImageGL::sCompressTextures)
-	{ //use texture compression
-		glHint(GL_TEXTURE_COMPRESSION_HINT, GL_NICEST);
-	}
-	else
-	{ //GL version is < 3.0, always disable texture compression
-		LLImageGL::sCompressTextures = false;
-	}
-	
-	// Trailing space necessary to keep "nVidia Corpor_ati_on" cards
-	// from being recognized as ATI.
+    }
+
+    if (mGLVersion >= 2.1f && LLImageGL::sCompressTextures)
+    { //use texture compression
+        glHint(GL_TEXTURE_COMPRESSION_HINT, GL_NICEST);
+    }
+    else
+    { //GL version is < 3.0, always disable texture compression
+        LLImageGL::sCompressTextures = false;
+    }
+
+    // Trailing space necessary to keep "nVidia Corpor_ati_on" cards
+    // from being recognized as ATI.
     // NOTE: AMD has been pretty good about not breaking this check, do not rename without good reason
-	if (mGLVendor.substr(0,4) == "ATI ")
-	{
-		mGLVendorShort = "AMD";
-		// *TODO: Fix this?
-		mIsAMD = TRUE;
-	}
-	else if (mGLVendor.find("NVIDIA ") != std::string::npos)
-	{
-		mGLVendorShort = "NVIDIA";
-		mIsNVIDIA = TRUE;
-	}
-	else if (mGLVendor.find("INTEL") != std::string::npos
+    if (mGLVendor.substr(0,4) == "ATI ")
+    {
+        mGLVendorShort = "AMD";
+        // *TODO: Fix this?
+        mIsAMD = TRUE;
+    }
+    else if (mGLVendor.find("NVIDIA ") != std::string::npos)
+    {
+        mGLVendorShort = "NVIDIA";
+        mIsNVIDIA = TRUE;
+    }
+    else if (mGLVendor.find("INTEL") != std::string::npos
 #if LL_LINUX
-		 // The Mesa-based drivers put this in the Renderer string,
-		 // not the Vendor string.
-		 || mGLRenderer.find("INTEL") != std::string::npos
+         // The Mesa-based drivers put this in the Renderer string,
+         // not the Vendor string.
+         || mGLRenderer.find("INTEL") != std::string::npos
 #endif //LL_LINUX
-		 )
-	{
-		mGLVendorShort = "INTEL";
-		mIsIntel = TRUE;
-	}
-	else
-	{
-		mGLVendorShort = "MISC";
-	}
-	
-	// This is called here because it depends on the setting of mIsGF2or4MX, and sets up mHasMultitexture.
-	initExtensions();
-
-	S32 old_vram = mVRAM;
-	mVRAM = 0;
+         )
+    {
+        mGLVendorShort = "INTEL";
+        mIsIntel = TRUE;
+    }
+    else
+    {
+        mGLVendorShort = "MISC";
+    }
+
+    // This is called here because it depends on the setting of mIsGF2or4MX, and sets up mHasMultitexture.
+    initExtensions();
+
+    S32 old_vram = mVRAM;
+    mVRAM = 0;
 
 #if LL_WINDOWS
-	if (mHasAMDAssociations)
-	{
-		GLuint gl_gpus_count = wglGetGPUIDsAMD(0, 0);
-		if (gl_gpus_count > 0)
-		{
-			GLuint* ids = new GLuint[gl_gpus_count];
-			wglGetGPUIDsAMD(gl_gpus_count, ids);
-
-			GLuint mem_mb = 0;
-			for (U32 i = 0; i < gl_gpus_count; i++)
-			{
-				wglGetGPUInfoAMD(ids[i],
-					WGL_GPU_RAM_AMD,
-					GL_UNSIGNED_INT,
-					sizeof(GLuint),
-					&mem_mb);
-				if (mVRAM < mem_mb)
-				{
-					// basically pick the best AMD and trust driver/OS to know to switch
-					mVRAM = mem_mb;
-				}
-			}
-		}
-		if (mVRAM != 0)
-		{
-			LL_WARNS("RenderInit") << "VRAM Detected (AMDAssociations):" << mVRAM << LL_ENDL;
-		}
-	}
+    if (mHasAMDAssociations)
+    {
+        GLuint gl_gpus_count = wglGetGPUIDsAMD(0, 0);
+        if (gl_gpus_count > 0)
+        {
+            GLuint* ids = new GLuint[gl_gpus_count];
+            wglGetGPUIDsAMD(gl_gpus_count, ids);
+
+            GLuint mem_mb = 0;
+            for (U32 i = 0; i < gl_gpus_count; i++)
+            {
+                wglGetGPUInfoAMD(ids[i],
+                    WGL_GPU_RAM_AMD,
+                    GL_UNSIGNED_INT,
+                    sizeof(GLuint),
+                    &mem_mb);
+                if (mVRAM < mem_mb)
+                {
+                    // basically pick the best AMD and trust driver/OS to know to switch
+                    mVRAM = mem_mb;
+                }
+            }
+        }
+        if (mVRAM != 0)
+        {
+            LL_WARNS("RenderInit") << "VRAM Detected (AMDAssociations):" << mVRAM << LL_ENDL;
+        }
+    }
 #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.
-		S32 mem = LLDXHardware::getMBVideoMemoryViaWMI();
-		if (mem != 0)
-		{
-			mVRAM = mem;
-			LL_WARNS("RenderInit") << "VRAM Detected (WMI):" << mVRAM<< LL_ENDL;
-		}
-	}
+    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.
+        S32 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;
-	}
-
-	glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &mNumTextureImageUnits);
-	glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &mMaxColorTextureSamples);
-	glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &mMaxDepthTextureSamples);
-	glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &mMaxIntegerSamples);
-	glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &mMaxSampleMaskWords);
+    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;
+    }
+
+    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &mNumTextureImageUnits);
+    glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &mMaxColorTextureSamples);
+    glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &mMaxDepthTextureSamples);
+    glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &mMaxIntegerSamples);
+    glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &mMaxSampleMaskWords);
     glGetIntegerv(GL_MAX_SAMPLES, &mMaxSamples);
 
     if (mGLVersion >= 4.59f)
@@ -1244,136 +1244,136 @@ bool LLGLManager::initGL()
         glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY, &mMaxAnisotropy);
     }
 
-	initGLStates();
+    initGLStates();
 
-	return true;
+    return true;
 }
 
 void LLGLManager::getGLInfo(LLSD& info)
 {
-	if (gHeadlessClient)
-	{
-		info["GLInfo"]["GLVendor"] = HEADLESS_VENDOR_STRING;
-		info["GLInfo"]["GLRenderer"] = HEADLESS_RENDERER_STRING;
-		info["GLInfo"]["GLVersion"] = HEADLESS_VERSION_STRING;
-		return;
-	}
-	else
-	{
-		info["GLInfo"]["GLVendor"] = ll_safe_string((const char *)glGetString(GL_VENDOR));
-		info["GLInfo"]["GLRenderer"] = ll_safe_string((const char *)glGetString(GL_RENDERER));
-		info["GLInfo"]["GLVersion"] = ll_safe_string((const char *)glGetString(GL_VERSION));
-	}
+    if (gHeadlessClient)
+    {
+        info["GLInfo"]["GLVendor"] = HEADLESS_VENDOR_STRING;
+        info["GLInfo"]["GLRenderer"] = HEADLESS_RENDERER_STRING;
+        info["GLInfo"]["GLVersion"] = HEADLESS_VERSION_STRING;
+        return;
+    }
+    else
+    {
+        info["GLInfo"]["GLVendor"] = ll_safe_string((const char *)glGetString(GL_VENDOR));
+        info["GLInfo"]["GLRenderer"] = ll_safe_string((const char *)glGetString(GL_RENDERER));
+        info["GLInfo"]["GLVersion"] = ll_safe_string((const char *)glGetString(GL_VERSION));
+    }
 
 #if !LL_MESA_HEADLESS
-	std::string all_exts = ll_safe_string((const char *)gGLHExts.mSysExts);
-	boost::char_separator<char> sep(" ");
-	boost::tokenizer<boost::char_separator<char> > tok(all_exts, sep);
-	for(boost::tokenizer<boost::char_separator<char> >::iterator i = tok.begin(); i != tok.end(); ++i)
-	{
-		info["GLInfo"]["GLExtensions"].append(*i);
-	}
+    std::string all_exts = ll_safe_string((const char *)gGLHExts.mSysExts);
+    boost::char_separator<char> sep(" ");
+    boost::tokenizer<boost::char_separator<char> > tok(all_exts, sep);
+    for(boost::tokenizer<boost::char_separator<char> >::iterator i = tok.begin(); i != tok.end(); ++i)
+    {
+        info["GLInfo"]["GLExtensions"].append(*i);
+    }
 #endif
 }
 
 std::string LLGLManager::getGLInfoString()
 {
-	std::string info_str;
-
-	if (gHeadlessClient)
-	{
-		info_str += std::string("GL_VENDOR      ") + HEADLESS_VENDOR_STRING + std::string("\n");
-		info_str += std::string("GL_RENDERER    ") + HEADLESS_RENDERER_STRING + std::string("\n");
-		info_str += std::string("GL_VERSION     ") + HEADLESS_VERSION_STRING + std::string("\n");
-	}
-	else
-	{
-		info_str += std::string("GL_VENDOR      ") + ll_safe_string((const char *)glGetString(GL_VENDOR)) + std::string("\n");
-		info_str += std::string("GL_RENDERER    ") + ll_safe_string((const char *)glGetString(GL_RENDERER)) + std::string("\n");
-		info_str += std::string("GL_VERSION     ") + ll_safe_string((const char *)glGetString(GL_VERSION)) + std::string("\n");
-	}
-
-#if !LL_MESA_HEADLESS 
-	std::string all_exts= ll_safe_string(((const char *)gGLHExts.mSysExts));
-	LLStringUtil::replaceChar(all_exts, ' ', '\n');
-	info_str += std::string("GL_EXTENSIONS:\n") + all_exts + std::string("\n");
+    std::string info_str;
+
+    if (gHeadlessClient)
+    {
+        info_str += std::string("GL_VENDOR      ") + HEADLESS_VENDOR_STRING + std::string("\n");
+        info_str += std::string("GL_RENDERER    ") + HEADLESS_RENDERER_STRING + std::string("\n");
+        info_str += std::string("GL_VERSION     ") + HEADLESS_VERSION_STRING + std::string("\n");
+    }
+    else
+    {
+        info_str += std::string("GL_VENDOR      ") + ll_safe_string((const char *)glGetString(GL_VENDOR)) + std::string("\n");
+        info_str += std::string("GL_RENDERER    ") + ll_safe_string((const char *)glGetString(GL_RENDERER)) + std::string("\n");
+        info_str += std::string("GL_VERSION     ") + ll_safe_string((const char *)glGetString(GL_VERSION)) + std::string("\n");
+    }
+
+#if !LL_MESA_HEADLESS
+    std::string all_exts= ll_safe_string(((const char *)gGLHExts.mSysExts));
+    LLStringUtil::replaceChar(all_exts, ' ', '\n');
+    info_str += std::string("GL_EXTENSIONS:\n") + all_exts + std::string("\n");
 #endif
-	
-	return info_str;
+
+    return info_str;
 }
 
 void LLGLManager::printGLInfoString()
 {
-	if (gHeadlessClient)
-	{
-		LL_INFOS("RenderInit") << "GL_VENDOR:     " << HEADLESS_VENDOR_STRING << LL_ENDL;
-		LL_INFOS("RenderInit") << "GL_RENDERER:   " << HEADLESS_RENDERER_STRING << LL_ENDL;
-		LL_INFOS("RenderInit") << "GL_VERSION:    " << HEADLESS_VERSION_STRING << LL_ENDL;
-	}
-	else
-	{
-		LL_INFOS("RenderInit") << "GL_VENDOR:     " << ll_safe_string((const char *)glGetString(GL_VENDOR)) << LL_ENDL;
-		LL_INFOS("RenderInit") << "GL_RENDERER:   " << ll_safe_string((const char *)glGetString(GL_RENDERER)) << LL_ENDL;
-		LL_INFOS("RenderInit") << "GL_VERSION:    " << ll_safe_string((const char *)glGetString(GL_VERSION)) << LL_ENDL;
-	}
+    if (gHeadlessClient)
+    {
+        LL_INFOS("RenderInit") << "GL_VENDOR:     " << HEADLESS_VENDOR_STRING << LL_ENDL;
+        LL_INFOS("RenderInit") << "GL_RENDERER:   " << HEADLESS_RENDERER_STRING << LL_ENDL;
+        LL_INFOS("RenderInit") << "GL_VERSION:    " << HEADLESS_VERSION_STRING << LL_ENDL;
+    }
+    else
+    {
+        LL_INFOS("RenderInit") << "GL_VENDOR:     " << ll_safe_string((const char *)glGetString(GL_VENDOR)) << LL_ENDL;
+        LL_INFOS("RenderInit") << "GL_RENDERER:   " << ll_safe_string((const char *)glGetString(GL_RENDERER)) << LL_ENDL;
+        LL_INFOS("RenderInit") << "GL_VERSION:    " << ll_safe_string((const char *)glGetString(GL_VERSION)) << LL_ENDL;
+    }
 
 #if !LL_MESA_HEADLESS
-	std::string all_exts= ll_safe_string(((const char *)gGLHExts.mSysExts));
-	LLStringUtil::replaceChar(all_exts, ' ', '\n');
-	LL_DEBUGS("RenderInit") << "GL_EXTENSIONS:\n" << all_exts << LL_ENDL;
+    std::string all_exts= ll_safe_string(((const char *)gGLHExts.mSysExts));
+    LLStringUtil::replaceChar(all_exts, ' ', '\n');
+    LL_DEBUGS("RenderInit") << "GL_EXTENSIONS:\n" << all_exts << LL_ENDL;
 #endif
 }
 
 std::string LLGLManager::getRawGLString()
 {
-	std::string gl_string;
-	if (gHeadlessClient)
-	{
-		gl_string = HEADLESS_VENDOR_STRING + " " + HEADLESS_RENDERER_STRING;
-	}
-	else
-	{
-		gl_string = ll_safe_string((char*)glGetString(GL_VENDOR)) + " " + ll_safe_string((char*)glGetString(GL_RENDERER));
-	}
-	return gl_string;
+    std::string gl_string;
+    if (gHeadlessClient)
+    {
+        gl_string = HEADLESS_VENDOR_STRING + " " + HEADLESS_RENDERER_STRING;
+    }
+    else
+    {
+        gl_string = ll_safe_string((char*)glGetString(GL_VENDOR)) + " " + ll_safe_string((char*)glGetString(GL_RENDERER));
+    }
+    return gl_string;
 }
 
 void LLGLManager::asLLSD(LLSD& info)
 {
-	// Currently these are duplicates of fields in "system".
-	info["gpu_vendor"] = mGLVendorShort;
-	info["gpu_version"] = mDriverVersionVendorString;
-	info["opengl_version"] = mGLVersionString;
-
-	info["vram"] = mVRAM;
-
-	// OpenGL limits
-	info["max_samples"] = mMaxSamples;
-	info["num_texture_image_units"] =  mNumTextureImageUnits;
-	info["max_sample_mask_words"] = mMaxSampleMaskWords;
-	info["max_color_texture_samples"] = mMaxColorTextureSamples;
-	info["max_depth_texture_samples"] = mMaxDepthTextureSamples;
-	info["max_integer_samples"] = mMaxIntegerSamples;
+    // Currently these are duplicates of fields in "system".
+    info["gpu_vendor"] = mGLVendorShort;
+    info["gpu_version"] = mDriverVersionVendorString;
+    info["opengl_version"] = mGLVersionString;
+
+    info["vram"] = mVRAM;
+
+    // OpenGL limits
+    info["max_samples"] = mMaxSamples;
+    info["num_texture_image_units"] =  mNumTextureImageUnits;
+    info["max_sample_mask_words"] = mMaxSampleMaskWords;
+    info["max_color_texture_samples"] = mMaxColorTextureSamples;
+    info["max_depth_texture_samples"] = mMaxDepthTextureSamples;
+    info["max_integer_samples"] = mMaxIntegerSamples;
     info["max_vertex_range"] = mGLMaxVertexRange;
     info["max_index_range"] = mGLMaxIndexRange;
     info["max_texture_size"] = mGLMaxTextureSize;
 
-	// Which vendor
-	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;
+    // Which vendor
+    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["gl_renderer"] = mGLRenderer;
+    info["gl_renderer"] = mGLRenderer;
 }
 
 void LLGLManager::shutdownGL()
 {
-	if (mInited)
-	{
-		glFinish();
-		stop_glerror();
-		mInited = FALSE;
-	}
+    if (mInited)
+    {
+        glFinish();
+        stop_glerror();
+        mInited = FALSE;
+    }
 }
 
 // these are used to turn software blending on. They appear in the Debug/Avatar menu
@@ -1398,22 +1398,22 @@ void LLGLManager::initExtensions()
 #endif
 
     // NOTE: version checks against mGLVersion should bias down by 0.01 because of F32 errors
-    
+
     // OpenGL 4.x capabilities
-    mHasCubeMapArray = mGLVersion >= 3.99f; 
+    mHasCubeMapArray = mGLVersion >= 3.99f;
     mHasTransformFeedback = mGLVersion >= 3.99f;
     mHasDebugOutput = mGLVersion >= 4.29f;
 
     // Misc
-	glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, (GLint*) &mGLMaxVertexRange);
-	glGetIntegerv(GL_MAX_ELEMENTS_INDICES, (GLint*) &mGLMaxIndexRange);
-	glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*) &mGLMaxTextureSize);
+    glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, (GLint*) &mGLMaxVertexRange);
+    glGetIntegerv(GL_MAX_ELEMENTS_INDICES, (GLint*) &mGLMaxIndexRange);
+    glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*) &mGLMaxTextureSize);
 
     mInited = TRUE;
 
 #if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
-	LL_DEBUGS("RenderInit") << "GL Probe: Getting symbols" << LL_ENDL;
-	
+    LL_DEBUGS("RenderInit") << "GL Probe: Getting symbols" << LL_ENDL;
+
 #if LL_WINDOWS
     // WGL_AMD_gpu_association
     wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)GLH_EXT_GET_PROC_ADDRESS("wglGetGPUIDsAMD");
@@ -2249,123 +2249,123 @@ void LLGLManager::initExtensions()
     glMultiDrawArraysIndirectCount = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC)GLH_EXT_GET_PROC_ADDRESS("glMultiDrawArraysIndirectCount");
     glMultiDrawElementsIndirectCount = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC)GLH_EXT_GET_PROC_ADDRESS("glMultiDrawElementsIndirectCount");
     glPolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC)GLH_EXT_GET_PROC_ADDRESS("glPolygonOffsetClamp");
-    
+
 #endif
 }
 
 void rotate_quat(LLQuaternion& rotation)
 {
-	F32 angle_radians, x, y, z;
-	rotation.getAngleAxis(&angle_radians, &x, &y, &z);
-	gGL.rotatef(angle_radians * RAD_TO_DEG, x, y, z);
+    F32 angle_radians, x, y, z;
+    rotation.getAngleAxis(&angle_radians, &x, &y, &z);
+    gGL.rotatef(angle_radians * RAD_TO_DEG, x, y, z);
 }
 
 void flush_glerror()
 {
-	glGetError();
+    glGetError();
 }
 
 //this function outputs gl error to the log file, does not crash the code.
 void log_glerror()
 {
-	if (LL_UNLIKELY(!gGLManager.mInited))
-	{
-		return ;
-	}
-	//  Create or update texture to be used with this data 
-	GLenum error;
-	error = glGetError();
-	while (LL_UNLIKELY(error))
-	{
-		GLubyte const * gl_error_msg = gluErrorString(error);
-		if (NULL != gl_error_msg)
-		{
-			LL_WARNS() << "GL Error: " << error << " GL Error String: " << gl_error_msg << LL_ENDL ;			
-		}
-		else
-		{
-			// gluErrorString returns NULL for some extensions' error codes.
-			// you'll probably have to grep for the number in glext.h.
-			LL_WARNS() << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << LL_ENDL;
-		}
-		error = glGetError();
-	}
+    if (LL_UNLIKELY(!gGLManager.mInited))
+    {
+        return ;
+    }
+    //  Create or update texture to be used with this data
+    GLenum error;
+    error = glGetError();
+    while (LL_UNLIKELY(error))
+    {
+        GLubyte const * gl_error_msg = gluErrorString(error);
+        if (NULL != gl_error_msg)
+        {
+            LL_WARNS() << "GL Error: " << error << " GL Error String: " << gl_error_msg << LL_ENDL ;
+        }
+        else
+        {
+            // gluErrorString returns NULL for some extensions' error codes.
+            // you'll probably have to grep for the number in glext.h.
+            LL_WARNS() << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << LL_ENDL;
+        }
+        error = glGetError();
+    }
 }
 
 void do_assert_glerror()
 {
-	//  Create or update texture to be used with this data 
-	GLenum error;
-	error = glGetError();
-	BOOL quit = FALSE;
-	if (LL_UNLIKELY(error))
-	{
-		quit = TRUE;
-		GLubyte const * gl_error_msg = gluErrorString(error);
-		if (NULL != gl_error_msg)
-		{
-			LL_WARNS("RenderState") << "GL Error:" << error<< LL_ENDL;
-			LL_WARNS("RenderState") << "GL Error String:" << gl_error_msg << LL_ENDL;
-
-			if (gDebugSession)
-			{
-				gFailLog << "GL Error:" << gl_error_msg << std::endl;
-			}
-		}
-		else
-		{
-			// gluErrorString returns NULL for some extensions' error codes.
-			// you'll probably have to grep for the number in glext.h.
-			LL_WARNS("RenderState") << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << LL_ENDL;
-
-			if (gDebugSession)
-			{
-				gFailLog << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << std::endl;
-			}
-		}
-	}
-
-	if (quit)
-	{
-		if (gDebugSession)
-		{
-			ll_fail("assert_glerror failed");
-		}
-		else
-		{
-			LL_ERRS() << "One or more unhandled GL errors." << LL_ENDL;
-		}
-	}
+    //  Create or update texture to be used with this data
+    GLenum error;
+    error = glGetError();
+    BOOL quit = FALSE;
+    if (LL_UNLIKELY(error))
+    {
+        quit = TRUE;
+        GLubyte const * gl_error_msg = gluErrorString(error);
+        if (NULL != gl_error_msg)
+        {
+            LL_WARNS("RenderState") << "GL Error:" << error<< LL_ENDL;
+            LL_WARNS("RenderState") << "GL Error String:" << gl_error_msg << LL_ENDL;
+
+            if (gDebugSession)
+            {
+                gFailLog << "GL Error:" << gl_error_msg << std::endl;
+            }
+        }
+        else
+        {
+            // gluErrorString returns NULL for some extensions' error codes.
+            // you'll probably have to grep for the number in glext.h.
+            LL_WARNS("RenderState") << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << LL_ENDL;
+
+            if (gDebugSession)
+            {
+                gFailLog << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << std::endl;
+            }
+        }
+    }
+
+    if (quit)
+    {
+        if (gDebugSession)
+        {
+            ll_fail("assert_glerror failed");
+        }
+        else
+        {
+            LL_ERRS() << "One or more unhandled GL errors." << LL_ENDL;
+        }
+    }
 }
 
 void assert_glerror()
 {
-/*	if (!gGLActive)
-	{
-		//LL_WARNS() << "GL used while not active!" << LL_ENDL;
-
-		if (gDebugSession)
-		{
-			//ll_fail("GL used while not active");
-		}
-	}
+/*  if (!gGLActive)
+    {
+        //LL_WARNS() << "GL used while not active!" << LL_ENDL;
+
+        if (gDebugSession)
+        {
+            //ll_fail("GL used while not active");
+        }
+    }
 */
 
-	if (!gDebugGL) 
-	{
-		//funny looking if for branch prediction -- gDebugGL is almost always false and assert_glerror is called often
-	}
-	else
-	{
-		do_assert_glerror();
-	}
+    if (!gDebugGL)
+    {
+        //funny looking if for branch prediction -- gDebugGL is almost always false and assert_glerror is called often
+    }
+    else
+    {
+        do_assert_glerror();
+    }
 }
-	
+
 
 void clear_glerror()
 {
-	glGetError();
-	glGetError();
+    glGetError();
+    glGetError();
 }
 
 ///////////////////////////////////////////////////////////////
@@ -2381,333 +2381,333 @@ GLenum LLGLDepthTest::sDepthFunc = GL_LESS; // OpenGL default
 GLboolean LLGLDepthTest::sWriteEnabled = GL_TRUE; // OpenGL default
 
 //static
-void LLGLState::initClass() 
+void LLGLState::initClass()
 {
-	sStateMap[GL_DITHER] = GL_TRUE;
-	// sStateMap[GL_TEXTURE_2D] = GL_TRUE;
-	
-	//make sure multisample defaults to disabled
-	sStateMap[GL_MULTISAMPLE] = GL_FALSE;
-	glDisable(GL_MULTISAMPLE);
+    sStateMap[GL_DITHER] = GL_TRUE;
+    // sStateMap[GL_TEXTURE_2D] = GL_TRUE;
+
+    //make sure multisample defaults to disabled
+    sStateMap[GL_MULTISAMPLE] = GL_FALSE;
+    glDisable(GL_MULTISAMPLE);
 }
 
 //static
 void LLGLState::restoreGL()
 {
-	sStateMap.clear();
-	initClass();
+    sStateMap.clear();
+    initClass();
 }
 
 //static
 // Really shouldn't be needed, but seems we sometimes do.
 void LLGLState::resetTextureStates()
 {
-	gGL.flush();
-	GLint maxTextureUnits;
-	
-	glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
-	for (S32 j = maxTextureUnits-1; j >=0; j--)
-	{
-		gGL.getTexUnit(j)->activate();
-		glClientActiveTexture(GL_TEXTURE0+j);
-		j == 0 ? gGL.getTexUnit(j)->enable(LLTexUnit::TT_TEXTURE) : gGL.getTexUnit(j)->disable();
-	}
+    gGL.flush();
+    GLint maxTextureUnits;
+
+    glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
+    for (S32 j = maxTextureUnits-1; j >=0; j--)
+    {
+        gGL.getTexUnit(j)->activate();
+        glClientActiveTexture(GL_TEXTURE0+j);
+        j == 0 ? gGL.getTexUnit(j)->enable(LLTexUnit::TT_TEXTURE) : gGL.getTexUnit(j)->disable();
+    }
 }
 
-void LLGLState::dumpStates() 
+void LLGLState::dumpStates()
 {
-	LL_INFOS("RenderState") << "GL States:" << LL_ENDL;
-	for (boost::unordered_map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
-		 iter != sStateMap.end(); ++iter)
-	{
-		LL_INFOS("RenderState") << llformat(" 0x%04x : %s",(S32)iter->first,iter->second?"TRUE":"FALSE") << LL_ENDL;
-	}
+    LL_INFOS("RenderState") << "GL States:" << LL_ENDL;
+    for (boost::unordered_map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
+         iter != sStateMap.end(); ++iter)
+    {
+        LL_INFOS("RenderState") << llformat(" 0x%04x : %s",(S32)iter->first,iter->second?"TRUE":"FALSE") << LL_ENDL;
+    }
 }
 
 void LLGLState::checkStates(GLboolean writeAlpha)
 {
-	if (!gDebugGL)
-	{
-		return;
-	}
-
-	GLint src;
-	GLint dst;
-	glGetIntegerv(GL_BLEND_SRC, &src);
-	glGetIntegerv(GL_BLEND_DST, &dst);
+    if (!gDebugGL)
+    {
+        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);
-  
+
     // disable for now until usage is consistent
     //GLboolean colorMask[4];
     //glGetBooleanv(GL_COLOR_WRITEMASK, colorMask);
     //llassert_always(colorMask[0]);
     //llassert_always(colorMask[1]);
     //llassert_always(colorMask[2]);
-    // llassert_always(colorMask[3] == writeAlpha);  
-	
-	for (boost::unordered_map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
-		 iter != sStateMap.end(); ++iter)
-	{
-		LLGLenum state = iter->first;
-		LLGLboolean cur_state = iter->second;
-		LLGLboolean gl_state = glIsEnabled(state);
-		if(cur_state != gl_state)
-		{
-			dumpStates();
-			LL_GL_ERRS << llformat("LLGLState error. State: 0x%04x",state) << LL_ENDL;
-		}
-	}
+    // llassert_always(colorMask[3] == writeAlpha);
+
+    for (boost::unordered_map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
+         iter != sStateMap.end(); ++iter)
+    {
+        LLGLenum state = iter->first;
+        LLGLboolean cur_state = iter->second;
+        LLGLboolean gl_state = glIsEnabled(state);
+        if(cur_state != gl_state)
+        {
+            dumpStates();
+            LL_GL_ERRS << llformat("LLGLState error. State: 0x%04x",state) << LL_ENDL;
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////
 
 LLGLState::LLGLState(LLGLenum state, S32 enabled) :
-	mState(state), mWasEnabled(FALSE), mIsEnabled(FALSE)
+    mState(state), mWasEnabled(FALSE), mIsEnabled(FALSE)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
 
-	if (mState)
-	{
-		mWasEnabled = sStateMap[state];
-		setEnabled(enabled);
-	}
+    if (mState)
+    {
+        mWasEnabled = sStateMap[state];
+        setEnabled(enabled);
+    }
 }
 
 void LLGLState::setEnabled(S32 enabled)
 {
-	if (!mState)
-	{
-		return;
-	}
-	if (enabled == CURRENT_STATE)
-	{
-		enabled = sStateMap[mState] == GL_TRUE ? TRUE : FALSE;
-	}
-	else if (enabled == TRUE && sStateMap[mState] != GL_TRUE)
-	{
-		gGL.flush();
-		glEnable(mState);
-		sStateMap[mState] = GL_TRUE;
-	}
-	else if (enabled == FALSE && sStateMap[mState] != GL_FALSE)
-	{
-		gGL.flush();
-		glDisable(mState);
-		sStateMap[mState] = GL_FALSE;
-	}
-	mIsEnabled = enabled;
+    if (!mState)
+    {
+        return;
+    }
+    if (enabled == CURRENT_STATE)
+    {
+        enabled = sStateMap[mState] == GL_TRUE ? TRUE : FALSE;
+    }
+    else if (enabled == TRUE && sStateMap[mState] != GL_TRUE)
+    {
+        gGL.flush();
+        glEnable(mState);
+        sStateMap[mState] = GL_TRUE;
+    }
+    else if (enabled == FALSE && sStateMap[mState] != GL_FALSE)
+    {
+        gGL.flush();
+        glDisable(mState);
+        sStateMap[mState] = GL_FALSE;
+    }
+    mIsEnabled = enabled;
 }
 
-LLGLState::~LLGLState() 
+LLGLState::~LLGLState()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
-	if (mState)
-	{
-		if (gDebugGL)
-		{
-			if (!gDebugSession)
-			{
-				llassert_always(sStateMap[mState] == glIsEnabled(mState));
-			}
-			else
-			{
-				if (sStateMap[mState] != glIsEnabled(mState))
-				{
-					ll_fail("GL enabled state does not match expected");
-				}
-			}
-		}
-
-		if (mIsEnabled != mWasEnabled)
-		{
-			gGL.flush();
-			if (mWasEnabled)
-			{
-				glEnable(mState);
-				sStateMap[mState] = GL_TRUE;
-			}
-			else
-			{
-				glDisable(mState);
-				sStateMap[mState] = GL_FALSE;
-			}
-		}
-	}
+    if (mState)
+    {
+        if (gDebugGL)
+        {
+            if (!gDebugSession)
+            {
+                llassert_always(sStateMap[mState] == glIsEnabled(mState));
+            }
+            else
+            {
+                if (sStateMap[mState] != glIsEnabled(mState))
+                {
+                    ll_fail("GL enabled state does not match expected");
+                }
+            }
+        }
+
+        if (mIsEnabled != mWasEnabled)
+        {
+            gGL.flush();
+            if (mWasEnabled)
+            {
+                glEnable(mState);
+                sStateMap[mState] = GL_TRUE;
+            }
+            else
+            {
+                glDisable(mState);
+                sStateMap[mState] = GL_FALSE;
+            }
+        }
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void LLGLManager::initGLStates()
 {
-	//gl states moved to classes in llglstates.h
-	LLGLState::initClass();
+    //gl states moved to classes in llglstates.h
+    LLGLState::initClass();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void parse_gl_version( S32* major, S32* minor, S32* release, std::string* vendor_specific, std::string* version_string )
 {
-	// GL_VERSION returns a null-terminated string with the format: 
-	// <major>.<minor>[.<release>] [<vendor specific>]
-
-	const char* version = (const char*) glGetString(GL_VERSION);
-	*major = 0;
-	*minor = 0;
-	*release = 0;
-	vendor_specific->assign("");
-
-	if( !version )
-	{
-		return;
-	}
-
-	version_string->assign(version);
-
-	std::string ver_copy( version );
-	S32 len = (S32)strlen( version );	/* Flawfinder: ignore */
-	S32 i = 0;
-	S32 start;
-	// Find the major version
-	start = i;
-	for( ; i < len; i++ )
-	{
-		if( '.' == version[i] )
-		{
-			break;
-		}
-	}
-	std::string major_str = ver_copy.substr(start,i-start);
-	LLStringUtil::convertToS32(major_str, *major);
-
-	if( '.' == version[i] )
-	{
-		i++;
-	}
-
-	// Find the minor version
-	start = i;
-	for( ; i < len; i++ )
-	{
-		if( ('.' == version[i]) || isspace(version[i]) )
-		{
-			break;
-		}
-	}
-	std::string minor_str = ver_copy.substr(start,i-start);
-	LLStringUtil::convertToS32(minor_str, *minor);
-
-	// Find the release number (optional)
-	if( '.' == version[i] )
-	{
-		i++;
-
-		start = i;
-		for( ; i < len; i++ )
-		{
-			if( isspace(version[i]) )
-			{
-				break;
-			}
-		}
-
-		std::string release_str = ver_copy.substr(start,i-start);
-		LLStringUtil::convertToS32(release_str, *release);
-	}
-
-	// Skip over any white space
-	while( version[i] && isspace( version[i] ) )
-	{
-		i++;
-	}
-
-	// Copy the vendor-specific string (optional)
-	if( version[i] )
-	{
-		vendor_specific->assign( version + i );
-	}
+    // GL_VERSION returns a null-terminated string with the format:
+    // <major>.<minor>[.<release>] [<vendor specific>]
+
+    const char* version = (const char*) glGetString(GL_VERSION);
+    *major = 0;
+    *minor = 0;
+    *release = 0;
+    vendor_specific->assign("");
+
+    if( !version )
+    {
+        return;
+    }
+
+    version_string->assign(version);
+
+    std::string ver_copy( version );
+    S32 len = (S32)strlen( version );   /* Flawfinder: ignore */
+    S32 i = 0;
+    S32 start;
+    // Find the major version
+    start = i;
+    for( ; i < len; i++ )
+    {
+        if( '.' == version[i] )
+        {
+            break;
+        }
+    }
+    std::string major_str = ver_copy.substr(start,i-start);
+    LLStringUtil::convertToS32(major_str, *major);
+
+    if( '.' == version[i] )
+    {
+        i++;
+    }
+
+    // Find the minor version
+    start = i;
+    for( ; i < len; i++ )
+    {
+        if( ('.' == version[i]) || isspace(version[i]) )
+        {
+            break;
+        }
+    }
+    std::string minor_str = ver_copy.substr(start,i-start);
+    LLStringUtil::convertToS32(minor_str, *minor);
+
+    // Find the release number (optional)
+    if( '.' == version[i] )
+    {
+        i++;
+
+        start = i;
+        for( ; i < len; i++ )
+        {
+            if( isspace(version[i]) )
+            {
+                break;
+            }
+        }
+
+        std::string release_str = ver_copy.substr(start,i-start);
+        LLStringUtil::convertToS32(release_str, *release);
+    }
+
+    // Skip over any white space
+    while( version[i] && isspace( version[i] ) )
+    {
+        i++;
+    }
+
+    // Copy the vendor-specific string (optional)
+    if( version[i] )
+    {
+        vendor_specific->assign( version + i );
+    }
 }
 
 
 void parse_glsl_version(S32& major, S32& minor)
 {
-	// GL_SHADING_LANGUAGE_VERSION returns a null-terminated string with the format: 
-	// <major>.<minor>[.<release>] [<vendor specific>]
-
-	const char* version = (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION);
-	major = 0;
-	minor = 0;
-	
-	if( !version )
-	{
-		return;
-	}
-
-	std::string ver_copy( version );
-	S32 len = (S32)strlen( version );	/* Flawfinder: ignore */
-	S32 i = 0;
-	S32 start;
-	// Find the major version
-	start = i;
-	for( ; i < len; i++ )
-	{
-		if( '.' == version[i] )
-		{
-			break;
-		}
-	}
-	std::string major_str = ver_copy.substr(start,i-start);
-	LLStringUtil::convertToS32(major_str, major);
-
-	if( '.' == version[i] )
-	{
-		i++;
-	}
-
-	// Find the minor version
-	start = i;
-	for( ; i < len; i++ )
-	{
-		if( ('.' == version[i]) || isspace(version[i]) )
-		{
-			break;
-		}
-	}
-	std::string minor_str = ver_copy.substr(start,i-start);
-	LLStringUtil::convertToS32(minor_str, minor);
+    // GL_SHADING_LANGUAGE_VERSION returns a null-terminated string with the format:
+    // <major>.<minor>[.<release>] [<vendor specific>]
+
+    const char* version = (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION);
+    major = 0;
+    minor = 0;
+
+    if( !version )
+    {
+        return;
+    }
+
+    std::string ver_copy( version );
+    S32 len = (S32)strlen( version );   /* Flawfinder: ignore */
+    S32 i = 0;
+    S32 start;
+    // Find the major version
+    start = i;
+    for( ; i < len; i++ )
+    {
+        if( '.' == version[i] )
+        {
+            break;
+        }
+    }
+    std::string major_str = ver_copy.substr(start,i-start);
+    LLStringUtil::convertToS32(major_str, major);
+
+    if( '.' == version[i] )
+    {
+        i++;
+    }
+
+    // Find the minor version
+    start = i;
+    for( ; i < len; i++ )
+    {
+        if( ('.' == version[i]) || isspace(version[i]) )
+        {
+            break;
+        }
+    }
+    std::string minor_str = ver_copy.substr(start,i-start);
+    LLStringUtil::convertToS32(minor_str, minor);
 }
 
 LLGLUserClipPlane::LLGLUserClipPlane(const LLPlane& p, const glh::matrix4f& modelview, const glh::matrix4f& projection, bool apply)
 {
-	mApply = apply;
+    mApply = apply;
 
-	if (mApply)
-	{
-		mModelview = modelview;
-		mProjection = projection;
+    if (mApply)
+    {
+        mModelview = modelview;
+        mProjection = projection;
 
         //flip incoming LLPlane to get consistent behavior compared to frustum culling
-		setPlane(-p[0], -p[1], -p[2], -p[3]);
-	}
+        setPlane(-p[0], -p[1], -p[2], -p[3]);
+    }
 }
 
 void LLGLUserClipPlane::disable()
 {
     if (mApply)
-	{
-		gGL.matrixMode(LLRender::MM_PROJECTION);
-		gGL.popMatrix();
-		gGL.matrixMode(LLRender::MM_MODELVIEW);
-	}
+    {
+        gGL.matrixMode(LLRender::MM_PROJECTION);
+        gGL.popMatrix();
+        gGL.matrixMode(LLRender::MM_MODELVIEW);
+    }
     mApply = false;
 }
 
 void LLGLUserClipPlane::setPlane(F32 a, F32 b, F32 c, F32 d)
 {
-	glh::matrix4f& P = mProjection;
-	glh::matrix4f& M = mModelview;
-    
-	glh::matrix4f invtrans_MVP = (P * M).inverse().transpose();
+    glh::matrix4f& P = mProjection;
+    glh::matrix4f& 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);
@@ -2722,100 +2722,100 @@ void LLGLUserClipPlane::setPlane(F32 a, F32 b, F32 c, F32 d)
     suffix.set_row(2, cplane);
     glh::matrix4f newP = suffix * P;
     gGL.matrixMode(LLRender::MM_PROJECTION);
-	gGL.pushMatrix();
+    gGL.pushMatrix();
     gGL.loadMatrix(newP.m);
-	gGLObliqueProjectionInverse = LLMatrix4(newP.inverse().transpose().m);
+    gGLObliqueProjectionInverse = LLMatrix4(newP.inverse().transpose().m);
     gGL.matrixMode(LLRender::MM_MODELVIEW);
 }
 
 LLGLUserClipPlane::~LLGLUserClipPlane()
 {
-	disable();
+    disable();
 }
 
 LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, GLenum depth_func)
 : mPrevDepthEnabled(sDepthEnabled), mPrevDepthFunc(sDepthFunc), mPrevWriteEnabled(sWriteEnabled)
 {
-	stop_glerror();
-	
-	checkState();
-
-	if (!depth_enabled)
-	{ // always disable depth writes if depth testing is disabled
-	  // GL spec defines this as a requirement, but some implementations allow depth writes with testing disabled
-	  // The proper way to write to depth buffer with testing disabled is to enable testing and use a depth_func of GL_ALWAYS
-		write_enabled = FALSE;
-	}
-
-	if (depth_enabled != sDepthEnabled)
-	{
-		gGL.flush();
-		if (depth_enabled) glEnable(GL_DEPTH_TEST);
-		else glDisable(GL_DEPTH_TEST);
-		sDepthEnabled = depth_enabled;
-	}
-	if (depth_func != sDepthFunc)
-	{
-		gGL.flush();
-		glDepthFunc(depth_func);
-		sDepthFunc = depth_func;
-	}
-	if (write_enabled != sWriteEnabled)
-	{
-		gGL.flush();
-		glDepthMask(write_enabled);
-		sWriteEnabled = write_enabled;
-	}
+    stop_glerror();
+
+    checkState();
+
+    if (!depth_enabled)
+    { // always disable depth writes if depth testing is disabled
+      // GL spec defines this as a requirement, but some implementations allow depth writes with testing disabled
+      // The proper way to write to depth buffer with testing disabled is to enable testing and use a depth_func of GL_ALWAYS
+        write_enabled = FALSE;
+    }
+
+    if (depth_enabled != sDepthEnabled)
+    {
+        gGL.flush();
+        if (depth_enabled) glEnable(GL_DEPTH_TEST);
+        else glDisable(GL_DEPTH_TEST);
+        sDepthEnabled = depth_enabled;
+    }
+    if (depth_func != sDepthFunc)
+    {
+        gGL.flush();
+        glDepthFunc(depth_func);
+        sDepthFunc = depth_func;
+    }
+    if (write_enabled != sWriteEnabled)
+    {
+        gGL.flush();
+        glDepthMask(write_enabled);
+        sWriteEnabled = write_enabled;
+    }
 }
 
 LLGLDepthTest::~LLGLDepthTest()
 {
-	checkState();
-	if (sDepthEnabled != mPrevDepthEnabled )
-	{
-		gGL.flush();
-		if (mPrevDepthEnabled) glEnable(GL_DEPTH_TEST);
-		else glDisable(GL_DEPTH_TEST);
-		sDepthEnabled = mPrevDepthEnabled;
-	}
-	if (sDepthFunc != mPrevDepthFunc)
-	{
-		gGL.flush();
-		glDepthFunc(mPrevDepthFunc);
-		sDepthFunc = mPrevDepthFunc;
-	}
-	if (sWriteEnabled != mPrevWriteEnabled )
-	{
-		gGL.flush();
-		glDepthMask(mPrevWriteEnabled);
-		sWriteEnabled = mPrevWriteEnabled;
-	}
+    checkState();
+    if (sDepthEnabled != mPrevDepthEnabled )
+    {
+        gGL.flush();
+        if (mPrevDepthEnabled) glEnable(GL_DEPTH_TEST);
+        else glDisable(GL_DEPTH_TEST);
+        sDepthEnabled = mPrevDepthEnabled;
+    }
+    if (sDepthFunc != mPrevDepthFunc)
+    {
+        gGL.flush();
+        glDepthFunc(mPrevDepthFunc);
+        sDepthFunc = mPrevDepthFunc;
+    }
+    if (sWriteEnabled != mPrevWriteEnabled )
+    {
+        gGL.flush();
+        glDepthMask(mPrevWriteEnabled);
+        sWriteEnabled = mPrevWriteEnabled;
+    }
 }
 
 void LLGLDepthTest::checkState()
 {
-	if (gDebugGL)
-	{
-		GLint func = 0;
-		GLboolean mask = FALSE;
-
-		glGetIntegerv(GL_DEPTH_FUNC, &func);
-		glGetBooleanv(GL_DEPTH_WRITEMASK, &mask);
-
-		if (glIsEnabled(GL_DEPTH_TEST) != sDepthEnabled ||
-			sWriteEnabled != mask ||
-			sDepthFunc != func)
-		{
-			if (gDebugSession)
-			{
-				gFailLog << "Unexpected depth testing state." << std::endl;
-			}
-			else
-			{
-				LL_GL_ERRS << "Unexpected depth testing state." << LL_ENDL;
-			}
-		}
-	}
+    if (gDebugGL)
+    {
+        GLint func = 0;
+        GLboolean mask = FALSE;
+
+        glGetIntegerv(GL_DEPTH_FUNC, &func);
+        glGetBooleanv(GL_DEPTH_WRITEMASK, &mask);
+
+        if (glIsEnabled(GL_DEPTH_TEST) != sDepthEnabled ||
+            sWriteEnabled != mask ||
+            sDepthFunc != func)
+        {
+            if (gDebugSession)
+            {
+                gFailLog << "Unexpected depth testing state." << std::endl;
+            }
+            else
+            {
+                LL_GL_ERRS << "Unexpected depth testing state." << LL_ENDL;
+            }
+        }
+    }
 }
 
 LLGLSquashToFarClip::LLGLSquashToFarClip()
@@ -2833,84 +2833,84 @@ LLGLSquashToFarClip::LLGLSquashToFarClip(glh::matrix4f& P, U32 layer)
 void LLGLSquashToFarClip::setProjectionMatrix(glh::matrix4f& projection, U32 layer)
 {
 
-	F32 depth = 0.99999f - 0.0001f * layer;
+    F32 depth = 0.99999f - 0.0001f * layer;
 
-	for (U32 i = 0; i < 4; i++)
-	{
-		projection.element(2, i) = projection.element(3, i) * depth;
-	}
+    for (U32 i = 0; i < 4; i++)
+    {
+        projection.element(2, i) = projection.element(3, i) * depth;
+    }
 
     LLRender::eMatrixMode last_matrix_mode = gGL.getMatrixMode();
 
-	gGL.matrixMode(LLRender::MM_PROJECTION);
-	gGL.pushMatrix();
-	gGL.loadMatrix(projection.m);
+    gGL.matrixMode(LLRender::MM_PROJECTION);
+    gGL.pushMatrix();
+    gGL.loadMatrix(projection.m);
 
-	gGL.matrixMode(last_matrix_mode);
+    gGL.matrixMode(last_matrix_mode);
 }
 
 LLGLSquashToFarClip::~LLGLSquashToFarClip()
 {
     LLRender::eMatrixMode last_matrix_mode = gGL.getMatrixMode();
 
-	gGL.matrixMode(LLRender::MM_PROJECTION);
-	gGL.popMatrix();
+    gGL.matrixMode(LLRender::MM_PROJECTION);
+    gGL.popMatrix();
 
-	gGL.matrixMode(last_matrix_mode);
+    gGL.matrixMode(last_matrix_mode);
 }
 
 
-	
+
 LLGLSyncFence::LLGLSyncFence()
 {
-	mSync = 0;
+    mSync = 0;
 }
 
 LLGLSyncFence::~LLGLSyncFence()
 {
-	if (mSync)
-	{
-		glDeleteSync(mSync);
-	}
+    if (mSync)
+    {
+        glDeleteSync(mSync);
+    }
 }
 
 void LLGLSyncFence::placeFence()
 {
-	if (mSync)
-	{
-		glDeleteSync(mSync);
-	}
-	mSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+    if (mSync)
+    {
+        glDeleteSync(mSync);
+    }
+    mSync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
 }
 
 bool LLGLSyncFence::isCompleted()
 {
-	bool ret = true;
-	if (mSync)
-	{
-		GLenum status = glClientWaitSync(mSync, 0, 1);
-		if (status == GL_TIMEOUT_EXPIRED)
-		{
-			ret = false;
-		}
-	}
-	return ret;
+    bool ret = true;
+    if (mSync)
+    {
+        GLenum status = glClientWaitSync(mSync, 0, 1);
+        if (status == GL_TIMEOUT_EXPIRED)
+        {
+            ret = false;
+        }
+    }
+    return ret;
 }
 
 void LLGLSyncFence::wait()
 {
-	if (mSync)
-	{
-		while (glClientWaitSync(mSync, 0, FENCE_WAIT_TIME_NANOSECONDS) == GL_TIMEOUT_EXPIRED)
-		{ //track the number of times we've waited here
-		}
-	}
+    if (mSync)
+    {
+        while (glClientWaitSync(mSync, 0, FENCE_WAIT_TIME_NANOSECONDS) == GL_TIMEOUT_EXPIRED)
+        { //track the number of times we've waited here
+        }
+    }
 }
 
 LLGLSPipelineSkyBox::LLGLSPipelineSkyBox()
 : mCullFace(GL_CULL_FACE)
 , mSquashClip()
-{ 
+{
 }
 
 LLGLSPipelineSkyBox::~LLGLSPipelineSkyBox()
@@ -2925,17 +2925,17 @@ LLGLSPipelineDepthTestSkyBox::LLGLSPipelineDepthTestSkyBox(bool depth_test, bool
 }
 
 LLGLSPipelineBlendSkyBox::LLGLSPipelineBlendSkyBox(bool depth_test, bool depth_write)
-: LLGLSPipelineDepthTestSkyBox(depth_test, depth_write)    
+: LLGLSPipelineDepthTestSkyBox(depth_test, depth_write)
 , mBlend(GL_BLEND)
-{ 
+{
     gGL.setSceneBlendType(LLRender::BT_ALPHA);
 }
 
 #if LL_WINDOWS
 // Expose desired use of high-performance graphics processor to Optimus driver and to AMD driver
 // https://docs.nvidia.com/gameworks/content/technologies/desktop/optimus.htm
-extern "C" 
-{ 
+extern "C"
+{
     __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
     __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }