Post-merge spaces fix

1 files changed, 1347 insertions, 1347 deletions

diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 5144b28ce9..d0846e3017 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llviewershadermgr.cpp
  * @brief Viewer shader manager implementation.
  *
  * $LicenseInfo:firstyear=2005&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$
  */
@@ -64,10 +64,10 @@ using std::pair;
 using std::make_pair;
 using std::string;
 
-BOOL				LLViewerShaderMgr::sInitialized = FALSE;
-bool				LLViewerShaderMgr::sSkipReload = false;
+BOOL                LLViewerShaderMgr::sInitialized = FALSE;
+bool                LLViewerShaderMgr::sSkipReload = false;
 
-LLVector4			gShinyOrigin;
+LLVector4           gShinyOrigin;
 
 S32 clamp_terrain_mapping(S32 mapping)
 {
@@ -78,155 +78,155 @@ S32 clamp_terrain_mapping(S32 mapping)
 }
 
 //utility shaders
-LLGLSLShader	gOcclusionProgram;
+LLGLSLShader    gOcclusionProgram;
 LLGLSLShader    gSkinnedOcclusionProgram;
-LLGLSLShader	gOcclusionCubeProgram;
-LLGLSLShader	gGlowCombineProgram;
-LLGLSLShader	gReflectionMipProgram;
+LLGLSLShader    gOcclusionCubeProgram;
+LLGLSLShader    gGlowCombineProgram;
+LLGLSLShader    gReflectionMipProgram;
 LLGLSLShader    gGaussianProgram;
 LLGLSLShader    gRadianceGenProgram;
 LLGLSLShader    gHeroRadianceGenProgram;
-LLGLSLShader	gIrradianceGenProgram;
-LLGLSLShader	gGlowCombineFXAAProgram;
-LLGLSLShader	gTwoTextureCompareProgram;
-LLGLSLShader	gOneTextureFilterProgram;
-LLGLSLShader	gDebugProgram;
+LLGLSLShader    gIrradianceGenProgram;
+LLGLSLShader    gGlowCombineFXAAProgram;
+LLGLSLShader    gTwoTextureCompareProgram;
+LLGLSLShader    gOneTextureFilterProgram;
+LLGLSLShader    gDebugProgram;
 LLGLSLShader    gSkinnedDebugProgram;
-LLGLSLShader	gNormalDebugProgram[NORMAL_DEBUG_SHADER_COUNT];
-LLGLSLShader	gSkinnedNormalDebugProgram[NORMAL_DEBUG_SHADER_COUNT];
-LLGLSLShader	gClipProgram;
-LLGLSLShader	gAlphaMaskProgram;
-LLGLSLShader	gBenchmarkProgram;
+LLGLSLShader    gNormalDebugProgram[NORMAL_DEBUG_SHADER_COUNT];
+LLGLSLShader    gSkinnedNormalDebugProgram[NORMAL_DEBUG_SHADER_COUNT];
+LLGLSLShader    gClipProgram;
+LLGLSLShader    gAlphaMaskProgram;
+LLGLSLShader    gBenchmarkProgram;
 LLGLSLShader    gReflectionProbeDisplayProgram;
 LLGLSLShader    gCopyProgram;
 LLGLSLShader    gCopyDepthProgram;
 
 //object shaders
-LLGLSLShader		gObjectPreviewProgram;
+LLGLSLShader        gObjectPreviewProgram;
 LLGLSLShader        gSkinnedObjectPreviewProgram;
 LLGLSLShader        gPhysicsPreviewProgram;
-LLGLSLShader		gObjectFullbrightAlphaMaskProgram;
-LLGLSLShader		gObjectBumpProgram;
+LLGLSLShader        gObjectFullbrightAlphaMaskProgram;
+LLGLSLShader        gObjectBumpProgram;
 LLGLSLShader        gSkinnedObjectBumpProgram;
-LLGLSLShader		gObjectAlphaMaskNoColorProgram;
+LLGLSLShader        gObjectAlphaMaskNoColorProgram;
 
 //environment shaders
-LLGLSLShader		gWaterProgram;
+LLGLSLShader        gWaterProgram;
 LLGLSLShader        gWaterEdgeProgram;
-LLGLSLShader		gUnderWaterProgram;
+LLGLSLShader        gUnderWaterProgram;
 
 //interface shaders
-LLGLSLShader		gHighlightProgram;
+LLGLSLShader        gHighlightProgram;
 LLGLSLShader        gSkinnedHighlightProgram;
-LLGLSLShader		gHighlightNormalProgram;
-LLGLSLShader		gHighlightSpecularProgram;
+LLGLSLShader        gHighlightNormalProgram;
+LLGLSLShader        gHighlightSpecularProgram;
 
-LLGLSLShader		gDeferredHighlightProgram;
+LLGLSLShader        gDeferredHighlightProgram;
 
-LLGLSLShader		gPathfindingProgram;
-LLGLSLShader		gPathfindingNoNormalsProgram;
+LLGLSLShader        gPathfindingProgram;
+LLGLSLShader        gPathfindingNoNormalsProgram;
 
 //avatar shader handles
-LLGLSLShader		gAvatarProgram;
-LLGLSLShader		gAvatarEyeballProgram;
-LLGLSLShader		gImpostorProgram;
+LLGLSLShader        gAvatarProgram;
+LLGLSLShader        gAvatarEyeballProgram;
+LLGLSLShader        gImpostorProgram;
 
 // Effects Shaders
-LLGLSLShader			gGlowProgram;
-LLGLSLShader			gGlowExtractProgram;
-LLGLSLShader			gPostScreenSpaceReflectionProgram;
+LLGLSLShader            gGlowProgram;
+LLGLSLShader            gGlowExtractProgram;
+LLGLSLShader            gPostScreenSpaceReflectionProgram;
 
 // Deferred rendering shaders
-LLGLSLShader			gDeferredImpostorProgram;
-LLGLSLShader			gDeferredDiffuseProgram;
-LLGLSLShader			gDeferredDiffuseAlphaMaskProgram;
+LLGLSLShader            gDeferredImpostorProgram;
+LLGLSLShader            gDeferredDiffuseProgram;
+LLGLSLShader            gDeferredDiffuseAlphaMaskProgram;
 LLGLSLShader            gDeferredSkinnedDiffuseAlphaMaskProgram;
-LLGLSLShader			gDeferredNonIndexedDiffuseAlphaMaskProgram;
-LLGLSLShader			gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram;
-LLGLSLShader			gDeferredSkinnedDiffuseProgram;
-LLGLSLShader			gDeferredSkinnedBumpProgram;
-LLGLSLShader			gDeferredBumpProgram;
-LLGLSLShader			gDeferredTerrainProgram;
-LLGLSLShader			gDeferredTreeProgram;
-LLGLSLShader			gDeferredTreeShadowProgram;
+LLGLSLShader            gDeferredNonIndexedDiffuseAlphaMaskProgram;
+LLGLSLShader            gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram;
+LLGLSLShader            gDeferredSkinnedDiffuseProgram;
+LLGLSLShader            gDeferredSkinnedBumpProgram;
+LLGLSLShader            gDeferredBumpProgram;
+LLGLSLShader            gDeferredTerrainProgram;
+LLGLSLShader            gDeferredTreeProgram;
+LLGLSLShader            gDeferredTreeShadowProgram;
 LLGLSLShader            gDeferredSkinnedTreeShadowProgram;
-LLGLSLShader			gDeferredAvatarProgram;
-LLGLSLShader			gDeferredAvatarAlphaProgram;
-LLGLSLShader			gDeferredLightProgram;
-LLGLSLShader			gDeferredMultiLightProgram[16];
-LLGLSLShader			gDeferredSpotLightProgram;
-LLGLSLShader			gDeferredMultiSpotLightProgram;
-LLGLSLShader			gDeferredSunProgram;
+LLGLSLShader            gDeferredAvatarProgram;
+LLGLSLShader            gDeferredAvatarAlphaProgram;
+LLGLSLShader            gDeferredLightProgram;
+LLGLSLShader            gDeferredMultiLightProgram[16];
+LLGLSLShader            gDeferredSpotLightProgram;
+LLGLSLShader            gDeferredMultiSpotLightProgram;
+LLGLSLShader            gDeferredSunProgram;
 LLGLSLShader            gHazeProgram;
 LLGLSLShader            gHazeWaterProgram;
-LLGLSLShader			gDeferredBlurLightProgram;
-LLGLSLShader			gDeferredSoftenProgram;
-LLGLSLShader			gDeferredShadowProgram;
+LLGLSLShader            gDeferredBlurLightProgram;
+LLGLSLShader            gDeferredSoftenProgram;
+LLGLSLShader            gDeferredShadowProgram;
 LLGLSLShader            gDeferredSkinnedShadowProgram;
-LLGLSLShader			gDeferredShadowCubeProgram;
-LLGLSLShader			gDeferredShadowAlphaMaskProgram;
+LLGLSLShader            gDeferredShadowCubeProgram;
+LLGLSLShader            gDeferredShadowAlphaMaskProgram;
 LLGLSLShader            gDeferredSkinnedShadowAlphaMaskProgram;
-LLGLSLShader			gDeferredShadowGLTFAlphaMaskProgram;
-LLGLSLShader			gDeferredSkinnedShadowGLTFAlphaMaskProgram;
+LLGLSLShader            gDeferredShadowGLTFAlphaMaskProgram;
+LLGLSLShader            gDeferredSkinnedShadowGLTFAlphaMaskProgram;
 LLGLSLShader            gDeferredShadowGLTFAlphaBlendProgram;
 LLGLSLShader            gDeferredSkinnedShadowGLTFAlphaBlendProgram;
-LLGLSLShader			gDeferredShadowFullbrightAlphaMaskProgram;
+LLGLSLShader            gDeferredShadowFullbrightAlphaMaskProgram;
 LLGLSLShader            gDeferredSkinnedShadowFullbrightAlphaMaskProgram;
-LLGLSLShader			gDeferredAvatarShadowProgram;
-LLGLSLShader			gDeferredAvatarAlphaShadowProgram;
-LLGLSLShader			gDeferredAvatarAlphaMaskShadowProgram;
-LLGLSLShader			gDeferredAlphaProgram;
-LLGLSLShader			gHUDAlphaProgram;
+LLGLSLShader            gDeferredAvatarShadowProgram;
+LLGLSLShader            gDeferredAvatarAlphaShadowProgram;
+LLGLSLShader            gDeferredAvatarAlphaMaskShadowProgram;
+LLGLSLShader            gDeferredAlphaProgram;
+LLGLSLShader            gHUDAlphaProgram;
 LLGLSLShader            gDeferredSkinnedAlphaProgram;
-LLGLSLShader			gDeferredAlphaImpostorProgram;
+LLGLSLShader            gDeferredAlphaImpostorProgram;
 LLGLSLShader            gDeferredSkinnedAlphaImpostorProgram;
-LLGLSLShader			gDeferredAvatarEyesProgram;
-LLGLSLShader			gDeferredFullbrightProgram;
+LLGLSLShader            gDeferredAvatarEyesProgram;
+LLGLSLShader            gDeferredFullbrightProgram;
 LLGLSLShader            gHUDFullbrightProgram;
-LLGLSLShader			gDeferredFullbrightAlphaMaskProgram;
-LLGLSLShader			gHUDFullbrightAlphaMaskProgram;
-LLGLSLShader			gDeferredFullbrightAlphaMaskAlphaProgram;
-LLGLSLShader			gHUDFullbrightAlphaMaskAlphaProgram;
-LLGLSLShader			gDeferredEmissiveProgram;
+LLGLSLShader            gDeferredFullbrightAlphaMaskProgram;
+LLGLSLShader            gHUDFullbrightAlphaMaskProgram;
+LLGLSLShader            gDeferredFullbrightAlphaMaskAlphaProgram;
+LLGLSLShader            gHUDFullbrightAlphaMaskAlphaProgram;
+LLGLSLShader            gDeferredEmissiveProgram;
 LLGLSLShader            gDeferredSkinnedEmissiveProgram;
-LLGLSLShader			gDeferredPostProgram;
-LLGLSLShader			gDeferredCoFProgram;
-LLGLSLShader			gDeferredDoFCombineProgram;
-LLGLSLShader			gDeferredPostGammaCorrectProgram;
+LLGLSLShader            gDeferredPostProgram;
+LLGLSLShader            gDeferredCoFProgram;
+LLGLSLShader            gDeferredDoFCombineProgram;
+LLGLSLShader            gDeferredPostGammaCorrectProgram;
 LLGLSLShader            gNoPostGammaCorrectProgram;
 LLGLSLShader            gLegacyPostGammaCorrectProgram;
-LLGLSLShader			gExposureProgram;
-LLGLSLShader			gExposureProgramNoFade;
-LLGLSLShader			gLuminanceProgram;
-LLGLSLShader			gFXAAProgram;
-LLGLSLShader			gDeferredPostNoDoFProgram;
-LLGLSLShader			gDeferredWLSkyProgram;
+LLGLSLShader            gExposureProgram;
+LLGLSLShader            gExposureProgramNoFade;
+LLGLSLShader            gLuminanceProgram;
+LLGLSLShader            gFXAAProgram;
+LLGLSLShader            gDeferredPostNoDoFProgram;
+LLGLSLShader            gDeferredWLSkyProgram;
 LLGLSLShader            gEnvironmentMapProgram;
-LLGLSLShader			gDeferredWLCloudProgram;
-LLGLSLShader			gDeferredWLSunProgram;
-LLGLSLShader			gDeferredWLMoonProgram;
-LLGLSLShader			gDeferredStarProgram;
-LLGLSLShader			gDeferredFullbrightShinyProgram;
+LLGLSLShader            gDeferredWLCloudProgram;
+LLGLSLShader            gDeferredWLSunProgram;
+LLGLSLShader            gDeferredWLMoonProgram;
+LLGLSLShader            gDeferredStarProgram;
+LLGLSLShader            gDeferredFullbrightShinyProgram;
 LLGLSLShader            gHUDFullbrightShinyProgram;
 LLGLSLShader            gDeferredSkinnedFullbrightShinyProgram;
-LLGLSLShader			gDeferredSkinnedFullbrightProgram;
+LLGLSLShader            gDeferredSkinnedFullbrightProgram;
 LLGLSLShader            gDeferredSkinnedFullbrightAlphaMaskProgram;
 LLGLSLShader            gDeferredSkinnedFullbrightAlphaMaskAlphaProgram;
-LLGLSLShader			gNormalMapGenProgram;
+LLGLSLShader            gNormalMapGenProgram;
 LLGLSLShader            gDeferredGenBrdfLutProgram;
 LLGLSLShader            gDeferredBufferVisualProgram;
 
 // Deferred materials shaders
-LLGLSLShader			gDeferredMaterialProgram[LLMaterial::SHADER_COUNT*2];
-LLGLSLShader			gHUDPBROpaqueProgram;
+LLGLSLShader            gDeferredMaterialProgram[LLMaterial::SHADER_COUNT*2];
+LLGLSLShader            gHUDPBROpaqueProgram;
 LLGLSLShader            gPBRGlowProgram;
 LLGLSLShader            gPBRGlowSkinnedProgram;
-LLGLSLShader			gDeferredPBROpaqueProgram;
+LLGLSLShader            gDeferredPBROpaqueProgram;
 LLGLSLShader            gDeferredSkinnedPBROpaqueProgram;
 LLGLSLShader            gHUDPBRAlphaProgram;
 LLGLSLShader            gDeferredPBRAlphaProgram;
 LLGLSLShader            gDeferredSkinnedPBRAlphaProgram;
-LLGLSLShader			gDeferredPBRTerrainProgram;
+LLGLSLShader            gDeferredPBRTerrainProgram;
 
 //helper for making a rigged variant of a given shader
 static bool make_rigged_variant(LLGLSLShader& shader, LLGLSLShader& riggedShader)
@@ -275,15 +275,15 @@ static bool no_redundant_shaders(const std::vector<LLGLSLShader*>& shaders)
 
 
 LLViewerShaderMgr::LLViewerShaderMgr() :
-	mShaderLevel(SHADER_COUNT, 0),
-	mMaxAvatarShaderLevel(0)
-{   
+    mShaderLevel(SHADER_COUNT, 0),
+    mMaxAvatarShaderLevel(0)
+{
 }
 
 LLViewerShaderMgr::~LLViewerShaderMgr()
 {
-	mShaderLevel.clear();
-	mShaderList.clear();
+    mShaderLevel.clear();
+    mShaderList.clear();
 }
 
 void LLViewerShaderMgr::finalizeShaderList()
@@ -336,46 +336,46 @@ void LLViewerShaderMgr::finalizeShaderList()
     mShaderList.push_back(&gDeferredNonIndexedDiffuseAlphaMaskProgram);
     mShaderList.push_back(&gDeferredTreeProgram);
 
-    // make sure there are no redundancies 
+    // make sure there are no redundancies
     llassert(no_redundant_shaders(mShaderList));
 }
 
 // static
 LLViewerShaderMgr * LLViewerShaderMgr::instance()
 {
-	if(NULL == sInstance)
-	{
-		sInstance = new LLViewerShaderMgr();
-	}
+    if(NULL == sInstance)
+    {
+        sInstance = new LLViewerShaderMgr();
+    }
 
-	return static_cast<LLViewerShaderMgr*>(sInstance);
+    return static_cast<LLViewerShaderMgr*>(sInstance);
 }
 
 // static
 void LLViewerShaderMgr::releaseInstance()
 {
-	if (sInstance != NULL)
-	{
-		delete sInstance;
-		sInstance = NULL;
-	}
+    if (sInstance != NULL)
+    {
+        delete sInstance;
+        sInstance = NULL;
+    }
 }
 
 void LLViewerShaderMgr::initAttribsAndUniforms(void)
 {
-	if (mReservedAttribs.empty())
-	{
-		LLShaderMgr::initAttribsAndUniforms();
-	}	
+    if (mReservedAttribs.empty())
+    {
+        LLShaderMgr::initAttribsAndUniforms();
+    }
 }
-	
+
 
 //============================================================================
 // Set Levels
 
 S32 LLViewerShaderMgr::getShaderLevel(S32 type)
 {
-	return mShaderLevel[type];
+    return mShaderLevel[type];
 }
 
 //============================================================================
@@ -386,7 +386,7 @@ void LLViewerShaderMgr::setShaders()
     LL_PROFILE_ZONE_SCOPED;
     //setShaders might be called redundantly by gSavedSettings, so return on reentrance
     static bool reentrance = false;
-    
+
     if (!gPipeline.mInitialized || !sInitialized || reentrance || sSkipReload)
     {
         return;
@@ -403,25 +403,25 @@ void LLViewerShaderMgr::setShaders()
         return;
     }
 
-	{
-		static LLCachedControl<bool> shader_cache_enabled(gSavedSettings, "RenderShaderCacheEnabled", true);
-		static LLUUID old_cache_version;
-		static LLUUID current_cache_version;
-		if (current_cache_version.isNull())
-		{
-			HBXXH128 hash_obj;
-			hash_obj.update(LLVersionInfo::instance().getVersion());
-			current_cache_version = hash_obj.digest();
+    {
+        static LLCachedControl<bool> shader_cache_enabled(gSavedSettings, "RenderShaderCacheEnabled", true);
+        static LLUUID old_cache_version;
+        static LLUUID current_cache_version;
+        if (current_cache_version.isNull())
+        {
+            HBXXH128 hash_obj;
+            hash_obj.update(LLVersionInfo::instance().getVersion());
+            current_cache_version = hash_obj.digest();
 
-			old_cache_version = LLUUID(gSavedSettings.getString("RenderShaderCacheVersion"));
-			gSavedSettings.setString("RenderShaderCacheVersion", current_cache_version.asString());
-		}
+            old_cache_version = LLUUID(gSavedSettings.getString("RenderShaderCacheVersion"));
+            gSavedSettings.setString("RenderShaderCacheVersion", current_cache_version.asString());
+        }
 
-		initShaderCache(shader_cache_enabled, old_cache_version, current_cache_version);
-	}
+        initShaderCache(shader_cache_enabled, old_cache_version, current_cache_version);
+    }
 
     static LLCachedControl<U32> max_texture_index(gSavedSettings, "RenderMaxTextureIndex", 16);
