Fix tabs.

3 files changed, 1449 insertions, 1449 deletions

diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 9a4eeb59df..5659bd327b 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -724,144 +724,144 @@ GLint LLGLSLShader::mapUniformTextureChannel(GLint location, GLenum type)
 
 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);
-
-	//........................................................................................................................................
-	//........................................................................................
-
-	/*
-	EXPLANATION:
-	This is part of code is temporary because as the final result the mapUniform() should be rewrited.
-	But it's a huge a volume of work which is need to be a more carefully performed for avoid possible
-	regression's (i.e. it should be formalized a separate ticket in JIRA).
-
-	RESON:
-	The reason of this code is that SL engine is very sensitive to fact that "diffuseMap" should be appear
-	first as uniform parameter which is should get 0-"texture channel" index (see mapUniformTextureChannel() and mActiveTextureChannels)
-	it influence to which is texture matrix will be updated during rendering.
-
-	But, order of indexe's of uniform variables is not defined and GLSL compiler can change it as want
-	, even if the "diffuseMap" will be appear and use first in shader code.
-
-	As example where this situation appear see: "Deferred Material Shader 28/29/30/31"
-	And tickets: MAINT-4165, MAINT-4839, MAINT-3568, MAINT-6437
-	*/
-
-
-	S32 diffuseMap = glGetUniformLocationARB(mProgramObject, "diffuseMap");
-	S32 specularMap = glGetUniformLocationARB(mProgramObject, "specularMap");
-	S32 bumpMap = glGetUniformLocationARB(mProgramObject, "bumpMap");
+    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);
+
+    //........................................................................................................................................
+    //........................................................................................
+
+    /*
+    EXPLANATION:
+    This is part of code is temporary because as the final result the mapUniform() should be rewrited.
+    But it's a huge a volume of work which is need to be a more carefully performed for avoid possible
+    regression's (i.e. it should be formalized a separate ticket in JIRA).
+
+    RESON:
+    The reason of this code is that SL engine is very sensitive to fact that "diffuseMap" should be appear
+    first as uniform parameter which is should get 0-"texture channel" index (see mapUniformTextureChannel() and mActiveTextureChannels)
+    it influence to which is texture matrix will be updated during rendering.
+
+    But, order of indexe's of uniform variables is not defined and GLSL compiler can change it as want
+    , even if the "diffuseMap" will be appear and use first in shader code.
+
+    As example where this situation appear see: "Deferred Material Shader 28/29/30/31"
+    And tickets: MAINT-4165, MAINT-4839, MAINT-3568, MAINT-6437
+    */
+
+
+    S32 diffuseMap = glGetUniformLocationARB(mProgramObject, "diffuseMap");
+    S32 specularMap = glGetUniformLocationARB(mProgramObject, "specularMap");
+    S32 bumpMap = glGetUniformLocationARB(mProgramObject, "bumpMap");
     S32 altDiffuseMap = glGetUniformLocationARB(mProgramObject, "altDiffuseMap");
-	S32 environmentMap = glGetUniformLocationARB(mProgramObject, "environmentMap");
+    S32 environmentMap = glGetUniformLocationARB(mProgramObject, "environmentMap");
 
-	std::set<S32> skip_index;
+    std::set<S32> skip_index;
 
-	if (-1 != diffuseMap && (-1 != specularMap || -1 != bumpMap || -1 != environmentMap || -1 != altDiffuseMap))
-	{
-		GLenum type;
-		GLsizei length;
-		GLint size = -1;
-		char name[1024];
+    if (-1 != diffuseMap && (-1 != specularMap || -1 != bumpMap || -1 != environmentMap || -1 != altDiffuseMap))
+    {
+        GLenum type;
+        GLsizei length;
+        GLint size = -1;
+        char name[1024];
 
-		diffuseMap = altDiffuseMap = specularMap = bumpMap = environmentMap = -1;
+        diffuseMap = altDiffuseMap = specularMap = bumpMap = environmentMap = -1;
 
-		for (S32 i = 0; i < activeCount; i++)
-		{
-			name[0] = '\0';
+        for (S32 i = 0; i < activeCount; i++)
+        {
+            name[0] = '\0';
 
-			glGetActiveUniformARB(mProgramObject, i, 1024, &length, &size, &type, (GLcharARB *)name);
+            glGetActiveUniformARB(mProgramObject, i, 1024, &length, &size, &type, (GLcharARB *)name);
 
-			if (-1 == diffuseMap && std::string(name) == "diffuseMap")
-			{
-				diffuseMap = i;
-				continue;
-			}
+            if (-1 == diffuseMap && std::string(name) == "diffuseMap")
+            {
+                diffuseMap = i;
+                continue;
+            }
 
-			if (-1 == specularMap && std::string(name) == "specularMap")
-			{
-				specularMap = i;
-				continue;
-			}
+            if (-1 == specularMap && std::string(name) == "specularMap")
+            {
+                specularMap = i;
+                continue;
+            }
 
-			if (-1 == bumpMap && std::string(name) == "bumpMap")
-			{
-				bumpMap = i;
-				continue;
-			}
+            if (-1 == bumpMap && std::string(name) == "bumpMap")
+            {
+                bumpMap = i;
+                continue;
+            }
 
-			if (-1 == environmentMap && std::string(name) == "environmentMap")
-			{
-				environmentMap = i;
-				continue;
-			}
+            if (-1 == environmentMap && std::string(name) == "environmentMap")
+            {
+                environmentMap = i;
+                continue;
+            }
 
             if (-1 == altDiffuseMap && std::string(name) == "altDiffuseMap")
-			{
-				altDiffuseMap = i;
-				continue;
-			}
-		}
+            {
+                altDiffuseMap = i;
+                continue;
+            }
+        }
 
-		bool specularDiff = specularMap < diffuseMap && -1 != specularMap;
-		bool bumpLessDiff = bumpMap < diffuseMap && -1 != bumpMap;
-		bool envLessDiff = environmentMap < diffuseMap && -1 != environmentMap;
+        bool specularDiff = specularMap < diffuseMap && -1 != specularMap;
+        bool bumpLessDiff = bumpMap < diffuseMap && -1 != bumpMap;
+        bool envLessDiff = environmentMap < diffuseMap && -1 != environmentMap;
 
-		if (specularDiff || bumpLessDiff || envLessDiff)
-		{
-			mapUniform(diffuseMap, uniforms);
-			skip_index.insert(diffuseMap);
+        if (specularDiff || bumpLessDiff || envLessDiff)
+        {
+            mapUniform(diffuseMap, uniforms);
+            skip_index.insert(diffuseMap);
 
-			if (-1 != specularMap) {
-				mapUniform(specularMap, uniforms);
-				skip_index.insert(specularMap);
-			}
+            if (-1 != specularMap) {
+                mapUniform(specularMap, uniforms);
+                skip_index.insert(specularMap);
+            }
 
-			if (-1 != bumpMap) {
-				mapUniform(bumpMap, uniforms);
-				skip_index.insert(bumpMap);
-			}
+            if (-1 != bumpMap) {
+                mapUniform(bumpMap, uniforms);
+                skip_index.insert(bumpMap);
+            }
 
-			if (-1 != environmentMap) {
-				mapUniform(environmentMap, uniforms);
-				skip_index.insert(environmentMap);
-			}
-		}
-	}
+            if (-1 != environmentMap) {
+                mapUniform(environmentMap, uniforms);
+                skip_index.insert(environmentMap);
+            }
+        }
+    }
 
-	//........................................................................................
+    //........................................................................................
 
-	for (S32 i = 0; i < activeCount; i++)
-	{
-		//........................................................................................
-		if (skip_index.end() != skip_index.find(i)) continue;
-		//........................................................................................
+    for (S32 i = 0; i < activeCount; i++)
+    {
+        //........................................................................................
+        if (skip_index.end() != skip_index.find(i)) continue;
+        //........................................................................................
 
-		mapUniform(i, uniforms);
-	}
-	//........................................................................................................................................
+        mapUniform(i, uniforms);
+    }
+    //........................................................................................................................................
 
-	unbind();
+    unbind();
 
-	LL_DEBUGS("ShaderUniform") << "Total Uniform Size: " << mTotalUniformSize << LL_ENDL;
-	return res;
+    LL_DEBUGS("ShaderUniform") << "Total Uniform Size: " << mTotalUniformSize << LL_ENDL;
+    return res;
 }
 
 
@@ -1286,19 +1286,19 @@ void LLGLSLShader::uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, c
 
 void LLGLSLShader::uniformMatrix3x4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
 {
-	if (mProgramObject)
-	{	
-		if (mUniform.size() <= index)
-		{
-			LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
-
-		if (mUniform[index] >= 0)
-		{
-			glUniformMatrix3x4fv(mUniform[index], count, transpose, v);
-		}
-	}
+    if (mProgramObject)
+    {   
+        if (mUniform.size() <= index)
+        {
+            LL_SHADER_UNIFORM_ERRS() << "Uniform index out of bounds." << LL_ENDL;
+            return;
+        }
+
+        if (mUniform[index] >= 0)
+        {
+            glUniformMatrix3x4fv(mUniform[index], count, transpose, v);
+        }
+    }
 }
 
 void LLGLSLShader::uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index e5110fe1c4..9c3effadbe 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -34,201 +34,201 @@
 class LLShaderFeatures
 {
 public:
-	bool atmosphericHelpers;
-	bool calculatesLighting;
-	bool calculatesAtmospherics;
-	bool hasLighting; // implies no transport (it's possible to have neither though)
-	bool isAlphaLighting; // indicates lighting shaders need not be linked in (lighting performed directly in alpha shader to match deferred lighting functions)
-	bool isShiny;
-	bool isFullbright; // implies no lighting
-	bool isSpecular;
-	bool hasWaterFog; // implies no gamma
-	bool hasTransport; // implies no lighting (it's possible to have neither though)
-	bool hasSkinning;	
-	bool hasObjectSkinning;
-	bool hasAtmospherics;
-	bool hasGamma;
+    bool atmosphericHelpers;
+    bool calculatesLighting;
+    bool calculatesAtmospherics;
+    bool hasLighting; // implies no transport (it's possible to have neither though)
+    bool isAlphaLighting; // indicates lighting shaders need not be linked in (lighting performed directly in alpha shader to match deferred lighting functions)
+    bool isShiny;
+    bool isFullbright; // implies no lighting
+    bool isSpecular;
+    bool hasWaterFog; // implies no gamma
+    bool hasTransport; // implies no lighting (it's possible to have neither though)
+    bool hasSkinning;   
+    bool hasObjectSkinning;
+    bool hasAtmospherics;
+    bool hasGamma;
     bool hasShadows;
     bool hasAmbientOcclusion;
-	bool hasSrgb;
+    bool hasSrgb;
     bool encodesNormal;
     bool isDeferred;
     bool hasIndirect;
-	S32 mIndexedTextureChannels;
-	bool disableTextureIndex;
-	bool hasAlphaMask;
-	bool attachNothing;
-
-	// char numLights;
-	
-	LLShaderFeatures();
+    S32 mIndexedTextureChannels;
+    bool disableTextureIndex;
+    bool hasAlphaMask;
+    bool attachNothing;
+
+    // char numLights;
+    
+    LLShaderFeatures();
 };
 
 class LLGLSLShader
 {
 public:
 
-	enum 
-	{
-		SG_DEFAULT = 0,
-		SG_SKY,
-		SG_WATER
-	};
-	
-	static std::set<LLGLSLShader*> sInstances;
-	static bool sProfileEnabled;
-
-	LLGLSLShader();
-	~LLGLSLShader();
-
-	static GLhandleARB sCurBoundShader;
-	static LLGLSLShader* sCurBoundShaderPtr;
-	static S32 sIndexedTextureChannels;
-	static bool sNoFixedFunction;
-
-	static void initProfile();
-	static void finishProfile(bool emit_report = true);
-
-	static void startProfile();
-	static void stopProfile(U32 count, U32 mode);
-
-	void unload();
-	void clearStats();
-	void dumpStats();
-	void placeProfileQuery();
-	void readProfileQuery(U32 count, U32 mode);
-
-	BOOL createShader(std::vector<LLStaticHashedString> * attributes,
-						std::vector<LLStaticHashedString> * uniforms,
-						U32 varying_count = 0,
-						const char** varyings = NULL);
-	BOOL attachObject(std::string object);
-	void attachObject(GLhandleARB object);
-	void attachObjects(GLhandleARB* objects = NULL, S32 count = 0);
-	BOOL mapAttributes(const std::vector<LLStaticHashedString> * attributes);
-	BOOL mapUniforms(const std::vector<LLStaticHashedString> *);
-	void mapUniform(GLint index, const std::vector<LLStaticHashedString> *);
-	void uniform1i(U32 index, GLint i);
-	void uniform1f(U32 index, GLfloat v);
-	void uniform2f(U32 index, GLfloat x, GLfloat y);
-	void uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z);
-	void uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-	void uniform1iv(U32 index, U32 count, const GLint* i);
-	void uniform1fv(U32 index, U32 count, const GLfloat* v);
-	void uniform2fv(U32 index, U32 count, const GLfloat* v);
-	void uniform3fv(U32 index, U32 count, const GLfloat* v);
-	void uniform4fv(U32 index, U32 count, const GLfloat* v);
-	void uniform2i(const LLStaticHashedString& uniform, GLint i, GLint j);
-	void uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
-	void uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
-	void uniformMatrix3x4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
-	void uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
-	void uniform1i(const LLStaticHashedString& uniform, GLint i);
-	void uniform1f(const LLStaticHashedString& uniform, GLfloat v);
-	void uniform2f(const LLStaticHashedString& uniform, GLfloat x, GLfloat y);
-	void uniform3f(const LLStaticHashedString& uniform, GLfloat x, GLfloat y, GLfloat z);
-	void uniform1fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v);
-	void uniform2fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v);
-	void uniform3fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v);
-	void uniform4fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v);
-	void uniformMatrix4fv(const LLStaticHashedString& uniform, U32 count, GLboolean transpose, const GLfloat *v);
-
-	void setMinimumAlpha(F32 minimum);
-
-	void vertexAttrib4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-	void vertexAttrib4fv(U32 index, GLfloat* v);
-	
-	//GLint getUniformLocation(const std::string& uniform);
-	GLint getUniformLocation(const LLStaticHashedString& uniform);	
-	GLint getUniformLocation(U32 index);
-
-	GLint getAttribLocation(U32 attrib);
-	GLint mapUniformTextureChannel(GLint location, GLenum type);
-	
+    enum 
+    {
+        SG_DEFAULT = 0,
+        SG_SKY,
+        SG_WATER
+    };
+    
+    static std::set<LLGLSLShader*> sInstances;
+    static bool sProfileEnabled;
+
+    LLGLSLShader();
+    ~LLGLSLShader();
+
+    static GLhandleARB sCurBoundShader;
+    static LLGLSLShader* sCurBoundShaderPtr;
+    static S32 sIndexedTextureChannels;
+    static bool sNoFixedFunction;
+
+    static void initProfile();
+    static void finishProfile(bool emit_report = true);
+
+    static void startProfile();
+    static void stopProfile(U32 count, U32 mode);
+
+    void unload();
+    void clearStats();
+    void dumpStats();
+    void placeProfileQuery();
+    void readProfileQuery(U32 count, U32 mode);
+
+    BOOL createShader(std::vector<LLStaticHashedString> * attributes,
+                        std::vector<LLStaticHashedString> * uniforms,
+                        U32 varying_count = 0,
+                        const char** varyings = NULL);
+    BOOL attachObject(std::string object);
+    void attachObject(GLhandleARB object);
+    void attachObjects(GLhandleARB* objects = NULL, S32 count = 0);
+    BOOL mapAttributes(const std::vector<LLStaticHashedString> * attributes);
+    BOOL mapUniforms(const std::vector<LLStaticHashedString> *);
+    void mapUniform(GLint index, const std::vector<LLStaticHashedString> *);
+    void uniform1i(U32 index, GLint i);
+    void uniform1f(U32 index, GLfloat v);
+    void uniform2f(U32 index, GLfloat x, GLfloat y);
+    void uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z);
+    void uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+    void uniform1iv(U32 index, U32 count, const GLint* i);
+    void uniform1fv(U32 index, U32 count, const GLfloat* v);
+    void uniform2fv(U32 index, U32 count, const GLfloat* v);
+    void uniform3fv(U32 index, U32 count, const GLfloat* v);
+    void uniform4fv(U32 index, U32 count, const GLfloat* v);
+    void uniform2i(const LLStaticHashedString& uniform, GLint i, GLint j);
+    void uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
+    void uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
+    void uniformMatrix3x4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
+    void uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
+    void uniform1i(const LLStaticHashedString& uniform, GLint i);
+    void uniform1f(const LLStaticHashedString& uniform, GLfloat v);
+    void uniform2f(const LLStaticHashedString& uniform, GLfloat x, GLfloat y);
+    void uniform3f(const LLStaticHashedString& uniform, GLfloat x, GLfloat y, GLfloat z);
+    void uniform1fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v);
+    void uniform2fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v);
+    void uniform3fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v);
+    void uniform4fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v);
+    void uniformMatrix4fv(const LLStaticHashedString& uniform, U32 count, GLboolean transpose, const GLfloat *v);
+
+    void setMinimumAlpha(F32 minimum);
+
+    void vertexAttrib4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+    void vertexAttrib4fv(U32 index, GLfloat* v);
+    
+    //GLint getUniformLocation(const std::string& uniform);
+    GLint getUniformLocation(const LLStaticHashedString& uniform);  
+    GLint getUniformLocation(U32 index);
+
+    GLint getAttribLocation(U32 attrib);
+    GLint mapUniformTextureChannel(GLint location, GLenum type);
+    
     void clearPermutations();
