merge

15 files changed, 1090 insertions, 1279 deletions

diff --git a/.hgtags b/.hgtags
index 5fb06c3609..8f6b31ecc6 100755
--- a/.hgtags
+++ b/.hgtags
@@ -494,3 +494,4 @@ bcc2770e21c125e0bab59141c51db9145aec068d 3.7.17-release
 82973b38a6c9a457333e3519e4f2b16bb5eedf47 3.7.19-release
 27094824773b907c2e559396e6f9ec3a963de52d 3.7.20-release
 9ecab4b0c7d8614767724a3422d3c1dca6bd4e4f 3.7.21-release
+bc61801f614022c920cb5c3df1d7d67a9561ce1f 3.7.22-release
diff --git a/indra/llimage/llimagefilter.cpp b/indra/llimage/llimagefilter.cpp
index 3d0c488768..0b9d136910 100755
--- a/indra/llimage/llimagefilter.cpp
+++ b/indra/llimage/llimagefilter.cpp
@@ -266,7 +266,7 @@ void LLImageFilter::executeFilter(LLPointer<LLImageRaw> raw_image)
         }
         else
         {
-            llwarns << "Filter unknown, cannot execute filter command : " << filter_name << llendl;
+            LL_WARNS() << "Filter unknown, cannot execute filter command : " << filter_name << LL_ENDL;
         }
     }
 }
diff --git a/indra/llprimitive/llmodel.cpp b/indra/llprimitive/llmodel.cpp
index b4963225dc..b19df0200d 100755
--- a/indra/llprimitive/llmodel.cpp
+++ b/indra/llprimitive/llmodel.cpp
@@ -172,7 +172,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
 
 	if (!pos_source)
 	{
-		llwarns << "Unable to process mesh without position data; invalid model;  invalid model." << llendl;
+		LL_WARNS() << "Unable to process mesh without position data; invalid model;  invalid model." << LL_ENDL;
 		return LLModel::BAD_ELEMENT;
 	}
 	
@@ -193,7 +193,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
 
 	if ((vertex_count == 0) || (tc_count == 0))
 	{
-		llwarns << "Unable to process mesh with empty position array; invalid model." << llendl;
+		LL_WARNS() << "Unable to process mesh with empty position array; invalid model." << LL_ENDL;
 		return LLModel::BAD_ELEMENT;
 	}
 
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index b81dd4c9a1..3ceed95248 100755
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -61,33 +61,33 @@ U64 LLGLSLShader::sTotalSamplesDrawn = 0;
 U32 LLGLSLShader::sTotalDrawCalls = 0;
 
 //UI shader -- declared here so llui_libtest will link properly
-LLGLSLShader	gUIProgram;
-LLGLSLShader	gSolidColorProgram;
+LLGLSLShader    gUIProgram;
+LLGLSLShader    gSolidColorProgram;
 
 BOOL shouldChange(const LLVector4& v1, const LLVector4& v2)
 {
-	return v1 != v2;
+    return v1 != v2;
 }
 
 LLShaderFeatures::LLShaderFeatures()
-	: atmosphericHelpers(false)
-	, calculatesLighting(false)
-	, calculatesAtmospherics(false)
-	, hasLighting(false)
-	, isAlphaLighting(false)
-	, isShiny(false)
-	, isFullbright(false)
-	, isSpecular(false)
-	, hasWaterFog(false)
-	, hasTransport(false)
-	, hasSkinning(false)
-	, hasObjectSkinning(false)
-	, hasAtmospherics(false)
-	, hasGamma(false)
-	, mIndexedTextureChannels(0)
-	, disableTextureIndex(false)
-	, hasAlphaMask(false)
-	, attachNothing(false)
+    : atmosphericHelpers(false)
+    , calculatesLighting(false)
+    , calculatesAtmospherics(false)
+    , hasLighting(false)
+    , isAlphaLighting(false)
+    , isShiny(false)
+    , isFullbright(false)
+    , isSpecular(false)
+    , hasWaterFog(false)
+    , hasTransport(false)
+    , hasSkinning(false)
+    , hasObjectSkinning(false)
+    , hasAtmospherics(false)
+    , hasGamma(false)
+    , mIndexedTextureChannels(0)
+    , disableTextureIndex(false)
+    , hasAlphaMask(false)
+    , attachNothing(false)
 {
 }
 