-    
+
     // when using indexed texture rendering, leave some texture units available for shadow and reflection maps
     static LLCachedControl<S32> reserved_texture_units(gSavedSettings, "RenderReservedTextureIndices", 14);
 
@@ -433,14 +433,14 @@ void LLViewerShaderMgr::setShaders()
     // Make sure the compiled shader map is cleared before we recompile shaders.
     mVertexShaderObjects.clear();
     mFragmentShaderObjects.clear();
-    
+
     initAttribsAndUniforms();
     gPipeline.releaseGLBuffers();
 
-	unloadShaders();
+    unloadShaders();
+
+    LLPipeline::sRenderGlow = gSavedSettings.getBOOL("RenderGlow");
 
-    LLPipeline::sRenderGlow = gSavedSettings.getBOOL("RenderGlow"); 
-    
     if (gViewerWindow)
     {
         gViewerWindow->setCursor(UI_CURSOR_WAIT);
@@ -460,7 +460,7 @@ void LLViewerShaderMgr::setShaders()
 
     llassert((gGLManager.mGLSLVersionMajor > 1 || gGLManager.mGLSLVersionMinor >= 10));
 
-    
+
     S32 light_class = 3;
     S32 interface_class = 2;
     S32 env_class = 2;
@@ -499,7 +499,7 @@ void LLViewerShaderMgr::setShaders()
         loadBasicShaders();
         LLError::setDefaultLevel(lvl);
         LL_ERRS() << "Unable to load basic shader " << shader_name << ", verify graphics driver installed and current." << LL_ENDL;
-        reentrance = false; // For hygiene only, re-try probably helps nothing 
+        reentrance = false; // For hygiene only, re-try probably helps nothing
         return;
     }
 
@@ -555,7 +555,7 @@ void LLViewerShaderMgr::setShaders()
         { //hardware skinning is enabled and rigged attachment shaders loaded correctly
             // cloth is a class3 shader
             S32 avatar_class = 1;
-                
+
             // Set the actual level
             mShaderLevel[SHADER_AVATAR] = avatar_class;
 
@@ -572,7 +572,7 @@ void LLViewerShaderMgr::setShaders()
     loaded = loaded && loadShadersDeferred();
     llassert(loaded);
 
-	persistShaderCacheMetadata();
+    persistShaderCacheMetadata();
 
     if (gViewerWindow)
     {
@@ -587,76 +587,76 @@ void LLViewerShaderMgr::setShaders()
 
 void LLViewerShaderMgr::unloadShaders()
 {
-	while (!LLGLSLShader::sInstances.empty())
-	{
-		LLGLSLShader* shader = *(LLGLSLShader::sInstances.begin());
-		shader->unload();
-	}
-
-	mShaderLevel[SHADER_LIGHTING] = 0;
-	mShaderLevel[SHADER_OBJECT] = 0;
-	mShaderLevel[SHADER_AVATAR] = 0;
-	mShaderLevel[SHADER_ENVIRONMENT] = 0;
-	mShaderLevel[SHADER_WATER] = 0;
-	mShaderLevel[SHADER_INTERFACE] = 0;
-	mShaderLevel[SHADER_EFFECT] = 0;
-	mShaderLevel[SHADER_WINDLIGHT] = 0;
-
-	gPipeline.mShadersLoaded = false;
+    while (!LLGLSLShader::sInstances.empty())
+    {
+        LLGLSLShader* shader = *(LLGLSLShader::sInstances.begin());
+        shader->unload();
+    }
+
+    mShaderLevel[SHADER_LIGHTING] = 0;
+    mShaderLevel[SHADER_OBJECT] = 0;
+    mShaderLevel[SHADER_AVATAR] = 0;
+    mShaderLevel[SHADER_ENVIRONMENT] = 0;
+    mShaderLevel[SHADER_WATER] = 0;
+    mShaderLevel[SHADER_INTERFACE] = 0;
+    mShaderLevel[SHADER_EFFECT] = 0;
+    mShaderLevel[SHADER_WINDLIGHT] = 0;
+
+    gPipeline.mShadersLoaded = false;
 }
 
 std::string LLViewerShaderMgr::loadBasicShaders()
 {
-	// Load basic dependency shaders first
-	// All of these have to load for any shaders to function
-	
-	S32 sum_lights_class = 3;
+    // Load basic dependency shaders first
+    // All of these have to load for any shaders to function
+
+    S32 sum_lights_class = 3;
 
 #if LL_DARWIN
-	// Work around driver crashes on older Macs when using deferred rendering
-	// NORSPEC-59
-	//
-	if (gGLManager.mIsMobileGF)
-		sum_lights_class = 3;
+    // Work around driver crashes on older Macs when using deferred rendering
+    // NORSPEC-59
+    //
+    if (gGLManager.mIsMobileGF)
+        sum_lights_class = 3;
 #endif
 
-	// Use the feature table to mask out the max light level to use.  Also make sure it's at least 1.
-	S32 max_light_class = gSavedSettings.getS32("RenderShaderLightingMaxLevel");
-	sum_lights_class = llclamp(sum_lights_class, 1, max_light_class);
-
-	// Load the Basic Vertex Shaders at the appropriate level. 
-	// (in order of shader function call depth for reference purposes, deepest level first)
-
-	vector< pair<string, S32> > shaders;
-	shaders.push_back( make_pair( "windlight/atmosphericsVarsV.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
-	shaders.push_back( make_pair( "windlight/atmosphericsHelpersV.glsl",    mShaderLevel[SHADER_WINDLIGHT] ) );
-	shaders.push_back( make_pair( "lighting/lightFuncV.glsl",               mShaderLevel[SHADER_LIGHTING] ) );
-	shaders.push_back( make_pair( "lighting/sumLightsV.glsl",               sum_lights_class ) );
-	shaders.push_back( make_pair( "lighting/lightV.glsl",                   mShaderLevel[SHADER_LIGHTING] ) );
-	shaders.push_back( make_pair( "lighting/lightFuncSpecularV.glsl",       mShaderLevel[SHADER_LIGHTING] ) );
-	shaders.push_back( make_pair( "lighting/sumLightsSpecularV.glsl",       sum_lights_class ) );
-	shaders.push_back( make_pair( "lighting/lightSpecularV.glsl",           mShaderLevel[SHADER_LIGHTING] ) );
+    // Use the feature table to mask out the max light level to use.  Also make sure it's at least 1.
+    S32 max_light_class = gSavedSettings.getS32("RenderShaderLightingMaxLevel");
+    sum_lights_class = llclamp(sum_lights_class, 1, max_light_class);
+
+    // Load the Basic Vertex Shaders at the appropriate level.
+    // (in order of shader function call depth for reference purposes, deepest level first)
+
+    vector< pair<string, S32> > shaders;
+    shaders.push_back( make_pair( "windlight/atmosphericsVarsV.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
+    shaders.push_back( make_pair( "windlight/atmosphericsHelpersV.glsl",    mShaderLevel[SHADER_WINDLIGHT] ) );
+    shaders.push_back( make_pair( "lighting/lightFuncV.glsl",               mShaderLevel[SHADER_LIGHTING] ) );
+    shaders.push_back( make_pair( "lighting/sumLightsV.glsl",               sum_lights_class ) );
+    shaders.push_back( make_pair( "lighting/lightV.glsl",                   mShaderLevel[SHADER_LIGHTING] ) );
+    shaders.push_back( make_pair( "lighting/lightFuncSpecularV.glsl",       mShaderLevel[SHADER_LIGHTING] ) );
+    shaders.push_back( make_pair( "lighting/sumLightsSpecularV.glsl",       sum_lights_class ) );
+    shaders.push_back( make_pair( "lighting/lightSpecularV.glsl",           mShaderLevel[SHADER_LIGHTING] ) );
     shaders.push_back( make_pair( "windlight/atmosphericsFuncs.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
-	shaders.push_back( make_pair( "windlight/atmosphericsV.glsl",           mShaderLevel[SHADER_WINDLIGHT] ) );
+    shaders.push_back( make_pair( "windlight/atmosphericsV.glsl",           mShaderLevel[SHADER_WINDLIGHT] ) );
     shaders.push_back( make_pair( "environment/srgbF.glsl",                 1 ) );
-	shaders.push_back( make_pair( "avatar/avatarSkinV.glsl",                1 ) );
-	shaders.push_back( make_pair( "avatar/objectSkinV.glsl",                1 ) );
+    shaders.push_back( make_pair( "avatar/avatarSkinV.glsl",                1 ) );
+    shaders.push_back( make_pair( "avatar/objectSkinV.glsl",                1 ) );
     shaders.push_back( make_pair( "deferred/textureUtilV.glsl",             1 ) );
-	if (gGLManager.mGLSLVersionMajor >= 2 || gGLManager.mGLSLVersionMinor >= 30)
-	{
-		shaders.push_back( make_pair( "objects/indexedTextureV.glsl",           1 ) );
-	}
-	shaders.push_back( make_pair( "objects/nonindexedTextureV.glsl",        1 ) );
+    if (gGLManager.mGLSLVersionMajor >= 2 || gGLManager.mGLSLVersionMinor >= 30)
+    {
+        shaders.push_back( make_pair( "objects/indexedTextureV.glsl",           1 ) );
+    }
+    shaders.push_back( make_pair( "objects/nonindexedTextureV.glsl",        1 ) );
 
-	std::map<std::string, std::string> attribs;
-	attribs["MAX_JOINTS_PER_MESH_OBJECT"] = 
-		std::to_string(LLSkinningUtil::getMaxJointCount());
+    std::map<std::string, std::string> attribs;
+    attribs["MAX_JOINTS_PER_MESH_OBJECT"] =
+        std::to_string(LLSkinningUtil::getMaxJointCount());
 
     BOOL ssr = gSavedSettings.getBOOL("RenderScreenSpaceReflections");
 
-	bool has_reflection_probes = gSavedSettings.getBOOL("RenderReflectionsEnabled") && gGLManager.mGLVersion > 3.99f;
+    bool has_reflection_probes = gSavedSettings.getBOOL("RenderReflectionsEnabled") && gGLManager.mGLVersion > 3.99f;
 
-	S32 probe_level = llclamp(gSavedSettings.getS32("RenderReflectionProbeLevel"), 0, 3);
+    S32 probe_level = llclamp(gSavedSettings.getS32("RenderReflectionProbeLevel"), 0, 3);
 
     S32 shadow_detail            = gSavedSettings.getS32("RenderShadowDetail");
 
@@ -675,11 +675,11 @@ std::string LLViewerShaderMgr::loadBasicShaders()
         attribs["SSR"] = "1";
     }
 
-	if (has_reflection_probes)
-	{
+    if (has_reflection_probes)
+    {
         attribs["REFMAP_LEVEL"] = std::to_string(probe_level);
-		attribs["REF_SAMPLE_COUNT"] = "32";
-	}
+        attribs["REF_SAMPLE_COUNT"] = "32";
+    }
 
     { // PBR terrain
         const S32 mapping = clamp_terrain_mapping(gSavedSettings.getS32("RenderTerrainPBRPlanarSampleCount"));
@@ -691,94 +691,94 @@ std::string LLViewerShaderMgr::loadBasicShaders()
         attribs["TERRAIN_PBR_DETAIL"] = llformat("%d", detail);
     }
 
-	LLGLSLShader::sGlobalDefines = attribs;
+    LLGLSLShader::sGlobalDefines = attribs;
 
-	// We no longer have to bind the shaders to global glhandles, they are automatically added to a map now.
-	for (U32 i = 0; i < shaders.size(); i++)
-	{
-		// Note usage of GL_VERTEX_SHADER
-		if (loadShaderFile(shaders[i].first, shaders[i].second, GL_VERTEX_SHADER, &attribs) == 0)
-		{
-			LL_WARNS("Shader") << "Failed to load vertex shader " << shaders[i].first << LL_ENDL;
-			return shaders[i].first;
-		}
-	}
+    // We no longer have to bind the shaders to global glhandles, they are automatically added to a map now.
+    for (U32 i = 0; i < shaders.size(); i++)
+    {
+        // Note usage of GL_VERTEX_SHADER
+        if (loadShaderFile(shaders[i].first, shaders[i].second, GL_VERTEX_SHADER, &attribs) == 0)
+        {
+            LL_WARNS("Shader") << "Failed to load vertex shader " << shaders[i].first << LL_ENDL;
+            return shaders[i].first;
+        }
+    }
 
-	// Load the Basic Fragment Shaders at the appropriate level. 
-	// (in order of shader function call depth for reference purposes, deepest level first)
+    // Load the Basic Fragment Shaders at the appropriate level.
+    // (in order of shader function call depth for reference purposes, deepest level first)
 
-	shaders.clear();
-	S32 ch = 1;
+    shaders.clear();
+    S32 ch = 1;
 
-	if (gGLManager.mGLSLVersionMajor > 1 || gGLManager.mGLSLVersionMinor >= 30)
-	{ //use indexed texture rendering for GLSL >= 1.30
-		ch = llmax(LLGLSLShader::sIndexedTextureChannels, 1);
-	}
+    if (gGLManager.mGLSLVersionMajor > 1 || gGLManager.mGLSLVersionMinor >= 30)
+    { //use indexed texture rendering for GLSL >= 1.30
+        ch = llmax(LLGLSLShader::sIndexedTextureChannels, 1);
+    }
 
 
-	std::vector<S32> index_channels;    
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsVarsF.glsl",      mShaderLevel[SHADER_WINDLIGHT] ) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsHelpersF.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/gammaF.glsl",                 mShaderLevel[SHADER_WINDLIGHT]) );
+    std::vector<S32> index_channels;
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsVarsF.glsl",      mShaderLevel[SHADER_WINDLIGHT] ) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsHelpersF.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/gammaF.glsl",                 mShaderLevel[SHADER_WINDLIGHT]) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsFuncs.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsF.glsl",          mShaderLevel[SHADER_WINDLIGHT] ) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "environment/waterFogF.glsl",                mShaderLevel[SHADER_WATER] ) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "environment/srgbF.glsl",                    mShaderLevel[SHADER_ENVIRONMENT] ) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/deferredUtil.glsl",                    1) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsF.glsl",          mShaderLevel[SHADER_WINDLIGHT] ) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "environment/waterFogF.glsl",                mShaderLevel[SHADER_WATER] ) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "environment/srgbF.glsl",                    mShaderLevel[SHADER_ENVIRONMENT] ) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/deferredUtil.glsl",                    1) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/globalF.glsl",                          1));
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/shadowUtil.glsl",                      1) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/aoUtil.glsl",                          1) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/pbrterrainUtilF.glsl",                 1) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/shadowUtil.glsl",                      1) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/aoUtil.glsl",                          1) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/pbrterrainUtilF.glsl",                 1) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/reflectionProbeF.glsl",                has_reflection_probes ? 3 : 2) );
     index_channels.push_back(-1);    shaders.push_back( make_pair( "deferred/screenSpaceReflUtil.glsl",             ssr ? 3 : 1) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "lighting/lightNonIndexedF.glsl",                    mShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);    shaders.push_back( make_pair( "lighting/lightAlphaMaskNonIndexedF.glsl",                   mShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightF.glsl",                  mShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightAlphaMaskF.glsl",                 mShaderLevel[SHADER_LIGHTING] ) );
-	
-	for (U32 i = 0; i < shaders.size(); i++)
-	{
-		// Note usage of GL_FRAGMENT_SHADER
-		if (loadShaderFile(shaders[i].first, shaders[i].second, GL_FRAGMENT_SHADER, &attribs, index_channels[i]) == 0)
-		{
-			LL_WARNS("Shader") << "Failed to load fragment shader " << shaders[i].first << LL_ENDL;
-			return shaders[i].first;
-		}
-	}
-
-	return std::string();
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "lighting/lightNonIndexedF.glsl",                    mShaderLevel[SHADER_LIGHTING] ) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "lighting/lightAlphaMaskNonIndexedF.glsl",                   mShaderLevel[SHADER_LIGHTING] ) );
+    index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightF.glsl",                  mShaderLevel[SHADER_LIGHTING] ) );
+    index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightAlphaMaskF.glsl",                 mShaderLevel[SHADER_LIGHTING] ) );
+
+    for (U32 i = 0; i < shaders.size(); i++)
+    {
+        // Note usage of GL_FRAGMENT_SHADER
+        if (loadShaderFile(shaders[i].first, shaders[i].second, GL_FRAGMENT_SHADER, &attribs, index_channels[i]) == 0)
+        {
+            LL_WARNS("Shader") << "Failed to load fragment shader " << shaders[i].first << LL_ENDL;
+            return shaders[i].first;
+        }
+    }
+
+    return std::string();
 }
 
 BOOL LLViewerShaderMgr::loadShadersWater()
 {
     LL_PROFILE_ZONE_SCOPED;
-	BOOL success = TRUE;
-	BOOL terrainWaterSuccess = TRUE;
-    
+    BOOL success = TRUE;
+    BOOL terrainWaterSuccess = TRUE;
+
     bool use_sun_shadow = mShaderLevel[SHADER_DEFERRED] > 1 &&
         gSavedSettings.getS32("RenderShadowDetail") > 0;
 
-	if (mShaderLevel[SHADER_WATER] == 0)
-	{
-		gWaterProgram.unload();
-		gWaterEdgeProgram.unload();
-		gUnderWaterProgram.unload();
-		return TRUE;
-	}
-
-	if (success)
-	{
-		// load water shader
-		gWaterProgram.mName = "Water Shader";
-		gWaterProgram.mFeatures.calculatesAtmospherics = true;
+    if (mShaderLevel[SHADER_WATER] == 0)
+    {
+        gWaterProgram.unload();
+        gWaterEdgeProgram.unload();
+        gUnderWaterProgram.unload();
+        return TRUE;
+    }
+
+    if (success)
+    {
+        // load water shader
+        gWaterProgram.mName = "Water Shader";
+        gWaterProgram.mFeatures.calculatesAtmospherics = true;
         gWaterProgram.mFeatures.hasAtmospherics = true;
-		gWaterProgram.mFeatures.hasGamma = true;
-		gWaterProgram.mFeatures.hasSrgb = true;
+        gWaterProgram.mFeatures.hasGamma = true;
+        gWaterProgram.mFeatures.hasSrgb = true;
         gWaterProgram.mFeatures.hasReflectionProbes = true;
         gWaterProgram.mFeatures.hasShadows = use_sun_shadow;
-		gWaterProgram.mShaderFiles.clear();
-		gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
-		gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER));
+        gWaterProgram.mShaderFiles.clear();
+        gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
+        gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER));
         gWaterProgram.clearPermutations();
         if (LLPipeline::sRenderTransparentWater)
         {
@@ -790,27 +790,27 @@ BOOL LLViewerShaderMgr::loadShadersWater()
             gWaterProgram.addPermutation("HAS_SUN_SHADOW", "1");
         }
 