-	void addPermutation(std::string name, std::string value);
-	void removePermutation(std::string name);
-	
-	//enable/disable texture channel for specified uniform
-	//if given texture uniform is active in the shader, 
-	//the corresponding channel will be active upon return
-	//returns channel texture is enabled in from [0-MAX)
-	S32 enableTexture(S32 uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
-	S32 disableTexture(S32 uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
-	
-	// bindTexture returns the texture unit we've bound the texture to.
-	// You can reuse the return value to unbind a texture when required.
-	S32 bindTexture(const std::string& uniform, LLTexture *texture, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
-	S32 bindTexture(S32 uniform, LLTexture *texture, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
-	S32 unbindTexture(const std::string& uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
-	S32 unbindTexture(S32 uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
-	
+    void addPermutation(std::string name, std::string value);
+    void removePermutation(std::string name);
+    
+    //enable/disable texture channel for specified uniform
+    //if given texture uniform is active in the shader, 
+    //the corresponding channel will be active upon return
+    //returns channel texture is enabled in from [0-MAX)
+    S32 enableTexture(S32 uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
+    S32 disableTexture(S32 uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
+    
+    // bindTexture returns the texture unit we've bound the texture to.
+    // You can reuse the return value to unbind a texture when required.
+    S32 bindTexture(const std::string& uniform, LLTexture *texture, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
+    S32 bindTexture(S32 uniform, LLTexture *texture, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
+    S32 unbindTexture(const std::string& uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
+    S32 unbindTexture(S32 uniform, LLTexUnit::eTextureType mode = LLTexUnit::TT_TEXTURE);
+    
     BOOL link(BOOL suppress_errors = FALSE);
-	void bind();
-	void unbind();
+    void bind();
+    void unbind();
 
-	// Unbinds any previously bound shader by explicitly binding no shader.
-	static void bindNoShader(void);
+    // Unbinds any previously bound shader by explicitly binding no shader.
+    static void bindNoShader(void);
 
-	U32 mMatHash[LLRender::NUM_MATRIX_MODES];
-	U32 mLightHash;
+    U32 mMatHash[LLRender::NUM_MATRIX_MODES];
+    U32 mLightHash;
 
-	GLhandleARB mProgramObject;
+    GLhandleARB mProgramObject;
 #if LL_RELEASE_WITH_DEBUG_INFO
-	struct attr_name
-	{
-		GLint loc;
-		const char *name;
-		void operator = (GLint _loc) { loc = _loc; }
-		operator GLint () { return loc; }
-	};
-	std::vector<attr_name> mAttribute; //lookup table of attribute enum to attribute channel
+    struct attr_name
+    {
+        GLint loc;
+        const char *name;
+        void operator = (GLint _loc) { loc = _loc; }
+        operator GLint () { return loc; }
+    };
+    std::vector<attr_name> mAttribute; //lookup table of attribute enum to attribute channel
 #else
-	std::vector<GLint> mAttribute; //lookup table of attribute enum to attribute channel
+    std::vector<GLint> mAttribute; //lookup table of attribute enum to attribute channel
 #endif
-	U32 mAttributeMask;  //mask of which reserved attributes are set (lines up with LLVertexBuffer::getTypeMask())
-	std::vector<GLint> mUniform;   //lookup table of uniform enum to uniform location
-	LLStaticStringTable<GLint> mUniformMap; //lookup map of uniform name to uniform location
-	std::map<GLint, std::string> mUniformNameMap; //lookup map of uniform location to uniform name
-	std::map<GLint, LLVector4> mValue; //lookup map of uniform location to last known value
-	std::vector<GLint> mTexture;
-	S32 mTotalUniformSize;
-	S32 mActiveTextureChannels;
-	S32 mShaderLevel;
-	S32 mShaderGroup;
-	BOOL mUniformsDirty;
-	LLShaderFeatures mFeatures;
-	std::vector< std::pair< std::string, GLenum > > mShaderFiles;
-	std::string mName;
-	boost::unordered_map<std::string, std::string> mDefines;
-
-	//statistcis for profiling shader performance
-	U32 mTimerQuery;
-	U32 mSamplesQuery;
-	U64 mTimeElapsed;
-	static U64 sTotalTimeElapsed;
-	U32 mTrianglesDrawn;
-	static U32 sTotalTrianglesDrawn;
-	U64 mSamplesDrawn;
-	static U64 sTotalSamplesDrawn;
-	U32 mDrawCalls;
-	static U32 sTotalDrawCalls;
-
-	bool mTextureStateFetched;
-	std::vector<U32> mTextureMagFilter;
-	std::vector<U32> mTextureMinFilter;
+    U32 mAttributeMask;  //mask of which reserved attributes are set (lines up with LLVertexBuffer::getTypeMask())
+    std::vector<GLint> mUniform;   //lookup table of uniform enum to uniform location
+    LLStaticStringTable<GLint> mUniformMap; //lookup map of uniform name to uniform location
+    std::map<GLint, std::string> mUniformNameMap; //lookup map of uniform location to uniform name
+    std::map<GLint, LLVector4> mValue; //lookup map of uniform location to last known value
+    std::vector<GLint> mTexture;
+    S32 mTotalUniformSize;
+    S32 mActiveTextureChannels;
+    S32 mShaderLevel;
+    S32 mShaderGroup;
+    BOOL mUniformsDirty;
+    LLShaderFeatures mFeatures;
+    std::vector< std::pair< std::string, GLenum > > mShaderFiles;
+    std::string mName;
+    boost::unordered_map<std::string, std::string> mDefines;
+
+    //statistcis for profiling shader performance
+    U32 mTimerQuery;
+    U32 mSamplesQuery;
+    U64 mTimeElapsed;
+    static U64 sTotalTimeElapsed;
+    U32 mTrianglesDrawn;
+    static U32 sTotalTrianglesDrawn;
+    U64 mSamplesDrawn;
+    static U64 sTotalSamplesDrawn;
+    U32 mDrawCalls;
+    static U32 sTotalDrawCalls;
+
+    bool mTextureStateFetched;
+    std::vector<U32> mTextureMagFilter;
+    std::vector<U32> mTextureMinFilter;
 
     GLhandleARB mExtraLinkObject = 0;
 
 private:
-	void unloadInternal();
+    void unloadInternal();
 };
 
 //UI shader (declared here so llui_libtest will link properly)
-extern LLGLSLShader			gUIProgram;
+extern LLGLSLShader         gUIProgram;
 //output vec4(color.rgb,color.a*tex0[tc0].a)
-extern LLGLSLShader			gSolidColorProgram;
+extern LLGLSLShader         gSolidColorProgram;
 //Alpha mask shader (declared here so llappearance can access properly)
-extern LLGLSLShader			gAlphaMaskProgram;
+extern LLGLSLShader         gAlphaMaskProgram;
 
 #endif
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index ec8f05e4ca..5b96667f9f 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -53,489 +53,489 @@ LLShaderMgr::~LLShaderMgr()
 // static
 LLShaderMgr * LLShaderMgr::instance()
 {
-	if(NULL == sInstance)
-	{
-		LL_ERRS("Shaders") << "LLShaderMgr should already have been instantiated by the application!" << LL_ENDL;
-	}
+    if(NULL == sInstance)
+    {
+        LL_ERRS("Shaders") << "LLShaderMgr should already have been instantiated by the application!" << LL_ENDL;
+    }
 
-	return sInstance;
+    return sInstance;
 }
 
 BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 {
-	llassert_always(shader != NULL);
-	LLShaderFeatures *features = & shader->mFeatures;
-
-	if (features->attachNothing)
-	{
-		return TRUE;
-	}
-	//////////////////////////////////////
-	// Attach Vertex Shader Features First
-	//////////////////////////////////////
-	
-	// NOTE order of shader object attaching is VERY IMPORTANT!!!
-	if (features->calculatesAtmospherics)
-	{
-		if (features->hasWaterFog)
-		{
-			if (!shader->attachObject("windlight/atmosphericsVarsWaterV.glsl"))
-			{
-				return FALSE;
-			}
-		}
-		else if (!shader->attachObject("windlight/atmosphericsVarsV.glsl"))
-		{
-			return FALSE;
-		}
-	}
-
-	if (features->calculatesLighting || features->calculatesAtmospherics)
-	{
-		if (!shader->attachObject("windlight/atmosphericsHelpersV.glsl"))
-		{
-			return FALSE;
-		}
-	}
-		
-	if (features->calculatesLighting)
-	{
-		if (features->isSpecular)
-		{
-			if (!shader->attachObject("lighting/lightFuncSpecularV.glsl"))
-			{
-				return FALSE;
-			}
-		
-			if (!features->isAlphaLighting)
-			{
-				if (!shader->attachObject("lighting/sumLightsSpecularV.glsl"))
-				{
-					return FALSE;
-				}
-			}
-			
-			if (!shader->attachObject("lighting/lightSpecularV.glsl"))
-			{
-				return FALSE;
-			}
-		}
-		else 
-		{
-			if (!shader->attachObject("lighting/lightFuncV.glsl"))
-			{
-				return FALSE;
-			}
-			
-			if (!features->isAlphaLighting)
-			{
-				if (!shader->attachObject("lighting/sumLightsV.glsl"))
-				{
-					return FALSE;
-				}
-			}
-			
-			if (!shader->attachObject("lighting/lightV.glsl"))
-			{
-				return FALSE;
-			}
-		}
-	}
-	
-	// NOTE order of shader object attaching is VERY IMPORTANT!!!
-	if (features->calculatesAtmospherics)
-	{
-		if (!shader->attachObject("windlight/atmosphericsV.glsl"))
-		{
-			return FALSE;
-		}
-	}
-
-	if (features->hasSkinning)
-	{
-		if (!shader->attachObject("avatar/avatarSkinV.glsl"))
-		{
-			return FALSE;
-		}
-	}
-
-	if (features->hasObjectSkinning)
-	{
-		if (!shader->attachObject("avatar/objectSkinV.glsl"))
-		{
-			return FALSE;
-		}
-	}
-	
-	///////////////////////////////////////
-	// Attach Fragment Shader Features Next
-	///////////////////////////////////////
+    llassert_always(shader != NULL);
+    LLShaderFeatures *features = & shader->mFeatures;
+
+    if (features->attachNothing)
+    {
+        return TRUE;
+    }
+    //////////////////////////////////////
+    // Attach Vertex Shader Features First
+    //////////////////////////////////////
+    
+    // NOTE order of shader object attaching is VERY IMPORTANT!!!
+    if (features->calculatesAtmospherics)
+    {
+        if (features->hasWaterFog)
+        {
+            if (!shader->attachObject("windlight/atmosphericsVarsWaterV.glsl"))
+            {
+                return FALSE;
+            }
+        }
+        else if (!shader->attachObject("windlight/atmosphericsVarsV.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
+    if (features->calculatesLighting || features->calculatesAtmospherics)
+    {
+        if (!shader->attachObject("windlight/atmosphericsHelpersV.glsl"))
+        {
+            return FALSE;
+        }
+    }
+        
+    if (features->calculatesLighting)
+    {
+        if (features->isSpecular)
+        {
+            if (!shader->attachObject("lighting/lightFuncSpecularV.glsl"))
+            {
+                return FALSE;
+            }
+        
+            if (!features->isAlphaLighting)
+            {
+                if (!shader->attachObject("lighting/sumLightsSpecularV.glsl"))
+                {
+                    return FALSE;
+                }
+            }
+            
+            if (!shader->attachObject("lighting/lightSpecularV.glsl"))
+            {
+                return FALSE;
+            }
+        }
+        else 
+        {
+            if (!shader->attachObject("lighting/lightFuncV.glsl"))
+            {
+                return FALSE;
+            }
+            
+            if (!features->isAlphaLighting)
+            {
+                if (!shader->attachObject("lighting/sumLightsV.glsl"))
+                {
+                    return FALSE;
+                }
+            }
+            
+            if (!shader->attachObject("lighting/lightV.glsl"))
+            {
+                return FALSE;
+            }
+        }
+    }
+    
+    // NOTE order of shader object attaching is VERY IMPORTANT!!!
+    if (features->calculatesAtmospherics)
+    {
+        if (!shader->attachObject("windlight/atmosphericsV.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
+    if (features->hasSkinning)
+    {
+        if (!shader->attachObject("avatar/avatarSkinV.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
+    if (features->hasObjectSkinning)
+    {
+        if (!shader->attachObject("avatar/objectSkinV.glsl"))
+        {
+            return FALSE;
+        }
+    }
+    
+    ///////////////////////////////////////
+    // Attach Fragment Shader Features Next
+    ///////////////////////////////////////
 
 // NOTE order of shader object attaching is VERY IMPORTANT!!!
 
-	if(features->calculatesAtmospherics)
-	{
-		if (features->hasWaterFog)
-		{
-			if (!shader->attachObject("windlight/atmosphericsVarsWaterF.glsl"))
-			{
-				return FALSE;
-			}
-		}
-		else if (!shader->attachObject("windlight/atmosphericsVarsF.glsl"))
-		{
-			return FALSE;
-		}
-	}
+    if(features->calculatesAtmospherics)
+    {
+        if (features->hasWaterFog)
+        {
+            if (!shader->attachObject("windlight/atmosphericsVarsWaterF.glsl"))
+            {
+                return FALSE;
+            }
+        }
+        else if (!shader->attachObject("windlight/atmosphericsVarsF.glsl"))
+        {
+            return FALSE;
+        }
+    }
 
     if (features->calculatesLighting || features->calculatesAtmospherics)
-	{
-		if (!shader->attachObject("windlight/atmosphericsHelpersF.glsl"))
-		{
-			return FALSE;
-		}
-	}
+    {
+        if (!shader->attachObject("windlight/atmosphericsHelpersF.glsl"))
+        {
+            return FALSE;
+        }
+    }
 
     // we want this BEFORE shadows and AO because those facilities use pos/norm access
     if (features->isDeferred)
-	{
-		if (!shader->attachObject("deferred/deferredUtil.glsl"))
-		{
-			return FALSE;
-		}
-	}
+    {
+        if (!shader->attachObject("deferred/deferredUtil.glsl"))
+        {
+            return FALSE;
+        }
+    }
 
     if (features->hasShadows)
-	{
-		if (!shader->attachObject("deferred/shadowUtil.glsl"))
-		{
-			return FALSE;
-		}
-	}
+    {
+        if (!shader->attachObject("deferred/shadowUtil.glsl"))
+        {
+            return FALSE;
+        }
+    }
 
     if (features->hasAmbientOcclusion)
-	{
-		if (!shader->attachObject("deferred/aoUtil.glsl"))
-		{
-			return FALSE;
-		}
-	}
+    {
+        if (!shader->attachObject("deferred/aoUtil.glsl"))
+        {
+            return FALSE;
+        }
+    }
 
     if (features->hasIndirect)
-	{
-		if (!shader->attachObject("deferred/indirect.glsl"))
-		{
-			return FALSE;
-		}
-	}
-
-	if (features->hasGamma)
-	{
-		if (!shader->attachObject("windlight/gammaF.glsl"))
-		{
-			return FALSE;
-		}
-	}
-
-	if (features->hasSrgb)
-	{
-		if (!shader->attachObject("environment/srgbF.glsl"))
-		{
-			return FALSE;
-		}
-	}
+    {
+        if (!shader->attachObject("deferred/indirect.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
+    if (features->hasGamma)
+    {
+        if (!shader->attachObject("windlight/gammaF.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
+    if (features->hasSrgb)
+    {
+        if (!shader->attachObject("environment/srgbF.glsl"))
+        {
+            return FALSE;
+        }
+    }
 
     if (features->encodesNormal)
-	{
-		if (!shader->attachObject("environment/encodeNormF.glsl"))
-		{
-			return FALSE;
-		}
-	}
-
-	if (features->hasAtmospherics)
-	{
-		if (!shader->attachObject("windlight/atmosphericsF.glsl"))
-		{
-			return FALSE;
-		}
-	}
-	
-	if (features->hasTransport)
-	{
-		if (!shader->attachObject("windlight/transportF.glsl"))
-		{
-			return FALSE;
-		}
-
-		// Test hasFullbright and hasShiny and attach fullbright and 
-		// fullbright shiny atmos transport if we split them out.
-	}
-
-	// NOTE order of shader object attaching is VERY IMPORTANT!!!
-	if (features->hasWaterFog)
-	{
-		if (!shader->attachObject("environment/waterFogF.glsl"))
-		{
-			return FALSE;
-		}
-	}
-	
-	if (features->hasLighting)
-	{
-		if (features->hasWaterFog)
-		{
-			if (features->disableTextureIndex)
-			{
-				if (features->hasAlphaMask)
-				{
-					if (!shader->attachObject("lighting/lightWaterAlphaMaskNonIndexedF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				else
-				{
-					if (!shader->attachObject("lighting/lightWaterNonIndexedF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-			}
-			else 
-			{
-				if (features->hasAlphaMask)
-				{
-					if (!shader->attachObject("lighting/lightWaterAlphaMaskF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				else
-				{
-					if (!shader->attachObject("lighting/lightWaterF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
-			}
-		}
-		
-		else
-		{
-			if (features->disableTextureIndex)
-			{
-				if (features->hasAlphaMask)
-				{
-					if (!shader->attachObject("lighting/lightAlphaMaskNonIndexedF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				else
-				{
-					if (!shader->attachObject("lighting/lightNonIndexedF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-			}
-			else 
-			{
-				if (features->hasAlphaMask)
-				{
-					if (!shader->attachObject("lighting/lightAlphaMaskF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				else
-				{
-					if (!shader->attachObject("lighting/lightF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
-			}
-		}
-	}
-	
-	// NOTE order of shader object attaching is VERY IMPORTANT!!!
-	else if (features->isFullbright)
-	{
-	
-		if (features->isShiny && features->hasWaterFog)
-		{
-			if (features->disableTextureIndex)
-			{
-				if (!shader->attachObject("lighting/lightFullbrightShinyWaterNonIndexedF.glsl"))
-				{
-					return FALSE;
-				}
-			}
-			else 
-			{
-				if (!shader->attachObject("lighting/lightFullbrightShinyWaterF.glsl"))
-				{
-					return FALSE;
-				}
-				shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
-			}
-		}
-		else if (features->hasWaterFog)
-		{
-			if (features->disableTextureIndex)
-			{
-				if (features->hasAlphaMask)
-				{
-					if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				else if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedF.glsl"))
-				{
-					return FALSE;
-				}
-			}
-			else 
-			{
-				if (features->hasAlphaMask)
-				{
-					if (!shader->attachObject("lighting/lightFullbrightWaterAlphaMaskF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				else if (!shader->attachObject("lighting/lightFullbrightWaterF.glsl"))
-				{
-					return FALSE;
-				}
-				shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
-			}
-		}
-		
-		else if (features->isShiny)
-		{
-			if (features->disableTextureIndex)
-			{
-				if (!shader->attachObject("lighting/lightFullbrightShinyNonIndexedF.glsl"))
-				{
-					return FALSE;
-				}
-			}
-			else 
-			{
-				if (!shader->attachObject("lighting/lightFullbrightShinyF.glsl"))
-				{
-					return FALSE;
-				}
-				shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
-			}
-		}
-		
-		else
-		{
-			if (features->disableTextureIndex)
-			{
-
-				if (features->hasAlphaMask)
-				{
-					if (!shader->attachObject("lighting/lightFullbrightNonIndexedAlphaMaskF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				else
-				{
-					if (!shader->attachObject("lighting/lightFullbrightNonIndexedF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-			}
-			else 
-			{
-				if (features->hasAlphaMask)
-				{
-					if (!shader->attachObject("lighting/lightFullbrightAlphaMaskF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				else
-				{
-					if (!shader->attachObject("lighting/lightFullbrightF.glsl"))
-					{
-						return FALSE;
-					}
-				}
-				shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
-			}
-		}
-	}
-
-	// NOTE order of shader object attaching is VERY IMPORTANT!!!
-	else if (features->isShiny)
-	{
-	
-		if (features->hasWaterFog)
-		{
-			if (features->disableTextureIndex)
-			{
-				if (!shader->attachObject("lighting/lightShinyWaterNonIndexedF.glsl"))
-				{
-					return FALSE;
-				}
-			}
-			else 
-			{
-				if (!shader->attachObject("lighting/lightShinyWaterF.glsl"))
-				{
-					return FALSE;
-				}
-				shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
-			}
-		}
-		
-		else 
-		{
-			if (features->disableTextureIndex)
-			{
-				if (!shader->attachObject("lighting/lightShinyNonIndexedF.glsl"))
-				{
-					return FALSE;
-				}
-			}
-			else 
-			{
-				if (!shader->attachObject("lighting/lightShinyF.glsl"))
-				{
-					return FALSE;
-				}
-				shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
-			}
-		}
-	}
-
-	if (features->mIndexedTextureChannels <= 1)
-	{
-		if (!shader->attachObject("objects/nonindexedTextureV.glsl"))
-		{
-			return FALSE;
-		}
-	}
-	else
-	{
-		if (!shader->attachObject("objects/indexedTextureV.glsl"))
-		{
-			return FALSE;
-		}
-	}
-
-	return TRUE;
+    {
+        if (!shader->attachObject("environment/encodeNormF.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
+    if (features->hasAtmospherics)
+    {
+        if (!shader->attachObject("windlight/atmosphericsF.glsl"))
+        {
+            return FALSE;
+        }
+    }
+    
+    if (features->hasTransport)
+    {
+        if (!shader->attachObject("windlight/transportF.glsl"))
+        {
+            return FALSE;
+        }
+
+        // Test hasFullbright and hasShiny and attach fullbright and 
+        // fullbright shiny atmos transport if we split them out.
+    }
+
+    // NOTE order of shader object attaching is VERY IMPORTANT!!!
+    if (features->hasWaterFog)
+    {
+        if (!shader->attachObject("environment/waterFogF.glsl"))
+        {
+            return FALSE;
+        }
+    }
+    
+    if (features->hasLighting)
+    {
+        if (features->hasWaterFog)
+        {
+            if (features->disableTextureIndex)
+            {
+                if (features->hasAlphaMask)
+                {
+                    if (!shader->attachObject("lighting/lightWaterAlphaMaskNonIndexedF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                else
+                {
+                    if (!shader->attachObject("lighting/lightWaterNonIndexedF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+            }
+            else 
+            {
+                if (features->hasAlphaMask)
+                {
+                    if (!shader->attachObject("lighting/lightWaterAlphaMaskF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                else
+                {
+                    if (!shader->attachObject("lighting/lightWaterF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            }
+        }
+        
+        else
+        {
+            if (features->disableTextureIndex)
+            {
+                if (features->hasAlphaMask)
+                {
+                    if (!shader->attachObject("lighting/lightAlphaMaskNonIndexedF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                else
+                {
+                    if (!shader->attachObject("lighting/lightNonIndexedF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+            }
+            else 
+            {
+                if (features->hasAlphaMask)
+                {
+                    if (!shader->attachObject("lighting/lightAlphaMaskF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                else
+                {
+                    if (!shader->attachObject("lighting/lightF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            }
+        }
+    }
+    
+    // NOTE order of shader object attaching is VERY IMPORTANT!!!
+    else if (features->isFullbright)
+    {
+    
+        if (features->isShiny && features->hasWaterFog)
+        {
+            if (features->disableTextureIndex)
+            {
+                if (!shader->attachObject("lighting/lightFullbrightShinyWaterNonIndexedF.glsl"))
+                {
+                    return FALSE;
+                }
+            }
+            else 
+            {
+                if (!shader->attachObject("lighting/lightFullbrightShinyWaterF.glsl"))
+                {
+                    return FALSE;
+                }
+                shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            }
+        }
+        else if (features->hasWaterFog)
+        {
+            if (features->disableTextureIndex)
+            {
+                if (features->hasAlphaMask)
+                {
+                    if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                else if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedF.glsl"))
+                {
+                    return FALSE;
+                }
+            }
+            else 
+            {
+                if (features->hasAlphaMask)
+                {
+                    if (!shader->attachObject("lighting/lightFullbrightWaterAlphaMaskF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                else if (!shader->attachObject("lighting/lightFullbrightWaterF.glsl"))
+                {
+                    return FALSE;
+                }
+                shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            }
+        }
+        
+        else if (features->isShiny)
+        {
+            if (features->disableTextureIndex)
+            {
+                if (!shader->attachObject("lighting/lightFullbrightShinyNonIndexedF.glsl"))
+                {
+                    return FALSE;
+                }
+            }
+            else 
+            {
+                if (!shader->attachObject("lighting/lightFullbrightShinyF.glsl"))
+                {
+                    return FALSE;
+                }
+                shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            }
+        }
+        
+        else
+        {
+            if (features->disableTextureIndex)
+            {
+
+                if (features->hasAlphaMask)
+                {
+                    if (!shader->attachObject("lighting/lightFullbrightNonIndexedAlphaMaskF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                else
+                {
+                    if (!shader->attachObject("lighting/lightFullbrightNonIndexedF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+            }
+            else 
+            {
+                if (features->hasAlphaMask)
+                {
+                    if (!shader->attachObject("lighting/lightFullbrightAlphaMaskF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                else
+                {
+                    if (!shader->attachObject("lighting/lightFullbrightF.glsl"))
+                    {
+                        return FALSE;
+                    }
+                }
+                shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            }
+        }
+    }
+
+    // NOTE order of shader object attaching is VERY IMPORTANT!!!
+    else if (features->isShiny)
+    {
+    
+        if (features->hasWaterFog)
+        {
+            if (features->disableTextureIndex)
+            {
+                if (!shader->attachObject("lighting/lightShinyWaterNonIndexedF.glsl"))
+                {
+                    return FALSE;
+                }
+            }
+            else 
+            {
+                if (!shader->attachObject("lighting/lightShinyWaterF.glsl"))
+                {
+                    return FALSE;
+                }
+                shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            }
+        }
+        
+        else 
+        {
+            if (features->disableTextureIndex)
+            {
+                if (!shader->attachObject("lighting/lightShinyNonIndexedF.glsl"))
+                {
+                    return FALSE;
+                }
+            }
+            else 
+            {
+                if (!shader->attachObject("lighting/lightShinyF.glsl"))
+                {
+                    return FALSE;
+                }
+                shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
+            }
+        }
+    }
+
+    if (features->mIndexedTextureChannels <= 1)
+    {
+        if (!shader->attachObject("objects/nonindexedTextureV.glsl"))
+        {
+            return FALSE;
+        }
+    }
+    else
+    {
+        if (!shader->attachObject("objects/indexedTextureV.glsl"))
+        {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
 }
 
 //============================================================================
@@ -543,46 +543,46 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 static std::string get_object_log(GLhandleARB ret)
 {
-	std::string res;
-	
-	//get log length 
-	GLint length;
-	glGetObjectParameterivARB(ret, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
-	if (length > 0)
-	{
-		//the log could be any size, so allocate appropriately
-		GLcharARB* log = new GLcharARB[length];
-		glGetInfoLogARB(ret, length, &length, log);
-		res = std::string((char *)log);
-		delete[] log;
-	}
-	return res;
+    std::string res;
+    
+    //get log length 
+    GLint length;
+    glGetObjectParameterivARB(ret, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
+    if (length > 0)
+    {
+        //the log could be any size, so allocate appropriately
+        GLcharARB* log = new GLcharARB[length];
+        glGetInfoLogARB(ret, length, &length, log);
+        res = std::string((char *)log);
+        delete[] log;
+    }
+    return res;
 }
 
 //dump shader source for debugging
 void LLShaderMgr::dumpShaderSource(U32 shader_code_count, GLcharARB** shader_code_text)
-{	
-	for (GLuint i = 0; i < shader_code_count; i++)
-	{
-		LL_SHADER_LOADING_WARNS() << i << ": " << shader_code_text[i] << LL_ENDL;
-	}
+{   
+    for (GLuint i = 0; i < shader_code_count; i++)
+    {
+        LL_SHADER_LOADING_WARNS() << i << ": " << shader_code_text[i] << LL_ENDL;
+    }
     LL_SHADER_LOADING_WARNS() << LL_ENDL;
 }
 
 void LLShaderMgr::dumpObjectLog(GLhandleARB ret, BOOL warns, const std::string& filename) 
 {
-	std::string log = get_object_log(ret);
+    std::string log = get_object_log(ret);
     std::string fname = filename;
     if (filename.empty())
     {
         fname = "unknown shader file";
     }
 
-	if (log.length() > 0)
-	{
+    if (log.length() > 0)
+    {
         LL_SHADER_LOADING_WARNS() << "Shader loading from " << fname << ":\n" << LL_ENDL;
         LL_SHADER_LOADING_WARNS() << log << LL_ENDL;
-	}
+    }
  }
 
 GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, boost::unordered_map<std::string, std::string>* defines, S32 texture_index_channels)
@@ -596,38 +596,38 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
     }
 #endif
 
-	GLenum error = GL_NO_ERROR;
-	if (gDebugGL)
-	{
-		error = glGetError();
-		if (error != GL_NO_ERROR)
-		{
-			LL_SHADER_LOADING_WARNS() << "GL ERROR entering loadShaderFile(): " << error << LL_ENDL;
-		}
-	}
-	
-	//LL_SHADER_LOADING_WARNS() << "Loading shader file: " << filename << " class " << shader_level << LL_ENDL;
+    GLenum error = GL_NO_ERROR;
+    if (gDebugGL)
+    {
+        error = glGetError();
+        if (error != GL_NO_ERROR)
+        {
+            LL_SHADER_LOADING_WARNS() << "GL ERROR entering loadShaderFile(): " << error << LL_ENDL;
+        }
+    }
+    
+    //LL_SHADER_LOADING_WARNS() << "Loading shader file: " << filename << " class " << shader_level << LL_ENDL;
 
-	if (filename.empty()) 
-	{
-		return 0;
-	}
+    if (filename.empty()) 
+    {
+        return 0;
+    }
 
 
-	//read in from file
-	LLFILE* file = NULL;
+    //read in from file
+    LLFILE* file = NULL;
 
-	S32 try_gpu_class = shader_level;
-	S32 gpu_class;
+    S32 try_gpu_class = shader_level;
+    S32 gpu_class;
 
     std::string open_file_name;
-	//find the most relevant file
-	for (gpu_class = try_gpu_class; gpu_class > 0; gpu_class--)
-	{	//search from the current gpu class down to class 1 to find the most relevant shader
-		std::stringstream fname;
-		fname << getShaderDirPrefix();
-		fname << gpu_class << "/" << filename;
-		
+    //find the most relevant file
+    for (gpu_class = try_gpu_class; gpu_class > 0; gpu_class--)
+    {   //search from the current gpu class down to class 1 to find the most relevant shader
+        std::stringstream fname;
+        fname << getShaderDirPrefix();
+        fname << gpu_class << "/" << filename;
+        
         open_file_name = fname.str();
 
         /*
@@ -643,23 +643,23 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 
         */
 
- 		LL_DEBUGS("ShaderLoading") << "Looking in " << open_file_name << LL_ENDL;
-		file = LLFile::fopen(open_file_name, "r");		/* Flawfinder: ignore */
-		if (file)
-		{
-			LL_DEBUGS("ShaderLoading") << "Loading file: " << open_file_name << " (Want class " << gpu_class << ")" << LL_ENDL;            
-			break; // done
-		}
-	}
-	
-	if (file == NULL)
-	{
-		LL_SHADER_LOADING_WARNS() << "GLSL Shader file not found: " << open_file_name << LL_ENDL;
-		return 0;
-	}
-
-	//we can't have any lines longer than 1024 characters 
-	//or any shaders longer than 4096 lines... deal - DaveP
+        LL_DEBUGS("ShaderLoading") << "Looking in " << open_file_name << LL_ENDL;
+        file = LLFile::fopen(open_file_name, "r");      /* Flawfinder: ignore */
+        if (file)
+        {
+            LL_DEBUGS("ShaderLoading") << "Loading file: " << open_file_name << " (Want class " << gpu_class << ")" << LL_ENDL;            
+            break; // done
+        }
+    }
+    
+    if (file == NULL)
+    {
+        LL_SHADER_LOADING_WARNS() << "GLSL Shader file not found: " << open_file_name << LL_ENDL;
+        return 0;
+    }
+
+    //we can't have any lines longer than 1024 characters 
+    //or any shaders longer than 4096 lines... deal - DaveP
     GLcharARB buff[1024];
     GLcharARB *extra_code_text[1024];
     GLcharARB *shader_code_text[4096 + LL_ARRAY_SIZE(extra_code_text)] = { NULL };
@@ -667,661 +667,661 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
     BOOST_STATIC_ASSERT(LL_ARRAY_SIZE(extra_code_text) < LL_ARRAY_SIZE(shader_code_text));
     
     
-	S32 major_version = gGLManager.mGLSLVersionMajor;
-	S32 minor_version = gGLManager.mGLSLVersionMinor;
-	
-	if (major_version == 1 && minor_version < 30)
-	{
-		if (minor_version < 10)
-		{
-			//should NEVER get here -- if major version is 1 and minor version is less than 10, 
-			// viewer should never attempt to use shaders, continuing will result in undefined behavior
-			LL_ERRS() << "Unsupported GLSL Version." << LL_ENDL;
-		}
-
-		if (minor_version <= 19)
-		{
-			shader_code_text[shader_code_count++] = strdup("#version 110\n");
-			extra_code_text[extra_code_count++] = strdup("#define ATTRIBUTE attribute\n");
-			extra_code_text[extra_code_count++] = strdup("#define VARYING varying\n");
-			extra_code_text[extra_code_count++] = strdup("#define VARYING_FLAT varying\n");
-		}
-		else if (minor_version <= 29)
-		{
-			//set version to 1.20
-			shader_code_text[shader_code_count++] = strdup("#version 120\n");
-       		extra_code_text[extra_code_count++] = strdup("#define FXAA_GLSL_120 1\n");
-			extra_code_text[extra_code_count++] = strdup("#define FXAA_FAST_PIXEL_OFFSET 0\n");
-			extra_code_text[extra_code_count++] = strdup("#define ATTRIBUTE attribute\n");
-			extra_code_text[extra_code_count++] = strdup("#define VARYING varying\n");
-			extra_code_text[extra_code_count++] = strdup("#define VARYING_FLAT varying\n");
-		}
-	}
-	else
-	{  
-		if (major_version < 4)
-		{
-			//set version to 1.30
-			shader_code_text[shader_code_count++] = strdup("#version 130\n");
-			//some implementations of GLSL 1.30 require integer precision be explicitly declared
-			extra_code_text[extra_code_count++] = strdup("precision mediump int;\n");
-			extra_code_text[extra_code_count++] = strdup("precision highp float;\n");
-		}
-		else
-		{ //set version to 400
-			shader_code_text[shader_code_count++] = strdup("#version 400\n");
-		}
-
-		extra_code_text[extra_code_count++] = strdup("#define DEFINE_GL_FRAGCOLOR 1\n");
-		extra_code_text[extra_code_count++] = strdup("#define FXAA_GLSL_130 1\n");
-
-		extra_code_text[extra_code_count++] = strdup("#define ATTRIBUTE in\n");
-
-		if (type == GL_VERTEX_SHADER_ARB)
-		{ //"varying" state is "out" in a vertex program, "in" in a fragment program 
-			// ("varying" is deprecated after version 1.20)
-			extra_code_text[extra_code_count++] = strdup("#define VARYING out\n");
-			extra_code_text[extra_code_count++] = strdup("#define VARYING_FLAT flat out\n");
-		}
-		else
-		{
-			extra_code_text[extra_code_count++] = strdup("#define VARYING in\n");
-			extra_code_text[extra_code_count++] = strdup("#define VARYING_FLAT flat in\n");
-		}
-
-		//backwards compatibility with legacy texture lookup syntax
-		extra_code_text[extra_code_count++] = strdup("#define texture2D texture\n");
-		extra_code_text[extra_code_count++] = strdup("#define textureCube texture\n");
-		extra_code_text[extra_code_count++] = strdup("#define texture2DLod textureLod\n");
-		extra_code_text[extra_code_count++] = strdup("#define shadow2D(a,b) vec2(texture(a,b))\n");
-		
-		if (major_version > 1 || minor_version >= 40)
-		{ //GLSL 1.40 replaces texture2DRect et al with texture
-			extra_code_text[extra_code_count++] = strdup("#define texture2DRect texture\n");
-			extra_code_text[extra_code_count++] = strdup("#define shadow2DRect(a,b) vec2(texture(a,b))\n");
-		}
-	}
-	
-	if (defines)
-	{
-		for (boost::unordered_map<std::string,std::string>::iterator iter = defines->begin(); iter != defines->end(); ++iter)
-		{
-			std::string define = "#define " + iter->first + " " + iter->second + "\n";
-			extra_code_text[extra_code_count++] = (GLcharARB *) strdup(define.c_str());
-		}
-	}
-
-	if( gGLManager.mIsATI )
-	{
-		extra_code_text[extra_code_count++] = strdup( "#define IS_AMD_CARD 1\n" );
-	}
-	
-	if (texture_index_channels > 0 && type == GL_FRAGMENT_SHADER_ARB)
-	{
-		//use specified number of texture channels for indexed texture rendering
-
-		/* prepend shader code that looks like this:
-
-		uniform sampler2D tex0;
-		uniform sampler2D tex1;
-		uniform sampler2D tex2;
-		.
-		.
-		.
-		uniform sampler2D texN;
-		
-		VARYING_FLAT ivec4 vary_texture_index;
-
-		vec4 ret = vec4(1,0,1,1);
-
-		vec4 diffuseLookup(vec2 texcoord)
-		{
-			switch (vary_texture_index.r))
-			{
-				case 0: ret = texture2D(tex0, texcoord); break;
-				case 1: ret = texture2D(tex1, texcoord); break;
-				case 2: ret = texture2D(tex2, texcoord); break;
-				.
-				.
-				.
-				case N: return texture2D(texN, texcoord); break;
-			}
-
-			return ret;
-		}
-		*/
-
-		extra_code_text[extra_code_count++] = strdup("#define HAS_DIFFUSE_LOOKUP\n");
-
-		//uniform declartion
-		for (S32 i = 0; i < texture_index_channels; ++i)
-		{
-			std::string decl = llformat("uniform sampler2D tex%d;\n", i);
-			extra_code_text[extra_code_count++] = strdup(decl.c_str());
-		}
-
-		if (texture_index_channels > 1)
-		{
-			extra_code_text[extra_code_count++] = strdup("VARYING_FLAT int vary_texture_index;\n");
-		}
-
-		extra_code_text[extra_code_count++] = strdup("vec4 diffuseLookup(vec2 texcoord)\n");
-		extra_code_text[extra_code_count++] = strdup("{\n");
-		
-		
-		if (texture_index_channels == 1)
-		{ //don't use flow control, that's silly
-			extra_code_text[extra_code_count++] = strdup("return texture2D(tex0, texcoord);\n");
-			extra_code_text[extra_code_count++] = strdup("}\n");
-		}
-		else if (major_version > 1 || minor_version >= 30)
-		{  //switches are supported in GLSL 1.30 and later
-			if (gGLManager.mIsNVIDIA)
-			{ //switches are unreliable on some NVIDIA drivers
-				for (U32 i = 0; i < texture_index_channels; ++i)
-				{
-					std::string if_string = llformat("\t%sif (vary_texture_index == %d) { return texture2D(tex%d, texcoord); }\n", i > 0 ? "else " : "", i, i); 
-					extra_code_text[extra_code_count++] = strdup(if_string.c_str());
-				}
-				extra_code_text[extra_code_count++] = strdup("\treturn vec4(1,0,1,1);\n");
-				extra_code_text[extra_code_count++] = strdup("}\n");
-			}
-			else
-			{
-				extra_code_text[extra_code_count++] = strdup("\tvec4 ret = vec4(1,0,1,1);\n");
-				extra_code_text[extra_code_count++] = strdup("\tswitch (vary_texture_index)\n");
-				extra_code_text[extra_code_count++] = strdup("\t{\n");
-		
-				//switch body
-				for (S32 i = 0; i < texture_index_channels; ++i)
-				{
-					std::string case_str = llformat("\t\tcase %d: return texture2D(tex%d, texcoord);\n", i, i);
-					extra_code_text[extra_code_count++] = strdup(case_str.c_str());
-				}
-
-				extra_code_text[extra_code_count++] = strdup("\t}\n");
-				extra_code_text[extra_code_count++] = strdup("\treturn ret;\n");
-				extra_code_text[extra_code_count++] = strdup("}\n");
-			}
-		}
-		else
-		{ //should never get here.  Indexed texture rendering requires GLSL 1.30 or later 
-			// (for passing integers between vertex and fragment shaders)
-			LL_ERRS() << "Indexed texture rendering requires GLSL 1.30 or later." << LL_ENDL;
-		}
-	}
+    S32 major_version = gGLManager.mGLSLVersionMajor;
+    S32 minor_version = gGLManager.mGLSLVersionMinor;
+    
+    if (major_version == 1 && minor_version < 30)
+    {
+        if (minor_version < 10)
+        {
+            //should NEVER get here -- if major version is 1 and minor version is less than 10, 
+            // viewer should never attempt to use shaders, continuing will result in undefined behavior
+            LL_ERRS() << "Unsupported GLSL Version." << LL_ENDL;
+        }
+
+        if (minor_version <= 19)
+        {
+            shader_code_text[shader_code_count++] = strdup("#version 110\n");
+            extra_code_text[extra_code_count++] = strdup("#define ATTRIBUTE attribute\n");
+            extra_code_text[extra_code_count++] = strdup("#define VARYING varying\n");
+            extra_code_text[extra_code_count++] = strdup("#define VARYING_FLAT varying\n");
+        }
+        else if (minor_version <= 29)
+        {
+            //set version to 1.20
+            shader_code_text[shader_code_count++] = strdup("#version 120\n");
+            extra_code_text[extra_code_count++] = strdup("#define FXAA_GLSL_120 1\n");
+            extra_code_text[extra_code_count++] = strdup("#define FXAA_FAST_PIXEL_OFFSET 0\n");
+            extra_code_text[extra_code_count++] = strdup("#define ATTRIBUTE attribute\n");
+            extra_code_text[extra_code_count++] = strdup("#define VARYING varying\n");
+            extra_code_text[extra_code_count++] = strdup("#define VARYING_FLAT varying\n");
+        }
+    }
+    else
+    {  
+        if (major_version < 4)
+        {
+            //set version to 1.30
+            shader_code_text[shader_code_count++] = strdup("#version 130\n");
+            //some implementations of GLSL 1.30 require integer precision be explicitly declared
+            extra_code_text[extra_code_count++] = strdup("precision mediump int;\n");
+            extra_code_text[extra_code_count++] = strdup("precision highp float;\n");
+        }
+        else
+        { //set version to 400
+            shader_code_text[shader_code_count++] = strdup("#version 400\n");
+        }
+
+        extra_code_text[extra_code_count++] = strdup("#define DEFINE_GL_FRAGCOLOR 1\n");
+        extra_code_text[extra_code_count++] = strdup("#define FXAA_GLSL_130 1\n");
+
+        extra_code_text[extra_code_count++] = strdup("#define ATTRIBUTE in\n");
+
+        if (type == GL_VERTEX_SHADER_ARB)
+        { //"varying" state is "out" in a vertex program, "in" in a fragment program 
+            // ("varying" is deprecated after version 1.20)
+            extra_code_text[extra_code_count++] = strdup("#define VARYING out\n");
+            extra_code_text[extra_code_count++] = strdup("#define VARYING_FLAT flat out\n");
+        }
+        else
+        {
+            extra_code_text[extra_code_count++] = strdup("#define VARYING in\n");
+            extra_code_text[extra_code_count++] = strdup("#define VARYING_FLAT flat in\n");
+        }
+
+        //backwards compatibility with legacy texture lookup syntax
+        extra_code_text[extra_code_count++] = strdup("#define texture2D texture\n");
+        extra_code_text[extra_code_count++] = strdup("#define textureCube texture\n");
+        extra_code_text[extra_code_count++] = strdup("#define texture2DLod textureLod\n");
+        extra_code_text[extra_code_count++] = strdup("#define shadow2D(a,b) vec2(texture(a,b))\n");
+        
+        if (major_version > 1 || minor_version >= 40)
+        { //GLSL 1.40 replaces texture2DRect et al with texture
+            extra_code_text[extra_code_count++] = strdup("#define texture2DRect texture\n");
+            extra_code_text[extra_code_count++] = strdup("#define shadow2DRect(a,b) vec2(texture(a,b))\n");
+        }
+    }
+    
+    if (defines)
+    {
+        for (boost::unordered_map<std::string,std::string>::iterator iter = defines->begin(); iter != defines->end(); ++iter)
+        {
+            std::string define = "#define " + iter->first + " " + iter->second + "\n";
+            extra_code_text[extra_code_count++] = (GLcharARB *) strdup(define.c_str());
+        }
+    }
+
+    if( gGLManager.mIsATI )
+    {
+        extra_code_text[extra_code_count++] = strdup( "#define IS_AMD_CARD 1\n" );
+    }
+    
+    if (texture_index_channels > 0 && type == GL_FRAGMENT_SHADER_ARB)
+    {
+        //use specified number of texture channels for indexed texture rendering
+
+        /* prepend shader code that looks like this:
+
+        uniform sampler2D tex0;
+        uniform sampler2D tex1;
+        uniform sampler2D tex2;
+        .
+        .
+        .
+        uniform sampler2D texN;
+        
+        VARYING_FLAT ivec4 vary_texture_index;
+
+        vec4 ret = vec4(1,0,1,1);
+
+        vec4 diffuseLookup(vec2 texcoord)
+        {
+            switch (vary_texture_index.r))
+            {
+                case 0: ret = texture2D(tex0, texcoord); break;
+                case 1: ret = texture2D(tex1, texcoord); break;
+                case 2: ret = texture2D(tex2, texcoord); break;
+                .
+                .
+                .
+                case N: return texture2D(texN, texcoord); break;
+            }
+
+            return ret;
+        }
+        */
+
+        extra_code_text[extra_code_count++] = strdup("#define HAS_DIFFUSE_LOOKUP\n");
+
+        //uniform declartion
+        for (S32 i = 0; i < texture_index_channels; ++i)
+        {
+            std::string decl = llformat("uniform sampler2D tex%d;\n", i);
+            extra_code_text[extra_code_count++] = strdup(decl.c_str());
+        }
+
+        if (texture_index_channels > 1)
+        {
+            extra_code_text[extra_code_count++] = strdup("VARYING_FLAT int vary_texture_index;\n");
+        }
+
+        extra_code_text[extra_code_count++] = strdup("vec4 diffuseLookup(vec2 texcoord)\n");
+        extra_code_text[extra_code_count++] = strdup("{\n");
+        
+        
+        if (texture_index_channels == 1)
+        { //don't use flow control, that's silly
+            extra_code_text[extra_code_count++] = strdup("return texture2D(tex0, texcoord);\n");
+            extra_code_text[extra_code_count++] = strdup("}\n");
+        }
+        else if (major_version > 1 || minor_version >= 30)
+        {  //switches are supported in GLSL 1.30 and later
+            if (gGLManager.mIsNVIDIA)
+            { //switches are unreliable on some NVIDIA drivers
+                for (U32 i = 0; i < texture_index_channels; ++i)
+                {
+                    std::string if_string = llformat("\t%sif (vary_texture_index == %d) { return texture2D(tex%d, texcoord); }\n", i > 0 ? "else " : "", i, i); 
+                    extra_code_text[extra_code_count++] = strdup(if_string.c_str());
+                }
+                extra_code_text[extra_code_count++] = strdup("\treturn vec4(1,0,1,1);\n");
+                extra_code_text[extra_code_count++] = strdup("}\n");
+            }
+            else
+            {
+                extra_code_text[extra_code_count++] = strdup("\tvec4 ret = vec4(1,0,1,1);\n");
+                extra_code_text[extra_code_count++] = strdup("\tswitch (vary_texture_index)\n");
+                extra_code_text[extra_code_count++] = strdup("\t{\n");
+        
+                //switch body
+                for (S32 i = 0; i < texture_index_channels; ++i)
+                {
+                    std::string case_str = llformat("\t\tcase %d: return texture2D(tex%d, texcoord);\n", i, i);
+                    extra_code_text[extra_code_count++] = strdup(case_str.c_str());
+                }
+
+                extra_code_text[extra_code_count++] = strdup("\t}\n");
+                extra_code_text[extra_code_count++] = strdup("\treturn ret;\n");
+                extra_code_text[extra_code_count++] = strdup("}\n");
+            }
+        }
+        else
+        { //should never get here.  Indexed texture rendering requires GLSL 1.30 or later 
+            // (for passing integers between vertex and fragment shaders)
+            LL_ERRS() << "Indexed texture rendering requires GLSL 1.30 or later." << LL_ENDL;
+        }
+    }
+    
+    //copy file into memory
+    enum {
+          flag_write_to_out_of_extra_block_area = 0x01
+        , flag_extra_block_marker_was_found = 0x02
+    };
+    
+    unsigned char flags = flag_write_to_out_of_extra_block_area;
+    
+    GLuint out_of_extra_block_counter = 0, start_shader_code = shader_code_count, file_lines_count = 0;
     
-	//copy file into memory
-	enum {
-		  flag_write_to_out_of_extra_block_area = 0x01
-		, flag_extra_block_marker_was_found = 0x02
-	};
-	
-	unsigned char flags = flag_write_to_out_of_extra_block_area;
-	
-	GLuint out_of_extra_block_counter = 0, start_shader_code = shader_code_count, file_lines_count = 0;
-	
-	while(NULL != fgets((char *)buff, 1024, file)
-		  && shader_code_count < (LL_ARRAY_SIZE(shader_code_text) - LL_ARRAY_SIZE(extra_code_text)))
-	{
-		file_lines_count++;
-
-		bool extra_block_area_found = NULL != strstr((const char*)buff, "[EXTRA_CODE_HERE]");
-		
-		if(extra_block_area_found && !(flag_extra_block_marker_was_found & flags))
-		{
-			if(!(flag_write_to_out_of_extra_block_area & flags))
-			{
-				//shift
-				for(GLuint to = start_shader_code, from = extra_code_count + start_shader_code;
-					from < shader_code_count; ++to, ++from)
-				{
-					shader_code_text[to] = shader_code_text[from];
-				}
-				
-				shader_code_count -= extra_code_count;
-			}
-		  
-			//copy extra code
-			for(GLuint n = 0; n < extra_code_count
-				&& shader_code_count < (LL_ARRAY_SIZE(shader_code_text) - LL_ARRAY_SIZE(extra_code_text)); ++n)
-			{
-				shader_code_text[shader_code_count++] = extra_code_text[n];
-			}
-			
-			extra_code_count = 0;
-			
-			flags &= ~flag_write_to_out_of_extra_block_area;
-			flags |= flag_extra_block_marker_was_found;
-		}
+    while(NULL != fgets((char *)buff, 1024, file)
+          && shader_code_count < (LL_ARRAY_SIZE(shader_code_text) - LL_ARRAY_SIZE(extra_code_text)))
+    {
+        file_lines_count++;
+
+        bool extra_block_area_found = NULL != strstr((const char*)buff, "[EXTRA_CODE_HERE]");
+        
+        if(extra_block_area_found && !(flag_extra_block_marker_was_found & flags))
+        {
+            if(!(flag_write_to_out_of_extra_block_area & flags))
+            {
+                //shift
+                for(GLuint to = start_shader_code, from = extra_code_count + start_shader_code;
+                    from < shader_code_count; ++to, ++from)
+                {
+                    shader_code_text[to] = shader_code_text[from];
+                }
+                
+                shader_code_count -= extra_code_count;
+            }
+          
+            //copy extra code
+            for(GLuint n = 0; n < extra_code_count
+                && shader_code_count < (LL_ARRAY_SIZE(shader_code_text) - LL_ARRAY_SIZE(extra_code_text)); ++n)
+            {
+                shader_code_text[shader_code_count++] = extra_code_text[n];
+            }
+            
+            extra_code_count = 0;
+            
+            flags &= ~flag_write_to_out_of_extra_block_area;
+            flags |= flag_extra_block_marker_was_found;
+        }
         else
         {
             shader_code_text[shader_code_count] = (GLcharARB *)strdup((char *)buff);
-		
+        
             if(flag_write_to_out_of_extra_block_area & flags)
             {
                 shader_code_text[extra_code_count + start_shader_code + out_of_extra_block_counter]
                     = shader_code_text[shader_code_count];
                 out_of_extra_block_counter++;
-			
+            
                 if(out_of_extra_block_counter == extra_code_count)
                 {
                     shader_code_count += extra_code_count;
                     flags &= ~flag_write_to_out_of_extra_block_area;
                 }
             }
-		
+        
             ++shader_code_count;
-		}
-	} //while
-	
-	if(!(flag_extra_block_marker_was_found & flags))
-	{
-		for(GLuint n = start_shader_code; n < extra_code_count + start_shader_code; ++n)
-		{
-			shader_code_text[n] = extra_code_text[n - start_shader_code];
-		}
-		
-		if (file_lines_count < extra_code_count)
-		{
-			shader_code_count += extra_code_count;
-		}
-
-		extra_code_count = 0;
-	}
-
-	fclose(file);
-
-	//create shader object
-	GLhandleARB ret = glCreateShaderObjectARB(type);
-	if (gDebugGL)
-	{
-		error = glGetError();
-		if (error != GL_NO_ERROR)
-		{
-			LL_WARNS("ShaderLoading") << "GL ERROR in glCreateShaderObjectARB: " << error << LL_ENDL;
-		}
-	}
-	
-	//load source
-	glShaderSourceARB(ret, shader_code_count, (const GLcharARB**) shader_code_text, NULL);
-
-	if (gDebugGL)
-	{
-		error = glGetError();
-		if (error != GL_NO_ERROR)
-		{
-			LL_WARNS("ShaderLoading") << "GL ERROR in glShaderSourceARB: " << error << LL_ENDL;
-		}
-	}
-
-	//compile source
-	glCompileShaderARB(ret);
-
-	if (gDebugGL)
-	{
-		error = glGetError();
-		if (error != GL_NO_ERROR)
-		{
-			LL_WARNS("ShaderLoading") << "GL ERROR in glCompileShaderARB: " << error << LL_ENDL;
-		}
-	}
-		
-	if (error == GL_NO_ERROR)
-	{
-		//check for errors
-		GLint success = GL_TRUE;
-		glGetObjectParameterivARB(ret, GL_OBJECT_COMPILE_STATUS_ARB, &success);
-		if (gDebugGL || success == GL_FALSE)
-		{
-			error = glGetError();
-			if (error != GL_NO_ERROR || success == GL_FALSE) 
-			{
-				//an error occured, print log
-				LL_WARNS("ShaderLoading") << "GLSL Compilation Error:" << LL_ENDL;
-				dumpObjectLog(ret, TRUE, open_file_name);
+        }
+    } //while
+    
+    if(!(flag_extra_block_marker_was_found & flags))
+    {
+        for(GLuint n = start_shader_code; n < extra_code_count + start_shader_code; ++n)
+        {
+            shader_code_text[n] = extra_code_text[n - start_shader_code];
+        }
+        
+        if (file_lines_count < extra_code_count)
+        {
+            shader_code_count += extra_code_count;
+        }
+
+        extra_code_count = 0;
+    }
+
+    fclose(file);
+
+    //create shader object
+    GLhandleARB ret = glCreateShaderObjectARB(type);
+    if (gDebugGL)
+    {
+        error = glGetError();
+        if (error != GL_NO_ERROR)
+        {
+            LL_WARNS("ShaderLoading") << "GL ERROR in glCreateShaderObjectARB: " << error << LL_ENDL;
+        }
+    }
+    
+    //load source
+    glShaderSourceARB(ret, shader_code_count, (const GLcharARB**) shader_code_text, NULL);
+
+    if (gDebugGL)
+    {
+        error = glGetError();
+        if (error != GL_NO_ERROR)
+        {
+            LL_WARNS("ShaderLoading") << "GL ERROR in glShaderSourceARB: " << error << LL_ENDL;
+        }
+    }
+
+    //compile source
+    glCompileShaderARB(ret);
+
+    if (gDebugGL)
+    {
+        error = glGetError();
+        if (error != GL_NO_ERROR)
+        {
+            LL_WARNS("ShaderLoading") << "GL ERROR in glCompileShaderARB: " << error << LL_ENDL;
+        }
+    }
+        
+    if (error == GL_NO_ERROR)
+    {
+        //check for errors
+        GLint success = GL_TRUE;
+        glGetObjectParameterivARB(ret, GL_OBJECT_COMPILE_STATUS_ARB, &success);
+        if (gDebugGL || success == GL_FALSE)
+        {
+            error = glGetError();
+            if (error != GL_NO_ERROR || success == GL_FALSE) 
+            {
+                //an error occured, print log
+                LL_WARNS("ShaderLoading") << "GLSL Compilation Error:" << LL_ENDL;
+                dumpObjectLog(ret, TRUE, open_file_name);
                 dumpShaderSource(shader_code_count, shader_code_text);
-				ret = 0;
-			}
-		}
-	}
-	else
-	{
-		ret = 0;
-	}
-	stop_glerror();
-
-	//free memory
-	for (GLuint i = 0; i < shader_code_count; i++)
-	{
-		free(shader_code_text[i]);
-	}
-
-	//successfully loaded, save results
-	if (ret)
-	{
-		// Add shader file to map
-		mShaderObjects[filename] = ret;
-		shader_level = try_gpu_class;
-	}
-	else
-	{
-		if (shader_level > 1)
-		{
-			shader_level--;
-			return loadShaderFile(filename, shader_level, type, defines, texture_index_channels);
-		}
-		LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;	
-	}
-	return ret;
+                ret = 0;
+            }
+        }
+    }
+    else
+    {
+        ret = 0;
+    }
+    stop_glerror();
+
+    //free memory
+    for (GLuint i = 0; i < shader_code_count; i++)
+    {
+        free(shader_code_text[i]);
+    }
+
+    //successfully loaded, save results
+    if (ret)
+    {
+        // Add shader file to map
+        mShaderObjects[filename] = ret;
+        shader_level = try_gpu_class;
+    }
+    else
+    {
+        if (shader_level > 1)
+        {
+            shader_level--;
+            return loadShaderFile(filename, shader_level, type, defines, texture_index_channels);
+        }
+        LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;  
+    }
+    return ret;
 }
 
 BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors) 
 {
-	//check for errors
-	glLinkProgramARB(obj);
-	GLint success = GL_TRUE;
-	glGetObjectParameterivARB(obj, GL_OBJECT_LINK_STATUS_ARB, &success);
-	if (!suppress_errors && success == GL_FALSE) 
-	{
-		//an error occured, print log
-		LL_SHADER_LOADING_WARNS() << "GLSL Linker Error:" << LL_ENDL;
-	}
+    //check for errors
+    glLinkProgramARB(obj);
+    GLint success = GL_TRUE;
+    glGetObjectParameterivARB(obj, GL_OBJECT_LINK_STATUS_ARB, &success);
+    if (!suppress_errors && success == GL_FALSE) 
+    {
+        //an error occured, print log
+        LL_SHADER_LOADING_WARNS() << "GLSL Linker Error:" << LL_ENDL;
+    }
 
 #if LL_DARWIN
 
-	// For some reason this absolutely kills the frame rate when VBO's are enabled
-	if (0)
-	{
-		// Force an evaluation of the gl state so the driver can tell if the shader will run in hardware or software
-		// per Apple's suggestion
-		LLGLSLShader::sNoFixedFunction = false;
-		
-		glUseProgramObjectARB(obj);
-
-		gGL.begin(LLRender::TRIANGLES);
-		gGL.vertex3f(0.0f, 0.0f, 0.0f);
-		gGL.vertex3f(0.0f, 0.0f, 0.0f);
-		gGL.vertex3f(0.0f, 0.0f, 0.0f);
-		gGL.end();
-		gGL.flush();
-		
-		glUseProgramObjectARB(0);
-		
-		LLGLSLShader::sNoFixedFunction = true;
-
-		// Query whether the shader can or cannot run in hardware
-		// http://developer.apple.com/qa/qa2007/qa1502.html
-		GLint vertexGPUProcessing, fragmentGPUProcessing;
-		CGLContextObj ctx = CGLGetCurrentContext();
-		CGLGetParameter(ctx, kCGLCPGPUVertexProcessing, &vertexGPUProcessing);	
-		CGLGetParameter(ctx, kCGLCPGPUFragmentProcessing, &fragmentGPUProcessing);
-		if (!fragmentGPUProcessing || !vertexGPUProcessing)
-		{
-			LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
-			success = GL_FALSE;
-			suppress_errors = FALSE;		
-		}
-	}
+    // For some reason this absolutely kills the frame rate when VBO's are enabled
+    if (0)
+    {
+        // Force an evaluation of the gl state so the driver can tell if the shader will run in hardware or software
+        // per Apple's suggestion
+        LLGLSLShader::sNoFixedFunction = false;
+        
+        glUseProgramObjectARB(obj);
+
+        gGL.begin(LLRender::TRIANGLES);
+        gGL.vertex3f(0.0f, 0.0f, 0.0f);
+        gGL.vertex3f(0.0f, 0.0f, 0.0f);
+        gGL.vertex3f(0.0f, 0.0f, 0.0f);
+        gGL.end();
+        gGL.flush();
+        
+        glUseProgramObjectARB(0);
+        
+        LLGLSLShader::sNoFixedFunction = true;
+
+        // Query whether the shader can or cannot run in hardware
+        // http://developer.apple.com/qa/qa2007/qa1502.html
+        GLint vertexGPUProcessing, fragmentGPUProcessing;
+        CGLContextObj ctx = CGLGetCurrentContext();
+        CGLGetParameter(ctx, kCGLCPGPUVertexProcessing, &vertexGPUProcessing);  
+        CGLGetParameter(ctx, kCGLCPGPUFragmentProcessing, &fragmentGPUProcessing);
+        if (!fragmentGPUProcessing || !vertexGPUProcessing)
+        {
+            LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
+            success = GL_FALSE;
+            suppress_errors = FALSE;        
+        }
+    }
 
 #else
-	std::string log = get_object_log(obj);
-	LLStringUtil::toLower(log);
-	if (log.find("software") != std::string::npos)
-	{
-		LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
-		success = GL_FALSE;
-		suppress_errors = FALSE;
-	}
+    std::string log = get_object_log(obj);
+    LLStringUtil::toLower(log);
+    if (log.find("software") != std::string::npos)
+    {
+        LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
+        success = GL_FALSE;
+        suppress_errors = FALSE;
+    }
 #endif
-	return success;
+    return success;
 }
 
 BOOL LLShaderMgr::validateProgramObject(GLhandleARB obj)
 {
-	//check program validity against current GL
-	glValidateProgramARB(obj);
-	GLint success = GL_TRUE;
-	glGetObjectParameterivARB(obj, GL_OBJECT_VALIDATE_STATUS_ARB, &success);
-	if (success == GL_FALSE)
-	{
-		LL_SHADER_LOADING_WARNS() << "GLSL program not valid: " << LL_ENDL;
-		dumpObjectLog(obj);
-	}
-	else
-	{
-		dumpObjectLog(obj, FALSE);
-	}
-
-	return success;
+    //check program validity against current GL
+    glValidateProgramARB(obj);
+    GLint success = GL_TRUE;
+    glGetObjectParameterivARB(obj, GL_OBJECT_VALIDATE_STATUS_ARB, &success);
+    if (success == GL_FALSE)
+    {
+        LL_SHADER_LOADING_WARNS() << "GLSL program not valid: " << LL_ENDL;
+        dumpObjectLog(obj);
+    }
+    else
+    {
+        dumpObjectLog(obj, FALSE);
+    }
+
+    return success;
 }
 
 //virtual
 void LLShaderMgr::initAttribsAndUniforms()
 {
-	//MUST match order of enum in LLVertexBuffer.h
-	mReservedAttribs.push_back("position");
-	mReservedAttribs.push_back("normal");
-	mReservedAttribs.push_back("texcoord0");
-	mReservedAttribs.push_back("texcoord1");
-	mReservedAttribs.push_back("texcoord2");
-	mReservedAttribs.push_back("texcoord3");
-	mReservedAttribs.push_back("diffuse_color");
-	mReservedAttribs.push_back("emissive");
-	mReservedAttribs.push_back("tangent");
-	mReservedAttribs.push_back("weight");
-	mReservedAttribs.push_back("weight4");
-	mReservedAttribs.push_back("clothing");
-	mReservedAttribs.push_back("texture_index");
-	
-	//matrix state
-	mReservedUniforms.push_back("modelview_matrix");
-	mReservedUniforms.push_back("projection_matrix");
-	mReservedUniforms.push_back("inv_proj");
-	mReservedUniforms.push_back("modelview_projection_matrix");
+    //MUST match order of enum in LLVertexBuffer.h
+    mReservedAttribs.push_back("position");
+    mReservedAttribs.push_back("normal");
+    mReservedAttribs.push_back("texcoord0");
+    mReservedAttribs.push_back("texcoord1");
+    mReservedAttribs.push_back("texcoord2");
+    mReservedAttribs.push_back("texcoord3");
+    mReservedAttribs.push_back("diffuse_color");
+    mReservedAttribs.push_back("emissive");
+    mReservedAttribs.push_back("tangent");
+    mReservedAttribs.push_back("weight");
+    mReservedAttribs.push_back("weight4");
+    mReservedAttribs.push_back("clothing");
+    mReservedAttribs.push_back("texture_index");
+    
+    //matrix state
+    mReservedUniforms.push_back("modelview_matrix");
+    mReservedUniforms.push_back("projection_matrix");
+    mReservedUniforms.push_back("inv_proj");
+    mReservedUniforms.push_back("modelview_projection_matrix");
     mReservedUniforms.push_back("inv_modelview");
-	mReservedUniforms.push_back("normal_matrix");
-	mReservedUniforms.push_back("texture_matrix0");
-	mReservedUniforms.push_back("texture_matrix1");
-	mReservedUniforms.push_back("texture_matrix2");
-	mReservedUniforms.push_back("texture_matrix3");
-	mReservedUniforms.push_back("object_plane_s");
-	mReservedUniforms.push_back("object_plane_t");
-	llassert(mReservedUniforms.size() == LLShaderMgr::OBJECT_PLANE_T+1);
-
-	mReservedUniforms.push_back("viewport");
-
-	mReservedUniforms.push_back("light_position");
-	mReservedUniforms.push_back("light_direction");
-	mReservedUniforms.push_back("light_attenuation");
-	mReservedUniforms.push_back("light_diffuse");
-	mReservedUniforms.push_back("light_ambient");
-	mReservedUniforms.push_back("light_count");
-	mReservedUniforms.push_back("light");
-	mReservedUniforms.push_back("light_col");
-	mReservedUniforms.push_back("far_z");
-
-	llassert(mReservedUniforms.size() == LLShaderMgr::MULTI_LIGHT_FAR_Z+1);
-
-
-	mReservedUniforms.push_back("proj_mat");
-	mReservedUniforms.push_back("proj_near");
-	mReservedUniforms.push_back("proj_p");
-	mReservedUniforms.push_back("proj_n");
-	mReservedUniforms.push_back("proj_origin");
-	mReservedUniforms.push_back("proj_range");
-	mReservedUniforms.push_back("proj_ambiance");
-	mReservedUniforms.push_back("proj_shadow_idx");
-	mReservedUniforms.push_back("shadow_fade");
-	mReservedUniforms.push_back("proj_focus");
-	mReservedUniforms.push_back("proj_lod");
-	mReservedUniforms.push_back("proj_ambient_lod");
-
-	llassert(mReservedUniforms.size() == LLShaderMgr::PROJECTOR_AMBIENT_LOD+1);
-
-	mReservedUniforms.push_back("color");
-		
-	mReservedUniforms.push_back("diffuseMap");
+    mReservedUniforms.push_back("normal_matrix");
+    mReservedUniforms.push_back("texture_matrix0");
+    mReservedUniforms.push_back("texture_matrix1");
+    mReservedUniforms.push_back("texture_matrix2");
+    mReservedUniforms.push_back("texture_matrix3");
+    mReservedUniforms.push_back("object_plane_s");
+    mReservedUniforms.push_back("object_plane_t");
+    llassert(mReservedUniforms.size() == LLShaderMgr::OBJECT_PLANE_T+1);
+
+    mReservedUniforms.push_back("viewport");
+
+    mReservedUniforms.push_back("light_position");
+    mReservedUniforms.push_back("light_direction");
+    mReservedUniforms.push_back("light_attenuation");
+    mReservedUniforms.push_back("light_diffuse");
+    mReservedUniforms.push_back("light_ambient");
+    mReservedUniforms.push_back("light_count");
+    mReservedUniforms.push_back("light");
+    mReservedUniforms.push_back("light_col");
+    mReservedUniforms.push_back("far_z");
+
+    llassert(mReservedUniforms.size() == LLShaderMgr::MULTI_LIGHT_FAR_Z+1);
+
+
+    mReservedUniforms.push_back("proj_mat");
+    mReservedUniforms.push_back("proj_near");
+    mReservedUniforms.push_back("proj_p");
+    mReservedUniforms.push_back("proj_n");
+    mReservedUniforms.push_back("proj_origin");
+    mReservedUniforms.push_back("proj_range");
+    mReservedUniforms.push_back("proj_ambiance");
+    mReservedUniforms.push_back("proj_shadow_idx");
+    mReservedUniforms.push_back("shadow_fade");
+    mReservedUniforms.push_back("proj_focus");
+    mReservedUniforms.push_back("proj_lod");
+    mReservedUniforms.push_back("proj_ambient_lod");
+
+    llassert(mReservedUniforms.size() == LLShaderMgr::PROJECTOR_AMBIENT_LOD+1);
+
+    mReservedUniforms.push_back("color");
+        
+    mReservedUniforms.push_back("diffuseMap");
     mReservedUniforms.push_back("altDiffuseMap");
-	mReservedUniforms.push_back("specularMap");
-	mReservedUniforms.push_back("bumpMap");
+    mReservedUniforms.push_back("specularMap");
+    mReservedUniforms.push_back("bumpMap");
     mReservedUniforms.push_back("bumpMap2");
-	mReservedUniforms.push_back("environmentMap");
-	mReservedUniforms.push_back("cloud_noise_texture");
+    mReservedUniforms.push_back("environmentMap");
+    mReservedUniforms.push_back("cloud_noise_texture");
     mReservedUniforms.push_back("cloud_noise_texture_next");
-	mReservedUniforms.push_back("fullbright");
-	mReservedUniforms.push_back("lightnorm");
-	mReservedUniforms.push_back("sunlight_color");
-	mReservedUniforms.push_back("ambient");
-	mReservedUniforms.push_back("blue_horizon");
-	mReservedUniforms.push_back("blue_density");
-	mReservedUniforms.push_back("haze_horizon");
-	mReservedUniforms.push_back("haze_density");
-	mReservedUniforms.push_back("cloud_shadow");
-	mReservedUniforms.push_back("density_multiplier");
-	mReservedUniforms.push_back("distance_multiplier");
-	mReservedUniforms.push_back("max_y");
-	mReservedUniforms.push_back("glow");
-	mReservedUniforms.push_back("cloud_color");
-	mReservedUniforms.push_back("cloud_pos_density1");
-	mReservedUniforms.push_back("cloud_pos_density2");
-	mReservedUniforms.push_back("cloud_scale");
-	mReservedUniforms.push_back("gamma");
-	mReservedUniforms.push_back("scene_light_strength");
-
-	llassert(mReservedUniforms.size() == LLShaderMgr::SCENE_LIGHT_STRENGTH+1);
-
-	mReservedUniforms.push_back("center");
-	mReservedUniforms.push_back("size");
-	mReservedUniforms.push_back("falloff");
-
-	mReservedUniforms.push_back("box_center");
-	mReservedUniforms.push_back("box_size");
-
-
-	mReservedUniforms.push_back("minLuminance");
-	mReservedUniforms.push_back("maxExtractAlpha");
-	mReservedUniforms.push_back("lumWeights");
-	mReservedUniforms.push_back("warmthWeights");
-	mReservedUniforms.push_back("warmthAmount");
-	mReservedUniforms.push_back("glowStrength");
-	mReservedUniforms.push_back("glowDelta");
-
-	llassert(mReservedUniforms.size() == LLShaderMgr::GLOW_DELTA+1);
-
-
-	mReservedUniforms.push_back("minimum_alpha");
-	mReservedUniforms.push_back("emissive_brightness");
-
-	mReservedUniforms.push_back("shadow_matrix");
-	mReservedUniforms.push_back("env_mat");
-	mReservedUniforms.push_back("shadow_clip");
-	mReservedUniforms.push_back("sun_wash");
-	mReservedUniforms.push_back("shadow_noise");
-	mReservedUniforms.push_back("blur_size");
-	mReservedUniforms.push_back("ssao_radius");
-	mReservedUniforms.push_back("ssao_max_radius");
-	mReservedUniforms.push_back("ssao_factor");
-	mReservedUniforms.push_back("ssao_factor_inv");
-	mReservedUniforms.push_back("ssao_effect_mat");
-	mReservedUniforms.push_back("screen_res");
-	mReservedUniforms.push_back("near_clip");
-	mReservedUniforms.push_back("shadow_offset");
-	mReservedUniforms.push_back("shadow_bias");
-	mReservedUniforms.push_back("spot_shadow_bias");
-	mReservedUniforms.push_back("spot_shadow_offset");
-	mReservedUniforms.push_back("sun_dir");
+    mReservedUniforms.push_back("fullbright");
+    mReservedUniforms.push_back("lightnorm");
+    mReservedUniforms.push_back("sunlight_color");
+    mReservedUniforms.push_back("ambient");
+    mReservedUniforms.push_back("blue_horizon");
+    mReservedUniforms.push_back("blue_density");
+    mReservedUniforms.push_back("haze_horizon");
+    mReservedUniforms.push_back("haze_density");
+    mReservedUniforms.push_back("cloud_shadow");
+    mReservedUniforms.push_back("density_multiplier");
+    mReservedUniforms.push_back("distance_multiplier");
+    mReservedUniforms.push_back("max_y");
+    mReservedUniforms.push_back("glow");
+    mReservedUniforms.push_back("cloud_color");
+    mReservedUniforms.push_back("cloud_pos_density1");
+    mReservedUniforms.push_back("cloud_pos_density2");
+    mReservedUniforms.push_back("cloud_scale");
+    mReservedUniforms.push_back("gamma");
+    mReservedUniforms.push_back("scene_light_strength");
+
+    llassert(mReservedUniforms.size() == LLShaderMgr::SCENE_LIGHT_STRENGTH+1);
+
+    mReservedUniforms.push_back("center");
+    mReservedUniforms.push_back("size");
+    mReservedUniforms.push_back("falloff");
+
+    mReservedUniforms.push_back("box_center");
+    mReservedUniforms.push_back("box_size");
+
+
+    mReservedUniforms.push_back("minLuminance");
+    mReservedUniforms.push_back("maxExtractAlpha");
+    mReservedUniforms.push_back("lumWeights");
+    mReservedUniforms.push_back("warmthWeights");
+    mReservedUniforms.push_back("warmthAmount");
+    mReservedUniforms.push_back("glowStrength");
+    mReservedUniforms.push_back("glowDelta");
+
+    llassert(mReservedUniforms.size() == LLShaderMgr::GLOW_DELTA+1);
+
+
+    mReservedUniforms.push_back("minimum_alpha");
+    mReservedUniforms.push_back("emissive_brightness");
+
+    mReservedUniforms.push_back("shadow_matrix");
+    mReservedUniforms.push_back("env_mat");
+    mReservedUniforms.push_back("shadow_clip");
+    mReservedUniforms.push_back("sun_wash");
+    mReservedUniforms.push_back("shadow_noise");
+    mReservedUniforms.push_back("blur_size");
+    mReservedUniforms.push_back("ssao_radius");
+    mReservedUniforms.push_back("ssao_max_radius");
+    mReservedUniforms.push_back("ssao_factor");
+    mReservedUniforms.push_back("ssao_factor_inv");
+    mReservedUniforms.push_back("ssao_effect_mat");
+    mReservedUniforms.push_back("screen_res");
+    mReservedUniforms.push_back("near_clip");
+    mReservedUniforms.push_back("shadow_offset");
+    mReservedUniforms.push_back("shadow_bias");
+    mReservedUniforms.push_back("spot_shadow_bias");
+    mReservedUniforms.push_back("spot_shadow_offset");
+    mReservedUniforms.push_back("sun_dir");
     mReservedUniforms.push_back("moon_dir");
-	mReservedUniforms.push_back("shadow_res");
-	mReservedUniforms.push_back("proj_shadow_res");
-	mReservedUniforms.push_back("depth_cutoff");
-	mReservedUniforms.push_back("norm_cutoff");
-	mReservedUniforms.push_back("shadow_target_width");
-	
-	llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH+1);
-
-	mReservedUniforms.push_back("tc_scale");
-	mReservedUniforms.push_back("rcp_screen_res");
-	mReservedUniforms.push_back("rcp_frame_opt");
-	mReservedUniforms.push_back("rcp_frame_opt2");
-	
-	mReservedUniforms.push_back("focal_distance");
-	mReservedUniforms.push_back("blur_constant");
-	mReservedUniforms.push_back("tan_pixel_angle");
-	mReservedUniforms.push_back("magnification");
-	mReservedUniforms.push_back("max_cof");
-	mReservedUniforms.push_back("res_scale");
-	mReservedUniforms.push_back("dof_width");
-	mReservedUniforms.push_back("dof_height");
-
-	mReservedUniforms.push_back("depthMap");
-	mReservedUniforms.push_back("shadowMap0");
-	mReservedUniforms.push_back("shadowMap1");
-	mReservedUniforms.push_back("shadowMap2");
-	mReservedUniforms.push_back("shadowMap3");
-	mReservedUniforms.push_back("shadowMap4");
-	mReservedUniforms.push_back("shadowMap5");
-
-	llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_SHADOW5+1);
-
-	mReservedUniforms.push_back("normalMap");
-	mReservedUniforms.push_back("positionMap");
-	mReservedUniforms.push_back("diffuseRect");
-	mReservedUniforms.push_back("specularRect");
-	mReservedUniforms.push_back("noiseMap");
-	mReservedUniforms.push_back("lightFunc");
-	mReservedUniforms.push_back("lightMap");
-	mReservedUniforms.push_back("bloomMap");
-	mReservedUniforms.push_back("projectionMap");
-	mReservedUniforms.push_back("norm_mat");
-
-	mReservedUniforms.push_back("global_gamma");
-	mReservedUniforms.push_back("texture_gamma");
-	
-	mReservedUniforms.push_back("specular_color");
-	mReservedUniforms.push_back("env_intensity");
-
-	mReservedUniforms.push_back("matrixPalette");
-	mReservedUniforms.push_back("translationPalette");
-	
-	mReservedUniforms.push_back("screenTex");
-	mReservedUniforms.push_back("screenDepth");
-	mReservedUniforms.push_back("refTex");
-	mReservedUniforms.push_back("eyeVec");
-	mReservedUniforms.push_back("time");
-	mReservedUniforms.push_back("waveDir1");
-	mReservedUniforms.push_back("waveDir2");
-	mReservedUniforms.push_back("lightDir");
-	mReservedUniforms.push_back("specular");
-	mReservedUniforms.push_back("lightExp");
-	mReservedUniforms.push_back("waterFogColor");
-	mReservedUniforms.push_back("waterFogDensity");
-	mReservedUniforms.push_back("waterFogKS");
-	mReservedUniforms.push_back("refScale");
-	mReservedUniforms.push_back("waterHeight");
-	mReservedUniforms.push_back("waterPlane");
-	mReservedUniforms.push_back("normScale");
-	mReservedUniforms.push_back("fresnelScale");
-	mReservedUniforms.push_back("fresnelOffset");
-	mReservedUniforms.push_back("blurMultiplier");
-	mReservedUniforms.push_back("sunAngle");
-	mReservedUniforms.push_back("scaledAngle");
-	mReservedUniforms.push_back("sunAngle2");
-	
-	mReservedUniforms.push_back("camPosLocal");
-
-	mReservedUniforms.push_back("gWindDir");
-	mReservedUniforms.push_back("gSinWaveParams");
-	mReservedUniforms.push_back("gGravity");
-
-	mReservedUniforms.push_back("detail_0");
-	mReservedUniforms.push_back("detail_1");
-	mReservedUniforms.push_back("detail_2");
-	mReservedUniforms.push_back("detail_3");
-	mReservedUniforms.push_back("alpha_ramp");
-
-	mReservedUniforms.push_back("origin");
-	mReservedUniforms.push_back("display_gamma");
+    mReservedUniforms.push_back("shadow_res");
+    mReservedUniforms.push_back("proj_shadow_res");
+    mReservedUniforms.push_back("depth_cutoff");
+    mReservedUniforms.push_back("norm_cutoff");
+    mReservedUniforms.push_back("shadow_target_width");
+    
+    llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH+1);
+
+    mReservedUniforms.push_back("tc_scale");
+    mReservedUniforms.push_back("rcp_screen_res");
+    mReservedUniforms.push_back("rcp_frame_opt");
+    mReservedUniforms.push_back("rcp_frame_opt2");
+    
+    mReservedUniforms.push_back("focal_distance");
+    mReservedUniforms.push_back("blur_constant");
+    mReservedUniforms.push_back("tan_pixel_angle");
+    mReservedUniforms.push_back("magnification");
+    mReservedUniforms.push_back("max_cof");
+    mReservedUniforms.push_back("res_scale");
+    mReservedUniforms.push_back("dof_width");
+    mReservedUniforms.push_back("dof_height");
+
+    mReservedUniforms.push_back("depthMap");
+    mReservedUniforms.push_back("shadowMap0");
+    mReservedUniforms.push_back("shadowMap1");
+    mReservedUniforms.push_back("shadowMap2");
+    mReservedUniforms.push_back("shadowMap3");
+    mReservedUniforms.push_back("shadowMap4");
+    mReservedUniforms.push_back("shadowMap5");
+
+    llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_SHADOW5+1);
+
+    mReservedUniforms.push_back("normalMap");
+    mReservedUniforms.push_back("positionMap");
+    mReservedUniforms.push_back("diffuseRect");
+    mReservedUniforms.push_back("specularRect");
+    mReservedUniforms.push_back("noiseMap");
+    mReservedUniforms.push_back("lightFunc");
+    mReservedUniforms.push_back("lightMap");
+    mReservedUniforms.push_back("bloomMap");
+    mReservedUniforms.push_back("projectionMap");
+    mReservedUniforms.push_back("norm_mat");
+
+    mReservedUniforms.push_back("global_gamma");
+    mReservedUniforms.push_back("texture_gamma");
+    
+    mReservedUniforms.push_back("specular_color");
+    mReservedUniforms.push_back("env_intensity");
+
+    mReservedUniforms.push_back("matrixPalette");
+    mReservedUniforms.push_back("translationPalette");
+    
+    mReservedUniforms.push_back("screenTex");
+    mReservedUniforms.push_back("screenDepth");
+    mReservedUniforms.push_back("refTex");
+    mReservedUniforms.push_back("eyeVec");
+    mReservedUniforms.push_back("time");
+    mReservedUniforms.push_back("waveDir1");
+    mReservedUniforms.push_back("waveDir2");
+    mReservedUniforms.push_back("lightDir");
+    mReservedUniforms.push_back("specular");
+    mReservedUniforms.push_back("lightExp");
+    mReservedUniforms.push_back("waterFogColor");
+    mReservedUniforms.push_back("waterFogDensity");
+    mReservedUniforms.push_back("waterFogKS");
+    mReservedUniforms.push_back("refScale");
+    mReservedUniforms.push_back("waterHeight");
+    mReservedUniforms.push_back("waterPlane");
+    mReservedUniforms.push_back("normScale");
+    mReservedUniforms.push_back("fresnelScale");
+    mReservedUniforms.push_back("fresnelOffset");
+    mReservedUniforms.push_back("blurMultiplier");
+    mReservedUniforms.push_back("sunAngle");
+    mReservedUniforms.push_back("scaledAngle");
+    mReservedUniforms.push_back("sunAngle2");
+    
+    mReservedUniforms.push_back("camPosLocal");
+
+    mReservedUniforms.push_back("gWindDir");
+    mReservedUniforms.push_back("gSinWaveParams");
+    mReservedUniforms.push_back("gGravity");
+
+    mReservedUniforms.push_back("detail_0");
+    mReservedUniforms.push_back("detail_1");
+    mReservedUniforms.push_back("detail_2");
+    mReservedUniforms.push_back("detail_3");
+    mReservedUniforms.push_back("alpha_ramp");
+
+    mReservedUniforms.push_back("origin");
+    mReservedUniforms.push_back("display_gamma");
 
     mReservedUniforms.push_back("inscatter");
     mReservedUniforms.push_back("sun_size");
@@ -1350,17 +1350,17 @@ void LLShaderMgr::initAttribsAndUniforms()
     mReservedUniforms.push_back("sun_up_factor");
     mReservedUniforms.push_back("moonlight_color");
 
-	llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);
+    llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);
 
-	std::set<std::string> dupe_check;
+    std::set<std::string> dupe_check;
 
-	for (U32 i = 0; i < mReservedUniforms.size(); ++i)
-	{
-		if (dupe_check.find(mReservedUniforms[i]) != dupe_check.end())
-		{
-			LL_ERRS() << "Duplicate reserved uniform name found: " << mReservedUniforms[i] << LL_ENDL;
-		}
-		dupe_check.insert(mReservedUniforms[i]);
-	}
+    for (U32 i = 0; i < mReservedUniforms.size(); ++i)
+    {
+        if (dupe_check.find(mReservedUniforms[i]) != dupe_check.end())
+        {
+            LL_ERRS() << "Duplicate reserved uniform name found: " << mReservedUniforms[i] << LL_ENDL;
+        }
+        dupe_check.insert(mReservedUniforms[i]);
+    }
 }