@@ -98,225 +98,225 @@ LLShaderFeatures::LLShaderFeatures()
 //static
 void LLGLSLShader::initProfile()
 {
-	sProfileEnabled = true;
-	sTotalTimeElapsed = 0;
-	sTotalTrianglesDrawn = 0;
-	sTotalSamplesDrawn = 0;
-	sTotalDrawCalls = 0;
-
-	for (std::set<LLGLSLShader*>::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
-	{
-		(*iter)->clearStats();
-	}
+    sProfileEnabled = true;
+    sTotalTimeElapsed = 0;
+    sTotalTrianglesDrawn = 0;
+    sTotalSamplesDrawn = 0;
+    sTotalDrawCalls = 0;
+
+    for (std::set<LLGLSLShader*>::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
+    {
+        (*iter)->clearStats();
+    }
 }
 
 
 struct LLGLSLShaderCompareTimeElapsed
 {
-		bool operator()(const LLGLSLShader* const& lhs, const LLGLSLShader* const& rhs)
-		{
-			return lhs->mTimeElapsed < rhs->mTimeElapsed;
-		}
+        bool operator()(const LLGLSLShader* const& lhs, const LLGLSLShader* const& rhs)
+        {
+            return lhs->mTimeElapsed < rhs->mTimeElapsed;
+        }
 };
 
 //static
 void LLGLSLShader::finishProfile(bool emit_report)
 {
-	sProfileEnabled = false;
-
-	if (emit_report)
-	{
-		std::vector<LLGLSLShader*> sorted;
-
-		for (std::set<LLGLSLShader*>::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
-		{
-			sorted.push_back(*iter);
-		}
-
-		std::sort(sorted.begin(), sorted.end(), LLGLSLShaderCompareTimeElapsed());
-
-		for (std::vector<LLGLSLShader*>::iterator iter = sorted.begin(); iter != sorted.end(); ++iter)
-		{
-			(*iter)->dumpStats();
-		}
-			
-	LL_INFOS() << "-----------------------------------" << LL_ENDL;
-	LL_INFOS() << "Total rendering time: " << llformat("%.4f ms", sTotalTimeElapsed/1000000.f) << LL_ENDL;
-	LL_INFOS() << "Total samples drawn: " << llformat("%.4f million", sTotalSamplesDrawn/1000000.f) << LL_ENDL;
-	LL_INFOS() << "Total triangles drawn: " << llformat("%.3f million", sTotalTrianglesDrawn/1000000.f) << LL_ENDL;
-	}
+    sProfileEnabled = false;
+
+    if (emit_report)
+    {
+        std::vector<LLGLSLShader*> sorted;
+
+        for (std::set<LLGLSLShader*>::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
+        {
+            sorted.push_back(*iter);
+        }
+
+        std::sort(sorted.begin(), sorted.end(), LLGLSLShaderCompareTimeElapsed());
+
+        for (std::vector<LLGLSLShader*>::iterator iter = sorted.begin(); iter != sorted.end(); ++iter)
+        {
+            (*iter)->dumpStats();
+        }
+            
+    LL_INFOS() << "-----------------------------------" << LL_ENDL;
+    LL_INFOS() << "Total rendering time: " << llformat("%.4f ms", sTotalTimeElapsed/1000000.f) << LL_ENDL;
+    LL_INFOS() << "Total samples drawn: " << llformat("%.4f million", sTotalSamplesDrawn/1000000.f) << LL_ENDL;
+    LL_INFOS() << "Total triangles drawn: " << llformat("%.3f million", sTotalTrianglesDrawn/1000000.f) << LL_ENDL;
+    }
 }
 
 void LLGLSLShader::clearStats()
 {
-	mTrianglesDrawn = 0;
-	mTimeElapsed = 0;
-	mSamplesDrawn = 0;
-	mDrawCalls = 0;
-	mTextureStateFetched = false;
-	mTextureMagFilter.clear();
-	mTextureMinFilter.clear();
+    mTrianglesDrawn = 0;
+    mTimeElapsed = 0;
+    mSamplesDrawn = 0;
+    mDrawCalls = 0;
+    mTextureStateFetched = false;
+    mTextureMagFilter.clear();
+    mTextureMinFilter.clear();
 }
 
 void LLGLSLShader::dumpStats()
 {
-	if (mDrawCalls > 0)
-	{
-		LL_INFOS() << "=============================================" << LL_ENDL;
-		LL_INFOS() << mName << LL_ENDL;
-		for (U32 i = 0; i < mShaderFiles.size(); ++i)
-		{
-			LL_INFOS() << mShaderFiles[i].first << LL_ENDL;
-		}
-		for (U32 i = 0; i < mTexture.size(); ++i)
-		{
-			GLint idx = mTexture[i];
-			
-			if (idx >= 0)
-			{
-				GLint uniform_idx = getUniformLocation(i);
-				LL_INFOS() << mUniformNameMap[uniform_idx] << " - " << std::hex << mTextureMagFilter[i] << "/" << mTextureMinFilter[i] << std::dec << LL_ENDL;
-			}
-		}
-		LL_INFOS() << "=============================================" << LL_ENDL;
-	
-		F32 ms = mTimeElapsed/1000000.f;
-		F32 seconds = ms/1000.f;
-
-		F32 pct_tris = (F32) mTrianglesDrawn/(F32)sTotalTrianglesDrawn*100.f;
-		F32 tris_sec = (F32) (mTrianglesDrawn/1000000.0);
-		tris_sec /= seconds;
-
-		F32 pct_samples = (F32) ((F64)mSamplesDrawn/(F64)sTotalSamplesDrawn)*100.f;
-		F32 samples_sec = (F32) mSamplesDrawn/1000000000.0;
-		samples_sec /= seconds;
-
-		F32 pct_calls = (F32) mDrawCalls/(F32)sTotalDrawCalls*100.f;
-		U32 avg_batch = mTrianglesDrawn/mDrawCalls;
-
-		LL_INFOS() << "Triangles Drawn: " << mTrianglesDrawn <<  " " << llformat("(%.2f pct of total, %.3f million/sec)", pct_tris, tris_sec ) << LL_ENDL;
-		LL_INFOS() << "Draw Calls: " << mDrawCalls << " " << llformat("(%.2f pct of total, avg %d tris/call)", pct_calls, avg_batch) << LL_ENDL;
-		LL_INFOS() << "SamplesDrawn: " << mSamplesDrawn << " " << llformat("(%.2f pct of total, %.3f billion/sec)", pct_samples, samples_sec) << LL_ENDL;
-		LL_INFOS() << "Time Elapsed: " << mTimeElapsed << " " << llformat("(%.2f pct of total, %.5f ms)\n", (F32) ((F64)mTimeElapsed/(F64)sTotalTimeElapsed)*100.f, ms) << LL_ENDL;
-	}
+    if (mDrawCalls > 0)
+    {
+        LL_INFOS() << "=============================================" << LL_ENDL;
+        LL_INFOS() << mName << LL_ENDL;
+        for (U32 i = 0; i < mShaderFiles.size(); ++i)
+        {
+            LL_INFOS() << mShaderFiles[i].first << LL_ENDL;
+        }
+        for (U32 i = 0; i < mTexture.size(); ++i)
+        {
+            GLint idx = mTexture[i];
+            
+            if (idx >= 0)
+            {
+                GLint uniform_idx = getUniformLocation(i);
+                LL_INFOS() << mUniformNameMap[uniform_idx] << " - " << std::hex << mTextureMagFilter[i] << "/" << mTextureMinFilter[i] << std::dec << LL_ENDL;
+            }
+        }
+        LL_INFOS() << "=============================================" << LL_ENDL;
+    
+        F32 ms = mTimeElapsed/1000000.f;
+        F32 seconds = ms/1000.f;
+
+        F32 pct_tris = (F32) mTrianglesDrawn/(F32)sTotalTrianglesDrawn*100.f;
+        F32 tris_sec = (F32) (mTrianglesDrawn/1000000.0);
+        tris_sec /= seconds;
+
+        F32 pct_samples = (F32) ((F64)mSamplesDrawn/(F64)sTotalSamplesDrawn)*100.f;
+        F32 samples_sec = (F32) mSamplesDrawn/1000000000.0;
+        samples_sec /= seconds;
+
+        F32 pct_calls = (F32) mDrawCalls/(F32)sTotalDrawCalls*100.f;
+        U32 avg_batch = mTrianglesDrawn/mDrawCalls;
+
+        LL_INFOS() << "Triangles Drawn: " << mTrianglesDrawn <<  " " << llformat("(%.2f pct of total, %.3f million/sec)", pct_tris, tris_sec ) << LL_ENDL;
+        LL_INFOS() << "Draw Calls: " << mDrawCalls << " " << llformat("(%.2f pct of total, avg %d tris/call)", pct_calls, avg_batch) << LL_ENDL;
+        LL_INFOS() << "SamplesDrawn: " << mSamplesDrawn << " " << llformat("(%.2f pct of total, %.3f billion/sec)", pct_samples, samples_sec) << LL_ENDL;
+        LL_INFOS() << "Time Elapsed: " << mTimeElapsed << " " << llformat("(%.2f pct of total, %.5f ms)\n", (F32) ((F64)mTimeElapsed/(F64)sTotalTimeElapsed)*100.f, ms) << LL_ENDL;
+    }
 }
 
 //static
 void LLGLSLShader::startProfile()
 {
-	if (sProfileEnabled && sCurBoundShaderPtr)
-	{
-		sCurBoundShaderPtr->placeProfileQuery();
-	}
+    if (sProfileEnabled && sCurBoundShaderPtr)
+    {
+        sCurBoundShaderPtr->placeProfileQuery();
+    }
 
 }
 
 //static
 void LLGLSLShader::stopProfile(U32 count, U32 mode)
 {
-	if (sProfileEnabled)
-	{
-		sCurBoundShaderPtr->readProfileQuery(count, mode);
-	}
+    if (sProfileEnabled && sCurBoundShaderPtr)
+    {
+        sCurBoundShaderPtr->readProfileQuery(count, mode);
+    }
 }
 
 void LLGLSLShader::placeProfileQuery()
 {
 #if !LL_DARWIN
-	if (mTimerQuery == 0)
-	{
-		glGenQueriesARB(1, &mSamplesQuery);
-		glGenQueriesARB(1, &mTimerQuery);
-	}
+    if (mTimerQuery == 0)
+    {
+        glGenQueriesARB(1, &mSamplesQuery);
+        glGenQueriesARB(1, &mTimerQuery);
+    }
 
-	if (!mTextureStateFetched)
-	{
-		mTextureStateFetched = true;
-		mTextureMagFilter.resize(mTexture.size());
-		mTextureMinFilter.resize(mTexture.size());
+    if (!mTextureStateFetched)
+    {
+        mTextureStateFetched = true;
+        mTextureMagFilter.resize(mTexture.size());
+        mTextureMinFilter.resize(mTexture.size());
 
-		U32 cur_active = gGL.getCurrentTexUnitIndex();
+        U32 cur_active = gGL.getCurrentTexUnitIndex();
 
-		for (U32 i = 0; i < mTexture.size(); ++i)
-		{
-			GLint idx = mTexture[i];
+        for (U32 i = 0; i < mTexture.size(); ++i)
+        {
+            GLint idx = mTexture[i];
 
-			if (idx >= 0)
-			{
-				gGL.getTexUnit(idx)->activate();
+            if (idx >= 0)
+            {
+                gGL.getTexUnit(idx)->activate();
 
-				U32 mag = 0xFFFFFFFF;
-				U32 min = 0xFFFFFFFF;
+                U32 mag = 0xFFFFFFFF;
+                U32 min = 0xFFFFFFFF;
 
-				U32 type = LLTexUnit::getInternalType(gGL.getTexUnit(idx)->getCurrType());
+                U32 type = LLTexUnit::getInternalType(gGL.getTexUnit(idx)->getCurrType());
 
-				glGetTexParameteriv(type, GL_TEXTURE_MAG_FILTER, (GLint*) &mag);
-				glGetTexParameteriv(type, GL_TEXTURE_MIN_FILTER, (GLint*) &min);
+                glGetTexParameteriv(type, GL_TEXTURE_MAG_FILTER, (GLint*) &mag);
+                glGetTexParameteriv(type, GL_TEXTURE_MIN_FILTER, (GLint*) &min);
 
-				mTextureMagFilter[i] = mag;
-				mTextureMinFilter[i] = min;
-			}
-		}
+                mTextureMagFilter[i] = mag;
+                mTextureMinFilter[i] = min;
+            }
+        }
 
-		gGL.getTexUnit(cur_active)->activate();
-	}
+        gGL.getTexUnit(cur_active)->activate();
+    }
 
 
-	glBeginQueryARB(GL_SAMPLES_PASSED, mSamplesQuery);
-	glBeginQueryARB(GL_TIME_ELAPSED, mTimerQuery);
+    glBeginQueryARB(GL_SAMPLES_PASSED, mSamplesQuery);
+    glBeginQueryARB(GL_TIME_ELAPSED, mTimerQuery);
 #endif
 }
 
 void LLGLSLShader::readProfileQuery(U32 count, U32 mode)
 {
 #if !LL_DARWIN
-	glEndQueryARB(GL_TIME_ELAPSED);
-	glEndQueryARB(GL_SAMPLES_PASSED);
-	
-	U64 time_elapsed = 0;
-	glGetQueryObjectui64v(mTimerQuery, GL_QUERY_RESULT, &time_elapsed);
-
-	U64 samples_passed = 0;
-	glGetQueryObjectui64v(mSamplesQuery, GL_QUERY_RESULT, &samples_passed);
-
-	sTotalTimeElapsed += time_elapsed;
-	mTimeElapsed += time_elapsed;
-
-	sTotalSamplesDrawn += samples_passed;
-	mSamplesDrawn += samples_passed;
-
-	U32 tri_count = 0;
-	switch (mode)
-	{
-		case LLRender::TRIANGLES: tri_count = count/3; break;
-		case LLRender::TRIANGLE_FAN: tri_count = count-2; break;
-		case LLRender::TRIANGLE_STRIP: tri_count = count-2; break;
-		default: tri_count = count; break; //points lines etc just use primitive count
-	}
-
-	mTrianglesDrawn += tri_count;
-	sTotalTrianglesDrawn += tri_count;
-
-	sTotalDrawCalls++;
-	mDrawCalls++;
+    glEndQueryARB(GL_TIME_ELAPSED);
+    glEndQueryARB(GL_SAMPLES_PASSED);
+    
+    U64 time_elapsed = 0;
+    glGetQueryObjectui64v(mTimerQuery, GL_QUERY_RESULT, &time_elapsed);
+
+    U64 samples_passed = 0;
+    glGetQueryObjectui64v(mSamplesQuery, GL_QUERY_RESULT, &samples_passed);
+
+    sTotalTimeElapsed += time_elapsed;
+    mTimeElapsed += time_elapsed;
+
+    sTotalSamplesDrawn += samples_passed;
+    mSamplesDrawn += samples_passed;
+
+    U32 tri_count = 0;
+    switch (mode)
+    {
+        case LLRender::TRIANGLES: tri_count = count/3; break;
+        case LLRender::TRIANGLE_FAN: tri_count = count-2; break;
+        case LLRender::TRIANGLE_STRIP: tri_count = count-2; break;
+        default: tri_count = count; break; //points lines etc just use primitive count
+    }
+
+    mTrianglesDrawn += tri_count;
+    sTotalTrianglesDrawn += tri_count;
+
+    sTotalDrawCalls++;
+    mDrawCalls++;
 #endif
 }
 
 
 
 LLGLSLShader::LLGLSLShader()
-	: mProgramObject(0), 
-	  mAttributeMask(0),
-	  mTotalUniformSize(0),
-	  mActiveTextureChannels(0), 
-	  mShaderLevel(0), 
-	  mShaderGroup(SG_DEFAULT), 
-	  mUniformsDirty(FALSE),
-	  mTimerQuery(0),
-	  mSamplesQuery(0)
+    : mProgramObject(0), 
+      mAttributeMask(0),
+      mTotalUniformSize(0),
+      mActiveTextureChannels(0), 
+      mShaderLevel(0), 
+      mShaderGroup(SG_DEFAULT), 
+      mUniformsDirty(FALSE),
+      mTimerQuery(0),
+      mSamplesQuery(0)
 
 {
-	
+    
 }
 
 LLGLSLShader::~LLGLSLShader()
@@ -325,1077 +325,1077 @@ LLGLSLShader::~LLGLSLShader()
 
 void LLGLSLShader::unload()
 {
-	sInstances.erase(this);
-
-	stop_glerror();
-	mAttribute.clear();
-	mTexture.clear();
-	mUniform.clear();
-	mShaderFiles.clear();
-	mDefines.clear();
-
-	if (mProgramObject)
-	{
-		GLhandleARB obj[1024];
-		GLsizei count;
-
-		glGetAttachedObjectsARB(mProgramObject, 1024, &count, obj);
-		for (GLsizei i = 0; i < count; i++)
-		{
+    sInstances.erase(this);
+
+    stop_glerror();
+    mAttribute.clear();
+    mTexture.clear();
+    mUniform.clear();
+    mShaderFiles.clear();
+    mDefines.clear();
+
+    if (mProgramObject)
+    {
+        GLhandleARB obj[1024];
+        GLsizei count;
+
+        glGetAttachedObjectsARB(mProgramObject, 1024, &count, obj);
+        for (GLsizei i = 0; i < count; i++)
+        {
 #if !LL_DARWIN
-			if (glIsProgramARB(obj[i]))
+            if (glIsProgramARB(obj[i]))
 #endif
-			{
-				glDeleteObjectARB(obj[i]);
-			}
-		}
-
-		glDeleteObjectARB(mProgramObject);
-
-		mProgramObject = 0;
-	}
-	
-	if (mTimerQuery)
-	{
-		glDeleteQueriesARB(1, &mTimerQuery);
-		mTimerQuery = 0;
-	}
-	
-	if (mSamplesQuery)
-	{
-		glDeleteQueriesARB(1, &mSamplesQuery);
-		mSamplesQuery = 0;
-	}
-
-	//hack to make apple not complain
-	glGetError();
-	
-	stop_glerror();
+            {
+                glDeleteObjectARB(obj[i]);
+            }
+        }
+
+        glDeleteObjectARB(mProgramObject);
+
+        mProgramObject = 0;
+    }
+    
+    if (mTimerQuery)
+    {
+        glDeleteQueriesARB(1, &mTimerQuery);
+        mTimerQuery = 0;
+    }
+    
+    if (mSamplesQuery)
+    {
+        glDeleteQueriesARB(1, &mSamplesQuery);
+        mSamplesQuery = 0;
+    }
+
+    //hack to make apple not complain
+    glGetError();
+    
+    stop_glerror();
 }
 
 BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString> * attributes,
-								std::vector<LLStaticHashedString> * uniforms,
-								U32 varying_count,
-								const char** varyings)
+                                std::vector<LLStaticHashedString> * uniforms,
+                                U32 varying_count,
+                                const char** varyings)
 {
-	sInstances.insert(this);
+    sInstances.insert(this);
 
-	//reloading, reset matrix hash values
-	for (U32 i = 0; i < LLRender::NUM_MATRIX_MODES; ++i)
-	{
-		mMatHash[i] = 0xFFFFFFFF;
-	}
-	mLightHash = 0xFFFFFFFF;
+    //reloading, reset matrix hash values
+    for (U32 i = 0; i < LLRender::NUM_MATRIX_MODES; ++i)
+    {
+        mMatHash[i] = 0xFFFFFFFF;
+    }
+    mLightHash = 0xFFFFFFFF;
 
-	llassert_always(!mShaderFiles.empty());
-	BOOL success = TRUE;
+    llassert_always(!mShaderFiles.empty());
+    BOOL success = TRUE;
 
-	// Create program
-	mProgramObject = glCreateProgramObjectARB();
-	
+    // Create program
+    mProgramObject = glCreateProgramObjectARB();
+    
 #if LL_DARWIN
     // work-around missing mix(vec3,vec3,bvec3)
     mDefines["OLD_SELECT"] = "1";
 #endif
-	
-	//compile new source
-	vector< pair<string,GLenum> >::iterator fileIter = mShaderFiles.begin();
-	for ( ; fileIter != mShaderFiles.end(); fileIter++ )
-	{
-		GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second, &mDefines, mFeatures.mIndexedTextureChannels);
-		LL_DEBUGS("ShaderLoading") << "SHADER FILE: " << (*fileIter).first << " mShaderLevel=" << mShaderLevel << LL_ENDL;
-		if (shaderhandle > 0)
-		{
-			attachObject(shaderhandle);
-		}
-		else
-		{
-			success = FALSE;
-		}
-	}
-
-	// Attach existing objects
-	if (!LLShaderMgr::instance()->attachShaderFeatures(this))
-	{
-		return FALSE;
-	}
-
-	if (gGLManager.mGLSLVersionMajor < 2 && gGLManager.mGLSLVersionMinor < 3)
-	{ //indexed texture rendering requires GLSL 1.3 or later
-		//attachShaderFeatures may have set the number of indexed texture channels, so set to 1 again
-		mFeatures.mIndexedTextureChannels = llmin(mFeatures.mIndexedTextureChannels, 1);
-	}
+    
+    //compile new source
+    vector< pair<string,GLenum> >::iterator fileIter = mShaderFiles.begin();
+    for ( ; fileIter != mShaderFiles.end(); fileIter++ )
+    {
+        GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second, &mDefines, mFeatures.mIndexedTextureChannels);
+        LL_DEBUGS("ShaderLoading") << "SHADER FILE: " << (*fileIter).first << " mShaderLevel=" << mShaderLevel << LL_ENDL;
+        if (shaderhandle > 0)
+        {
+            attachObject(shaderhandle);
+        }
+        else
+        {
+            success = FALSE;
+        }
+    }
+
+    // Attach existing objects
+    if (!LLShaderMgr::instance()->attachShaderFeatures(this))
+    {
+        return FALSE;
+    }
+
+    if (gGLManager.mGLSLVersionMajor < 2 && gGLManager.mGLSLVersionMinor < 3)
+    { //indexed texture rendering requires GLSL 1.3 or later
+        //attachShaderFeatures may have set the number of indexed texture channels, so set to 1 again
+        mFeatures.mIndexedTextureChannels = llmin(mFeatures.mIndexedTextureChannels, 1);
+    }
 
 #ifdef GL_INTERLEAVED_ATTRIBS
-	if (varying_count > 0 && varyings)
-	{
-		glTransformFeedbackVaryings(mProgramObject, varying_count, varyings, GL_INTERLEAVED_ATTRIBS);
-	}
+    if (varying_count > 0 && varyings)
+    {
+        glTransformFeedbackVaryings(mProgramObject, varying_count, varyings, GL_INTERLEAVED_ATTRIBS);
+    }
 #endif
 
-	// Map attributes and uniforms
-	if (success)
-	{
-		success = mapAttributes(attributes);
-	}
-	if (success)
-	{
-		success = mapUniforms(uniforms);
-	}
-	if( !success )
-	{
-		LL_WARNS("ShaderLoading") << "Failed to link shader: " << mName << LL_ENDL;
-
-		// Try again using a lower shader level;
-		if (mShaderLevel > 0)
-		{
-			LL_WARNS("ShaderLoading") << "Failed to link using shader level " << mShaderLevel << " trying again using shader level " << (mShaderLevel - 1) << LL_ENDL;
-			mShaderLevel--;
-			return createShader(attributes,uniforms);
-		}
-	}
-	else if (mFeatures.mIndexedTextureChannels > 0)
-	{ //override texture channels for indexed texture rendering
-		bind();
-		S32 channel_count = mFeatures.mIndexedTextureChannels;
-
-		for (S32 i = 0; i < channel_count; i++)
-		{
-			LLStaticHashedString uniName(llformat("tex%d", i));
-			uniform1i(uniName, i);
-		}
-
-		S32 cur_tex = channel_count; //adjust any texture channels that might have been overwritten
-		for (U32 i = 0; i < mTexture.size(); i++)
-		{
-			if (mTexture[i] > -1 && mTexture[i] < channel_count)
-			{
-				llassert(cur_tex < gGLManager.mNumTextureImageUnits);
-				uniform1i(i, cur_tex);
-				mTexture[i] = cur_tex++;
-			}
-		}
-		unbind();
-	}
-
-	return success;
+    // Map attributes and uniforms
+    if (success)
+    {
+        success = mapAttributes(attributes);
+    }
+    if (success)
+    {
+        success = mapUniforms(uniforms);
+    }
+    if( !success )
+    {
+        LL_WARNS("ShaderLoading") << "Failed to link shader: " << mName << LL_ENDL;
+
+        // Try again using a lower shader level;
+        if (mShaderLevel > 0)
+        {
+            LL_WARNS("ShaderLoading") << "Failed to link using shader level " << mShaderLevel << " trying again using shader level " << (mShaderLevel - 1) << LL_ENDL;
+            mShaderLevel--;
+            return createShader(attributes,uniforms);
+        }
+    }
+    else if (mFeatures.mIndexedTextureChannels > 0)
+    { //override texture channels for indexed texture rendering
+        bind();
+        S32 channel_count = mFeatures.mIndexedTextureChannels;
+
+        for (S32 i = 0; i < channel_count; i++)
+        {
+            LLStaticHashedString uniName(llformat("tex%d", i));
+            uniform1i(uniName, i);
+        }
+
+        S32 cur_tex = channel_count; //adjust any texture channels that might have been overwritten
+        for (U32 i = 0; i < mTexture.size(); i++)
+        {
+            if (mTexture[i] > -1 && mTexture[i] < channel_count)
+            {
+                llassert(cur_tex < gGLManager.mNumTextureImageUnits);
+                uniform1i(i, cur_tex);
+                mTexture[i] = cur_tex++;
+            }
+        }
+        unbind();
+    }
+
+    return success;
 }
 
 BOOL LLGLSLShader::attachObject(std::string object)
 {
-	if (LLShaderMgr::instance()->mShaderObjects.count(object) > 0)
-	{
-		stop_glerror();
-		glAttachObjectARB(mProgramObject, LLShaderMgr::instance()->mShaderObjects[object]);
-		stop_glerror();
-		return TRUE;
-	}
-	else
-	{
-		LL_WARNS("ShaderLoading") << "Attempting to attach shader object that hasn't been compiled: " << object << LL_ENDL;
-		return FALSE;
-	}
+    if (LLShaderMgr::instance()->mShaderObjects.count(object) > 0)
+    {
+        stop_glerror();
+        glAttachObjectARB(mProgramObject, LLShaderMgr::instance()->mShaderObjects[object]);
+        stop_glerror();
+        return TRUE;
+    }
+    else
+    {
+        LL_WARNS("ShaderLoading") << "Attempting to attach shader object that hasn't been compiled: " << object << LL_ENDL;
+        return FALSE;
+    }
 }
 
 void LLGLSLShader::attachObject(GLhandleARB object)
 {
-	if (object != 0)
-	{
-		stop_glerror();
-		glAttachObjectARB(mProgramObject, object);
-		stop_glerror();
-	}
-	else
-	{
-		LL_WARNS("ShaderLoading") << "Attempting to attach non existing shader object. " << LL_ENDL;
-	}
+    if (object != 0)
+    {
+        stop_glerror();
+        glAttachObjectARB(mProgramObject, object);
+        stop_glerror();
+    }
+    else
+    {
+        LL_WARNS("ShaderLoading") << "Attempting to attach non existing shader object. " << LL_ENDL;
+    }
 }
 
 void LLGLSLShader::attachObjects(GLhandleARB* objects, S32 count)
 {
-	for (S32 i = 0; i < count; i++)
-	{
-		attachObject(objects[i]);
-	}
+    for (S32 i = 0; i < count; i++)
+    {
+        attachObject(objects[i]);
+    }
 }
 
 BOOL LLGLSLShader::mapAttributes(const std::vector<LLStaticHashedString> * attributes)
 {
-	//before linking, make sure reserved attributes always have consistent locations
-	for (U32 i = 0; i < LLShaderMgr::instance()->mReservedAttribs.size(); i++)
-	{
-		const char* name = LLShaderMgr::instance()->mReservedAttribs[i].c_str();
-		glBindAttribLocationARB(mProgramObject, i, (const GLcharARB *) name);
-	}
-	
-	//link the program
-	BOOL res = link();
-
-	mAttribute.clear();
-	U32 numAttributes = (attributes == NULL) ? 0 : attributes->size();
-	mAttribute.resize(LLShaderMgr::instance()->mReservedAttribs.size() + numAttributes, -1);
-	
-	if (res)
-	{ //read back channel locations
-
-		mAttributeMask = 0;
-
-		//read back reserved channels first
-		for (U32 i = 0; i < LLShaderMgr::instance()->mReservedAttribs.size(); i++)
-		{
-			const char* name = LLShaderMgr::instance()->mReservedAttribs[i].c_str();
-			S32 index = glGetAttribLocationARB(mProgramObject, (const GLcharARB *)name);
-			if (index != -1)
-			{
-				mAttribute[i] = index;
-				mAttributeMask |= 1 << i;
-				LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
-			}
-		}
-		if (attributes != NULL)
-		{
-			for (U32 i = 0; i < numAttributes; i++)
-			{
-				const char* name = (*attributes)[i].String().c_str();
-				S32 index = glGetAttribLocationARB(mProgramObject, name);
-				if (index != -1)
-				{
-					mAttribute[LLShaderMgr::instance()->mReservedAttribs.size() + i] = index;
-					LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
-				}
-			}
-		}
-
-		return TRUE;
-	}
-	
-	return FALSE;
+    //before linking, make sure reserved attributes always have consistent locations
+    for (U32 i = 0; i < LLShaderMgr::instance()->mReservedAttribs.size(); i++)
+    {
+        const char* name = LLShaderMgr::instance()->mReservedAttribs[i].c_str();
+        glBindAttribLocationARB(mProgramObject, i, (const GLcharARB *) name);
+    }
+    
+    //link the program
+    BOOL res = link();
+
+    mAttribute.clear();
+    U32 numAttributes = (attributes == NULL) ? 0 : attributes->size();
+    mAttribute.resize(LLShaderMgr::instance()->mReservedAttribs.size() + numAttributes, -1);
+    
+    if (res)
+    { //read back channel locations
+
+        mAttributeMask = 0;
+
+        //read back reserved channels first
+        for (U32 i = 0; i < LLShaderMgr::instance()->mReservedAttribs.size(); i++)
+        {
+            const char* name = LLShaderMgr::instance()->mReservedAttribs[i].c_str();
+            S32 index = glGetAttribLocationARB(mProgramObject, (const GLcharARB *)name);
+            if (index != -1)
+            {
+                mAttribute[i] = index;
+                mAttributeMask |= 1 << i;
+                LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
+            }
+        }
+        if (attributes != NULL)
+        {
+            for (U32 i = 0; i < numAttributes; i++)
+            {
+                const char* name = (*attributes)[i].String().c_str();
+                S32 index = glGetAttribLocationARB(mProgramObject, name);
+                if (index != -1)
+                {
+                    mAttribute[LLShaderMgr::instance()->mReservedAttribs.size() + i] = index;
+                    LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
+                }
+            }
+        }
+
+        return TRUE;
+    }
+    
+    return FALSE;
 }
 
 void LLGLSLShader::mapUniform(GLint index, const vector<LLStaticHashedString> * uniforms)
 {
-	if (index == -1)
-	{
-		return;
-	}
+    if (index == -1)
+    {
+        return;
+    }
 
-	GLenum type;
-	GLsizei length;
-	GLint size = -1;
-	char name[1024];		/* Flawfinder: ignore */
-	name[0] = 0;
+    GLenum type;
+    GLsizei length;
+    GLint size = -1;
+    char name[1024];        /* Flawfinder: ignore */
+    name[0] = 0;
 
 
-	glGetActiveUniformARB(mProgramObject, index, 1024, &length, &size, &type, (GLcharARB *)name);
+    glGetActiveUniformARB(mProgramObject, index, 1024, &length, &size, &type, (GLcharARB *)name);
 #if !LL_DARWIN
-	if (size > 0)
-	{
-		switch(type)
-		{
-			case GL_FLOAT_VEC2: size *= 2; break;
-			case GL_FLOAT_VEC3: size *= 3; break;
-			case GL_FLOAT_VEC4: size *= 4; break;
-			case GL_DOUBLE: size *= 2; break;
-			case GL_DOUBLE_VEC2: size *= 2; break;
-			case GL_DOUBLE_VEC3: size *= 6; break;
-			case GL_DOUBLE_VEC4: size *= 8; break;
-			case GL_INT_VEC2: size *= 2; break;
-			case GL_INT_VEC3: size *= 3; break;
-			case GL_INT_VEC4: size *= 4; break;
-			case GL_UNSIGNED_INT_VEC2: size *= 2; break;
-			case GL_UNSIGNED_INT_VEC3: size *= 3; break;
-			case GL_UNSIGNED_INT_VEC4: size *= 4; break;
-			case GL_BOOL_VEC2: size *= 2; break;
-			case GL_BOOL_VEC3: size *= 3; break;
-			case GL_BOOL_VEC4: size *= 4; break;
-			case GL_FLOAT_MAT2: size *= 4; break;
-			case GL_FLOAT_MAT3: size *= 9; break;
-			case GL_FLOAT_MAT4: size *= 16; break;
-			case GL_FLOAT_MAT2x3: size *= 6; break;
-			case GL_FLOAT_MAT2x4: size *= 8; break;
-			case GL_FLOAT_MAT3x2: size *= 6; break;
-			case GL_FLOAT_MAT3x4: size *= 12; break;
-			case GL_FLOAT_MAT4x2: size *= 8; break;
-			case GL_FLOAT_MAT4x3: size *= 12; break;
-			case GL_DOUBLE_MAT2: size *= 8; break;
-			case GL_DOUBLE_MAT3: size *= 18; break;
-			case GL_DOUBLE_MAT4: size *= 32; break;
-			case GL_DOUBLE_MAT2x3: size *= 12; break;
-			case GL_DOUBLE_MAT2x4: size *= 16; break;
-			case GL_DOUBLE_MAT3x2: size *= 12; break;
-			case GL_DOUBLE_MAT3x4: size *= 24; break;
-			case GL_DOUBLE_MAT4x2: size *= 16; break;
-			case GL_DOUBLE_MAT4x3: size *= 24; break;
-		}
-		mTotalUniformSize += size;
-	}
+    if (size > 0)
+    {
+        switch(type)
+        {
+            case GL_FLOAT_VEC2: size *= 2; break;
+            case GL_FLOAT_VEC3: size *= 3; break;
+            case GL_FLOAT_VEC4: size *= 4; break;
+            case GL_DOUBLE: size *= 2; break;
+            case GL_DOUBLE_VEC2: size *= 2; break;
+            case GL_DOUBLE_VEC3: size *= 6; break;
+            case GL_DOUBLE_VEC4: size *= 8; break;
+            case GL_INT_VEC2: size *= 2; break;
+            case GL_INT_VEC3: size *= 3; break;
+            case GL_INT_VEC4: size *= 4; break;
+            case GL_UNSIGNED_INT_VEC2: size *= 2; break;
+            case GL_UNSIGNED_INT_VEC3: size *= 3; break;
+            case GL_UNSIGNED_INT_VEC4: size *= 4; break;
+            case GL_BOOL_VEC2: size *= 2; break;
+            case GL_BOOL_VEC3: size *= 3; break;
+            case GL_BOOL_VEC4: size *= 4; break;
+            case GL_FLOAT_MAT2: size *= 4; break;
+            case GL_FLOAT_MAT3: size *= 9; break;
+            case GL_FLOAT_MAT4: size *= 16; break;
+            case GL_FLOAT_MAT2x3: size *= 6; break;
+            case GL_FLOAT_MAT2x4: size *= 8; break;
+            case GL_FLOAT_MAT3x2: size *= 6; break;
+            case GL_FLOAT_MAT3x4: size *= 12; break;
+            case GL_FLOAT_MAT4x2: size *= 8; break;
+            case GL_FLOAT_MAT4x3: size *= 12; break;
+            case GL_DOUBLE_MAT2: size *= 8; break;
+            case GL_DOUBLE_MAT3: size *= 18; break;
+            case GL_DOUBLE_MAT4: size *= 32; break;
+            case GL_DOUBLE_MAT2x3: size *= 12; break;
+            case GL_DOUBLE_MAT2x4: size *= 16; break;
+            case GL_DOUBLE_MAT3x2: size *= 12; break;
+            case GL_DOUBLE_MAT3x4: size *= 24; break;
+            case GL_DOUBLE_MAT4x2: size *= 16; break;
+            case GL_DOUBLE_MAT4x3: size *= 24; break;
+        }
+        mTotalUniformSize += size;
+    }
 #endif
 
-	S32 location = glGetUniformLocationARB(mProgramObject, name);
-	if (location != -1)
-	{
-		//chop off "[0]" so we can always access the first element
-		//of an array by the array name
-		char* is_array = strstr(name, "[0]");
-		if (is_array)
-		{
-			is_array[0] = 0;
-		}
-
-		LLStaticHashedString hashedName(name);
-		mUniformNameMap[location] = name;
-		mUniformMap[hashedName] = location;
-
-		LL_DEBUGS("ShaderLoading") << "Uniform " << name << " is at location " << location << LL_ENDL;
-	
-		//find the index of this uniform
-		for (S32 i = 0; i < (S32) LLShaderMgr::instance()->mReservedUniforms.size(); i++)
-		{
-			if ( (mUniform[i] == -1)
-				&& (LLShaderMgr::instance()->mReservedUniforms[i] == name))
-			{
-				//found it
-				mUniform[i] = location;
-				mTexture[i] = mapUniformTextureChannel(location, type);
-				return;
-			}
-		}
-
-		if (uniforms != NULL)
-		{
-			for (U32 i = 0; i < uniforms->size(); i++)
-			{
-				if ( (mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] == -1)
-					&& ((*uniforms)[i].String() == name))
-				{
-					//found it
-					mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] = location;
-					mTexture[i+LLShaderMgr::instance()->mReservedUniforms.size()] = mapUniformTextureChannel(location, type);
-					return;
-				}
-			}
-		}
-	}
+    S32 location = glGetUniformLocationARB(mProgramObject, name);
+    if (location != -1)
+    {
+        //chop off "[0]" so we can always access the first element
+        //of an array by the array name
+        char* is_array = strstr(name, "[0]");
+        if (is_array)
+        {
+            is_array[0] = 0;
+        }
+
+        LLStaticHashedString hashedName(name);
+        mUniformNameMap[location] = name;
+        mUniformMap[hashedName] = location;
+
+        LL_DEBUGS("ShaderLoading") << "Uniform " << name << " is at location " << location << LL_ENDL;
+    
+        //find the index of this uniform
+        for (S32 i = 0; i < (S32) LLShaderMgr::instance()->mReservedUniforms.size(); i++)
+        {
+            if ( (mUniform[i] == -1)
+                && (LLShaderMgr::instance()->mReservedUniforms[i] == name))
+            {
+                //found it
+                mUniform[i] = location;
+                mTexture[i] = mapUniformTextureChannel(location, type);
+                return;
+            }
+        }
+
+        if (uniforms != NULL)
+        {
+            for (U32 i = 0; i < uniforms->size(); i++)
+            {
+                if ( (mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] == -1)
+                    && ((*uniforms)[i].String() == name))
+                {
+                    //found it
+                    mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] = location;
+                    mTexture[i+LLShaderMgr::instance()->mReservedUniforms.size()] = mapUniformTextureChannel(location, type);
+                    return;
+                }
+            }
+        }
+    }
 }
 
 void LLGLSLShader::addPermutation(std::string name, std::string value)
 {
-	mDefines[name] = value;
+    mDefines[name] = value;
 }
 
 void LLGLSLShader::removePermutation(std::string name)
 {
-	mDefines[name].erase();
+    mDefines[name].erase();
 }
 
 GLint LLGLSLShader::mapUniformTextureChannel(GLint location, GLenum type)
 {
-	if ((type >= GL_SAMPLER_1D_ARB && type <= GL_SAMPLER_2D_RECT_SHADOW_ARB) ||
-		type == GL_SAMPLER_2D_MULTISAMPLE)
-	{	//this here is a texture
-		glUniform1iARB(location, mActiveTextureChannels);
-		LL_DEBUGS("ShaderLoading") << "Assigned to texture channel " << mActiveTextureChannels << LL_ENDL;
-		return mActiveTextureChannels++;
-	}
-	return -1;
+    if ((type >= GL_SAMPLER_1D_ARB && type <= GL_SAMPLER_2D_RECT_SHADOW_ARB) ||
+        type == GL_SAMPLER_2D_MULTISAMPLE)
+    {   //this here is a texture
+        glUniform1iARB(location, mActiveTextureChannels);
+        LL_DEBUGS("ShaderLoading") << "Assigned to texture channel " << mActiveTextureChannels << LL_ENDL;
+        return mActiveTextureChannels++;
+    }
+    return -1;
 }
 
 BOOL LLGLSLShader::mapUniforms(const vector<LLStaticHashedString> * uniforms)
 {
-	BOOL res = TRUE;
-	
-	mTotalUniformSize = 0;
-	mActiveTextureChannels = 0;
-	mUniform.clear();
-	mUniformMap.clear();
-	mUniformNameMap.clear();
-	mTexture.clear();
-	mValue.clear();
-	//initialize arrays
-	U32 numUniforms = (uniforms == NULL) ? 0 : uniforms->size();
-	mUniform.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
-	mTexture.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
-	
-	bind();
-
-	//get the number of active uniforms
-	GLint activeCount;
-	glGetObjectParameterivARB(mProgramObject, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &activeCount);
-
-	for (S32 i = 0; i < activeCount; i++)
-	{
-		mapUniform(i, uniforms);
-	}
-
-	unbind();
-
-	LL_DEBUGS("ShaderLoading") << "Total Uniform Size: " << mTotalUniformSize << LL_ENDL;
-	return res;
+    BOOL res = TRUE;
+    
+    mTotalUniformSize = 0;
+    mActiveTextureChannels = 0;
+    mUniform.clear();
+    mUniformMap.clear();
+    mUniformNameMap.clear();
+    mTexture.clear();
+    mValue.clear();
+    //initialize arrays
+    U32 numUniforms = (uniforms == NULL) ? 0 : uniforms->size();
+    mUniform.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
+    mTexture.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
+    
+    bind();
+
+    //get the number of active uniforms
+    GLint activeCount;
+    glGetObjectParameterivARB(mProgramObject, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &activeCount);
+
+    for (S32 i = 0; i < activeCount; i++)
+    {
+        mapUniform(i, uniforms);
+    }
+
+    unbind();
+
+    LL_DEBUGS("ShaderLoading") << "Total Uniform Size: " << mTotalUniformSize << LL_ENDL;
+    return res;
 }
 
 BOOL LLGLSLShader::link(BOOL suppress_errors)
 {
-	BOOL success = LLShaderMgr::instance()->linkProgramObject(mProgramObject, suppress_errors);
+    BOOL success = LLShaderMgr::instance()->linkProgramObject(mProgramObject, suppress_errors);
 
-	if (!suppress_errors)
-	{
+    if (!suppress_errors)
+    {
         LLShaderMgr::instance()->dumpObjectLog(mProgramObject, !success, mName);
-	}
+    }
 
-	return success;
+    return success;
 }
 
 void LLGLSLShader::bind()
 {
-	gGL.flush();
-	if (gGLManager.mHasShaderObjects)
-	{
-		LLVertexBuffer::unbind();
-		glUseProgramObjectARB(mProgramObject);
-		sCurBoundShader = mProgramObject;
-		sCurBoundShaderPtr = this;
-		if (mUniformsDirty)
-		{
-			LLShaderMgr::instance()->updateShaderUniforms(this);
-			mUniformsDirty = FALSE;
-		}
-	}
+    gGL.flush();
+    if (gGLManager.mHasShaderObjects)
+    {
+        LLVertexBuffer::unbind();
+        glUseProgramObjectARB(mProgramObject);
+        sCurBoundShader = mProgramObject;
+        sCurBoundShaderPtr = this;
+        if (mUniformsDirty)
+        {
+            LLShaderMgr::instance()->updateShaderUniforms(this);
+            mUniformsDirty = FALSE;
+        }
+    }
 }
 
 void LLGLSLShader::unbind()
 {
-	gGL.flush();
-	if (gGLManager.mHasShaderObjects)
-	{
-		stop_glerror();
-		if (gGLManager.mIsNVIDIA)
-		{
-			for (U32 i = 0; i < mAttribute.size(); ++i)
-			{
-				vertexAttrib4f(i, 0,0,0,1);
-				stop_glerror();
-			}
-		}
-		LLVertexBuffer::unbind();
-		glUseProgramObjectARB(0);
-		sCurBoundShader = 0;
-		sCurBoundShaderPtr = NULL;
-		stop_glerror();
-	}
+    gGL.flush();
+    if (gGLManager.mHasShaderObjects)
+    {
+        stop_glerror();
+        if (gGLManager.mIsNVIDIA)
+        {
+            for (U32 i = 0; i < mAttribute.size(); ++i)
+            {
+                vertexAttrib4f(i, 0,0,0,1);
+                stop_glerror();
+            }
+        }
+        LLVertexBuffer::unbind();
+        glUseProgramObjectARB(0);
+        sCurBoundShader = 0;
+        sCurBoundShaderPtr = NULL;
+        stop_glerror();
+    }
 }
 
 void LLGLSLShader::bindNoShader(void)
 {
-	LLVertexBuffer::unbind();
-	if (gGLManager.mHasShaderObjects)
-	{
-		glUseProgramObjectARB(0);
-		sCurBoundShader = 0;
-		sCurBoundShaderPtr = NULL;
-	}
+    LLVertexBuffer::unbind();
+    if (gGLManager.mHasShaderObjects)
+    {
+        glUseProgramObjectARB(0);
+        sCurBoundShader = 0;
+        sCurBoundShaderPtr = NULL;
+    }
 }
 
 S32 LLGLSLShader::bindTexture(const std::string &uniform, LLTexture *texture, LLTexUnit::eTextureType mode)
 {
-	S32 channel = 0;
-	channel = getUniformLocation(uniform);
-	
-	return bindTexture(channel, texture, mode);
+    S32 channel = 0;
+    channel = getUniformLocation(uniform);
+    
+    return bindTexture(channel, texture, mode);
 }
 
 S32 LLGLSLShader::bindTexture(S32 uniform, LLTexture *texture, LLTexUnit::eTextureType mode)
 {
-	if (uniform < 0 || uniform >= (S32)mTexture.size())
-	{
-		UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
-		return -1;
-	}
-	
-	uniform = mTexture[uniform];
-	
-	if (uniform > -1)
-	{
-		gGL.getTexUnit(uniform)->bind(texture, mode);
-	}
-	
-	return uniform;
+    if (uniform < 0 || uniform >= (S32)mTexture.size())
+    {
+        UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
+        return -1;
+    }
+    
+    uniform = mTexture[uniform];
+    
+    if (uniform > -1)
+    {
+        gGL.getTexUnit(uniform)->bind(texture, mode);
+    }
+    
+    return uniform;
 }
 
 S32 LLGLSLShader::unbindTexture(const std::string &uniform, LLTexUnit::eTextureType mode)
 {
-	S32 channel = 0;
-	channel = getUniformLocation(uniform);
-	
-	return unbindTexture(channel);
+    S32 channel = 0;
+    channel = getUniformLocation(uniform);
+    
+    return unbindTexture(channel);
 }
 
 S32 LLGLSLShader::unbindTexture(S32 uniform, LLTexUnit::eTextureType mode)
 {
-	if (uniform < 0 || uniform >= (S32)mTexture.size())
-	{
-		UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
-		return -1;
-	}
-	
-	uniform = mTexture[uniform];
-	
-	if (uniform > -1)
-	{
-		gGL.getTexUnit(uniform)->unbind(mode);
-	}
-	
-	return uniform;
+    if (uniform < 0 || uniform >= (S32)mTexture.size())
+    {
+        UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
+        return -1;
+    }
+    
+    uniform = mTexture[uniform];
+    
+    if (uniform > -1)
+    {
+        gGL.getTexUnit(uniform)->unbind(mode);
+    }
+    
+    return uniform;
 }
 
 S32 LLGLSLShader::enableTexture(S32 uniform, LLTexUnit::eTextureType mode)
 {
-	if (uniform < 0 || uniform >= (S32)mTexture.size())
-	{
-		UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
-		return -1;
-	}
-	S32 index = mTexture[uniform];
-	if (index != -1)
-	{
-		gGL.getTexUnit(index)->activate();
-		gGL.getTexUnit(index)->enable(mode);
-	}
-	return index;
+    if (uniform < 0 || uniform >= (S32)mTexture.size())
+    {
+        UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
+        return -1;
+    }
+    S32 index = mTexture[uniform];
+    if (index != -1)
+    {
+        gGL.getTexUnit(index)->activate();
+        gGL.getTexUnit(index)->enable(mode);
+    }
+    return index;
 }
 
 S32 LLGLSLShader::disableTexture(S32 uniform, LLTexUnit::eTextureType mode)
 {
-	if (uniform < 0 || uniform >= (S32)mTexture.size())
-	{
-		UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
-		return -1;
-	}
-	S32 index = mTexture[uniform];
-	if (index != -1 && gGL.getTexUnit(index)->getCurrType() != LLTexUnit::TT_NONE)
-	{
-		if (gDebugGL && gGL.getTexUnit(index)->getCurrType() != mode)
-		{
-			if (gDebugSession)
-			{
-				gFailLog << "Texture channel " << index << " texture type corrupted." << std::endl;
-				ll_fail("LLGLSLShader::disableTexture failed");
-			}
-			else
-			{
-				LL_ERRS() << "Texture channel " << index << " texture type corrupted." << LL_ENDL;
-			}
-		}
-		gGL.getTexUnit(index)->disable();
-	}
-	return index;
+    if (uniform < 0 || uniform >= (S32)mTexture.size())
+    {
+        UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
+        return -1;
+    }
+    S32 index = mTexture[uniform];
+    if (index != -1 && gGL.getTexUnit(index)->getCurrType() != LLTexUnit::TT_NONE)
+    {
+        if (gDebugGL && gGL.getTexUnit(index)->getCurrType() != mode)
+        {
+            if (gDebugSession)
+            {
+                gFailLog << "Texture channel " << index << " texture type corrupted." << std::endl;
+                ll_fail("LLGLSLShader::disableTexture failed");
+            }
+            else
+            {
+                LL_ERRS() << "Texture channel " << index << " texture type corrupted." << LL_ENDL;
+            }
+        }
+        gGL.getTexUnit(index)->disable();
+    }
+    return index;
 }
 
 void LLGLSLShader::uniform1i(U32 index, GLint x)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			if (iter == mValue.end() || iter->second.mV[0] != x)