-		gWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		gWaterProgram.mShaderLevel = mShaderLevel[SHADER_WATER];
-		success = gWaterProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-	// load water shader
-		gWaterEdgeProgram.mName = "Water Edge Shader";
-		gWaterEdgeProgram.mFeatures.calculatesAtmospherics = true;
+        gWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
+        gWaterProgram.mShaderLevel = mShaderLevel[SHADER_WATER];
+        success = gWaterProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+    // load water shader
+        gWaterEdgeProgram.mName = "Water Edge Shader";
+        gWaterEdgeProgram.mFeatures.calculatesAtmospherics = true;
         gWaterEdgeProgram.mFeatures.hasAtmospherics = true;
-		gWaterEdgeProgram.mFeatures.hasGamma = true;
-		gWaterEdgeProgram.mFeatures.hasSrgb = true;
+        gWaterEdgeProgram.mFeatures.hasGamma = true;
+        gWaterEdgeProgram.mFeatures.hasSrgb = true;
         gWaterEdgeProgram.mFeatures.hasReflectionProbes = true;
         gWaterEdgeProgram.mFeatures.hasShadows = use_sun_shadow;
-		gWaterEdgeProgram.mShaderFiles.clear();
-		gWaterEdgeProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
-		gWaterEdgeProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER));
+        gWaterEdgeProgram.mShaderFiles.clear();
+        gWaterEdgeProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
+        gWaterEdgeProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER));
         gWaterEdgeProgram.clearPermutations();
-		gWaterEdgeProgram.addPermutation("WATER_EDGE", "1");
+        gWaterEdgeProgram.addPermutation("WATER_EDGE", "1");
         if (LLPipeline::sRenderTransparentWater)
         {
             gWaterEdgeProgram.addPermutation("TRANSPARENT_WATER", "1");
@@ -820,54 +820,54 @@ BOOL LLViewerShaderMgr::loadShadersWater()
         {
             gWaterEdgeProgram.addPermutation("HAS_SUN_SHADOW", "1");
         }
-		gWaterEdgeProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		gWaterEdgeProgram.mShaderLevel = mShaderLevel[SHADER_WATER];
-		success = gWaterEdgeProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		//load under water vertex shader
-		gUnderWaterProgram.mName = "Underwater Shader";
-		gUnderWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gUnderWaterProgram.mFeatures.hasAtmospherics = true;
-		gUnderWaterProgram.mShaderFiles.clear();
-		gUnderWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
-		gUnderWaterProgram.mShaderFiles.push_back(make_pair("environment/underWaterF.glsl", GL_FRAGMENT_SHADER));
-		gUnderWaterProgram.mShaderLevel = mShaderLevel[SHADER_WATER];        
-		gUnderWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;       
+        gWaterEdgeProgram.mShaderGroup = LLGLSLShader::SG_WATER;
+        gWaterEdgeProgram.mShaderLevel = mShaderLevel[SHADER_WATER];
+        success = gWaterEdgeProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        //load under water vertex shader
+        gUnderWaterProgram.mName = "Underwater Shader";
+        gUnderWaterProgram.mFeatures.calculatesAtmospherics = true;
+        gUnderWaterProgram.mFeatures.hasAtmospherics = true;
+        gUnderWaterProgram.mShaderFiles.clear();
+        gUnderWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
+        gUnderWaterProgram.mShaderFiles.push_back(make_pair("environment/underWaterF.glsl", GL_FRAGMENT_SHADER));
+        gUnderWaterProgram.mShaderLevel = mShaderLevel[SHADER_WATER];
+        gUnderWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
         gUnderWaterProgram.clearPermutations();
         if (LLPipeline::sRenderTransparentWater)
         {
             gUnderWaterProgram.addPermutation("TRANSPARENT_WATER", "1");
         }
-		success = gUnderWaterProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	/// Keep track of water shader levels
-	if (gWaterProgram.mShaderLevel != mShaderLevel[SHADER_WATER]
-		|| gUnderWaterProgram.mShaderLevel != mShaderLevel[SHADER_WATER])
-	{
-		mShaderLevel[SHADER_WATER] = llmin(gWaterProgram.mShaderLevel, gUnderWaterProgram.mShaderLevel);
-	}
-
-	if (!success)
-	{
-		mShaderLevel[SHADER_WATER] = 0;
-		return FALSE;
-	}
-
-	// if we failed to load the terrain water shaders and we need them (using class2 water),
-	// then drop down to class1 water.
-	if (mShaderLevel[SHADER_WATER] > 1 && !terrainWaterSuccess)
-	{
-		mShaderLevel[SHADER_WATER]--;
-		return loadShadersWater();
-	}
-	
-	LLWorld::getInstance()->updateWaterObjects();
+        success = gUnderWaterProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    /// Keep track of water shader levels
+    if (gWaterProgram.mShaderLevel != mShaderLevel[SHADER_WATER]
+        || gUnderWaterProgram.mShaderLevel != mShaderLevel[SHADER_WATER])
+    {
+        mShaderLevel[SHADER_WATER] = llmin(gWaterProgram.mShaderLevel, gUnderWaterProgram.mShaderLevel);
+    }
+
+    if (!success)
+    {
+        mShaderLevel[SHADER_WATER] = 0;
+        return FALSE;
+    }
+
+    // if we failed to load the terrain water shaders and we need them (using class2 water),
+    // then drop down to class1 water.
+    if (mShaderLevel[SHADER_WATER] > 1 && !terrainWaterSuccess)
+    {
+        mShaderLevel[SHADER_WATER]--;
+        return loadShadersWater();
+    }
+
+    LLWorld::getInstance()->updateWaterObjects();
 
     return TRUE;
 }
@@ -875,146 +875,146 @@ BOOL LLViewerShaderMgr::loadShadersWater()
 BOOL LLViewerShaderMgr::loadShadersEffects()
 {
     LL_PROFILE_ZONE_SCOPED;
-	BOOL success = TRUE;
-
-	if (mShaderLevel[SHADER_EFFECT] == 0)
-	{
-		gGlowProgram.unload();
-		gGlowExtractProgram.unload();
-		return TRUE;
-	}
-
-	if (success)
-	{
-		gGlowProgram.mName = "Glow Shader (Post)";
-		gGlowProgram.mShaderFiles.clear();
-		gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowV.glsl", GL_VERTEX_SHADER));
-		gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowF.glsl", GL_FRAGMENT_SHADER));
-		gGlowProgram.mShaderLevel = mShaderLevel[SHADER_EFFECT];
-		success = gGlowProgram.createShader(NULL, NULL);
-		if (!success)
-		{
-			LLPipeline::sRenderGlow = FALSE;
-		}
-	}
-	
-	if (success)
-	{
+    BOOL success = TRUE;
+
+    if (mShaderLevel[SHADER_EFFECT] == 0)
+    {
+        gGlowProgram.unload();
+        gGlowExtractProgram.unload();
+        return TRUE;
+    }
+
+    if (success)
+    {
+        gGlowProgram.mName = "Glow Shader (Post)";
+        gGlowProgram.mShaderFiles.clear();
+        gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowV.glsl", GL_VERTEX_SHADER));
+        gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowF.glsl", GL_FRAGMENT_SHADER));
+        gGlowProgram.mShaderLevel = mShaderLevel[SHADER_EFFECT];
+        success = gGlowProgram.createShader(NULL, NULL);
+        if (!success)
+        {
+            LLPipeline::sRenderGlow = FALSE;
+        }
+    }
+
+    if (success)
+    {
         const bool use_glow_noise = gSavedSettings.getBOOL("RenderGlowNoise");
         const std::string glow_noise_label = use_glow_noise ? " (+Noise)" : "";
 
-		gGlowExtractProgram.mName = llformat("Glow Extract Shader (Post)%s", glow_noise_label.c_str());
-		gGlowExtractProgram.mShaderFiles.clear();
-		gGlowExtractProgram.mShaderFiles.push_back(make_pair("effects/glowExtractV.glsl", GL_VERTEX_SHADER));
-		gGlowExtractProgram.mShaderFiles.push_back(make_pair("effects/glowExtractF.glsl", GL_FRAGMENT_SHADER));
-		gGlowExtractProgram.mShaderLevel = mShaderLevel[SHADER_EFFECT];
+        gGlowExtractProgram.mName = llformat("Glow Extract Shader (Post)%s", glow_noise_label.c_str());
+        gGlowExtractProgram.mShaderFiles.clear();
+        gGlowExtractProgram.mShaderFiles.push_back(make_pair("effects/glowExtractV.glsl", GL_VERTEX_SHADER));
+        gGlowExtractProgram.mShaderFiles.push_back(make_pair("effects/glowExtractF.glsl", GL_FRAGMENT_SHADER));
+        gGlowExtractProgram.mShaderLevel = mShaderLevel[SHADER_EFFECT];
 
         if (use_glow_noise)
         {
             gGlowExtractProgram.addPermutation("HAS_NOISE", "1");
         }
 
-		success = gGlowExtractProgram.createShader(NULL, NULL);
-		if (!success)
-		{
-			LLPipeline::sRenderGlow = FALSE;
-		}
-	}
-	
-	return success;
+        success = gGlowExtractProgram.createShader(NULL, NULL);
+        if (!success)
+        {
+            LLPipeline::sRenderGlow = FALSE;
+        }
+    }
+
+    return success;
 
 }
 
 BOOL LLViewerShaderMgr::loadShadersDeferred()
 {
     LL_PROFILE_ZONE_SCOPED;
-    bool use_sun_shadow = mShaderLevel[SHADER_DEFERRED] > 1 && 
+    bool use_sun_shadow = mShaderLevel[SHADER_DEFERRED] > 1 &&
         gSavedSettings.getS32("RenderShadowDetail") > 0;
 
-	if (mShaderLevel[SHADER_DEFERRED] == 0)
-	{
-		gDeferredTreeProgram.unload();
-		gDeferredTreeShadowProgram.unload();
+    if (mShaderLevel[SHADER_DEFERRED] == 0)
+    {
+        gDeferredTreeProgram.unload();
+        gDeferredTreeShadowProgram.unload();
         gDeferredSkinnedTreeShadowProgram.unload();
-		gDeferredDiffuseProgram.unload();
+        gDeferredDiffuseProgram.unload();
         gDeferredSkinnedDiffuseProgram.unload();
-		gDeferredDiffuseAlphaMaskProgram.unload();
+        gDeferredDiffuseAlphaMaskProgram.unload();
         gDeferredSkinnedDiffuseAlphaMaskProgram.unload();
-		gDeferredNonIndexedDiffuseAlphaMaskProgram.unload();
-		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.unload();
-		gDeferredBumpProgram.unload();
+        gDeferredNonIndexedDiffuseAlphaMaskProgram.unload();
+        gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.unload();
+        gDeferredBumpProgram.unload();
         gDeferredSkinnedBumpProgram.unload();
-		gDeferredImpostorProgram.unload();
-		gDeferredTerrainProgram.unload();
-		gDeferredLightProgram.unload();
-		for (U32 i = 0; i < LL_DEFERRED_MULTI_LIGHT_COUNT; ++i)
-		{
-			gDeferredMultiLightProgram[i].unload();
-		}
-		gDeferredSpotLightProgram.unload();
-		gDeferredMultiSpotLightProgram.unload();
-		gDeferredSunProgram.unload();
-		gDeferredBlurLightProgram.unload();
-		gDeferredSoftenProgram.unload();
-		gDeferredShadowProgram.unload();
+        gDeferredImpostorProgram.unload();
+        gDeferredTerrainProgram.unload();
+        gDeferredLightProgram.unload();
+        for (U32 i = 0; i < LL_DEFERRED_MULTI_LIGHT_COUNT; ++i)
+        {
+            gDeferredMultiLightProgram[i].unload();
+        }
+        gDeferredSpotLightProgram.unload();
+        gDeferredMultiSpotLightProgram.unload();
+        gDeferredSunProgram.unload();
+        gDeferredBlurLightProgram.unload();
+        gDeferredSoftenProgram.unload();
+        gDeferredShadowProgram.unload();
         gDeferredSkinnedShadowProgram.unload();
-		gDeferredShadowCubeProgram.unload();
+        gDeferredShadowCubeProgram.unload();
         gDeferredShadowAlphaMaskProgram.unload();
         gDeferredSkinnedShadowAlphaMaskProgram.unload();
         gDeferredShadowGLTFAlphaMaskProgram.unload();
         gDeferredSkinnedShadowGLTFAlphaMaskProgram.unload();
         gDeferredShadowFullbrightAlphaMaskProgram.unload();
         gDeferredSkinnedShadowFullbrightAlphaMaskProgram.unload();
-		gDeferredAvatarShadowProgram.unload();
+        gDeferredAvatarShadowProgram.unload();
         gDeferredAvatarAlphaShadowProgram.unload();
         gDeferredAvatarAlphaMaskShadowProgram.unload();
-		gDeferredAvatarProgram.unload();
-		gDeferredAvatarAlphaProgram.unload();
-		gDeferredAlphaProgram.unload();
+        gDeferredAvatarProgram.unload();
+        gDeferredAvatarAlphaProgram.unload();
+        gDeferredAlphaProgram.unload();
         gHUDAlphaProgram.unload();
         gDeferredSkinnedAlphaProgram.unload();
-		gDeferredFullbrightProgram.unload();
+        gDeferredFullbrightProgram.unload();
         gHUDFullbrightProgram.unload();
-		gDeferredFullbrightAlphaMaskProgram.unload();
+        gDeferredFullbrightAlphaMaskProgram.unload();
         gHUDFullbrightAlphaMaskProgram.unload();
         gDeferredFullbrightAlphaMaskAlphaProgram.unload();
         gHUDFullbrightAlphaMaskAlphaProgram.unload();
-		gDeferredEmissiveProgram.unload();
+        gDeferredEmissiveProgram.unload();
         gDeferredSkinnedEmissiveProgram.unload();
-		gDeferredAvatarEyesProgram.unload();
-		gDeferredPostProgram.unload();		
-		gDeferredCoFProgram.unload();		
-		gDeferredDoFCombineProgram.unload();
+        gDeferredAvatarEyesProgram.unload();
+        gDeferredPostProgram.unload();
+        gDeferredCoFProgram.unload();
+        gDeferredDoFCombineProgram.unload();
         gExposureProgram.unload();
         gExposureProgramNoFade.unload();
         gLuminanceProgram.unload();
-		gDeferredPostGammaCorrectProgram.unload();
+        gDeferredPostGammaCorrectProgram.unload();
         gNoPostGammaCorrectProgram.unload();
         gLegacyPostGammaCorrectProgram.unload();
-		gFXAAProgram.unload();
+        gFXAAProgram.unload();
         gEnvironmentMapProgram.unload();
-		gDeferredWLSkyProgram.unload();
-		gDeferredWLCloudProgram.unload();
+        gDeferredWLSkyProgram.unload();
+        gDeferredWLCloudProgram.unload();
         gDeferredWLSunProgram.unload();
         gDeferredWLMoonProgram.unload();
-		gDeferredStarProgram.unload();
-		gDeferredFullbrightShinyProgram.unload();
+        gDeferredStarProgram.unload();
+        gDeferredFullbrightShinyProgram.unload();
         gHUDFullbrightShinyProgram.unload();
         gDeferredSkinnedFullbrightShinyProgram.unload();
-		gDeferredSkinnedFullbrightProgram.unload();
+        gDeferredSkinnedFullbrightProgram.unload();
         gDeferredSkinnedFullbrightAlphaMaskProgram.unload();
         gDeferredSkinnedFullbrightAlphaMaskAlphaProgram.unload();
 
         gDeferredHighlightProgram.unload();
-        
-		gNormalMapGenProgram.unload();
+
+        gNormalMapGenProgram.unload();
         gDeferredGenBrdfLutProgram.unload();
-		gDeferredBufferVisualProgram.unload();
+        gDeferredBufferVisualProgram.unload();
 
-		for (U32 i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
-		{
-			gDeferredMaterialProgram[i].unload();
-		}
+        for (U32 i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
+        {
+            gDeferredMaterialProgram[i].unload();
+        }
 
         gHUDPBROpaqueProgram.unload();
         gPBRGlowProgram.unload();
@@ -1022,95 +1022,95 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredSkinnedPBROpaqueProgram.unload();
         gDeferredPBRAlphaProgram.unload();
         gDeferredSkinnedPBRAlphaProgram.unload();
-		gDeferredPBRTerrainProgram.unload();
+        gDeferredPBRTerrainProgram.unload();
 
-		return TRUE;
-	}
+        return TRUE;
+    }
 
-	BOOL success = TRUE;
+    BOOL success = TRUE;
 
     if (success)
-	{
-		gDeferredHighlightProgram.mName = "Deferred Highlight Shader";
-		gDeferredHighlightProgram.mShaderFiles.clear();
-		gDeferredHighlightProgram.mShaderFiles.push_back(make_pair("interface/highlightV.glsl", GL_VERTEX_SHADER));
-		gDeferredHighlightProgram.mShaderFiles.push_back(make_pair("deferred/highlightF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredHighlightProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];		
-		success = gDeferredHighlightProgram.createShader(NULL, NULL);
-	}
+    {
+        gDeferredHighlightProgram.mName = "Deferred Highlight Shader";
+        gDeferredHighlightProgram.mShaderFiles.clear();
+        gDeferredHighlightProgram.mShaderFiles.push_back(make_pair("interface/highlightV.glsl", GL_VERTEX_SHADER));
+        gDeferredHighlightProgram.mShaderFiles.push_back(make_pair("deferred/highlightF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredHighlightProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gDeferredHighlightProgram.createShader(NULL, NULL);
+    }
 
-	if (success)
-	{
-		gDeferredDiffuseProgram.mName = "Deferred Diffuse Shader";
+    if (success)
+    {
+        gDeferredDiffuseProgram.mName = "Deferred Diffuse Shader";
         gDeferredDiffuseProgram.mFeatures.hasSrgb = true;
-		gDeferredDiffuseProgram.mShaderFiles.clear();
-		gDeferredDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
-		gDeferredDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseIndexedF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredDiffuseProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-		gDeferredDiffuseProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredDiffuseProgram.mShaderFiles.clear();
+        gDeferredDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
+        gDeferredDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseIndexedF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredDiffuseProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+        gDeferredDiffuseProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = make_rigged_variant(gDeferredDiffuseProgram, gDeferredSkinnedDiffuseProgram);
-		success = success && gDeferredDiffuseProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gDeferredDiffuseAlphaMaskProgram.mName = "Deferred Diffuse Alpha Mask Shader";
-		gDeferredDiffuseAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredDiffuseAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
-		gDeferredDiffuseAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/diffuseAlphaMaskIndexedF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredDiffuseAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-		gDeferredDiffuseAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = success && gDeferredDiffuseProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gDeferredDiffuseAlphaMaskProgram.mName = "Deferred Diffuse Alpha Mask Shader";
+        gDeferredDiffuseAlphaMaskProgram.mShaderFiles.clear();
+        gDeferredDiffuseAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
+        gDeferredDiffuseAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/diffuseAlphaMaskIndexedF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredDiffuseAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+        gDeferredDiffuseAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = make_rigged_variant(gDeferredDiffuseAlphaMaskProgram, gDeferredSkinnedDiffuseAlphaMaskProgram);
-		success = success && gDeferredDiffuseAlphaMaskProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gDeferredNonIndexedDiffuseAlphaMaskProgram.mName = "Deferred Diffuse Non-Indexed Alpha Mask Shader";
-		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
-		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/diffuseAlphaMaskF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredNonIndexedDiffuseAlphaMaskProgram.createShader(NULL, NULL);
+        success = success && gDeferredDiffuseAlphaMaskProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gDeferredNonIndexedDiffuseAlphaMaskProgram.mName = "Deferred Diffuse Non-Indexed Alpha Mask Shader";
+        gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.clear();
+        gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
+        gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/diffuseAlphaMaskF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredNonIndexedDiffuseAlphaMaskProgram.createShader(NULL, NULL);
         llassert(success);
-	}
-    
-	if (success)
-	{
-		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mName = "Deferred Diffuse Non-Indexed Alpha Mask No Color Shader";
-		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.clear();
-		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.push_back(make_pair("deferred/diffuseNoColorV.glsl", GL_VERTEX_SHADER));
-		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.push_back(make_pair("deferred/diffuseAlphaMaskNoColorF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredBumpProgram.mName = "Deferred Bump Shader";
-		gDeferredBumpProgram.mShaderFiles.clear();
-		gDeferredBumpProgram.mShaderFiles.push_back(make_pair("deferred/bumpV.glsl", GL_VERTEX_SHADER));
-		gDeferredBumpProgram.mShaderFiles.push_back(make_pair("deferred/bumpF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredBumpProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+    }
+
+    if (success)
+    {
+        gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mName = "Deferred Diffuse Non-Indexed Alpha Mask No Color Shader";
+        gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.clear();
+        gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.push_back(make_pair("deferred/diffuseNoColorV.glsl", GL_VERTEX_SHADER));
+        gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.push_back(make_pair("deferred/diffuseAlphaMaskNoColorF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredBumpProgram.mName = "Deferred Bump Shader";
+        gDeferredBumpProgram.mShaderFiles.clear();
+        gDeferredBumpProgram.mShaderFiles.push_back(make_pair("deferred/bumpV.glsl", GL_VERTEX_SHADER));
+        gDeferredBumpProgram.mShaderFiles.push_back(make_pair("deferred/bumpF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredBumpProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = make_rigged_variant(gDeferredBumpProgram, gDeferredSkinnedBumpProgram);
-		success = success && gDeferredBumpProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	gDeferredMaterialProgram[1].mFeatures.hasLighting = false;
-	gDeferredMaterialProgram[5].mFeatures.hasLighting = false;
-	gDeferredMaterialProgram[9].mFeatures.hasLighting = false;
-	gDeferredMaterialProgram[13].mFeatures.hasLighting = false;
-	gDeferredMaterialProgram[1+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
-	gDeferredMaterialProgram[5+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
-	gDeferredMaterialProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
-	gDeferredMaterialProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
-
-	for (U32 i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
-	{
-		if (success)
-		{
+        success = success && gDeferredBumpProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    gDeferredMaterialProgram[1].mFeatures.hasLighting = false;
+    gDeferredMaterialProgram[5].mFeatures.hasLighting = false;
+    gDeferredMaterialProgram[9].mFeatures.hasLighting = false;
+    gDeferredMaterialProgram[13].mFeatures.hasLighting = false;
+    gDeferredMaterialProgram[1+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
+    gDeferredMaterialProgram[5+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
+    gDeferredMaterialProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
+    gDeferredMaterialProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
+
+    for (U32 i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
+    {
+        if (success)
+        {
             bool has_skin = i & 0x10;
 
             if (!has_skin)
@@ -1122,28 +1122,28 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
             {
                 gDeferredMaterialProgram[i].mName = llformat("Skinned Material Shader %d", i);
             }
-			
-			U32 alpha_mode = i & 0x3;
 
-			gDeferredMaterialProgram[i].mShaderFiles.clear();
-			gDeferredMaterialProgram[i].mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER));
-			gDeferredMaterialProgram[i].mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER));
-			gDeferredMaterialProgram[i].mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+            U32 alpha_mode = i & 0x3;
 
-			gDeferredMaterialProgram[i].clearPermutations();
+            gDeferredMaterialProgram[i].mShaderFiles.clear();
+            gDeferredMaterialProgram[i].mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER));
+            gDeferredMaterialProgram[i].mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER));
+            gDeferredMaterialProgram[i].mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
-			bool has_normal_map   = (i & 0x8) > 0;
-			bool has_specular_map = (i & 0x4) > 0;
+            gDeferredMaterialProgram[i].clearPermutations();
 
-			if (has_normal_map)
-			{
-				gDeferredMaterialProgram[i].addPermutation("HAS_NORMAL_MAP", "1");
-			}
+            bool has_normal_map   = (i & 0x8) > 0;
+            bool has_specular_map = (i & 0x4) > 0;
 
-			if (has_specular_map)
-			{
-				gDeferredMaterialProgram[i].addPermutation("HAS_SPECULAR_MAP", "1");
-			}
+            if (has_normal_map)
+            {
+                gDeferredMaterialProgram[i].addPermutation("HAS_NORMAL_MAP", "1");
+            }
+
+            if (has_specular_map)
+            {
+                gDeferredMaterialProgram[i].addPermutation("HAS_SPECULAR_MAP", "1");
+            }
 
             gDeferredMaterialProgram[i].addPermutation("DIFFUSE_ALPHA_MODE", llformat("%d", alpha_mode));
 
@@ -1158,7 +1158,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
                 gDeferredMaterialProgram[i].addPermutation("HAS_SUN_SHADOW", "1");
             }
 
-            
+
             gDeferredMaterialProgram[i].mFeatures.hasSrgb = true;
             gDeferredMaterialProgram[i].mFeatures.calculatesAtmospherics = true;
             gDeferredMaterialProgram[i].mFeatures.hasAtmospherics = true;
@@ -1178,17 +1178,17 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 
             success = gDeferredMaterialProgram[i].createShader(NULL, NULL);
             llassert(success);
-		}
-	}
+        }
+    }
 
-	gDeferredMaterialProgram[1].mFeatures.hasLighting = true;
-	gDeferredMaterialProgram[5].mFeatures.hasLighting = true;
-	gDeferredMaterialProgram[9].mFeatures.hasLighting = true;
-	gDeferredMaterialProgram[13].mFeatures.hasLighting = true;
-	gDeferredMaterialProgram[1+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
-	gDeferredMaterialProgram[5+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
-	gDeferredMaterialProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
-	gDeferredMaterialProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
+    gDeferredMaterialProgram[1].mFeatures.hasLighting = true;
+    gDeferredMaterialProgram[5].mFeatures.hasLighting = true;
+    gDeferredMaterialProgram[9].mFeatures.hasLighting = true;
+    gDeferredMaterialProgram[13].mFeatures.hasLighting = true;
+    gDeferredMaterialProgram[1+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
+    gDeferredMaterialProgram[5+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
+    gDeferredMaterialProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
+    gDeferredMaterialProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
 
     if (success)
     {
@@ -1200,7 +1200,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredPBROpaqueProgram.mShaderFiles.push_back(make_pair("deferred/pbropaqueF.glsl", GL_FRAGMENT_SHADER));
         gDeferredPBROpaqueProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         gDeferredPBROpaqueProgram.clearPermutations();
-        
+
         success = make_rigged_variant(gDeferredPBROpaqueProgram, gDeferredSkinnedPBROpaqueProgram);
         if (success)
         {
@@ -1238,17 +1238,17 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gHUDPBROpaqueProgram.addPermutation("IS_HUD", "1");
 
         success = gHUDPBROpaqueProgram.createShader(NULL, NULL);
- 
+
         llassert(success);
     }
 
-    
 
-	if (success)
-	{
+
+    if (success)
+    {
         LLGLSLShader* shader = &gDeferredPBRAlphaProgram;
         shader->mName = "Deferred PBR Alpha Shader";
-                          
+
         shader->mFeatures.calculatesLighting = false;
         shader->mFeatures.hasLighting = false;
         shader->mFeatures.isAlphaLighting = true;
@@ -1301,7 +1301,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         shader->mName = "HUD PBR Alpha Shader";
 
         shader->mFeatures.hasSrgb = true;
-        
+
         shader->mShaderFiles.clear();
         shader->mShaderFiles.push_back(make_pair("deferred/pbralphaV.glsl", GL_VERTEX_SHADER));
         shader->mShaderFiles.push_back(make_pair("deferred/pbralphaF.glsl", GL_FRAGMENT_SHADER));
@@ -1315,8 +1315,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
+    if (success)
+    {
         S32 detail = gSavedSettings.getS32("RenderTerrainPBRDetail");
         detail = llclamp(detail, TERRAIN_PBR_DETAIL_MIN, TERRAIN_PBR_DETAIL_MAX);
         const S32 mapping = clamp_terrain_mapping(gSavedSettings.getS32("RenderTerrainPBRPlanarSampleCount"));
@@ -1340,29 +1340,29 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredPBRTerrainProgram.addPermutation("TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT", llformat("%d", mapping));
         success = gDeferredPBRTerrainProgram.createShader(NULL, NULL);
         llassert(success);
-	}
-	
-	if (success)
-	{
-		gDeferredTreeProgram.mName = "Deferred Tree Shader";
-		gDeferredTreeProgram.mShaderFiles.clear();
-		gDeferredTreeProgram.mShaderFiles.push_back(make_pair("deferred/treeV.glsl", GL_VERTEX_SHADER));
-		gDeferredTreeProgram.mShaderFiles.push_back(make_pair("deferred/treeF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredTreeProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredTreeProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gDeferredTreeShadowProgram.mName = "Deferred Tree Shadow Shader";
-		gDeferredTreeShadowProgram.mShaderFiles.clear();
-		gDeferredTreeShadowProgram.mShaderFiles.push_back(make_pair("deferred/treeShadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredTreeShadowProgram.mShaderFiles.push_back(make_pair("deferred/treeShadowF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredTreeShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+    }
+
+    if (success)
+    {
+        gDeferredTreeProgram.mName = "Deferred Tree Shader";
+        gDeferredTreeProgram.mShaderFiles.clear();
+        gDeferredTreeProgram.mShaderFiles.push_back(make_pair("deferred/treeV.glsl", GL_VERTEX_SHADER));
+        gDeferredTreeProgram.mShaderFiles.push_back(make_pair("deferred/treeF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredTreeProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredTreeProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gDeferredTreeShadowProgram.mName = "Deferred Tree Shadow Shader";
+        gDeferredTreeShadowProgram.mShaderFiles.clear();
+        gDeferredTreeShadowProgram.mShaderFiles.push_back(make_pair("deferred/treeShadowV.glsl", GL_VERTEX_SHADER));
+        gDeferredTreeShadowProgram.mShaderFiles.push_back(make_pair("deferred/treeShadowF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredTreeShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         gDeferredTreeShadowProgram.mRiggedVariant = &gDeferredSkinnedTreeShadowProgram;
-		success = gDeferredTreeShadowProgram.createShader(NULL, NULL);
+        success = gDeferredTreeShadowProgram.createShader(NULL, NULL);
         llassert(success);
-	}
+    }
 
     if (success)
     {
@@ -1376,96 +1376,96 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
-		gDeferredImpostorProgram.mName = "Deferred Impostor Shader";
-		gDeferredImpostorProgram.mFeatures.hasSrgb = true;
-		gDeferredImpostorProgram.mShaderFiles.clear();
-		gDeferredImpostorProgram.mShaderFiles.push_back(make_pair("deferred/impostorV.glsl", GL_VERTEX_SHADER));
+    if (success)
+    {
+        gDeferredImpostorProgram.mName = "Deferred Impostor Shader";
+        gDeferredImpostorProgram.mFeatures.hasSrgb = true;
+        gDeferredImpostorProgram.mShaderFiles.clear();
+        gDeferredImpostorProgram.mShaderFiles.push_back(make_pair("deferred/impostorV.glsl", GL_VERTEX_SHADER));
         gDeferredImpostorProgram.mShaderFiles.push_back(make_pair("deferred/impostorF.glsl", GL_FRAGMENT_SHADER));
         gDeferredImpostorProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = gDeferredImpostorProgram.createShader(NULL, NULL);
         llassert(success);
-	}
+    }
 
-	if (success)
-	{       
-		gDeferredLightProgram.mName = "Deferred Light Shader";
-		gDeferredLightProgram.mFeatures.isDeferred = true;
-		gDeferredLightProgram.mFeatures.hasShadows = true;
+    if (success)
+    {
+        gDeferredLightProgram.mName = "Deferred Light Shader";
+        gDeferredLightProgram.mFeatures.isDeferred = true;
+        gDeferredLightProgram.mFeatures.hasShadows = true;
         gDeferredLightProgram.mFeatures.hasSrgb = true;
 
-		gDeferredLightProgram.mShaderFiles.clear();
-		gDeferredLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER));
-		gDeferredLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredLightProgram.mShaderFiles.clear();
+        gDeferredLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER));
+        gDeferredLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
         gDeferredLightProgram.clearPermutations();
 
-		success = gDeferredLightProgram.createShader(NULL, NULL);
+        success = gDeferredLightProgram.createShader(NULL, NULL);
         llassert(success);
-	}
-
-	for (U32 i = 0; i < LL_DEFERRED_MULTI_LIGHT_COUNT; i++)
-	{
-		if (success)
-		{
-			gDeferredMultiLightProgram[i].mName = llformat("Deferred MultiLight Shader %d", i);
-			gDeferredMultiLightProgram[i].mFeatures.isDeferred = true;
-			gDeferredMultiLightProgram[i].mFeatures.hasShadows = true;
+    }
+
+    for (U32 i = 0; i < LL_DEFERRED_MULTI_LIGHT_COUNT; i++)
+    {
+        if (success)
+        {
+            gDeferredMultiLightProgram[i].mName = llformat("Deferred MultiLight Shader %d", i);
+            gDeferredMultiLightProgram[i].mFeatures.isDeferred = true;
+            gDeferredMultiLightProgram[i].mFeatures.hasShadows = true;
             gDeferredMultiLightProgram[i].mFeatures.hasSrgb = true;
 
             gDeferredMultiLightProgram[i].clearPermutations();
-			gDeferredMultiLightProgram[i].mShaderFiles.clear();
-			gDeferredMultiLightProgram[i].mShaderFiles.push_back(make_pair("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER));
-			gDeferredMultiLightProgram[i].mShaderFiles.push_back(make_pair("deferred/multiPointLightF.glsl", GL_FRAGMENT_SHADER));
-			gDeferredMultiLightProgram[i].mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-			gDeferredMultiLightProgram[i].addPermutation("LIGHT_COUNT", llformat("%d", i+1));
+            gDeferredMultiLightProgram[i].mShaderFiles.clear();
+            gDeferredMultiLightProgram[i].mShaderFiles.push_back(make_pair("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER));
+            gDeferredMultiLightProgram[i].mShaderFiles.push_back(make_pair("deferred/multiPointLightF.glsl", GL_FRAGMENT_SHADER));
+            gDeferredMultiLightProgram[i].mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+            gDeferredMultiLightProgram[i].addPermutation("LIGHT_COUNT", llformat("%d", i+1));
 
-			success = gDeferredMultiLightProgram[i].createShader(NULL, NULL);
+            success = gDeferredMultiLightProgram[i].createShader(NULL, NULL);
             llassert(success);
-		}
-	}
+        }
+    }
 
-	if (success)
-	{
-		gDeferredSpotLightProgram.mName = "Deferred SpotLight Shader";
-		gDeferredSpotLightProgram.mShaderFiles.clear();
-		gDeferredSpotLightProgram.mFeatures.hasSrgb = true;
-		gDeferredSpotLightProgram.mFeatures.isDeferred = true;
-		gDeferredSpotLightProgram.mFeatures.hasShadows = true;
+    if (success)
+    {
+        gDeferredSpotLightProgram.mName = "Deferred SpotLight Shader";
+        gDeferredSpotLightProgram.mShaderFiles.clear();
+        gDeferredSpotLightProgram.mFeatures.hasSrgb = true;
+        gDeferredSpotLightProgram.mFeatures.isDeferred = true;
+        gDeferredSpotLightProgram.mFeatures.hasShadows = true;
 
         gDeferredSpotLightProgram.clearPermutations();
-		gDeferredSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER));
-		gDeferredSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/spotLightF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredSpotLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER));
+        gDeferredSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/spotLightF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredSpotLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
-		success = gDeferredSpotLightProgram.createShader(NULL, NULL);
+        success = gDeferredSpotLightProgram.createShader(NULL, NULL);
         llassert(success);
-	}
+    }
 
-	if (success)
-	{
-		gDeferredMultiSpotLightProgram.mName = "Deferred MultiSpotLight Shader";
-		gDeferredMultiSpotLightProgram.mFeatures.hasSrgb = true;
-		gDeferredMultiSpotLightProgram.mFeatures.isDeferred = true;
-		gDeferredMultiSpotLightProgram.mFeatures.hasShadows = true;
+    if (success)
+    {
+        gDeferredMultiSpotLightProgram.mName = "Deferred MultiSpotLight Shader";
+        gDeferredMultiSpotLightProgram.mFeatures.hasSrgb = true;
+        gDeferredMultiSpotLightProgram.mFeatures.isDeferred = true;
+        gDeferredMultiSpotLightProgram.mFeatures.hasShadows = true;
 
         gDeferredMultiSpotLightProgram.clearPermutations();
         gDeferredMultiSpotLightProgram.addPermutation("MULTI_SPOTLIGHT", "1");
-		gDeferredMultiSpotLightProgram.mShaderFiles.clear();
-		gDeferredMultiSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER));
-		gDeferredMultiSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/spotLightF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredMultiSpotLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredMultiSpotLightProgram.mShaderFiles.clear();
+        gDeferredMultiSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER));
+        gDeferredMultiSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/spotLightF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredMultiSpotLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
-		success = gDeferredMultiSpotLightProgram.createShader(NULL, NULL);
+        success = gDeferredMultiSpotLightProgram.createShader(NULL, NULL);
         llassert(success);
-	}
+    }
 
-	if (success)
-	{
-		std::string fragment;
-		std::string vertex = "deferred/sunLightV.glsl";
+    if (success)
+    {
+        std::string fragment;
+        std::string vertex = "deferred/sunLightV.glsl";
 
         bool use_ao = gSavedSettings.getBOOL("RenderDeferredSSAO");
 
@@ -1488,30 +1488,30 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredSunProgram.mFeatures.hasAmbientOcclusion = use_ao;
 
         gDeferredSunProgram.mShaderFiles.clear();
-		gDeferredSunProgram.mShaderFiles.push_back(make_pair(vertex, GL_VERTEX_SHADER));
-		gDeferredSunProgram.mShaderFiles.push_back(make_pair(fragment, GL_FRAGMENT_SHADER));
-		gDeferredSunProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredSunProgram.mShaderFiles.push_back(make_pair(vertex, GL_VERTEX_SHADER));
+        gDeferredSunProgram.mShaderFiles.push_back(make_pair(fragment, GL_FRAGMENT_SHADER));
+        gDeferredSunProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
         success = gDeferredSunProgram.createShader(NULL, NULL);
         llassert(success);
-	}
+    }
 
-	if (success)
-	{
-		gDeferredBlurLightProgram.mName = "Deferred Blur Light Shader";
-		gDeferredBlurLightProgram.mFeatures.isDeferred = true;
+    if (success)
+    {
+        gDeferredBlurLightProgram.mName = "Deferred Blur Light Shader";
+        gDeferredBlurLightProgram.mFeatures.isDeferred = true;
 
-		gDeferredBlurLightProgram.mShaderFiles.clear();
-		gDeferredBlurLightProgram.mShaderFiles.push_back(make_pair("deferred/blurLightV.glsl", GL_VERTEX_SHADER));
-		gDeferredBlurLightProgram.mShaderFiles.push_back(make_pair("deferred/blurLightF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredBlurLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredBlurLightProgram.mShaderFiles.clear();
+        gDeferredBlurLightProgram.mShaderFiles.push_back(make_pair("deferred/blurLightV.glsl", GL_VERTEX_SHADER));
+        gDeferredBlurLightProgram.mShaderFiles.push_back(make_pair("deferred/blurLightF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredBlurLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
-		success = gDeferredBlurLightProgram.createShader(NULL, NULL);
+        success = gDeferredBlurLightProgram.createShader(NULL, NULL);
         llassert(success);
-	}
+    }
 
-	if (success)
-	{
+    if (success)
+    {
         for (int i = 0; i < 3 && success; ++i)
         {
             LLGLSLShader* shader = nullptr;
@@ -1584,9 +1584,9 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 
     if (success)
     {
-        LLGLSLShader* shaders[] = { 
-            &gDeferredAlphaImpostorProgram, 
-            &gDeferredSkinnedAlphaImpostorProgram 
+        LLGLSLShader* shaders[] = {
+            &gDeferredAlphaImpostorProgram,
+            &gDeferredSkinnedAlphaImpostorProgram
         };
 
         for (int i = 0; i < 2 && success; ++i)
@@ -1641,40 +1641,40 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         }
     }
 
-	if (success)
-	{
-		gDeferredAvatarEyesProgram.mName = "Deferred Avatar Eyes Shader";
-		gDeferredAvatarEyesProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredAvatarEyesProgram.mFeatures.hasGamma = true;
-		gDeferredAvatarEyesProgram.mFeatures.hasAtmospherics = true;
-		gDeferredAvatarEyesProgram.mFeatures.disableTextureIndex = true;
-		gDeferredAvatarEyesProgram.mFeatures.hasSrgb = true;
-		gDeferredAvatarEyesProgram.mFeatures.hasShadows = true;
-
-		gDeferredAvatarEyesProgram.mShaderFiles.clear();
-		gDeferredAvatarEyesProgram.mShaderFiles.push_back(make_pair("deferred/avatarEyesV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarEyesProgram.mShaderFiles.push_back(make_pair("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredAvatarEyesProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredAvatarEyesProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredFullbrightProgram.mName = "Deferred Fullbright Shader";
-		gDeferredFullbrightProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredFullbrightProgram.mFeatures.hasGamma = true;
-		gDeferredFullbrightProgram.mFeatures.hasAtmospherics = true;
-		gDeferredFullbrightProgram.mFeatures.hasSrgb = true;
-		gDeferredFullbrightProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-		gDeferredFullbrightProgram.mShaderFiles.clear();
-		gDeferredFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gDeferredFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredFullbrightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+    if (success)
+    {
+        gDeferredAvatarEyesProgram.mName = "Deferred Avatar Eyes Shader";
+        gDeferredAvatarEyesProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredAvatarEyesProgram.mFeatures.hasGamma = true;
+        gDeferredAvatarEyesProgram.mFeatures.hasAtmospherics = true;
+        gDeferredAvatarEyesProgram.mFeatures.disableTextureIndex = true;
+        gDeferredAvatarEyesProgram.mFeatures.hasSrgb = true;
+        gDeferredAvatarEyesProgram.mFeatures.hasShadows = true;
+
+        gDeferredAvatarEyesProgram.mShaderFiles.clear();
+        gDeferredAvatarEyesProgram.mShaderFiles.push_back(make_pair("deferred/avatarEyesV.glsl", GL_VERTEX_SHADER));
+        gDeferredAvatarEyesProgram.mShaderFiles.push_back(make_pair("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredAvatarEyesProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredAvatarEyesProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredFullbrightProgram.mName = "Deferred Fullbright Shader";
+        gDeferredFullbrightProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredFullbrightProgram.mFeatures.hasGamma = true;
+        gDeferredFullbrightProgram.mFeatures.hasAtmospherics = true;
+        gDeferredFullbrightProgram.mFeatures.hasSrgb = true;
+        gDeferredFullbrightProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+        gDeferredFullbrightProgram.mShaderFiles.clear();
+        gDeferredFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
+        gDeferredFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredFullbrightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = make_rigged_variant(gDeferredFullbrightProgram, gDeferredSkinnedFullbrightProgram);
-		success = gDeferredFullbrightProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
+        success = gDeferredFullbrightProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
 
     if (success)
     {
@@ -1694,24 +1694,24 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
-		gDeferredFullbrightAlphaMaskProgram.mName = "Deferred Fullbright Alpha Masking Shader";
-		gDeferredFullbrightAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredFullbrightAlphaMaskProgram.mFeatures.hasGamma = true;
-		gDeferredFullbrightAlphaMaskProgram.mFeatures.hasAtmospherics = true;
-		gDeferredFullbrightAlphaMaskProgram.mFeatures.hasSrgb = true;		
-		gDeferredFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+    if (success)
+    {
+        gDeferredFullbrightAlphaMaskProgram.mName = "Deferred Fullbright Alpha Masking Shader";
+        gDeferredFullbrightAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredFullbrightAlphaMaskProgram.mFeatures.hasGamma = true;
+        gDeferredFullbrightAlphaMaskProgram.mFeatures.hasAtmospherics = true;
+        gDeferredFullbrightAlphaMaskProgram.mFeatures.hasSrgb = true;
+        gDeferredFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+        gDeferredFullbrightAlphaMaskProgram.mShaderFiles.clear();
+        gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
+        gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
         gDeferredFullbrightAlphaMaskProgram.clearPermutations();
-		gDeferredFullbrightAlphaMaskProgram.addPermutation("HAS_ALPHA_MASK","1");
-		gDeferredFullbrightAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredFullbrightAlphaMaskProgram.addPermutation("HAS_ALPHA_MASK","1");
+        gDeferredFullbrightAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = make_rigged_variant(gDeferredFullbrightAlphaMaskProgram, gDeferredSkinnedFullbrightAlphaMaskProgram);
-		success = success && gDeferredFullbrightAlphaMaskProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
+        success = success && gDeferredFullbrightAlphaMaskProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
 
     if (success)
     {
@@ -1774,23 +1774,23 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
-		gDeferredFullbrightShinyProgram.mName = "Deferred FullbrightShiny Shader";
-		gDeferredFullbrightShinyProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredFullbrightShinyProgram.mFeatures.hasAtmospherics = true;
-		gDeferredFullbrightShinyProgram.mFeatures.hasGamma = true;
-		gDeferredFullbrightShinyProgram.mFeatures.hasSrgb = true;
-		gDeferredFullbrightShinyProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-		gDeferredFullbrightShinyProgram.mShaderFiles.clear();
-		gDeferredFullbrightShinyProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
-		gDeferredFullbrightShinyProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredFullbrightShinyProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+    if (success)
+    {
+        gDeferredFullbrightShinyProgram.mName = "Deferred FullbrightShiny Shader";
+        gDeferredFullbrightShinyProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredFullbrightShinyProgram.mFeatures.hasAtmospherics = true;
+        gDeferredFullbrightShinyProgram.mFeatures.hasGamma = true;
+        gDeferredFullbrightShinyProgram.mFeatures.hasSrgb = true;
+        gDeferredFullbrightShinyProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+        gDeferredFullbrightShinyProgram.mShaderFiles.clear();
+        gDeferredFullbrightShinyProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
+        gDeferredFullbrightShinyProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredFullbrightShinyProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         gDeferredFullbrightShinyProgram.mFeatures.hasReflectionProbes = true;
         success = make_rigged_variant(gDeferredFullbrightShinyProgram, gDeferredSkinnedFullbrightShinyProgram);
-		success = success && gDeferredFullbrightShinyProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
+        success = success && gDeferredFullbrightShinyProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
 
     if (success)
     {
@@ -1811,54 +1811,54 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
-		gDeferredEmissiveProgram.mName = "Deferred Emissive Shader";
-		gDeferredEmissiveProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredEmissiveProgram.mFeatures.hasGamma = true;
-		gDeferredEmissiveProgram.mFeatures.hasAtmospherics = true;
-		gDeferredEmissiveProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-		gDeferredEmissiveProgram.mShaderFiles.clear();
-		gDeferredEmissiveProgram.mShaderFiles.push_back(make_pair("deferred/emissiveV.glsl", GL_VERTEX_SHADER));
-		gDeferredEmissiveProgram.mShaderFiles.push_back(make_pair("deferred/emissiveF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredEmissiveProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+    if (success)
+    {
+        gDeferredEmissiveProgram.mName = "Deferred Emissive Shader";
+        gDeferredEmissiveProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredEmissiveProgram.mFeatures.hasGamma = true;
+        gDeferredEmissiveProgram.mFeatures.hasAtmospherics = true;
+        gDeferredEmissiveProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+        gDeferredEmissiveProgram.mShaderFiles.clear();
+        gDeferredEmissiveProgram.mShaderFiles.push_back(make_pair("deferred/emissiveV.glsl", GL_VERTEX_SHADER));
+        gDeferredEmissiveProgram.mShaderFiles.push_back(make_pair("deferred/emissiveF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredEmissiveProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = make_rigged_variant(gDeferredEmissiveProgram, gDeferredSkinnedEmissiveProgram);
-		success = success && gDeferredEmissiveProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredSoftenProgram.mName = "Deferred Soften Shader";
-		gDeferredSoftenProgram.mShaderFiles.clear();
-		gDeferredSoftenProgram.mFeatures.hasSrgb = true;
-		gDeferredSoftenProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredSoftenProgram.mFeatures.hasAtmospherics = true;
-		gDeferredSoftenProgram.mFeatures.hasGamma = true;
-		gDeferredSoftenProgram.mFeatures.isDeferred = true;
-		gDeferredSoftenProgram.mFeatures.hasShadows = use_sun_shadow;
+        success = success && gDeferredEmissiveProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredSoftenProgram.mName = "Deferred Soften Shader";
+        gDeferredSoftenProgram.mShaderFiles.clear();
+        gDeferredSoftenProgram.mFeatures.hasSrgb = true;
+        gDeferredSoftenProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredSoftenProgram.mFeatures.hasAtmospherics = true;
+        gDeferredSoftenProgram.mFeatures.hasGamma = true;
+        gDeferredSoftenProgram.mFeatures.isDeferred = true;
+        gDeferredSoftenProgram.mFeatures.hasShadows = use_sun_shadow;
         gDeferredSoftenProgram.mFeatures.hasReflectionProbes = mShaderLevel[SHADER_DEFERRED] > 2;
 
         gDeferredSoftenProgram.clearPermutations();
-		gDeferredSoftenProgram.mShaderFiles.push_back(make_pair("deferred/softenLightV.glsl", GL_VERTEX_SHADER));
-		gDeferredSoftenProgram.mShaderFiles.push_back(make_pair("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredSoftenProgram.mShaderFiles.push_back(make_pair("deferred/softenLightV.glsl", GL_VERTEX_SHADER));
+        gDeferredSoftenProgram.mShaderFiles.push_back(make_pair("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER));
 
-		gDeferredSoftenProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredSoftenProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
         if (use_sun_shadow)
         {
             gDeferredSoftenProgram.addPermutation("HAS_SUN_SHADOW", "1");
         }
 
-		if (gSavedSettings.getBOOL("RenderDeferredSSAO"))
-		{ //if using SSAO, take screen space light map into account as if shadows are enabled
-			gDeferredSoftenProgram.mShaderLevel = llmax(gDeferredSoftenProgram.mShaderLevel, 2);
+        if (gSavedSettings.getBOOL("RenderDeferredSSAO"))
+        { //if using SSAO, take screen space light map into account as if shadows are enabled
+            gDeferredSoftenProgram.mShaderLevel = llmax(gDeferredSoftenProgram.mShaderLevel, 2);
             gDeferredSoftenProgram.addPermutation("HAS_SSAO", "1");
-		}
-				
-		success = gDeferredSoftenProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
+        }
+
+        success = gDeferredSoftenProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
 
     if (success)
     {
@@ -1907,17 +1907,17 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
     }
 
 
-	if (success)
-	{
-		gDeferredShadowProgram.mName = "Deferred Shadow Shader";
-		gDeferredShadowProgram.mShaderFiles.clear();
-		gDeferredShadowProgram.mShaderFiles.push_back(make_pair("deferred/shadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredShadowProgram.mShaderFiles.push_back(make_pair("deferred/shadowF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		gDeferredShadowProgram.mRiggedVariant = &gDeferredSkinnedShadowProgram;
-		success = gDeferredShadowProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
+    if (success)
+    {
+        gDeferredShadowProgram.mName = "Deferred Shadow Shader";
+        gDeferredShadowProgram.mShaderFiles.clear();
+        gDeferredShadowProgram.mShaderFiles.push_back(make_pair("deferred/shadowV.glsl", GL_VERTEX_SHADER));
+        gDeferredShadowProgram.mShaderFiles.push_back(make_pair("deferred/shadowF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredShadowProgram.mRiggedVariant = &gDeferredSkinnedShadowProgram;
+        success = gDeferredShadowProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
 
     if (success)
     {
@@ -1934,52 +1934,52 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
-		gDeferredShadowCubeProgram.mName = "Deferred Shadow Cube Shader";
-		gDeferredShadowCubeProgram.mFeatures.isDeferred = true;
-		gDeferredShadowCubeProgram.mFeatures.hasShadows = true;
-		gDeferredShadowCubeProgram.mShaderFiles.clear();
-		gDeferredShadowCubeProgram.mShaderFiles.push_back(make_pair("deferred/shadowCubeV.glsl", GL_VERTEX_SHADER));
-		gDeferredShadowCubeProgram.mShaderFiles.push_back(make_pair("deferred/shadowF.glsl", GL_FRAGMENT_SHADER));
-		// gDeferredShadowCubeProgram.addPermutation("DEPTH_CLAMP", "1");
-		gDeferredShadowCubeProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredShadowCubeProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredShadowFullbrightAlphaMaskProgram.mName = "Deferred Shadow Fullbright Alpha Mask Shader";
-		gDeferredShadowFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-
-		gDeferredShadowFullbrightAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredShadowFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/shadowAlphaMaskV.glsl", GL_VERTEX_SHADER));
-		gDeferredShadowFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/shadowAlphaMaskF.glsl", GL_FRAGMENT_SHADER));
+    if (success)
+    {
+        gDeferredShadowCubeProgram.mName = "Deferred Shadow Cube Shader";
+        gDeferredShadowCubeProgram.mFeatures.isDeferred = true;
+        gDeferredShadowCubeProgram.mFeatures.hasShadows = true;
+        gDeferredShadowCubeProgram.mShaderFiles.clear();
+        gDeferredShadowCubeProgram.mShaderFiles.push_back(make_pair("deferred/shadowCubeV.glsl", GL_VERTEX_SHADER));
+        gDeferredShadowCubeProgram.mShaderFiles.push_back(make_pair("deferred/shadowF.glsl", GL_FRAGMENT_SHADER));
+        // gDeferredShadowCubeProgram.addPermutation("DEPTH_CLAMP", "1");
+        gDeferredShadowCubeProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredShadowCubeProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredShadowFullbrightAlphaMaskProgram.mName = "Deferred Shadow Fullbright Alpha Mask Shader";
+        gDeferredShadowFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+
+        gDeferredShadowFullbrightAlphaMaskProgram.mShaderFiles.clear();
+        gDeferredShadowFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/shadowAlphaMaskV.glsl", GL_VERTEX_SHADER));
+        gDeferredShadowFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/shadowAlphaMaskF.glsl", GL_FRAGMENT_SHADER));
 
         gDeferredShadowFullbrightAlphaMaskProgram.clearPermutations();
-		gDeferredShadowFullbrightAlphaMaskProgram.addPermutation("DEPTH_CLAMP", "1");
+        gDeferredShadowFullbrightAlphaMaskProgram.addPermutation("DEPTH_CLAMP", "1");
         gDeferredShadowFullbrightAlphaMaskProgram.addPermutation("IS_FULLBRIGHT", "1");
-		gDeferredShadowFullbrightAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredShadowFullbrightAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = make_rigged_variant(gDeferredShadowFullbrightAlphaMaskProgram, gDeferredSkinnedShadowFullbrightAlphaMaskProgram);
         success = success && gDeferredShadowFullbrightAlphaMaskProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-    
-    if (success)
-	{
-		gDeferredShadowAlphaMaskProgram.mName = "Deferred Shadow Alpha Mask Shader";
-		gDeferredShadowAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
-
-		gDeferredShadowAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredShadowAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/shadowAlphaMaskV.glsl", GL_VERTEX_SHADER));
-		gDeferredShadowAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/shadowAlphaMaskF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredShadowAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredShadowAlphaMaskProgram.mName = "Deferred Shadow Alpha Mask Shader";
+        gDeferredShadowAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+
+        gDeferredShadowAlphaMaskProgram.mShaderFiles.clear();
+        gDeferredShadowAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/shadowAlphaMaskV.glsl", GL_VERTEX_SHADER));
+        gDeferredShadowAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/shadowAlphaMaskF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredShadowAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = make_rigged_variant(gDeferredShadowAlphaMaskProgram, gDeferredSkinnedShadowAlphaMaskProgram);
         success = success && gDeferredShadowAlphaMaskProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-    
+        llassert(success);
+    }
+
 
     if (success)
     {
@@ -2007,108 +2007,108 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
-		gDeferredAvatarShadowProgram.mName = "Deferred Avatar Shadow Shader";
-		gDeferredAvatarShadowProgram.mFeatures.hasSkinning = true;
-
-		gDeferredAvatarShadowProgram.mShaderFiles.clear();
-		gDeferredAvatarShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarShadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarShadowF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredAvatarShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredAvatarShadowProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredAvatarAlphaShadowProgram.mName = "Deferred Avatar Alpha Shadow Shader";
-		gDeferredAvatarAlphaShadowProgram.mFeatures.hasSkinning = true;
-		gDeferredAvatarAlphaShadowProgram.mShaderFiles.clear();
-		gDeferredAvatarAlphaShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaShadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarAlphaShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaShadowF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredAvatarAlphaShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredAvatarAlphaShadowProgram.createShader(NULL, NULL);
+    if (success)
+    {
+        gDeferredAvatarShadowProgram.mName = "Deferred Avatar Shadow Shader";
+        gDeferredAvatarShadowProgram.mFeatures.hasSkinning = true;
+
+        gDeferredAvatarShadowProgram.mShaderFiles.clear();
+        gDeferredAvatarShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarShadowV.glsl", GL_VERTEX_SHADER));
+        gDeferredAvatarShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarShadowF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredAvatarShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredAvatarShadowProgram.createShader(NULL, NULL);
         llassert(success);
-	}
-    if (success)
-	{
-		gDeferredAvatarAlphaMaskShadowProgram.mName = "Deferred Avatar Alpha Mask Shadow Shader";
-		gDeferredAvatarAlphaMaskShadowProgram.mFeatures.hasSkinning  = true;
-		gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.clear();
-		gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaShadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaMaskShadowF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredAvatarAlphaMaskShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredAvatarAlphaMaskShadowProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gDeferredAvatarAlphaShadowProgram.mName = "Deferred Avatar Alpha Shadow Shader";
+        gDeferredAvatarAlphaShadowProgram.mFeatures.hasSkinning = true;
+        gDeferredAvatarAlphaShadowProgram.mShaderFiles.clear();
+        gDeferredAvatarAlphaShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaShadowV.glsl", GL_VERTEX_SHADER));
+        gDeferredAvatarAlphaShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaShadowF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredAvatarAlphaShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredAvatarAlphaShadowProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+    if (success)
+    {
+        gDeferredAvatarAlphaMaskShadowProgram.mName = "Deferred Avatar Alpha Mask Shadow Shader";
+        gDeferredAvatarAlphaMaskShadowProgram.mFeatures.hasSkinning  = true;
+        gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.clear();
+        gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaShadowV.glsl", GL_VERTEX_SHADER));
+        gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarAlphaMaskShadowF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredAvatarAlphaMaskShadowProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredAvatarAlphaMaskShadowProgram.createShader(NULL, NULL);
         llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredTerrainProgram.mName = "Deferred Terrain Shader";
-		gDeferredTerrainProgram.mFeatures.hasSrgb = true;
-		gDeferredTerrainProgram.mFeatures.isAlphaLighting = true;
-		gDeferredTerrainProgram.mFeatures.disableTextureIndex = true; //hack to disable auto-setup of texture channels
-		gDeferredTerrainProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredTerrainProgram.mFeatures.hasAtmospherics = true;
-		gDeferredTerrainProgram.mFeatures.hasGamma = true;
-
-		gDeferredTerrainProgram.mShaderFiles.clear();
-		gDeferredTerrainProgram.mShaderFiles.push_back(make_pair("deferred/terrainV.glsl", GL_VERTEX_SHADER));
-		gDeferredTerrainProgram.mShaderFiles.push_back(make_pair("deferred/terrainF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredTerrainProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+    }
+
+    if (success)
+    {
+        gDeferredTerrainProgram.mName = "Deferred Terrain Shader";
+        gDeferredTerrainProgram.mFeatures.hasSrgb = true;
+        gDeferredTerrainProgram.mFeatures.isAlphaLighting = true;
+        gDeferredTerrainProgram.mFeatures.disableTextureIndex = true; //hack to disable auto-setup of texture channels
+        gDeferredTerrainProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredTerrainProgram.mFeatures.hasAtmospherics = true;
+        gDeferredTerrainProgram.mFeatures.hasGamma = true;
+
+        gDeferredTerrainProgram.mShaderFiles.clear();
+        gDeferredTerrainProgram.mShaderFiles.push_back(make_pair("deferred/terrainV.glsl", GL_VERTEX_SHADER));
+        gDeferredTerrainProgram.mShaderFiles.push_back(make_pair("deferred/terrainF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredTerrainProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         success = gDeferredTerrainProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredAvatarProgram.mName = "Deferred Avatar Shader";
-		gDeferredAvatarProgram.mFeatures.hasSkinning = true;
-		gDeferredAvatarProgram.mShaderFiles.clear();
-		gDeferredAvatarProgram.mShaderFiles.push_back(make_pair("deferred/avatarV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarProgram.mShaderFiles.push_back(make_pair("deferred/avatarF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredAvatarProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredAvatarProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredAvatarAlphaProgram.mName = "Deferred Avatar Alpha Shader";
-		gDeferredAvatarAlphaProgram.mFeatures.hasSkinning = true;
-		gDeferredAvatarAlphaProgram.mFeatures.calculatesLighting = false;
-		gDeferredAvatarAlphaProgram.mFeatures.hasLighting = false;
-		gDeferredAvatarAlphaProgram.mFeatures.isAlphaLighting = true;
-		gDeferredAvatarAlphaProgram.mFeatures.disableTextureIndex = true;
-		gDeferredAvatarAlphaProgram.mFeatures.hasSrgb = true;
-		gDeferredAvatarAlphaProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredAvatarAlphaProgram.mFeatures.hasAtmospherics = true;
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredAvatarProgram.mName = "Deferred Avatar Shader";
+        gDeferredAvatarProgram.mFeatures.hasSkinning = true;
+        gDeferredAvatarProgram.mShaderFiles.clear();
+        gDeferredAvatarProgram.mShaderFiles.push_back(make_pair("deferred/avatarV.glsl", GL_VERTEX_SHADER));
+        gDeferredAvatarProgram.mShaderFiles.push_back(make_pair("deferred/avatarF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredAvatarProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredAvatarProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredAvatarAlphaProgram.mName = "Deferred Avatar Alpha Shader";
+        gDeferredAvatarAlphaProgram.mFeatures.hasSkinning = true;
+        gDeferredAvatarAlphaProgram.mFeatures.calculatesLighting = false;
+        gDeferredAvatarAlphaProgram.mFeatures.hasLighting = false;
+        gDeferredAvatarAlphaProgram.mFeatures.isAlphaLighting = true;
+        gDeferredAvatarAlphaProgram.mFeatures.disableTextureIndex = true;
+        gDeferredAvatarAlphaProgram.mFeatures.hasSrgb = true;
+        gDeferredAvatarAlphaProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredAvatarAlphaProgram.mFeatures.hasAtmospherics = true;
         gDeferredAvatarAlphaProgram.mFeatures.hasGamma = true;
         gDeferredAvatarAlphaProgram.mFeatures.isDeferred = true;
-		gDeferredAvatarAlphaProgram.mFeatures.hasShadows = true;
+        gDeferredAvatarAlphaProgram.mFeatures.hasShadows = true;
         gDeferredAvatarAlphaProgram.mFeatures.hasReflectionProbes = true;
 
-		gDeferredAvatarAlphaProgram.mShaderFiles.clear();
+        gDeferredAvatarAlphaProgram.mShaderFiles.clear();
         gDeferredAvatarAlphaProgram.mShaderFiles.push_back(make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER));
         gDeferredAvatarAlphaProgram.mShaderFiles.push_back(make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER));
 
-		gDeferredAvatarAlphaProgram.clearPermutations();
-		gDeferredAvatarAlphaProgram.addPermutation("USE_DIFFUSE_TEX", "1");
-		gDeferredAvatarAlphaProgram.addPermutation("IS_AVATAR_SKIN", "1");
-		if (use_sun_shadow)
-		{
-			gDeferredAvatarAlphaProgram.addPermutation("HAS_SUN_SHADOW", "1");
-		}
+        gDeferredAvatarAlphaProgram.clearPermutations();
+        gDeferredAvatarAlphaProgram.addPermutation("USE_DIFFUSE_TEX", "1");
+        gDeferredAvatarAlphaProgram.addPermutation("IS_AVATAR_SKIN", "1");
+        if (use_sun_shadow)
+        {
+            gDeferredAvatarAlphaProgram.addPermutation("HAS_SUN_SHADOW", "1");
+        }
 
-		gDeferredAvatarAlphaProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredAvatarAlphaProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
-		success = gDeferredAvatarAlphaProgram.createShader(NULL, NULL);
-		llassert(success);
+        success = gDeferredAvatarAlphaProgram.createShader(NULL, NULL);
+        llassert(success);
 
-		gDeferredAvatarAlphaProgram.mFeatures.calculatesLighting = true;
-		gDeferredAvatarAlphaProgram.mFeatures.hasLighting = true;
-	}
+        gDeferredAvatarAlphaProgram.mFeatures.calculatesLighting = true;
+        gDeferredAvatarAlphaProgram.mFeatures.hasLighting = true;
+    }
 
     if (success)
     {
@@ -2151,20 +2151,20 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
-		gDeferredPostGammaCorrectProgram.mName = "Deferred Gamma Correction Post Process";
-		gDeferredPostGammaCorrectProgram.mFeatures.hasSrgb = true;
-		gDeferredPostGammaCorrectProgram.mFeatures.isDeferred = true;
-		gDeferredPostGammaCorrectProgram.mShaderFiles.clear();
+    if (success)
+    {
+        gDeferredPostGammaCorrectProgram.mName = "Deferred Gamma Correction Post Process";
+        gDeferredPostGammaCorrectProgram.mFeatures.hasSrgb = true;
+        gDeferredPostGammaCorrectProgram.mFeatures.isDeferred = true;
+        gDeferredPostGammaCorrectProgram.mShaderFiles.clear();
         gDeferredPostGammaCorrectProgram.clearPermutations();
         gDeferredPostGammaCorrectProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredPostGammaCorrectProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredGammaCorrect.glsl", GL_FRAGMENT_SHADER));
+        gDeferredPostGammaCorrectProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredGammaCorrect.glsl", GL_FRAGMENT_SHADER));
         gDeferredPostGammaCorrectProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredPostGammaCorrectProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-    
+        success = gDeferredPostGammaCorrectProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
     if (success)
     {
         gNoPostGammaCorrectProgram.mName = "No Post Gamma Correction Post Process";
@@ -2196,65 +2196,65 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
     }
 
 
-	if (success && gGLManager.mGLVersion > 3.9f)
-	{
-		gFXAAProgram.mName = "FXAA Shader";
-		gFXAAProgram.mFeatures.isDeferred = true;
-		gFXAAProgram.mShaderFiles.clear();
-		gFXAAProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredV.glsl", GL_VERTEX_SHADER));
-		gFXAAProgram.mShaderFiles.push_back(make_pair("deferred/fxaaF.glsl", GL_FRAGMENT_SHADER));
-		gFXAAProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gFXAAProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
+    if (success && gGLManager.mGLVersion > 3.9f)
+    {
+        gFXAAProgram.mName = "FXAA Shader";
+        gFXAAProgram.mFeatures.isDeferred = true;
+        gFXAAProgram.mShaderFiles.clear();
+        gFXAAProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredV.glsl", GL_VERTEX_SHADER));
+        gFXAAProgram.mShaderFiles.push_back(make_pair("deferred/fxaaF.glsl", GL_FRAGMENT_SHADER));
+        gFXAAProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gFXAAProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
 
-	if (success)
-	{
-		gDeferredPostProgram.mName = "Deferred Post Shader";
+    if (success)
+    {
+        gDeferredPostProgram.mName = "Deferred Post Shader";
         gDeferredPostProgram.mFeatures.isDeferred = true;
-		gDeferredPostProgram.mShaderFiles.clear();
-		gDeferredPostProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredPostProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredPostProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredPostProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredCoFProgram.mName = "Deferred CoF Shader";
-		gDeferredCoFProgram.mShaderFiles.clear();
-		gDeferredCoFProgram.mFeatures.isDeferred = true;
-		gDeferredCoFProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredCoFProgram.mShaderFiles.push_back(make_pair("deferred/cofF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredCoFProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredCoFProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredDoFCombineProgram.mName = "Deferred DoFCombine Shader";
-		gDeferredDoFCombineProgram.mFeatures.isDeferred = true;
-		gDeferredDoFCombineProgram.mShaderFiles.clear();
-		gDeferredDoFCombineProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredDoFCombineProgram.mShaderFiles.push_back(make_pair("deferred/dofCombineF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredDoFCombineProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredDoFCombineProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredPostNoDoFProgram.mName = "Deferred Post NoDoF Shader";
-		gDeferredPostNoDoFProgram.mFeatures.isDeferred = true;
-		gDeferredPostNoDoFProgram.mShaderFiles.clear();
-		gDeferredPostNoDoFProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredPostNoDoFProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoDoFF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredPostNoDoFProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredPostNoDoFProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
+        gDeferredPostProgram.mShaderFiles.clear();
+        gDeferredPostProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
+        gDeferredPostProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredPostProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredPostProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredCoFProgram.mName = "Deferred CoF Shader";
+        gDeferredCoFProgram.mShaderFiles.clear();
+        gDeferredCoFProgram.mFeatures.isDeferred = true;
+        gDeferredCoFProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
+        gDeferredCoFProgram.mShaderFiles.push_back(make_pair("deferred/cofF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredCoFProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredCoFProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredDoFCombineProgram.mName = "Deferred DoFCombine Shader";
+        gDeferredDoFCombineProgram.mFeatures.isDeferred = true;
+        gDeferredDoFCombineProgram.mShaderFiles.clear();
+        gDeferredDoFCombineProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
+        gDeferredDoFCombineProgram.mShaderFiles.push_back(make_pair("deferred/dofCombineF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredDoFCombineProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredDoFCombineProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredPostNoDoFProgram.mName = "Deferred Post NoDoF Shader";
+        gDeferredPostNoDoFProgram.mFeatures.isDeferred = true;
+        gDeferredPostNoDoFProgram.mShaderFiles.clear();
+        gDeferredPostNoDoFProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
+        gDeferredPostNoDoFProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoDoFF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredPostNoDoFProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredPostNoDoFProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
 
     if (success)
     {
@@ -2276,45 +2276,45 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         llassert(success);
     }
 
-	if (success)
-	{
-		gDeferredWLSkyProgram.mName = "Deferred Windlight Sky Shader";
-		gDeferredWLSkyProgram.mShaderFiles.clear();
-		gDeferredWLSkyProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredWLSkyProgram.mFeatures.hasAtmospherics = true;
-		gDeferredWLSkyProgram.mFeatures.hasGamma = true;
-		gDeferredWLSkyProgram.mFeatures.hasSrgb = true;
-
-		gDeferredWLSkyProgram.mShaderFiles.push_back(make_pair("deferred/skyV.glsl", GL_VERTEX_SHADER));
-		gDeferredWLSkyProgram.mShaderFiles.push_back(make_pair("deferred/skyF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredWLSkyProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		gDeferredWLSkyProgram.mShaderGroup = LLGLSLShader::SG_SKY;
-
-		success = gDeferredWLSkyProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
-
-	if (success)
-	{
-		gDeferredWLCloudProgram.mName = "Deferred Windlight Cloud Program";
-		gDeferredWLCloudProgram.mShaderFiles.clear();
-		gDeferredWLCloudProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredWLCloudProgram.mFeatures.hasAtmospherics = true;
+    if (success)
+    {
+        gDeferredWLSkyProgram.mName = "Deferred Windlight Sky Shader";
+        gDeferredWLSkyProgram.mShaderFiles.clear();
+        gDeferredWLSkyProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredWLSkyProgram.mFeatures.hasAtmospherics = true;
+        gDeferredWLSkyProgram.mFeatures.hasGamma = true;
+        gDeferredWLSkyProgram.mFeatures.hasSrgb = true;
+
+        gDeferredWLSkyProgram.mShaderFiles.push_back(make_pair("deferred/skyV.glsl", GL_VERTEX_SHADER));
+        gDeferredWLSkyProgram.mShaderFiles.push_back(make_pair("deferred/skyF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredWLSkyProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredWLSkyProgram.mShaderGroup = LLGLSLShader::SG_SKY;
+
+        success = gDeferredWLSkyProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
+
+    if (success)
+    {
+        gDeferredWLCloudProgram.mName = "Deferred Windlight Cloud Program";
+        gDeferredWLCloudProgram.mShaderFiles.clear();
+        gDeferredWLCloudProgram.mFeatures.calculatesAtmospherics = true;
+        gDeferredWLCloudProgram.mFeatures.hasAtmospherics = true;
         gDeferredWLCloudProgram.mFeatures.hasGamma = true;
         gDeferredWLCloudProgram.mFeatures.hasSrgb = true;
-        
-		gDeferredWLCloudProgram.mShaderFiles.push_back(make_pair("deferred/cloudsV.glsl", GL_VERTEX_SHADER));
-		gDeferredWLCloudProgram.mShaderFiles.push_back(make_pair("deferred/cloudsF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredWLCloudProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		gDeferredWLCloudProgram.mShaderGroup = LLGLSLShader::SG_SKY;
+
+        gDeferredWLCloudProgram.mShaderFiles.push_back(make_pair("deferred/cloudsV.glsl", GL_VERTEX_SHADER));
+        gDeferredWLCloudProgram.mShaderFiles.push_back(make_pair("deferred/cloudsF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredWLCloudProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredWLCloudProgram.mShaderGroup = LLGLSLShader::SG_SKY;
         gDeferredWLCloudProgram.addConstant( LLGLSLShader::SHADER_CONST_CLOUD_MOON_DEPTH ); // SL-14113
-		success = gDeferredWLCloudProgram.createShader(NULL, NULL);
-		llassert(success);
-	}
+        success = gDeferredWLCloudProgram.createShader(NULL, NULL);
+        llassert(success);
+    }
 
-	if (success)
-	{
-	    gDeferredWLSunProgram.mName = "Deferred Windlight Sun Program";
+    if (success)
+    {
+        gDeferredWLSunProgram.mName = "Deferred Windlight Sun Program";
         gDeferredWLSunProgram.mFeatures.calculatesAtmospherics = true;
         gDeferredWLSunProgram.mFeatures.hasAtmospherics = true;
         gDeferredWLSunProgram.mFeatures.hasGamma = true;
@@ -2339,40 +2339,40 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredWLMoonProgram.mFeatures.hasAtmospherics = true;
         gDeferredWLMoonProgram.mFeatures.hasSrgb = true;
         gDeferredWLMoonProgram.mFeatures.disableTextureIndex = true;
-        
+
         gDeferredWLMoonProgram.mShaderFiles.clear();
         gDeferredWLMoonProgram.mShaderFiles.push_back(make_pair("deferred/moonV.glsl", GL_VERTEX_SHADER));
         gDeferredWLMoonProgram.mShaderFiles.push_back(make_pair("deferred/moonF.glsl", GL_FRAGMENT_SHADER));
         gDeferredWLMoonProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         gDeferredWLMoonProgram.mShaderGroup = LLGLSLShader::SG_SKY;
         gDeferredWLMoonProgram.addConstant( LLGLSLShader::SHADER_CONST_CLOUD_MOON_DEPTH ); // SL-14113
- 	 	success = gDeferredWLMoonProgram.createShader(NULL, NULL);
+        success = gDeferredWLMoonProgram.createShader(NULL, NULL);
         llassert(success);
- 	}
-
- 	if (success)
-	{
-		gDeferredStarProgram.mName = "Deferred Star Program";
-		gDeferredStarProgram.mShaderFiles.clear();
-		gDeferredStarProgram.mShaderFiles.push_back(make_pair("deferred/starsV.glsl", GL_VERTEX_SHADER));
-		gDeferredStarProgram.mShaderFiles.push_back(make_pair("deferred/starsF.glsl", GL_FRAGMENT_SHADER));
-		gDeferredStarProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		gDeferredStarProgram.mShaderGroup = LLGLSLShader::SG_SKY;
+    }
+
+    if (success)
+    {
+        gDeferredStarProgram.mName = "Deferred Star Program";
+        gDeferredStarProgram.mShaderFiles.clear();
+        gDeferredStarProgram.mShaderFiles.push_back(make_pair("deferred/starsV.glsl", GL_VERTEX_SHADER));
+        gDeferredStarProgram.mShaderFiles.push_back(make_pair("deferred/starsF.glsl", GL_FRAGMENT_SHADER));
+        gDeferredStarProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gDeferredStarProgram.mShaderGroup = LLGLSLShader::SG_SKY;
         gDeferredStarProgram.addConstant( LLGLSLShader::SHADER_CONST_STAR_DEPTH ); // SL-14113
-		success = gDeferredStarProgram.createShader(NULL, NULL);
+        success = gDeferredStarProgram.createShader(NULL, NULL);
         llassert(success);
-	}
+    }
 
-	if (success)
-	{
-		gNormalMapGenProgram.mName = "Normal Map Generation Program";
-		gNormalMapGenProgram.mShaderFiles.clear();
-		gNormalMapGenProgram.mShaderFiles.push_back(make_pair("deferred/normgenV.glsl", GL_VERTEX_SHADER));
-		gNormalMapGenProgram.mShaderFiles.push_back(make_pair("deferred/normgenF.glsl", GL_FRAGMENT_SHADER));
-		gNormalMapGenProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		gNormalMapGenProgram.mShaderGroup = LLGLSLShader::SG_SKY;
-		success = gNormalMapGenProgram.createShader(NULL, NULL);
-	}
+    if (success)
+    {
+        gNormalMapGenProgram.mName = "Normal Map Generation Program";
+        gNormalMapGenProgram.mShaderFiles.clear();
+        gNormalMapGenProgram.mShaderFiles.push_back(make_pair("deferred/normgenV.glsl", GL_VERTEX_SHADER));
+        gNormalMapGenProgram.mShaderFiles.push_back(make_pair("deferred/normgenF.glsl", GL_FRAGMENT_SHADER));
+        gNormalMapGenProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        gNormalMapGenProgram.mShaderGroup = LLGLSLShader::SG_SKY;
+        success = gNormalMapGenProgram.createShader(NULL, NULL);
+    }
 
     if (success)
     {
@@ -2384,7 +2384,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         success = gDeferredGenBrdfLutProgram.createShader(NULL, NULL);
     }
 
-	if (success) {
+    if (success) {
         gPostScreenSpaceReflectionProgram.mName = "Screen Space Reflection Post";
         gPostScreenSpaceReflectionProgram.mShaderFiles.clear();
         gPostScreenSpaceReflectionProgram.mShaderFiles.push_back(make_pair("deferred/screenSpaceReflPostV.glsl", GL_VERTEX_SHADER));
@@ -2393,24 +2393,24 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gPostScreenSpaceReflectionProgram.mFeatures.isDeferred                = true;
         gPostScreenSpaceReflectionProgram.mShaderLevel = 3;
         success = gPostScreenSpaceReflectionProgram.createShader(NULL, NULL);
-	}
-
-	if (success) {
-		gDeferredBufferVisualProgram.mName = "Deferred Buffer Visualization Shader";
-		gDeferredBufferVisualProgram.mShaderFiles.clear();
-		gDeferredBufferVisualProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredBufferVisualProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredVisualizeBuffers.glsl", GL_FRAGMENT_SHADER));
-		gDeferredBufferVisualProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
-		success = gDeferredBufferVisualProgram.createShader(NULL, NULL);
-	}
-
-	return success;
+    }
+
+    if (success) {
+        gDeferredBufferVisualProgram.mName = "Deferred Buffer Visualization Shader";
+        gDeferredBufferVisualProgram.mShaderFiles.clear();
+        gDeferredBufferVisualProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
+        gDeferredBufferVisualProgram.mShaderFiles.push_back(make_pair("deferred/postDeferredVisualizeBuffers.glsl", GL_FRAGMENT_SHADER));
+        gDeferredBufferVisualProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
+        success = gDeferredBufferVisualProgram.createShader(NULL, NULL);
+    }
+
+    return success;
 }
 
 BOOL LLViewerShaderMgr::loadShadersObject()
 {
     LL_PROFILE_ZONE_SCOPED;
-	BOOL success = TRUE;
+    BOOL success = TRUE;
 
     if (success)
     {
@@ -2434,66 +2434,66 @@ BOOL LLViewerShaderMgr::loadShadersObject()
         }
     }
 
-	if (success)
-	{
-		gObjectAlphaMaskNoColorProgram.mName = "No color alpha mask Shader";
-		gObjectAlphaMaskNoColorProgram.mFeatures.calculatesLighting = true;
-		gObjectAlphaMaskNoColorProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectAlphaMaskNoColorProgram.mFeatures.hasGamma = true;
-		gObjectAlphaMaskNoColorProgram.mFeatures.hasAtmospherics = true;
-		gObjectAlphaMaskNoColorProgram.mFeatures.hasLighting = true;
-		gObjectAlphaMaskNoColorProgram.mFeatures.disableTextureIndex = true;
-		gObjectAlphaMaskNoColorProgram.mFeatures.hasAlphaMask = true;
-		gObjectAlphaMaskNoColorProgram.mShaderFiles.clear();
-		gObjectAlphaMaskNoColorProgram.mShaderFiles.push_back(make_pair("objects/simpleNoColorV.glsl", GL_VERTEX_SHADER));
-		gObjectAlphaMaskNoColorProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
-		gObjectAlphaMaskNoColorProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
-		success = gObjectAlphaMaskNoColorProgram.createShader(NULL, NULL);
-	}
-	
-	if (success)
-	{
-		gImpostorProgram.mName = "Impostor Shader";
-		gImpostorProgram.mFeatures.disableTextureIndex = true;
-		gImpostorProgram.mFeatures.hasSrgb = true;
-		gImpostorProgram.mShaderFiles.clear();
-		gImpostorProgram.mShaderFiles.push_back(make_pair("objects/impostorV.glsl", GL_VERTEX_SHADER));
-		gImpostorProgram.mShaderFiles.push_back(make_pair("objects/impostorF.glsl", GL_FRAGMENT_SHADER));
-		gImpostorProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
-		success = gImpostorProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectPreviewProgram.mName = "Object Preview Shader";
-		gObjectPreviewProgram.mFeatures.disableTextureIndex = true;
-		gObjectPreviewProgram.mShaderFiles.clear();
-		gObjectPreviewProgram.mShaderFiles.push_back(make_pair("objects/previewV.glsl", GL_VERTEX_SHADER));
-		gObjectPreviewProgram.mShaderFiles.push_back(make_pair("objects/previewF.glsl", GL_FRAGMENT_SHADER));
-		gObjectPreviewProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
+    if (success)
+    {
+        gObjectAlphaMaskNoColorProgram.mName = "No color alpha mask Shader";
+        gObjectAlphaMaskNoColorProgram.mFeatures.calculatesLighting = true;
+        gObjectAlphaMaskNoColorProgram.mFeatures.calculatesAtmospherics = true;
+        gObjectAlphaMaskNoColorProgram.mFeatures.hasGamma = true;
+        gObjectAlphaMaskNoColorProgram.mFeatures.hasAtmospherics = true;
+        gObjectAlphaMaskNoColorProgram.mFeatures.hasLighting = true;
+        gObjectAlphaMaskNoColorProgram.mFeatures.disableTextureIndex = true;
+        gObjectAlphaMaskNoColorProgram.mFeatures.hasAlphaMask = true;
+        gObjectAlphaMaskNoColorProgram.mShaderFiles.clear();
+        gObjectAlphaMaskNoColorProgram.mShaderFiles.push_back(make_pair("objects/simpleNoColorV.glsl", GL_VERTEX_SHADER));
+        gObjectAlphaMaskNoColorProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+        gObjectAlphaMaskNoColorProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
+        success = gObjectAlphaMaskNoColorProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gImpostorProgram.mName = "Impostor Shader";
+        gImpostorProgram.mFeatures.disableTextureIndex = true;
+        gImpostorProgram.mFeatures.hasSrgb = true;
+        gImpostorProgram.mShaderFiles.clear();
+        gImpostorProgram.mShaderFiles.push_back(make_pair("objects/impostorV.glsl", GL_VERTEX_SHADER));
+        gImpostorProgram.mShaderFiles.push_back(make_pair("objects/impostorF.glsl", GL_FRAGMENT_SHADER));
+        gImpostorProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
+        success = gImpostorProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gObjectPreviewProgram.mName = "Object Preview Shader";
+        gObjectPreviewProgram.mFeatures.disableTextureIndex = true;
+        gObjectPreviewProgram.mShaderFiles.clear();
+        gObjectPreviewProgram.mShaderFiles.push_back(make_pair("objects/previewV.glsl", GL_VERTEX_SHADER));
+        gObjectPreviewProgram.mShaderFiles.push_back(make_pair("objects/previewF.glsl", GL_FRAGMENT_SHADER));
+        gObjectPreviewProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
         success = make_rigged_variant(gObjectPreviewProgram, gSkinnedObjectPreviewProgram);
-		success = gObjectPreviewProgram.createShader(NULL, NULL);
-		gObjectPreviewProgram.mFeatures.hasLighting = true;
+        success = gObjectPreviewProgram.createShader(NULL, NULL);
+        gObjectPreviewProgram.mFeatures.hasLighting = true;
         gSkinnedObjectPreviewProgram.mFeatures.hasLighting = true;
-	}
-
-	if (success)
-	{
-		gPhysicsPreviewProgram.mName = "Preview Physics Shader";
-		gPhysicsPreviewProgram.mFeatures.calculatesLighting = false;
-		gPhysicsPreviewProgram.mFeatures.calculatesAtmospherics = false;
-		gPhysicsPreviewProgram.mFeatures.hasGamma = false;
-		gPhysicsPreviewProgram.mFeatures.hasAtmospherics = false;
-		gPhysicsPreviewProgram.mFeatures.hasLighting = false;
-		gPhysicsPreviewProgram.mFeatures.mIndexedTextureChannels = 0;
-		gPhysicsPreviewProgram.mFeatures.disableTextureIndex = true;
-		gPhysicsPreviewProgram.mShaderFiles.clear();
-		gPhysicsPreviewProgram.mShaderFiles.push_back(make_pair("objects/previewPhysicsV.glsl", GL_VERTEX_SHADER));
-		gPhysicsPreviewProgram.mShaderFiles.push_back(make_pair("objects/previewPhysicsF.glsl", GL_FRAGMENT_SHADER));
-		gPhysicsPreviewProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
-		success = gPhysicsPreviewProgram.createShader(NULL, NULL);
-		gPhysicsPreviewProgram.mFeatures.hasLighting = false;
-	}
+    }
+
+    if (success)
+    {
+        gPhysicsPreviewProgram.mName = "Preview Physics Shader";
+        gPhysicsPreviewProgram.mFeatures.calculatesLighting = false;
+        gPhysicsPreviewProgram.mFeatures.calculatesAtmospherics = false;
+        gPhysicsPreviewProgram.mFeatures.hasGamma = false;
+        gPhysicsPreviewProgram.mFeatures.hasAtmospherics = false;
+        gPhysicsPreviewProgram.mFeatures.hasLighting = false;
+        gPhysicsPreviewProgram.mFeatures.mIndexedTextureChannels = 0;
+        gPhysicsPreviewProgram.mFeatures.disableTextureIndex = true;
+        gPhysicsPreviewProgram.mShaderFiles.clear();
+        gPhysicsPreviewProgram.mShaderFiles.push_back(make_pair("objects/previewPhysicsV.glsl", GL_VERTEX_SHADER));
+        gPhysicsPreviewProgram.mShaderFiles.push_back(make_pair("objects/previewPhysicsF.glsl", GL_FRAGMENT_SHADER));
+        gPhysicsPreviewProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
+        success = gPhysicsPreviewProgram.createShader(NULL, NULL);
+        gPhysicsPreviewProgram.mFeatures.hasLighting = false;
+    }
 
     if (!success)
     {
@@ -2501,234 +2501,234 @@ BOOL LLViewerShaderMgr::loadShadersObject()
         return FALSE;
     }
 
-	return TRUE;
+    return TRUE;
 }
 
 BOOL LLViewerShaderMgr::loadShadersAvatar()
 {
     LL_PROFILE_ZONE_SCOPED;
 #if 1 // DEPRECATED -- forward rendering is deprecated
-	BOOL success = TRUE;
-
-	if (mShaderLevel[SHADER_AVATAR] == 0)
-	{
-		gAvatarProgram.unload();
-		gAvatarEyeballProgram.unload();
-		return TRUE;
-	}
-
-	if (success)
-	{
-		gAvatarProgram.mName = "Avatar Shader";
-		gAvatarProgram.mFeatures.hasSkinning = true;
-		gAvatarProgram.mFeatures.calculatesAtmospherics = true;
-		gAvatarProgram.mFeatures.calculatesLighting = true;
-		gAvatarProgram.mFeatures.hasGamma = true;
-		gAvatarProgram.mFeatures.hasAtmospherics = true;
-		gAvatarProgram.mFeatures.hasLighting = true;
-		gAvatarProgram.mFeatures.hasAlphaMask = true;
-		gAvatarProgram.mFeatures.disableTextureIndex = true;
-		gAvatarProgram.mShaderFiles.clear();
-		gAvatarProgram.mShaderFiles.push_back(make_pair("avatar/avatarV.glsl", GL_VERTEX_SHADER));
-		gAvatarProgram.mShaderFiles.push_back(make_pair("avatar/avatarF.glsl", GL_FRAGMENT_SHADER));
-		gAvatarProgram.mShaderLevel = mShaderLevel[SHADER_AVATAR];
-		success = gAvatarProgram.createShader(NULL, NULL);
-			
-		/// Keep track of avatar levels
-		if (gAvatarProgram.mShaderLevel != mShaderLevel[SHADER_AVATAR])
-		{
-			mMaxAvatarShaderLevel = mShaderLevel[SHADER_AVATAR] = gAvatarProgram.mShaderLevel;
-		}
-	}
-
-	if (success)
-	{
-		gAvatarEyeballProgram.mName = "Avatar Eyeball Program";
-		gAvatarEyeballProgram.mFeatures.calculatesLighting = true;
-		gAvatarEyeballProgram.mFeatures.isSpecular = true;
-		gAvatarEyeballProgram.mFeatures.calculatesAtmospherics = true;
-		gAvatarEyeballProgram.mFeatures.hasGamma = true;
-		gAvatarEyeballProgram.mFeatures.hasAtmospherics = true;
-		gAvatarEyeballProgram.mFeatures.hasLighting = true;
-		gAvatarEyeballProgram.mFeatures.hasAlphaMask = true;
-		gAvatarEyeballProgram.mFeatures.disableTextureIndex = true;
-		gAvatarEyeballProgram.mShaderFiles.clear();
-		gAvatarEyeballProgram.mShaderFiles.push_back(make_pair("avatar/eyeballV.glsl", GL_VERTEX_SHADER));
-		gAvatarEyeballProgram.mShaderFiles.push_back(make_pair("avatar/eyeballF.glsl", GL_FRAGMENT_SHADER));
-		gAvatarEyeballProgram.mShaderLevel = mShaderLevel[SHADER_AVATAR];
-		success = gAvatarEyeballProgram.createShader(NULL, NULL);
-	}
-
-	if( !success )
-	{
-		mShaderLevel[SHADER_AVATAR] = 0;
-		mMaxAvatarShaderLevel = 0;
-		return FALSE;
-	}
+    BOOL success = TRUE;
+
+    if (mShaderLevel[SHADER_AVATAR] == 0)
+    {
+        gAvatarProgram.unload();
+        gAvatarEyeballProgram.unload();
+        return TRUE;
+    }
+
+    if (success)
+    {
+        gAvatarProgram.mName = "Avatar Shader";
+        gAvatarProgram.mFeatures.hasSkinning = true;
+        gAvatarProgram.mFeatures.calculatesAtmospherics = true;
+        gAvatarProgram.mFeatures.calculatesLighting = true;
+        gAvatarProgram.mFeatures.hasGamma = true;
+        gAvatarProgram.mFeatures.hasAtmospherics = true;
+        gAvatarProgram.mFeatures.hasLighting = true;
+        gAvatarProgram.mFeatures.hasAlphaMask = true;
+        gAvatarProgram.mFeatures.disableTextureIndex = true;
+        gAvatarProgram.mShaderFiles.clear();
+        gAvatarProgram.mShaderFiles.push_back(make_pair("avatar/avatarV.glsl", GL_VERTEX_SHADER));
+        gAvatarProgram.mShaderFiles.push_back(make_pair("avatar/avatarF.glsl", GL_FRAGMENT_SHADER));
+        gAvatarProgram.mShaderLevel = mShaderLevel[SHADER_AVATAR];
+        success = gAvatarProgram.createShader(NULL, NULL);
+
+        /// Keep track of avatar levels
+        if (gAvatarProgram.mShaderLevel != mShaderLevel[SHADER_AVATAR])
+        {
+            mMaxAvatarShaderLevel = mShaderLevel[SHADER_AVATAR] = gAvatarProgram.mShaderLevel;
+        }
+    }
+
+    if (success)
+    {
+        gAvatarEyeballProgram.mName = "Avatar Eyeball Program";
+        gAvatarEyeballProgram.mFeatures.calculatesLighting = true;
+        gAvatarEyeballProgram.mFeatures.isSpecular = true;
+        gAvatarEyeballProgram.mFeatures.calculatesAtmospherics = true;
+        gAvatarEyeballProgram.mFeatures.hasGamma = true;
+        gAvatarEyeballProgram.mFeatures.hasAtmospherics = true;
+        gAvatarEyeballProgram.mFeatures.hasLighting = true;
+        gAvatarEyeballProgram.mFeatures.hasAlphaMask = true;
+        gAvatarEyeballProgram.mFeatures.disableTextureIndex = true;
+        gAvatarEyeballProgram.mShaderFiles.clear();
+        gAvatarEyeballProgram.mShaderFiles.push_back(make_pair("avatar/eyeballV.glsl", GL_VERTEX_SHADER));
+        gAvatarEyeballProgram.mShaderFiles.push_back(make_pair("avatar/eyeballF.glsl", GL_FRAGMENT_SHADER));
+        gAvatarEyeballProgram.mShaderLevel = mShaderLevel[SHADER_AVATAR];
+        success = gAvatarEyeballProgram.createShader(NULL, NULL);
+    }
+
+    if( !success )
+    {
+        mShaderLevel[SHADER_AVATAR] = 0;
+        mMaxAvatarShaderLevel = 0;
+        return FALSE;
+    }
 #endif
-	return TRUE;
+    return TRUE;
 }
 
 BOOL LLViewerShaderMgr::loadShadersInterface()
 {
     LL_PROFILE_ZONE_SCOPED;
-	BOOL success = TRUE;
-
-	if (success)
-	{
-		gHighlightProgram.mName = "Highlight Shader";
-		gHighlightProgram.mShaderFiles.clear();
-		gHighlightProgram.mShaderFiles.push_back(make_pair("interface/highlightV.glsl", GL_VERTEX_SHADER));
-		gHighlightProgram.mShaderFiles.push_back(make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
-		gHighlightProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+    BOOL success = TRUE;
+
+    if (success)
+    {
+        gHighlightProgram.mName = "Highlight Shader";
+        gHighlightProgram.mShaderFiles.clear();
+        gHighlightProgram.mShaderFiles.push_back(make_pair("interface/highlightV.glsl", GL_VERTEX_SHADER));
+        gHighlightProgram.mShaderFiles.push_back(make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
+        gHighlightProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
         success = make_rigged_variant(gHighlightProgram, gSkinnedHighlightProgram);
-		success = success && gHighlightProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gHighlightNormalProgram.mName = "Highlight Normals Shader";
-		gHighlightNormalProgram.mShaderFiles.clear();
-		gHighlightNormalProgram.mShaderFiles.push_back(make_pair("interface/highlightNormV.glsl", GL_VERTEX_SHADER));
-		gHighlightNormalProgram.mShaderFiles.push_back(make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
-		gHighlightNormalProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gHighlightNormalProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gHighlightSpecularProgram.mName = "Highlight Spec Shader";
-		gHighlightSpecularProgram.mShaderFiles.clear();
-		gHighlightSpecularProgram.mShaderFiles.push_back(make_pair("interface/highlightSpecV.glsl", GL_VERTEX_SHADER));
-		gHighlightSpecularProgram.mShaderFiles.push_back(make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
-		gHighlightSpecularProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gHighlightSpecularProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gUIProgram.mName = "UI Shader";
-		gUIProgram.mShaderFiles.clear();
-		gUIProgram.mShaderFiles.push_back(make_pair("interface/uiV.glsl", GL_VERTEX_SHADER));
-		gUIProgram.mShaderFiles.push_back(make_pair("interface/uiF.glsl", GL_FRAGMENT_SHADER));
-		gUIProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gUIProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gPathfindingProgram.mName = "Pathfinding Shader";
-		gPathfindingProgram.mShaderFiles.clear();
-		gPathfindingProgram.mShaderFiles.push_back(make_pair("interface/pathfindingV.glsl", GL_VERTEX_SHADER));
-		gPathfindingProgram.mShaderFiles.push_back(make_pair("interface/pathfindingF.glsl", GL_FRAGMENT_SHADER));
-		gPathfindingProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gPathfindingProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gPathfindingNoNormalsProgram.mName = "PathfindingNoNormals Shader";
-		gPathfindingNoNormalsProgram.mShaderFiles.clear();
-		gPathfindingNoNormalsProgram.mShaderFiles.push_back(make_pair("interface/pathfindingNoNormalV.glsl", GL_VERTEX_SHADER));
-		gPathfindingNoNormalsProgram.mShaderFiles.push_back(make_pair("interface/pathfindingF.glsl", GL_FRAGMENT_SHADER));
-		gPathfindingNoNormalsProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gPathfindingNoNormalsProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gGlowCombineProgram.mName = "Glow Combine Shader";
-		gGlowCombineProgram.mShaderFiles.clear();
-		gGlowCombineProgram.mShaderFiles.push_back(make_pair("interface/glowcombineV.glsl", GL_VERTEX_SHADER));
-		gGlowCombineProgram.mShaderFiles.push_back(make_pair("interface/glowcombineF.glsl", GL_FRAGMENT_SHADER));
-		gGlowCombineProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gGlowCombineProgram.createShader(NULL, NULL);
-		if (success)
-		{
-			gGlowCombineProgram.bind();
-			gGlowCombineProgram.uniform1i(sGlowMap, 0);
-			gGlowCombineProgram.uniform1i(sScreenMap, 1);
-			gGlowCombineProgram.unbind();
-		}
-	}
-
-	if (success)
-	{
-		gGlowCombineFXAAProgram.mName = "Glow CombineFXAA Shader";
-		gGlowCombineFXAAProgram.mShaderFiles.clear();
-		gGlowCombineFXAAProgram.mShaderFiles.push_back(make_pair("interface/glowcombineFXAAV.glsl", GL_VERTEX_SHADER));
-		gGlowCombineFXAAProgram.mShaderFiles.push_back(make_pair("interface/glowcombineFXAAF.glsl", GL_FRAGMENT_SHADER));
-		gGlowCombineFXAAProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gGlowCombineFXAAProgram.createShader(NULL, NULL);
-		if (success)
-		{
-			gGlowCombineFXAAProgram.bind();
-			gGlowCombineFXAAProgram.uniform1i(sGlowMap, 0);
-			gGlowCombineFXAAProgram.uniform1i(sScreenMap, 1);
-			gGlowCombineFXAAProgram.unbind();
-		}
-	}
+        success = success && gHighlightProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gHighlightNormalProgram.mName = "Highlight Normals Shader";
+        gHighlightNormalProgram.mShaderFiles.clear();
+        gHighlightNormalProgram.mShaderFiles.push_back(make_pair("interface/highlightNormV.glsl", GL_VERTEX_SHADER));
+        gHighlightNormalProgram.mShaderFiles.push_back(make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
+        gHighlightNormalProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gHighlightNormalProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gHighlightSpecularProgram.mName = "Highlight Spec Shader";
+        gHighlightSpecularProgram.mShaderFiles.clear();
+        gHighlightSpecularProgram.mShaderFiles.push_back(make_pair("interface/highlightSpecV.glsl", GL_VERTEX_SHADER));
+        gHighlightSpecularProgram.mShaderFiles.push_back(make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
+        gHighlightSpecularProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gHighlightSpecularProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gUIProgram.mName = "UI Shader";
+        gUIProgram.mShaderFiles.clear();
+        gUIProgram.mShaderFiles.push_back(make_pair("interface/uiV.glsl", GL_VERTEX_SHADER));
+        gUIProgram.mShaderFiles.push_back(make_pair("interface/uiF.glsl", GL_FRAGMENT_SHADER));
+        gUIProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gUIProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gPathfindingProgram.mName = "Pathfinding Shader";
+        gPathfindingProgram.mShaderFiles.clear();
+        gPathfindingProgram.mShaderFiles.push_back(make_pair("interface/pathfindingV.glsl", GL_VERTEX_SHADER));
+        gPathfindingProgram.mShaderFiles.push_back(make_pair("interface/pathfindingF.glsl", GL_FRAGMENT_SHADER));
+        gPathfindingProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gPathfindingProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gPathfindingNoNormalsProgram.mName = "PathfindingNoNormals Shader";
+        gPathfindingNoNormalsProgram.mShaderFiles.clear();
+        gPathfindingNoNormalsProgram.mShaderFiles.push_back(make_pair("interface/pathfindingNoNormalV.glsl", GL_VERTEX_SHADER));
+        gPathfindingNoNormalsProgram.mShaderFiles.push_back(make_pair("interface/pathfindingF.glsl", GL_FRAGMENT_SHADER));
+        gPathfindingNoNormalsProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gPathfindingNoNormalsProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gGlowCombineProgram.mName = "Glow Combine Shader";
+        gGlowCombineProgram.mShaderFiles.clear();
+        gGlowCombineProgram.mShaderFiles.push_back(make_pair("interface/glowcombineV.glsl", GL_VERTEX_SHADER));
+        gGlowCombineProgram.mShaderFiles.push_back(make_pair("interface/glowcombineF.glsl", GL_FRAGMENT_SHADER));
+        gGlowCombineProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gGlowCombineProgram.createShader(NULL, NULL);
+        if (success)
+        {
+            gGlowCombineProgram.bind();
+            gGlowCombineProgram.uniform1i(sGlowMap, 0);
+            gGlowCombineProgram.uniform1i(sScreenMap, 1);
+            gGlowCombineProgram.unbind();
+        }
+    }
+
+    if (success)
+    {
+        gGlowCombineFXAAProgram.mName = "Glow CombineFXAA Shader";
+        gGlowCombineFXAAProgram.mShaderFiles.clear();
+        gGlowCombineFXAAProgram.mShaderFiles.push_back(make_pair("interface/glowcombineFXAAV.glsl", GL_VERTEX_SHADER));
+        gGlowCombineFXAAProgram.mShaderFiles.push_back(make_pair("interface/glowcombineFXAAF.glsl", GL_FRAGMENT_SHADER));
+        gGlowCombineFXAAProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gGlowCombineFXAAProgram.createShader(NULL, NULL);
+        if (success)
+        {
+            gGlowCombineFXAAProgram.bind();
+            gGlowCombineFXAAProgram.uniform1i(sGlowMap, 0);
+            gGlowCombineFXAAProgram.uniform1i(sScreenMap, 1);
+            gGlowCombineFXAAProgram.unbind();
+        }
+    }
 
 #ifdef LL_WINDOWS
-	if (success)
-	{
-		gTwoTextureCompareProgram.mName = "Two Texture Compare Shader";
-		gTwoTextureCompareProgram.mShaderFiles.clear();
-		gTwoTextureCompareProgram.mShaderFiles.push_back(make_pair("interface/twotexturecompareV.glsl", GL_VERTEX_SHADER));
-		gTwoTextureCompareProgram.mShaderFiles.push_back(make_pair("interface/twotexturecompareF.glsl", GL_FRAGMENT_SHADER));
-		gTwoTextureCompareProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gTwoTextureCompareProgram.createShader(NULL, NULL);
-		if (success)
-		{
-			gTwoTextureCompareProgram.bind();
-			gTwoTextureCompareProgram.uniform1i(sTex0, 0);
-			gTwoTextureCompareProgram.uniform1i(sTex1, 1);
-			gTwoTextureCompareProgram.uniform1i(sDitherTex, 2);
-		}
-	}
-
-	if (success)
-	{
-		gOneTextureFilterProgram.mName = "One Texture Filter Shader";
-		gOneTextureFilterProgram.mShaderFiles.clear();
-		gOneTextureFilterProgram.mShaderFiles.push_back(make_pair("interface/onetexturefilterV.glsl", GL_VERTEX_SHADER));
-		gOneTextureFilterProgram.mShaderFiles.push_back(make_pair("interface/onetexturefilterF.glsl", GL_FRAGMENT_SHADER));
-		gOneTextureFilterProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gOneTextureFilterProgram.createShader(NULL, NULL);
-		if (success)
-		{
-			gOneTextureFilterProgram.bind();
-			gOneTextureFilterProgram.uniform1i(sTex0, 0);
-		}
-	}
+    if (success)
+    {
+        gTwoTextureCompareProgram.mName = "Two Texture Compare Shader";
+        gTwoTextureCompareProgram.mShaderFiles.clear();
+        gTwoTextureCompareProgram.mShaderFiles.push_back(make_pair("interface/twotexturecompareV.glsl", GL_VERTEX_SHADER));
+        gTwoTextureCompareProgram.mShaderFiles.push_back(make_pair("interface/twotexturecompareF.glsl", GL_FRAGMENT_SHADER));
+        gTwoTextureCompareProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gTwoTextureCompareProgram.createShader(NULL, NULL);
+        if (success)
+        {
+            gTwoTextureCompareProgram.bind();
+            gTwoTextureCompareProgram.uniform1i(sTex0, 0);
+            gTwoTextureCompareProgram.uniform1i(sTex1, 1);
+            gTwoTextureCompareProgram.uniform1i(sDitherTex, 2);
+        }
+    }
+
+    if (success)
+    {
+        gOneTextureFilterProgram.mName = "One Texture Filter Shader";
+        gOneTextureFilterProgram.mShaderFiles.clear();
+        gOneTextureFilterProgram.mShaderFiles.push_back(make_pair("interface/onetexturefilterV.glsl", GL_VERTEX_SHADER));
+        gOneTextureFilterProgram.mShaderFiles.push_back(make_pair("interface/onetexturefilterF.glsl", GL_FRAGMENT_SHADER));
+        gOneTextureFilterProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gOneTextureFilterProgram.createShader(NULL, NULL);
+        if (success)
+        {
+            gOneTextureFilterProgram.bind();
+            gOneTextureFilterProgram.uniform1i(sTex0, 0);
+        }
+    }
 #endif
 
-	if (success)
-	{
-		gSolidColorProgram.mName = "Solid Color Shader";
-		gSolidColorProgram.mShaderFiles.clear();
-		gSolidColorProgram.mShaderFiles.push_back(make_pair("interface/solidcolorV.glsl", GL_VERTEX_SHADER));
-		gSolidColorProgram.mShaderFiles.push_back(make_pair("interface/solidcolorF.glsl", GL_FRAGMENT_SHADER));
-		gSolidColorProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gSolidColorProgram.createShader(NULL, NULL);
-		if (success)
-		{
-			gSolidColorProgram.bind();
-			gSolidColorProgram.uniform1i(sTex0, 0);
-			gSolidColorProgram.unbind();
-		}
-	}
-
-	if (success)
-	{
-		gOcclusionProgram.mName = "Occlusion Shader";
-		gOcclusionProgram.mShaderFiles.clear();
-		gOcclusionProgram.mShaderFiles.push_back(make_pair("interface/occlusionV.glsl", GL_VERTEX_SHADER));
-		gOcclusionProgram.mShaderFiles.push_back(make_pair("interface/occlusionF.glsl", GL_FRAGMENT_SHADER));
-		gOcclusionProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+    if (success)
+    {
+        gSolidColorProgram.mName = "Solid Color Shader";
+        gSolidColorProgram.mShaderFiles.clear();
+        gSolidColorProgram.mShaderFiles.push_back(make_pair("interface/solidcolorV.glsl", GL_VERTEX_SHADER));
+        gSolidColorProgram.mShaderFiles.push_back(make_pair("interface/solidcolorF.glsl", GL_FRAGMENT_SHADER));
+        gSolidColorProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gSolidColorProgram.createShader(NULL, NULL);
+        if (success)
+        {
+            gSolidColorProgram.bind();
+            gSolidColorProgram.uniform1i(sTex0, 0);
+            gSolidColorProgram.unbind();
+        }
+    }
+
+    if (success)
+    {
+        gOcclusionProgram.mName = "Occlusion Shader";
+        gOcclusionProgram.mShaderFiles.clear();
+        gOcclusionProgram.mShaderFiles.push_back(make_pair("interface/occlusionV.glsl", GL_VERTEX_SHADER));
+        gOcclusionProgram.mShaderFiles.push_back(make_pair("interface/occlusionF.glsl", GL_FRAGMENT_SHADER));
+        gOcclusionProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
         gOcclusionProgram.mRiggedVariant = &gSkinnedOcclusionProgram;
-		success = gOcclusionProgram.createShader(NULL, NULL);
-	}
+        success = gOcclusionProgram.createShader(NULL, NULL);
+    }
 
     if (success)
     {
@@ -2741,30 +2741,30 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
         success = gSkinnedOcclusionProgram.createShader(NULL, NULL);
     }
 
-	if (success)
-	{
-		gOcclusionCubeProgram.mName = "Occlusion Cube Shader";
-		gOcclusionCubeProgram.mShaderFiles.clear();
-		gOcclusionCubeProgram.mShaderFiles.push_back(make_pair("interface/occlusionCubeV.glsl", GL_VERTEX_SHADER));
-		gOcclusionCubeProgram.mShaderFiles.push_back(make_pair("interface/occlusionF.glsl", GL_FRAGMENT_SHADER));
-		gOcclusionCubeProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gOcclusionCubeProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gDebugProgram.mName = "Debug Shader";
-		gDebugProgram.mShaderFiles.clear();
-		gDebugProgram.mShaderFiles.push_back(make_pair("interface/debugV.glsl", GL_VERTEX_SHADER));
-		gDebugProgram.mShaderFiles.push_back(make_pair("interface/debugF.glsl", GL_FRAGMENT_SHADER));
+    if (success)
+    {
+        gOcclusionCubeProgram.mName = "Occlusion Cube Shader";
+        gOcclusionCubeProgram.mShaderFiles.clear();
+        gOcclusionCubeProgram.mShaderFiles.push_back(make_pair("interface/occlusionCubeV.glsl", GL_VERTEX_SHADER));
+        gOcclusionCubeProgram.mShaderFiles.push_back(make_pair("interface/occlusionF.glsl", GL_FRAGMENT_SHADER));
+        gOcclusionCubeProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gOcclusionCubeProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gDebugProgram.mName = "Debug Shader";
+        gDebugProgram.mShaderFiles.clear();
+        gDebugProgram.mShaderFiles.push_back(make_pair("interface/debugV.glsl", GL_VERTEX_SHADER));
+        gDebugProgram.mShaderFiles.push_back(make_pair("interface/debugF.glsl", GL_FRAGMENT_SHADER));
         gDebugProgram.mRiggedVariant = &gSkinnedDebugProgram;
-		gDebugProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        gDebugProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
         success = make_rigged_variant(gDebugProgram, gSkinnedDebugProgram);
-		success = success && gDebugProgram.createShader(NULL, NULL);
-	}
+        success = success && gDebugProgram.createShader(NULL, NULL);
+    }
 
-	if (success)
-	{
+    if (success)
+    {
         for (S32 variant = 0; variant < NORMAL_DEBUG_SHADER_COUNT; ++variant)
         {
             LLGLSLShader& shader = gNormalDebugProgram[variant];
@@ -2788,27 +2788,27 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
             success = make_rigged_variant(shader, skinned_shader);
             success = success && shader.createShader(NULL, NULL);
         }
-	}
-
-	if (success)
-	{
-		gClipProgram.mName = "Clip Shader";
-		gClipProgram.mShaderFiles.clear();
-		gClipProgram.mShaderFiles.push_back(make_pair("interface/clipV.glsl", GL_VERTEX_SHADER));
-		gClipProgram.mShaderFiles.push_back(make_pair("interface/clipF.glsl", GL_FRAGMENT_SHADER));
-		gClipProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gClipProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gBenchmarkProgram.mName = "Benchmark Shader";
-		gBenchmarkProgram.mShaderFiles.clear();
-		gBenchmarkProgram.mShaderFiles.push_back(make_pair("interface/benchmarkV.glsl", GL_VERTEX_SHADER));
-		gBenchmarkProgram.mShaderFiles.push_back(make_pair("interface/benchmarkF.glsl", GL_FRAGMENT_SHADER));
-		gBenchmarkProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gBenchmarkProgram.createShader(NULL, NULL);
-	}
+    }
+
+    if (success)
+    {
+        gClipProgram.mName = "Clip Shader";
+        gClipProgram.mShaderFiles.clear();
+        gClipProgram.mShaderFiles.push_back(make_pair("interface/clipV.glsl", GL_VERTEX_SHADER));
+        gClipProgram.mShaderFiles.push_back(make_pair("interface/clipF.glsl", GL_FRAGMENT_SHADER));
+        gClipProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gClipProgram.createShader(NULL, NULL);
+    }
+
+    if (success)
+    {
+        gBenchmarkProgram.mName = "Benchmark Shader";
+        gBenchmarkProgram.mShaderFiles.clear();
+        gBenchmarkProgram.mShaderFiles.push_back(make_pair("interface/benchmarkV.glsl", GL_VERTEX_SHADER));
+        gBenchmarkProgram.mShaderFiles.push_back(make_pair("interface/benchmarkF.glsl", GL_FRAGMENT_SHADER));
+        gBenchmarkProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gBenchmarkProgram.createShader(NULL, NULL);
+    }
 
     if (success)
     {
@@ -2847,16 +2847,16 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
         gCopyDepthProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
         success = gCopyDepthProgram.createShader(NULL, NULL);
     }
-    
-	if (success)
-	{
-		gAlphaMaskProgram.mName = "Alpha Mask Shader";
-		gAlphaMaskProgram.mShaderFiles.clear();
-		gAlphaMaskProgram.mShaderFiles.push_back(make_pair("interface/alphamaskV.glsl", GL_VERTEX_SHADER));
-		gAlphaMaskProgram.mShaderFiles.push_back(make_pair("interface/alphamaskF.glsl", GL_FRAGMENT_SHADER));
-		gAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
-		success = gAlphaMaskProgram.createShader(NULL, NULL);
-	}
+
+    if (success)
+    {
+        gAlphaMaskProgram.mName = "Alpha Mask Shader";
+        gAlphaMaskProgram.mShaderFiles.clear();
+        gAlphaMaskProgram.mShaderFiles.push_back(make_pair("interface/alphamaskV.glsl", GL_VERTEX_SHADER));
+        gAlphaMaskProgram.mShaderFiles.push_back(make_pair("interface/alphamaskF.glsl", GL_FRAGMENT_SHADER));
+        gAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_INTERFACE];
+        success = gAlphaMaskProgram.createShader(NULL, NULL);
+    }
 
     if (success)
     {
@@ -2896,7 +2896,7 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
         gRadianceGenProgram.addPermutation("PROBE_FILTER_SAMPLES", "32");
         success = gRadianceGenProgram.createShader(NULL, NULL);
     }
-	
+
     if (success && gGLManager.mHasCubeMapArray)
     {
         gHeroRadianceGenProgram.mName = "Hero Radiance Gen Shader";
@@ -2919,19 +2919,19 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
         success = gIrradianceGenProgram.createShader(NULL, NULL);
     }
 
-	if( !success )
-	{
-		mShaderLevel[SHADER_INTERFACE] = 0;
-		return FALSE;
-	}
-	
-	return TRUE;
+    if( !success )
+    {
+        mShaderLevel[SHADER_INTERFACE] = 0;
+        return FALSE;
+    }
+
+    return TRUE;
 }
 
 
 std::string LLViewerShaderMgr::getShaderDirPrefix(void)
 {
-	return gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "shaders/class");
+    return gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "shaders/class");
 }
 
 void LLViewerShaderMgr::updateShaderUniforms(LLGLSLShader * shader)
@@ -2941,11 +2941,11 @@ void LLViewerShaderMgr::updateShaderUniforms(LLGLSLShader * shader)
 
 LLViewerShaderMgr::shader_iter LLViewerShaderMgr::beginShaders() const
 {
-	return mShaderList.begin();
+    return mShaderList.begin();
 }
 
 LLViewerShaderMgr::shader_iter LLViewerShaderMgr::endShaders() const
 {
-	return mShaderList.end();
+    return mShaderList.end();
 }