-			{
-				glUniform1iARB(mUniform[index], x);
-				mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            if (iter == mValue.end() || iter->second.mV[0] != x)
+            {
+                glUniform1iARB(mUniform[index], x);
+                mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform1f(U32 index, GLfloat x)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			if (iter == mValue.end() || iter->second.mV[0] != x)
-			{
-				glUniform1fARB(mUniform[index], x);
-				mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            if (iter == mValue.end() || iter->second.mV[0] != x)
+            {
+                glUniform1fARB(mUniform[index], x);
+                mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform2f(U32 index, GLfloat x, GLfloat y)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			LLVector4 vec(x,y,0.f,0.f);
-			if (iter == mValue.end() || shouldChange(iter->second,vec))
-			{
-				glUniform2fARB(mUniform[index], x, y);
-				mValue[mUniform[index]] = vec;
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            LLVector4 vec(x,y,0.f,0.f);
+            if (iter == mValue.end() || shouldChange(iter->second,vec))
+            {
+                glUniform2fARB(mUniform[index], x, y);
+                mValue[mUniform[index]] = vec;
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			LLVector4 vec(x,y,z,0.f);
-			if (iter == mValue.end() || shouldChange(iter->second,vec))
-			{
-				glUniform3fARB(mUniform[index], x, y, z);
-				mValue[mUniform[index]] = vec;
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            LLVector4 vec(x,y,z,0.f);
+            if (iter == mValue.end() || shouldChange(iter->second,vec))
+            {
+                glUniform3fARB(mUniform[index], x, y, z);
+                mValue[mUniform[index]] = vec;
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			LLVector4 vec(x,y,z,w);
-			if (iter == mValue.end() || shouldChange(iter->second,vec))
-			{
-				glUniform4fARB(mUniform[index], x, y, z, w);
-				mValue[mUniform[index]] = vec;
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            LLVector4 vec(x,y,z,w);
+            if (iter == mValue.end() || shouldChange(iter->second,vec))
+            {
+                glUniform4fARB(mUniform[index], x, y, z, w);
+                mValue[mUniform[index]] = vec;
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform1iv(U32 index, U32 count, const GLint* v)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			LLVector4 vec(v[0],0.f,0.f,0.f);
-			if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-			{
-				glUniform1ivARB(mUniform[index], count, v);
-				mValue[mUniform[index]] = vec;
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            LLVector4 vec(v[0],0.f,0.f,0.f);
+            if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+            {
+                glUniform1ivARB(mUniform[index], count, v);
+                mValue[mUniform[index]] = vec;
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform1fv(U32 index, U32 count, const GLfloat* v)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			LLVector4 vec(v[0],0.f,0.f,0.f);
-			if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-			{
-				glUniform1fvARB(mUniform[index], count, v);
-				mValue[mUniform[index]] = vec;
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            LLVector4 vec(v[0],0.f,0.f,0.f);
+            if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+            {
+                glUniform1fvARB(mUniform[index], count, v);
+                mValue[mUniform[index]] = vec;
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform2fv(U32 index, U32 count, const GLfloat* v)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			LLVector4 vec(v[0],v[1],0.f,0.f);
-			if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-			{
-				glUniform2fvARB(mUniform[index], count, v);
-				mValue[mUniform[index]] = vec;
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            LLVector4 vec(v[0],v[1],0.f,0.f);
+            if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+            {
+                glUniform2fvARB(mUniform[index], count, v);
+                mValue[mUniform[index]] = vec;
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform3fv(U32 index, U32 count, const GLfloat* v)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			LLVector4 vec(v[0],v[1],v[2],0.f);
-			if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-			{
-				glUniform3fvARB(mUniform[index], count, v);
-				mValue[mUniform[index]] = vec;
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            LLVector4 vec(v[0],v[1],v[2],0.f);
+            if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+            {
+                glUniform3fvARB(mUniform[index], count, v);
+                mValue[mUniform[index]] = vec;
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniform4fv(U32 index, U32 count, const GLfloat* v)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
-			LLVector4 vec(v[0],v[1],v[2],v[3]);
-			if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-			{
-				glUniform4fvARB(mUniform[index], count, v);
-				mValue[mUniform[index]] = vec;
-			}
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            LLVector4 vec(v[0],v[1],v[2],v[3]);
+            if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+            {
+                glUniform4fvARB(mUniform[index], count, v);
+                mValue[mUniform[index]] = vec;
+            }
+        }
+    }
 }
 
 void LLGLSLShader::uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			glUniformMatrix2fvARB(mUniform[index], count, transpose, v);
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            glUniformMatrix2fvARB(mUniform[index], count, transpose, v);
+        }
+    }
 }
 
 void LLGLSLShader::uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			glUniformMatrix3fvARB(mUniform[index], count, transpose, v);
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            glUniformMatrix3fvARB(mUniform[index], count, transpose, v);
+        }
+    }
 }
 
 void LLGLSLShader::uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
 {
-	if (mProgramObject > 0)
-	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			glUniformMatrix4fvARB(mUniform[index], count, transpose, v);
-		}
-	}
+    if (mProgramObject > 0)
+    {   
+        if (mUniform.size() <= index)
+        {
+            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            glUniformMatrix4fvARB(mUniform[index], count, transpose, v);
+        }
+    }
 }
 
 GLint LLGLSLShader::getUniformLocation(const LLStaticHashedString& uniform)
 {
-	GLint ret = -1;
-	if (mProgramObject > 0)
-	{
-		LLStaticStringTable<GLint>::iterator iter = mUniformMap.find(uniform);
-		if (iter != mUniformMap.end())
-		{
-			if (gDebugGL)
-			{
-				stop_glerror();
-				if (iter->second != glGetUniformLocationARB(mProgramObject, uniform.String().c_str()))
-				{
-					LL_ERRS() << "Uniform does not match." << LL_ENDL;
-				}
-				stop_glerror();
-			}
-			ret = iter->second;
-		}
-	}
-
-	return ret;
+    GLint ret = -1;
+    if (mProgramObject > 0)
+    {
+        LLStaticStringTable<GLint>::iterator iter = mUniformMap.find(uniform);
+        if (iter != mUniformMap.end())
+        {
+            if (gDebugGL)
+            {
+                stop_glerror();
+                if (iter->second != glGetUniformLocationARB(mProgramObject, uniform.String().c_str()))
+                {
+                    LL_ERRS() << "Uniform does not match." << LL_ENDL;
+                }
+                stop_glerror();
+            }
+            ret = iter->second;
+        }
+    }
+
+    return ret;
 }
 
 GLint LLGLSLShader::getUniformLocation(U32 index)
 {
-	GLint ret = -1;
-	if (mProgramObject > 0)
-	{
-		llassert(index < mUniform.size());
-		return mUniform[index];
-	}
-
-	return ret;
+    GLint ret = -1;
+    if (mProgramObject > 0)
+    {
+        llassert(index < mUniform.size());
+        return mUniform[index];
+    }
+
+    return ret;
 }
 
 GLint LLGLSLShader::getAttribLocation(U32 attrib)
 {
-	if (attrib < mAttribute.size())
-	{
-		return mAttribute[attrib];
-	}
-	else
-	{
-		return -1;
-	}
+    if (attrib < mAttribute.size())
+    {
+        return mAttribute[attrib];
+    }
+    else
+    {
+        return -1;
+    }
 }
 
 void LLGLSLShader::uniform1i(const LLStaticHashedString& uniform, GLint v)
 {
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(v,0.f,0.f,0.f);
-		if (iter == mValue.end() || shouldChange(iter->second,vec))
-		{
-			glUniform1iARB(location, v);
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+                
+    if (location >= 0)
+    {
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        LLVector4 vec(v,0.f,0.f,0.f);
+        if (iter == mValue.end() || shouldChange(iter->second,vec))
+        {
+            glUniform1iARB(location, v);
+            mValue[location] = vec;
+        }
+    }
 }
 
 void LLGLSLShader::uniform2i(const LLStaticHashedString& uniform, GLint i, GLint j)
 {
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(i,j,0.f,0.f);
-		if (iter == mValue.end() || shouldChange(iter->second,vec))
-		{
-			glUniform2iARB(location, i, j);
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+                
+    if (location >= 0)
+    {
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        LLVector4 vec(i,j,0.f,0.f);
+        if (iter == mValue.end() || shouldChange(iter->second,vec))
+        {
+            glUniform2iARB(location, i, j);
+            mValue[location] = vec;
+        }
+    }
 }
 
 
 void LLGLSLShader::uniform1f(const LLStaticHashedString& uniform, GLfloat v)
 {
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(v,0.f,0.f,0.f);
-		if (iter == mValue.end() || shouldChange(iter->second,vec))
-		{
-			glUniform1fARB(location, v);
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+                
+    if (location >= 0)
+    {
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        LLVector4 vec(v,0.f,0.f,0.f);
+        if (iter == mValue.end() || shouldChange(iter->second,vec))
+        {
+            glUniform1fARB(location, v);
+            mValue[location] = vec;
+        }
+    }
 }
 
 void LLGLSLShader::uniform2f(const LLStaticHashedString& uniform, GLfloat x, GLfloat y)
 {
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(x,y,0.f,0.f);
-		if (iter == mValue.end() || shouldChange(iter->second,vec))
-		{
-			glUniform2fARB(location, x,y);
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+                
+    if (location >= 0)
+    {
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        LLVector4 vec(x,y,0.f,0.f);
+        if (iter == mValue.end() || shouldChange(iter->second,vec))
+        {
+            glUniform2fARB(location, x,y);
+            mValue[location] = vec;
+        }
+    }
 
 }
 
 void LLGLSLShader::uniform3f(const LLStaticHashedString& uniform, GLfloat x, GLfloat y, GLfloat z)
 {
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(x,y,z,0.f);
-		if (iter == mValue.end() || shouldChange(iter->second,vec))
-		{
-			glUniform3fARB(location, x,y,z);
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+                
+    if (location >= 0)
+    {
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        LLVector4 vec(x,y,z,0.f);
+        if (iter == mValue.end() || shouldChange(iter->second,vec))
+        {
+            glUniform3fARB(location, x,y,z);
+            mValue[location] = vec;
+        }
+    }
 }
 
 void LLGLSLShader::uniform1fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v)
 {
-	GLint location = getUniformLocation(uniform);
-
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(v[0],0.f,0.f,0.f);
-		if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-		{
-			glUniform1fvARB(location, count, v);
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+
+    if (location >= 0)
+    {
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        LLVector4 vec(v[0],0.f,0.f,0.f);
+        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+        {
+            glUniform1fvARB(location, count, v);
+            mValue[location] = vec;
+        }
+    }
 }
 
 void LLGLSLShader::uniform2fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v)
 {
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(v[0],v[1],0.f,0.f);
-		if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-		{
-			glUniform2fvARB(location, count, v);
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+                
+    if (location >= 0)
+    {
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        LLVector4 vec(v[0],v[1],0.f,0.f);
+        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+        {
+            glUniform2fvARB(location, count, v);
+            mValue[location] = vec;
+        }
+    }
 }
 
 void LLGLSLShader::uniform3fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v)
 {
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(v[0],v[1],v[2],0.f);
-		if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-		{
-			glUniform3fvARB(location, count, v);
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+                
+    if (location >= 0)
+    {
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        LLVector4 vec(v[0],v[1],v[2],0.f);
+        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+        {
+            glUniform3fvARB(location, count, v);
+            mValue[location] = vec;
+        }
+    }
 }
 
 void LLGLSLShader::uniform4fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v)
 {
-	GLint location = getUniformLocation(uniform);
-
-	if (location >= 0)
-	{
-		LLVector4 vec(v);
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
-		{
-			stop_glerror();
-			glUniform4fvARB(location, count, v);
-			stop_glerror();
-			mValue[location] = vec;
-		}
-	}
+    GLint location = getUniformLocation(uniform);
+
+    if (location >= 0)
+    {
+        LLVector4 vec(v);
+        std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+        {
+            stop_glerror();
+            glUniform4fvARB(location, count, v);
+            stop_glerror();
+            mValue[location] = vec;
+        }
+    }
 }
 
 void LLGLSLShader::uniformMatrix4fv(const LLStaticHashedString& uniform, U32 count, GLboolean transpose, const GLfloat* v)
 {
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		stop_glerror();
-		glUniformMatrix4fvARB(location, count, transpose, v);
-		stop_glerror();
-	}
+    GLint location = getUniformLocation(uniform);
+                
+    if (location >= 0)
+    {
+        stop_glerror();
+        glUniformMatrix4fvARB(location, count, transpose, v);
+        stop_glerror();
+    }
 }
 
 
 void LLGLSLShader::vertexAttrib4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-	if (mAttribute[index] > 0)
-	{
-		glVertexAttrib4fARB(mAttribute[index], x, y, z, w);
-	}
+    if (mAttribute[index] > 0)
+    {
+        glVertexAttrib4fARB(mAttribute[index], x, y, z, w);
+    }
 }
 
 void LLGLSLShader::vertexAttrib4fv(U32 index, GLfloat* v)
 {
-	if (mAttribute[index] > 0)
-	{
-		glVertexAttrib4fvARB(mAttribute[index], v);
-	}
+    if (mAttribute[index] > 0)
+    {
+        glVertexAttrib4fvARB(mAttribute[index], v);
+    }
 }
 
 void LLGLSLShader::setMinimumAlpha(F32 minimum)
 {
-	gGL.flush();
-	uniform1f(LLShaderMgr::MINIMUM_ALPHA, minimum);
+    gGL.flush();
+    uniform1f(LLShaderMgr::MINIMUM_ALPHA, minimum);
 }
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index d06564df36..0fae600a90 100755
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -843,9 +843,11 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
 	{
 		LL_RECORD_BLOCK_TIME(FTM_GL_DRAW_ARRAYS);
 		stop_glerror();
-	LLGLSLShader::startProfile();
+		LLGLSLShader::startProfile();
+		stop_glerror();
 		glDrawArrays(sGLMode[mode], first, count);
-	LLGLSLShader::stopProfile(count, mode);
+		stop_glerror();
+		LLGLSLShader::stopProfile(count, mode);
 	}
 
 	stop_glerror();
diff --git a/indra/newview/VIEWER_VERSION.txt b/indra/newview/VIEWER_VERSION.txt
index b49c354524..a4de059bbc 100644
--- a/indra/newview/VIEWER_VERSION.txt
+++ b/indra/newview/VIEWER_VERSION.txt
@@ -1 +1 @@
-3.7.22
+3.7.23
diff --git a/indra/newview/llfeaturemanager.cpp b/indra/newview/llfeaturemanager.cpp
index 4db0422634..d89599cb45 100755
--- a/indra/newview/llfeaturemanager.cpp
+++ b/indra/newview/llfeaturemanager.cpp
@@ -76,9 +76,6 @@ const char FEATURE_TABLE_FILENAME[] = "featuretable%s.txt";
 const char FEATURE_TABLE_VER_FILENAME[] = "featuretable%s.%s.txt";
 #endif
 
-const char GPU_TABLE_FILENAME[] = "gpu_table.txt";
-const char GPU_TABLE_VER_FILENAME[] = "gpu_table.%s.txt";
-
 LLFeatureInfo::LLFeatureInfo(const std::string& name, const BOOL available, const F32 level)
 	: mValid(TRUE), mName(name), mAvailable(available), mRecommendedLevel(level)
 {
@@ -428,6 +425,7 @@ bool LLFeatureManager::loadGPUClass()
 	{ //couldn't bench, use GLVersion
 #if LL_DARWIN
         //GLVersion is misleading on OSX, just default to class 3 if we can't bench
+		LL_WARNS() << "Unable to get an accurate benchmark; defaulting to class 3" << LL_ENDL;
         mGPUClass = GPU_CLASS_3;
 #else
 		if (gGLManager.mGLVersion < 2.f)
@@ -452,23 +450,31 @@ bool LLFeatureManager::loadGPUClass()
 		}
 #endif
 	}
-	else if (gbps < 5.f)
+	else if (gGLManager.mGLVersion <= 2.f)
+	{
+		mGPUClass = GPU_CLASS_0;
+	}
+	else if (gGLManager.mGLVersion <= 3.f)
+	{
+		mGPUClass = GPU_CLASS_1;
+	}
+	else if (gbps <= 5.f)
 	{
 		mGPUClass = GPU_CLASS_0;
 	}
-	else if (gbps < 10.f)
+	else if (gbps <= 8.f)
 	{
 		mGPUClass = GPU_CLASS_1;
 	}
-	else if (gbps < 20.f)
+	else if (gbps <= 16.f)
 	{
 		mGPUClass = GPU_CLASS_2;
 	}
-	else if (gbps < 40.f)
+	else if (gbps <= 40.f)
 	{
 		mGPUClass = GPU_CLASS_3;
 	}
-	else if (gbps < 80.f)
+	else if (gbps <= 80.f)
 	{
 		mGPUClass = GPU_CLASS_4;
 	}
@@ -476,195 +482,15 @@ bool LLFeatureManager::loadGPUClass()
 	{
 		mGPUClass = GPU_CLASS_5;
 	}
-	
+
 	// defaults
 	mGPUString = gGLManager.getRawGLString();
 	mGPUSupported = TRUE;
 
-#if 0
-	// first table is in the app dir
-	std::string app_path = gDirUtilp->getAppRODataDir();
-	app_path += gDirUtilp->getDirDelimiter();
-	app_path += GPU_TABLE_FILENAME;
-	
-	// second table is downloaded with HTTP
-	std::string http_filename = llformat(GPU_TABLE_VER_FILENAME, LLVersionInfo::getVersion().c_str());
-	std::string http_path = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, http_filename);
-
-	// use HTTP table if it exists
-	std::string path;
-	bool parse_ok = false;
-	if (gDirUtilp->fileExists(http_path))
-	{
-		parse_ok = parseGPUTable(http_path);
-		if (!parse_ok)
-		{
-			// the HTTP table failed to parse, so delete it
-			LLFile::remove(http_path);
-			LL_WARNS("RenderInit") << "Removed invalid gpu table '" << http_path << "'" << LL_ENDL;
-	}
-	}
-
-	if (!parse_ok)
-	{
-		parse_ok = parseGPUTable(app_path);
-	}
-#endif
-	return true; // indicates that the file parsed correctly, not that the gpu was recognized
+	return true; // indicates that a gpu value was established
 }
 
 	
-bool LLFeatureManager::parseGPUTable(std::string filename)
-{
-	llifstream file;
-		
-	LL_INFOS("RenderInit") << "Attempting to parse GPU table from " << filename << LL_ENDL;
-	file.open(filename);
-
-	if (file)
-	{
-		const char recognizer[] = "//GPU_TABLE";
-		char first_line[MAX_STRING];
-		file.getline(first_line, MAX_STRING);
-		if (0 != strncmp(first_line, recognizer, strlen(recognizer)))
-		{
-			LL_WARNS("RenderInit") << "Invalid GPU table: " << filename << "!" << LL_ENDL;
-			return false;
-		}
-	}
-	else
-	{
-		LL_WARNS("RenderInit") << "Unable to open GPU table: " << filename << "!" << LL_ENDL;
-		return false;
-	}
-
-	std::string rawRenderer = gGLManager.getRawGLString();
-	std::string renderer = rawRenderer;
-	for (std::string::iterator i = renderer.begin(); i != renderer.end(); ++i)
-	{
-		*i = tolower(*i);
-	}
-
-#if LL_EXPORT_GPU_TABLE
-	llofstream json;
-	json.open("gpu_table.json");
-
-	json << "var gpu_table = [" << std::endl;
-#endif
-
-	bool gpuFound;
-	U32 lineNumber;
-	for (gpuFound = false, lineNumber = 0; !gpuFound && !file.eof(); lineNumber++)
-	{
-		char buffer[MAX_STRING];		 /*Flawfinder: ignore*/
-		buffer[0] = 0;
-
-		file.getline(buffer, MAX_STRING);
-		
-		if (strlen(buffer) >= 2 && 	 /*Flawfinder: ignore*/
-			buffer[0] == '/' && 
-			buffer[1] == '/')
-		{
-			// This is a comment.
-			continue;
-		}
-
-		if (strlen(buffer) == 0)	 /*Flawfinder: ignore*/
-		{
-			// This is a blank line
-			continue;
-		}
-
-		// setup the tokenizer
-		std::string buf(buffer);
-		std::string cls, label, expr, supported, stats_based, expected_gl_version;
-		boost_tokenizer tokens(buf, boost::char_separator<char>("\t\n"));
-		boost_tokenizer::iterator token_iter = tokens.begin();
-
-		// grab the label, pseudo regular expression, and class
-		if(token_iter != tokens.end())
-		{
-			label = *token_iter++;
-		}
-		if(token_iter != tokens.end())
-		{
-			expr = *token_iter++;
-		}
-		if(token_iter != tokens.end())
-		{
-			cls = *token_iter++;
-		}
-		if(token_iter != tokens.end())
-		{
-			supported = *token_iter++;
-		}
-		if (token_iter != tokens.end())
-		{
-			stats_based = *token_iter++;
-		}
-		if (token_iter != tokens.end())
-		{
-			expected_gl_version = *token_iter++;
-		}
-
-		if (label.empty() || expr.empty() || cls.empty() || supported.empty())
-		{
-			LL_WARNS("RenderInit") << "invald gpu_table.txt:" << lineNumber << ": '" << buffer << "'" << LL_ENDL;
-			continue;
-		}
-#if LL_EXPORT_GPU_TABLE
-		json << "{'label' : '" << label << "',\n" << 
-			"'regexp' : '" << expr << "',\n" <<
-			"'class' : '" << cls << "',\n" <<
-			"'supported' : '" << supported << "',\n" <<
-			"'stats_based' : " << stats_based <<  ",\n" <<
-			"'gl_version' : " << expected_gl_version << "\n},\n";
-#endif
-
-		for (U32 i = 0; i < expr.length(); i++)	 /*Flawfinder: ignore*/
-		{
-			expr[i] = tolower(expr[i]);
-		}
-
-		// run the regular expression against the renderer
-		boost::regex re(expr.c_str());
-		if(boost::regex_search(renderer, re))
-		{
-			// if we found it, stop!
-#if !LL_EXPORT_GPU_TABLE
-			gpuFound = true;
-#endif
-			mGPUString = label;
-			mGPUClass = (EGPUClass) strtol(cls.c_str(), NULL, 10);
-			mGPUSupported = (BOOL) strtol(supported.c_str(), NULL, 10);
-			sscanf(expected_gl_version.c_str(), "%f", &mExpectedGLVersion);
-		}
-	}
-#if LL_EXPORT_GPU_TABLE
-	json << "];\n\n";
-	json.close();
-#endif
-	file.close();
-
-	if ( gpuFound )
-	{
-		LL_INFOS("RenderInit") << "GPU '" << rawRenderer << "' recognized as '" << mGPUString << "'" << LL_ENDL;
-		if (!mGPUSupported)
-		{
-			LL_INFOS("RenderInit") << "GPU '" << mGPUString << "' is not supported." << LL_ENDL;
-		}
-	}
-	else
-	{
-		LL_WARNS("RenderInit") << "GPU '" << rawRenderer << "' not recognized" << LL_ENDL;
-	}
-
-#if LL_DARWIN // never go over "Mid" settings by default on OS X
-	mGPUClass = llmin(mGPUClass, GPU_CLASS_2);
-#endif
-	return true;
-}
-
 // responder saves table into file
 class LLHTTPFeatureTableResponder : public LLHTTPClient::Responder
 {
@@ -745,26 +571,11 @@ void fetch_feature_table(std::string table)
 	LLHTTPClient::get(url, new LLHTTPFeatureTableResponder(path));
 }
 
-void fetch_gpu_table(std::string table)
-{
-	const std::string base       = gSavedSettings.getString("FeatureManagerHTTPTable");
-
-	const std::string filename   = llformat(table.c_str(), LLVersionInfo::getVersion().c_str());
-
-	const std::string url        = base + "/" + filename;
-
-	const std::string path       = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, filename);
-
-	LL_INFOS() << "LLFeatureManager fetching " << url << " into " << path << LL_ENDL;
-	
-	LLHTTPClient::get(url, new LLHTTPFeatureTableResponder(path));
-}
 
 // fetch table(s) from a website (S3)
 void LLFeatureManager::fetchHTTPTables()
 {
 	fetch_feature_table(FEATURE_TABLE_VER_FILENAME);
-	fetch_gpu_table(GPU_TABLE_VER_FILENAME);
 }
 
 
diff --git a/indra/newview/llfeaturemanager.h b/indra/newview/llfeaturemanager.h
index 95141b241d..69078ccc21 100755
--- a/indra/newview/llfeaturemanager.h
+++ b/indra/newview/llfeaturemanager.h
@@ -162,9 +162,6 @@ protected:
 	bool parseFeatureTable(std::string filename);
 	///< @returns TRUE is file parsed correctly, FALSE if not
 
-	bool parseGPUTable(std::string filename);
-	///< @returns true if file parsed correctly, false if not - does not reflect whether or not the gpu was recognized
-
 	void initBaseMask();
 
 
diff --git a/indra/newview/llflickrconnect.cpp b/indra/newview/llflickrconnect.cpp
index b715896264..b75660ea00 100644
--- a/indra/newview/llflickrconnect.cpp
+++ b/indra/newview/llflickrconnect.cpp
@@ -400,7 +400,7 @@ void LLFlickrConnect::uploadPhoto(LLPointer<LLImageFormatted> image, const std::
 	}
 	else
 	{
-		llwarns << "Image to upload is not a PNG or JPEG" << llendl;
+		LL_WARNS() << "Image to upload is not a PNG or JPEG" << LL_ENDL;
 		return;
 	}
 	
diff --git a/indra/newview/llfloatergroupbulkban.cpp b/indra/newview/llfloatergroupbulkban.cpp
index 54a2283b13..44074047a7 100644
--- a/indra/newview/llfloatergroupbulkban.cpp
+++ b/indra/newview/llfloatergroupbulkban.cpp
@@ -101,7 +101,7 @@ void LLFloaterGroupBulkBan::showForGroup(const LLUUID& group_id, uuid_vec_t* age
 	// Make sure group_id isn't null
 	if (group_id.isNull())
 	{
-		llwarns << "LLFloaterGroupInvite::showForGroup with null group_id!" << llendl;
+		LL_WARNS() << "LLFloaterGroupInvite::showForGroup with null group_id!" << LL_ENDL;
 		return;
 	}
 
diff --git a/indra/newview/llglsandbox.cpp b/indra/newview/llglsandbox.cpp
index 4b8ac2b3cf..64f796e1fd 100755
--- a/indra/newview/llglsandbox.cpp
+++ b/indra/newview/llglsandbox.cpp
@@ -881,13 +881,14 @@ void LLViewerObjectList::renderObjectBeacons()
 
 F32 gpu_benchmark()
 {
-	if (!gGLManager.mHasShaderObjects)
-	{ //don't bother benchmarking the fixed function
+	if (!gGLManager.mHasShaderObjects || !gGLManager.mHasTimerQuery)
+	{ // don't bother benchmarking the fixed function
+      // or venerable drivers which don't support accurate timing anyway
+      // and are likely to be correctly identified by the GPU table already.
 		return -1.f;
 	}
 
-	
-	if (gBenchmarkProgram.mProgramObject == 0)
+    if (gBenchmarkProgram.mProgramObject == 0)
 	{
 		LLViewerShaderMgr::instance()->initAttribsAndUniforms();
 
@@ -920,7 +921,10 @@ F32 gpu_benchmark()
 	//number of samples to take
 	const S32 samples = 64;
 
-	LLGLSLShader::initProfile();
+	if (gGLManager.mHasTimerQuery)
+	{
+		LLGLSLShader::initProfile();
+	}
 
 	LLRenderTarget dest[count];
 	U32 source[count];
@@ -964,16 +968,16 @@ F32 gpu_benchmark()
 	v[0].set(-1,1,0);
 	v[1].set(-1,-3,0);
 	v[2].set(3,1,0);
+
 	buff->flush();
 
 	gBenchmarkProgram.bind();
-	buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
-
-	//wait for any previoius GL commands to finish
-	glFinish();
 	
 	bool busted_finish = false;
 
+	buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
+	glFinish();
+
 	for (S32 c = -1; c < samples; ++c)
 	{
 		LLTimer timer;
@@ -1013,6 +1017,7 @@ F32 gpu_benchmark()
 			if (!gGLManager.mHasTimerQuery && !busted_finish && gbps > 128.f)
 			{ //unrealistically high bandwidth for a card without timer queries, glFinish is probably ignored
 				busted_finish = true;
+				LL_WARNS() << "GPU Benchmark detected GL driver with broken glFinish implementation." << LL_ENDL;
 			}
 			else
 			{
@@ -1023,10 +1028,12 @@ F32 gpu_benchmark()
 
 	gBenchmarkProgram.unbind();
 
-	LLGLSLShader::finishProfile(false);
-	
-	LLImageGL::deleteTextures(count, source);
+	if (gGLManager.mHasTimerQuery)
+	{
+		LLGLSLShader::finishProfile(false);
+	}
 
+	LLImageGL::deleteTextures(count, source);
 
 	std::sort(results.begin(), results.end());
 
@@ -1037,27 +1044,20 @@ F32 gpu_benchmark()
 #if LL_DARWIN
     if (gbps > 512.f)
     { 
-        LL_INFOS() << "Memory bandwidth is improbably high and likely incorrect." << LL_ENDL;
+        LL_WARNS() << "Memory bandwidth is improbably high and likely incorrect; discarding result." << LL_ENDL;
         //OSX is probably lying, discard result
         gbps = -1.f;
     }
 #endif
 
-	if (gGLManager.mHasTimerQuery)
-	{
-		F32 ms = gBenchmarkProgram.mTimeElapsed/1000000.f;
-		F32 seconds = ms/1000.f;
+	F32 ms = gBenchmarkProgram.mTimeElapsed/1000000.f;
+	F32 seconds = ms/1000.f;
 
-		F64 samples_drawn = res*res*count*samples;
-		F32 samples_sec = (samples_drawn/1000000000.0)/seconds;
-		gbps = samples_sec*8;
+	F64 samples_drawn = res*res*count*samples;
+	F32 samples_sec = (samples_drawn/1000000000.0)/seconds;
+	gbps = samples_sec*8;
 
-		LL_INFOS() << "Memory bandwidth is " << llformat("%.3f", gbps) << "GB/sec according to ARB_timer_query" << LL_ENDL;
-	}
-	else
-	{
-		LL_INFOS() << "ARB_timer_query unavailable." << LL_ENDL;
-	}
+	LL_INFOS() << "Memory bandwidth is " << llformat("%.3f", gbps) << "GB/sec according to ARB_timer_query" << LL_ENDL;
 
 	return gbps;
 }
diff --git a/indra/newview/lllogchat.cpp b/indra/newview/lllogchat.cpp
index 06e517a861..cadbc16f1e 100755
--- a/indra/newview/lllogchat.cpp
+++ b/indra/newview/lllogchat.cpp
@@ -1022,7 +1022,7 @@ void LLLoadHistoryThread::run()
 	{
 		loadHistory(mFileName, mMessages, mLoadParams);
 		int count = mMessages->size();
-		llinfos << "mMessages->size(): " << count << llendl;
+		LL_INFOS() << "mMessages->size(): " << count << LL_ENDL;
 		setFinished();
 	}
 }
diff --git a/indra/newview/llpanelgroupbulk.cpp b/indra/newview/llpanelgroupbulk.cpp
index 1eafc5bd64..76792cc6fd 100644
--- a/indra/newview/llpanelgroupbulk.cpp
+++ b/indra/newview/llpanelgroupbulk.cpp
@@ -387,7 +387,7 @@ void LLPanelGroupBulk::addUsers(uuid_vec_t& agent_ids)
 			} 
 			else 
 			{
-				llwarns << "llPanelGroupBulk: Selected avatar has no name: " << dest->getID() << llendl;
+				LL_WARNS() << "llPanelGroupBulk: Selected avatar has no name: " << dest->getID() << LL_ENDL;
 				names.push_back("(Unknown)");
 			}
 		}
diff --git a/indra/newview/llpanelgroupinvite.cpp b/indra/newview/llpanelgroupinvite.cpp
index 236ad861a5..e662a05dfc 100755
--- a/indra/newview/llpanelgroupinvite.cpp
+++ b/indra/newview/llpanelgroupinvite.cpp
@@ -492,7 +492,7 @@ void LLPanelGroupInvite::addUsers(uuid_vec_t& agent_ids)
 			} 
 			else 
 			{
-				llwarns << "llPanelGroupInvite: Selected avatar has no name: " << dest->getID() << llendl;
+				LL_WARNS() << "llPanelGroupInvite: Selected avatar has no name: " << dest->getID() << LL_ENDL;
 				names.push_back("(Unknown)");
 			}
 		}
diff --git a/indra/newview/lltwitterconnect.cpp b/indra/newview/lltwitterconnect.cpp
index 7088558b83..e983bc883f 100644
--- a/indra/newview/lltwitterconnect.cpp
+++ b/indra/newview/lltwitterconnect.cpp
@@ -397,7 +397,7 @@ void LLTwitterConnect::uploadPhoto(LLPointer<LLImageFormatted> image, const std:
 	}
 	else
 	{
-		llwarns << "Image to upload is not a PNG or JPEG" << llendl;
+		LL_WARNS() << "Image to upload is not a PNG or JPEG" << LL_ENDL;
 		return;
 	}