Tab restoration project.

'warn-on-failure:no-tabs'

6 files changed, 2633 insertions, 2635 deletions

diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 5659bd327b..9a4eeb59df 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 9c3effadbe..830bad2aef 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -34,201 +34,199 @@
 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;
-
-    GLhandleARB mExtraLinkObject = 0;
+	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;
 
 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 5b96667f9f..ec8f05e4ca 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;
-        }
-    }
-    
-    //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;
+	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;
+		}
+	}
     
-    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;
-        }
+	//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;
+		}
         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]);
+	}
 }
 
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 07972e0d77..641b42b56a 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -94,7 +94,7 @@ BOOL gAnimateTextures = TRUE;
 //extern BOOL gHideSelectedObjects;
 
 F32 LLVOVolume::sLODFactor = 1.f;
-F32 LLVOVolume::sLODSlopDistanceFactor = 0.5f; //Changing this to zero, effectively disables the LOD transition slop 
+F32	LLVOVolume::sLODSlopDistanceFactor = 0.5f; //Changing this to zero, effectively disables the LOD transition slop 
 F32 LLVOVolume::sDistanceFactor = 1.0f;
 S32 LLVOVolume::sNumLODChanges = 0;
 S32 LLVOVolume::mRenderComplexity_last = 0;
@@ -112,200 +112,200 @@ extern BOOL gGLDebugLoggingEnabled;
 class LLMediaDataClientObjectImpl : public LLMediaDataClientObject
 {
 public:
-    LLMediaDataClientObjectImpl(LLVOVolume *obj, bool isNew) : mObject(obj), mNew(isNew) 
-    {
-        mObject->addMDCImpl();
-    }
-    ~LLMediaDataClientObjectImpl()
-    {
-        mObject->removeMDCImpl();
-    }
-    
-    virtual U8 getMediaDataCount() const 
-        { return mObject->getNumTEs(); }
-
-    virtual LLSD getMediaDataLLSD(U8 index) const 
-        {
-            LLSD result;
-            LLTextureEntry *te = mObject->getTE(index); 
-            if (NULL != te)
-            {
-                llassert((te->getMediaData() != NULL) == te->hasMedia());
-                if (te->getMediaData() != NULL)
-                {
-                    result = te->getMediaData()->asLLSD();
-                    // XXX HACK: workaround bug in asLLSD() where whitelist is not set properly
-                    // See DEV-41949
-                    if (!result.has(LLMediaEntry::WHITELIST_KEY))
-                    {
-                        result[LLMediaEntry::WHITELIST_KEY] = LLSD::emptyArray();
-                    }
-                }
-            }
-            return result;
-        }
-    virtual bool isCurrentMediaUrl(U8 index, const std::string &url) const
-        {
-            LLTextureEntry *te = mObject->getTE(index); 
-            if (te)
-            {
-                if (te->getMediaData())
-                {
-                    return (te->getMediaData()->getCurrentURL() == url);
-                }
-            }
-            return url.empty();
-        }
-
-    virtual LLUUID getID() const
-        { return mObject->getID(); }
-
-    virtual void mediaNavigateBounceBack(U8 index)
-        { mObject->mediaNavigateBounceBack(index); }
-    
-    virtual bool hasMedia() const
-        { return mObject->hasMedia(); }
-    
-    virtual void updateObjectMediaData(LLSD const &data, const std::string &version_string) 
-        { mObject->updateObjectMediaData(data, version_string); }
-    
-    virtual F64 getMediaInterest() const 
-        { 
-            F64 interest = mObject->getTotalMediaInterest();
-            if (interest < (F64)0.0)
-            {
-                // media interest not valid yet, try pixel area
-                interest = mObject->getPixelArea();
-                // HACK: force recalculation of pixel area if interest is the "magic default" of 1024.
-                if (interest == 1024.f)
-                {
-                    const_cast<LLVOVolume*>(static_cast<LLVOVolume*>(mObject))->setPixelAreaAndAngle(gAgent);
-                    interest = mObject->getPixelArea();
-                }
-            }
-            return interest; 
-        }
-    
-    virtual bool isInterestingEnough() const
-        {
-            return LLViewerMedia::isInterestingEnough(mObject, getMediaInterest());
-        }
-
-    virtual std::string getCapabilityUrl(const std::string &name) const
-        { return mObject->getRegion()->getCapability(name); }
-    
-    virtual bool isDead() const
-        { return mObject->isDead(); }
-    
-    virtual U32 getMediaVersion() const
-        { return LLTextureEntry::getVersionFromMediaVersionString(mObject->getMediaURL()); }
-    
-    virtual bool isNew() const
-        { return mNew; }
+	LLMediaDataClientObjectImpl(LLVOVolume *obj, bool isNew) : mObject(obj), mNew(isNew) 
+	{
+		mObject->addMDCImpl();
+	}
+	~LLMediaDataClientObjectImpl()
+	{
+		mObject->removeMDCImpl();
+	}
+	
+	virtual U8 getMediaDataCount() const 
+		{ return mObject->getNumTEs(); }
+
+	virtual LLSD getMediaDataLLSD(U8 index) const 
+		{
+			LLSD result;
+			LLTextureEntry *te = mObject->getTE(index); 
+			if (NULL != te)
+			{
+				llassert((te->getMediaData() != NULL) == te->hasMedia());
+				if (te->getMediaData() != NULL)
+				{
+					result = te->getMediaData()->asLLSD();
+					// XXX HACK: workaround bug in asLLSD() where whitelist is not set properly
+					// See DEV-41949
+					if (!result.has(LLMediaEntry::WHITELIST_KEY))
+					{
+						result[LLMediaEntry::WHITELIST_KEY] = LLSD::emptyArray();
+					}
+				}
+			}
+			return result;
+		}
+	virtual bool isCurrentMediaUrl(U8 index, const std::string &url) const
+		{
+			LLTextureEntry *te = mObject->getTE(index); 
+			if (te)
+			{
+				if (te->getMediaData())
+				{
+					return (te->getMediaData()->getCurrentURL() == url);
+				}
+			}
+			return url.empty();
+		}
+
+	virtual LLUUID getID() const
+		{ return mObject->getID(); }
+
+	virtual void mediaNavigateBounceBack(U8 index)
+		{ mObject->mediaNavigateBounceBack(index); }
+	
+	virtual bool hasMedia() const
+		{ return mObject->hasMedia(); }
+	
+	virtual void updateObjectMediaData(LLSD const &data, const std::string &version_string) 
+		{ mObject->updateObjectMediaData(data, version_string); }
+	
+	virtual F64 getMediaInterest() const 
+		{ 
+			F64 interest = mObject->getTotalMediaInterest();
+			if (interest < (F64)0.0)
+			{
+				// media interest not valid yet, try pixel area
+				interest = mObject->getPixelArea();
+				// HACK: force recalculation of pixel area if interest is the "magic default" of 1024.
+				if (interest == 1024.f)
+				{
+					const_cast<LLVOVolume*>(static_cast<LLVOVolume*>(mObject))->setPixelAreaAndAngle(gAgent);
+					interest = mObject->getPixelArea();
+				}
+			}
+			return interest; 
+		}
+	
+	virtual bool isInterestingEnough() const
+		{
+			return LLViewerMedia::isInterestingEnough(mObject, getMediaInterest());
+		}
+
+	virtual std::string getCapabilityUrl(const std::string &name) const
+		{ return mObject->getRegion()->getCapability(name); }
+	
+	virtual bool isDead() const
+		{ return mObject->isDead(); }
+	
+	virtual U32 getMediaVersion() const
+		{ return LLTextureEntry::getVersionFromMediaVersionString(mObject->getMediaURL()); }
+	
+	virtual bool isNew() const
+		{ return mNew; }
 
 private:
-    LLPointer<LLVOVolume> mObject;
-    bool mNew;
+	LLPointer<LLVOVolume> mObject;
+	bool mNew;
 };
 
 
 LLVOVolume::LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
-    : LLViewerObject(id, pcode, regionp),
-      mVolumeImpl(NULL)
+	: LLViewerObject(id, pcode, regionp),
+	  mVolumeImpl(NULL)
 {
-    mTexAnimMode = 0;
-    mRelativeXform.setIdentity();
-    mRelativeXformInvTrans.setIdentity();
+	mTexAnimMode = 0;
+	mRelativeXform.setIdentity();
+	mRelativeXformInvTrans.setIdentity();
 
-    mFaceMappingChanged = FALSE;
-    mLOD = MIN_LOD;
+	mFaceMappingChanged = FALSE;
+	mLOD = MIN_LOD;
     mLODDistance = 0.0f;
     mLODAdjustedDistance = 0.0f;
     mLODRadius = 0.0f;
-    mTextureAnimp = NULL;
-    mVolumeChanged = FALSE;
-    mVObjRadius = LLVector3(1,1,0.5f).length();
-    mNumFaces = 0;
-    mLODChanged = FALSE;
-    mSculptChanged = FALSE;
-    mSpotLightPriority = 0.f;
-
-    mMediaImplList.resize(getNumTEs());
-    mLastFetchedMediaVersion = -1;
-    memset(&mIndexInTex, 0, sizeof(S32) * LLRender::NUM_VOLUME_TEXTURE_CHANNELS);
-    mMDCImplCount = 0;
+	mTextureAnimp = NULL;
+	mVolumeChanged = FALSE;
+	mVObjRadius = LLVector3(1,1,0.5f).length();
+	mNumFaces = 0;
+	mLODChanged = FALSE;
+	mSculptChanged = FALSE;
+	mSpotLightPriority = 0.f;
+
+	mMediaImplList.resize(getNumTEs());
+	mLastFetchedMediaVersion = -1;
+	memset(&mIndexInTex, 0, sizeof(S32) * LLRender::NUM_VOLUME_TEXTURE_CHANNELS);
+	mMDCImplCount = 0;
     mLastRiggingInfoLOD = -1;
 }
 
 LLVOVolume::~LLVOVolume()
 {
-    delete mTextureAnimp;
-    mTextureAnimp = NULL;
-    delete mVolumeImpl;
-    mVolumeImpl = NULL;
+	delete mTextureAnimp;
+	mTextureAnimp = NULL;
+	delete mVolumeImpl;
+	mVolumeImpl = NULL;
 
-    if(!mMediaImplList.empty())
-    {
-        for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
-        {
-            if(mMediaImplList[i].notNull())
-            {
-                mMediaImplList[i]->removeObject(this) ;
-            }
-        }
-    }
+	if(!mMediaImplList.empty())
+	{
+		for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
+		{
+			if(mMediaImplList[i].notNull())
+			{
+				mMediaImplList[i]->removeObject(this) ;
+			}
+		}
+	}
 }
 
 void LLVOVolume::markDead()
 {
-    if (!mDead)
-    {
-        LLSculptIDSize::instance().rem(getVolume()->getParams().getSculptID());
-
-        if(getMDCImplCount() > 0)
-        {
-            LLMediaDataClientObject::ptr_t obj = new LLMediaDataClientObjectImpl(const_cast<LLVOVolume*>(this), false);
-            if (sObjectMediaClient) sObjectMediaClient->removeFromQueue(obj);
-            if (sObjectMediaNavigateClient) sObjectMediaNavigateClient->removeFromQueue(obj);
-        }
-        
-        // Detach all media impls from this object
-        for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
-        {
-            removeMediaImpl(i);
-        }
-
-        if (mSculptTexture.notNull())
-        {
-            mSculptTexture->removeVolume(LLRender::SCULPT_TEX, this);
-        }
-
-        if (mLightTexture.notNull())
-        {
-            mLightTexture->removeVolume(LLRender::LIGHT_TEX, this);
-        }
-    }
-    
-    LLViewerObject::markDead();
+	if (!mDead)
+	{
+		LLSculptIDSize::instance().rem(getVolume()->getParams().getSculptID());
+
+		if(getMDCImplCount() > 0)
+		{
+			LLMediaDataClientObject::ptr_t obj = new LLMediaDataClientObjectImpl(const_cast<LLVOVolume*>(this), false);
+			if (sObjectMediaClient) sObjectMediaClient->removeFromQueue(obj);
+			if (sObjectMediaNavigateClient) sObjectMediaNavigateClient->removeFromQueue(obj);
+		}
+		
+		// Detach all media impls from this object
+		for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
+		{
+			removeMediaImpl(i);
+		}
+
+		if (mSculptTexture.notNull())
+		{
+			mSculptTexture->removeVolume(LLRender::SCULPT_TEX, this);
+		}
+
+		if (mLightTexture.notNull())
+		{
+			mLightTexture->removeVolume(LLRender::LIGHT_TEX, this);
+		}
+	}
+	
+	LLViewerObject::markDead();
 }
 
 
 // static
 void LLVOVolume::initClass()
 {
-    // gSavedSettings better be around
-    if (gSavedSettings.getBOOL("PrimMediaMasterEnabled"))
-    {
-        const F32 queue_timer_delay = gSavedSettings.getF32("PrimMediaRequestQueueDelay");
-        const F32 retry_timer_delay = gSavedSettings.getF32("PrimMediaRetryTimerDelay");
-        const U32 max_retries = gSavedSettings.getU32("PrimMediaMaxRetries");
-        const U32 max_sorted_queue_size = gSavedSettings.getU32("PrimMediaMaxSortedQueueSize");
-        const U32 max_round_robin_queue_size = gSavedSettings.getU32("PrimMediaMaxRoundRobinQueueSize");
-        sObjectMediaClient = new LLObjectMediaDataClient(queue_timer_delay, retry_timer_delay, max_retries, 
-                                                         max_sorted_queue_size, max_round_robin_queue_size);
-        sObjectMediaNavigateClient = new LLObjectMediaNavigateClient(queue_timer_delay, retry_timer_delay, 
-                                                                     max_retries, max_sorted_queue_size, max_round_robin_queue_size);
-    }
+	// gSavedSettings better be around
+	if (gSavedSettings.getBOOL("PrimMediaMasterEnabled"))
+	{
+		const F32 queue_timer_delay = gSavedSettings.getF32("PrimMediaRequestQueueDelay");
+		const F32 retry_timer_delay = gSavedSettings.getF32("PrimMediaRetryTimerDelay");
+		const U32 max_retries = gSavedSettings.getU32("PrimMediaMaxRetries");
+		const U32 max_sorted_queue_size = gSavedSettings.getU32("PrimMediaMaxSortedQueueSize");
+		const U32 max_round_robin_queue_size = gSavedSettings.getU32("PrimMediaMaxRoundRobinQueueSize");
+		sObjectMediaClient = new LLObjectMediaDataClient(queue_timer_delay, retry_timer_delay, max_retries, 
+														 max_sorted_queue_size, max_round_robin_queue_size);
+		sObjectMediaNavigateClient = new LLObjectMediaNavigateClient(queue_timer_delay, retry_timer_delay, 
+																	 max_retries, max_sorted_queue_size, max_round_robin_queue_size);
+	}
 }
 
 // static
@@ -316,201 +316,201 @@ void LLVOVolume::cleanupClass()
 }
 
 U32 LLVOVolume::processUpdateMessage(LLMessageSystem *mesgsys,
-                                          void **user_data,
-                                          U32 block_num, EObjectUpdateType update_type,
-                                          LLDataPacker *dp)
+										  void **user_data,
+										  U32 block_num, EObjectUpdateType update_type,
+										  LLDataPacker *dp)
 {
-        
-    LLColor4U color;
-    const S32 teDirtyBits = (TEM_CHANGE_TEXTURE|TEM_CHANGE_COLOR|TEM_CHANGE_MEDIA);
+	 	
+	LLColor4U color;
+	const S32 teDirtyBits = (TEM_CHANGE_TEXTURE|TEM_CHANGE_COLOR|TEM_CHANGE_MEDIA);
 
-    // Do base class updates...
-    U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
+	// Do base class updates...
+	U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
 
-    LLUUID sculpt_id;
-    U8 sculpt_type = 0;
-    if (isSculpted())
-    {
-        LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
-        sculpt_id = sculpt_params->getSculptTexture();
-        sculpt_type = sculpt_params->getSculptType();
+	LLUUID sculpt_id;
+	U8 sculpt_type = 0;
+	if (isSculpted())
+	{
+		LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
+		sculpt_id = sculpt_params->getSculptTexture();
+		sculpt_type = sculpt_params->getSculptType();
 
         LL_DEBUGS("ObjectUpdate") << "uuid " << mID << " set sculpt_id " << sculpt_id << LL_ENDL;
         dumpStack("ObjectUpdateStack");
-    }
-
-    if (!dp)
-    {
-        if (update_type == OUT_FULL)
-        {
-            ////////////////////////////////
-            //
-            // Unpack texture animation data
-            //
-            //
-
-            if (mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureAnim))
-            {
-                if (!mTextureAnimp)
-                {
-                    mTextureAnimp = new LLViewerTextureAnim(this);
-                }
-                else
-                {
-                    if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
-                    {
-                        mTextureAnimp->reset();
-                    }
-                }
-                mTexAnimMode = 0;
-                
-                mTextureAnimp->unpackTAMessage(mesgsys, block_num);
-            }
-            else
-            {
-                if (mTextureAnimp)
-                {
-                    delete mTextureAnimp;
-                    mTextureAnimp = NULL;
-                    gPipeline.markTextured(mDrawable);
-                    mFaceMappingChanged = TRUE;
-                    mTexAnimMode = 0;
-                }
-            }
-
-            // Unpack volume data
-            LLVolumeParams volume_params;
-            LLVolumeMessage::unpackVolumeParams(&volume_params, mesgsys, _PREHASH_ObjectData, block_num);
-            volume_params.setSculptID(sculpt_id, sculpt_type);
-
-            if (setVolume(volume_params, 0))
-            {
-                markForUpdate(TRUE);
-            }
-        }
-
-        // Sigh, this needs to be done AFTER the volume is set as well, otherwise bad stuff happens...
-        ////////////////////////////
-        //
-        // Unpack texture entry data
-        //
-
-        S32 result = unpackTEMessage(mesgsys, _PREHASH_ObjectData, (S32) block_num);
-        if (result & teDirtyBits)
-        {
-            updateTEData();
-        }
-        if (result & TEM_CHANGE_MEDIA)
-        {
-            retval |= MEDIA_FLAGS_CHANGED;
-        }
-    }
-    else
-    {
-        if (update_type != OUT_TERSE_IMPROVED)
-        {
-            LLVolumeParams volume_params;
-            BOOL res = LLVolumeMessage::unpackVolumeParams(&volume_params, *dp);
-            if (!res)
-            {
-                LL_WARNS() << "Bogus volume parameters in object " << getID() << LL_ENDL;
-                LL_WARNS() << getRegion()->getOriginGlobal() << LL_ENDL;
-            }
-
-            volume_params.setSculptID(sculpt_id, sculpt_type);
-
-            if (setVolume(volume_params, 0))
-            {
-                markForUpdate(TRUE);
-            }
-            S32 res2 = unpackTEMessage(*dp);
-            if (TEM_INVALID == res2)
-            {
-                // There's something bogus in the data that we're unpacking.
-                dp->dumpBufferToLog();
-                LL_WARNS() << "Flushing cache files" << LL_ENDL;
-
-                if(LLVOCache::instanceExists() && getRegion())
-                {
-                    LLVOCache::getInstance()->removeEntry(getRegion()->getHandle()) ;
-                }
-                
-                LL_WARNS() << "Bogus TE data in " << getID() << LL_ENDL;
-            }
-            else 
-            {
-                if (res2 & teDirtyBits) 
-                {
-                    updateTEData();
-                }
-                if (res2 & TEM_CHANGE_MEDIA)
-                {
-                    retval |= MEDIA_FLAGS_CHANGED;
-                }
-            }
-
-            U32 value = dp->getPassFlags();
-
-            if (value & 0x40)
-            {
-                if (!mTextureAnimp)
-                {
-                    mTextureAnimp = new LLViewerTextureAnim(this);
-                }
-                else
-                {
-                    if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
-                    {
-                        mTextureAnimp->reset();
-                    }
-                }
-                mTexAnimMode = 0;
-                mTextureAnimp->unpackTAMessage(*dp);
-            }
-            else if (mTextureAnimp)
-            {
-                delete mTextureAnimp;
-                mTextureAnimp = NULL;
-                gPipeline.markTextured(mDrawable);
-                mFaceMappingChanged = TRUE;
-                mTexAnimMode = 0;
-            }
-
-            if (value & 0x400)
-            { //particle system (new)
-                unpackParticleSource(*dp, mOwnerID, false);
-            }
-        }
-        else
-        {
-            S32 texture_length = mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureEntry);
-            if (texture_length)
-            {
-                U8                          tdpbuffer[1024];
-                LLDataPackerBinaryBuffer    tdp(tdpbuffer, 1024);
-                mesgsys->getBinaryDataFast(_PREHASH_ObjectData, _PREHASH_TextureEntry, tdpbuffer, 0, block_num, 1024);
-                S32 result = unpackTEMessage(tdp);
-                if (result & teDirtyBits)
-                {
-                    updateTEData();
-                }
-                if (result & TEM_CHANGE_MEDIA)
-                {
-                    retval |= MEDIA_FLAGS_CHANGED;
-                }
-            }
-        }
-    }
-    if (retval & (MEDIA_URL_REMOVED | MEDIA_URL_ADDED | MEDIA_URL_UPDATED | MEDIA_FLAGS_CHANGED)) 
-    {
-        // If only the media URL changed, and it isn't a media version URL,
-        // ignore it
-        if ( ! ( retval & (MEDIA_URL_ADDED | MEDIA_URL_UPDATED) &&
-                 mMedia && ! mMedia->mMediaURL.empty() &&
-                 ! LLTextureEntry::isMediaVersionString(mMedia->mMediaURL) ) )
-        {
-            // If the media changed at all, request new media data
-            LL_DEBUGS("MediaOnAPrim") << "Media update: " << getID() << ": retval=" << retval << " Media URL: " <<
+	}
+
+	if (!dp)
+	{
+		if (update_type == OUT_FULL)
+		{
+			////////////////////////////////
+			//
+			// Unpack texture animation data
+			//
+			//
+
+			if (mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureAnim))
+			{
+				if (!mTextureAnimp)
+				{
+					mTextureAnimp = new LLViewerTextureAnim(this);
+				}
+				else
+				{
+					if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
+					{
+						mTextureAnimp->reset();
+					}
+				}
+				mTexAnimMode = 0;
+				
+				mTextureAnimp->unpackTAMessage(mesgsys, block_num);
+			}
+			else
+			{
+				if (mTextureAnimp)
+				{
+					delete mTextureAnimp;
+					mTextureAnimp = NULL;
+					gPipeline.markTextured(mDrawable);
+					mFaceMappingChanged = TRUE;
+					mTexAnimMode = 0;
+				}
+			}
+
+			// Unpack volume data
+			LLVolumeParams volume_params;
+			LLVolumeMessage::unpackVolumeParams(&volume_params, mesgsys, _PREHASH_ObjectData, block_num);
+			volume_params.setSculptID(sculpt_id, sculpt_type);
+
+			if (setVolume(volume_params, 0))
+			{
+				markForUpdate(TRUE);
+			}
+		}
+
+		// Sigh, this needs to be done AFTER the volume is set as well, otherwise bad stuff happens...
+		////////////////////////////
+		//
+		// Unpack texture entry data
+		//
+
+		S32 result = unpackTEMessage(mesgsys, _PREHASH_ObjectData, (S32) block_num);
+		if (result & teDirtyBits)
+		{
+			updateTEData();
+		}
+		if (result & TEM_CHANGE_MEDIA)
+		{
+			retval |= MEDIA_FLAGS_CHANGED;
+		}
+	}
+	else
+	{
+		if (update_type != OUT_TERSE_IMPROVED)
+		{
+			LLVolumeParams volume_params;
+			BOOL res = LLVolumeMessage::unpackVolumeParams(&volume_params, *dp);
+			if (!res)
+			{
+				LL_WARNS() << "Bogus volume parameters in object " << getID() << LL_ENDL;
+				LL_WARNS() << getRegion()->getOriginGlobal() << LL_ENDL;
+			}
+
+			volume_params.setSculptID(sculpt_id, sculpt_type);
+
+			if (setVolume(volume_params, 0))
+			{
+				markForUpdate(TRUE);
+			}
+			S32 res2 = unpackTEMessage(*dp);
+			if (TEM_INVALID == res2)
+			{
+				// There's something bogus in the data that we're unpacking.
+				dp->dumpBufferToLog();
+				LL_WARNS() << "Flushing cache files" << LL_ENDL;
+
+				if(LLVOCache::instanceExists() && getRegion())
+				{
+					LLVOCache::getInstance()->removeEntry(getRegion()->getHandle()) ;
+				}
+				
+				LL_WARNS() << "Bogus TE data in " << getID() << LL_ENDL;
+			}
+			else 
+			{
+				if (res2 & teDirtyBits) 
+				{
+					updateTEData();
+				}
+				if (res2 & TEM_CHANGE_MEDIA)
+				{
+					retval |= MEDIA_FLAGS_CHANGED;
+				}
+			}
+
+			U32 value = dp->getPassFlags();
+
+			if (value & 0x40)
+			{
+				if (!mTextureAnimp)
+				{
+					mTextureAnimp = new LLViewerTextureAnim(this);
+				}
+				else
+				{
+					if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
+					{
+						mTextureAnimp->reset();
+					}
+				}
+				mTexAnimMode = 0;
+				mTextureAnimp->unpackTAMessage(*dp);
+			}
+			else if (mTextureAnimp)
+			{
+				delete mTextureAnimp;
+				mTextureAnimp = NULL;
+				gPipeline.markTextured(mDrawable);
+				mFaceMappingChanged = TRUE;
+				mTexAnimMode = 0;
+			}
+
+			if (value & 0x400)
+			{ //particle system (new)
+				unpackParticleSource(*dp, mOwnerID, false);
+			}
+		}
+		else
+		{
+			S32 texture_length = mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureEntry);
+			if (texture_length)
+			{
+				U8							tdpbuffer[1024];
+				LLDataPackerBinaryBuffer	tdp(tdpbuffer, 1024);
+				mesgsys->getBinaryDataFast(_PREHASH_ObjectData, _PREHASH_TextureEntry, tdpbuffer, 0, block_num, 1024);
+				S32 result = unpackTEMessage(tdp);
+				if (result & teDirtyBits)
+				{
+					updateTEData();
+				}
+				if (result & TEM_CHANGE_MEDIA)
+				{
+					retval |= MEDIA_FLAGS_CHANGED;
+				}
+			}
+		}
+	}
+	if (retval & (MEDIA_URL_REMOVED | MEDIA_URL_ADDED | MEDIA_URL_UPDATED | MEDIA_FLAGS_CHANGED)) 
+	{
+		// If only the media URL changed, and it isn't a media version URL,
+		// ignore it
+		if ( ! ( retval & (MEDIA_URL_ADDED | MEDIA_URL_UPDATED) &&
+				 mMedia && ! mMedia->mMediaURL.empty() &&
+				 ! LLTextureEntry::isMediaVersionString(mMedia->mMediaURL) ) )
+		{
+			// If the media changed at all, request new media data
+			LL_DEBUGS("MediaOnAPrim") << "Media update: " << getID() << ": retval=" << retval << " Media URL: " <<
                 ((mMedia) ?  mMedia->mMediaURL : std::string("")) << LL_ENDL;
             requestMediaDataUpdate(retval & MEDIA_FLAGS_CHANGED);
         }
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index b63f5bd05a..6e7e8eef21 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -9993,14 +9993,14 @@ bool LLPipeline::getVisiblePointCloud(LLCamera& camera, LLVector3& min, LLVector
 void LLPipeline::renderHighlight(const LLViewerObject* obj, F32 fade)
 {
     BOOL shaders = canUseVertexShaders();
-    if(shaders) 
-    {
-        gHighlightProgram.bind();
-    }
-    else
-    {
-        gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
-    }
+	if(shaders) 
+	{
+		gHighlightProgram.bind();
+	}
+	else
+	{
+		gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
+	}
 
     if (obj && obj->getVolume())
     {
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index 38fb26d811..a31f880fbf 100644
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -53,8 +53,8 @@ class LLDrawPoolAlpha;
 
 typedef enum e_avatar_skinning_method
 {
-    SKIN_METHOD_SOFTWARE,
-    SKIN_METHOD_VERTEX_PROGRAM
+	SKIN_METHOD_SOFTWARE,
+	SKIN_METHOD_VERTEX_PROGRAM
 } EAvatarSkinningMethod;
 
 bool compute_min_max(LLMatrix4& box, LLVector2& min, LLVector2& max); // Shouldn't be defined here!
@@ -93,861 +93,861 @@ extern LLTrace::BlockTimerStatHandle FTM_RENDER_UI_SCENE_MON;
 class LLPipeline
 {
 public:
-    LLPipeline();
-    ~LLPipeline();
-
-    void destroyGL();
-    void restoreGL();
-    void resetVertexBuffers();
-    void doResetVertexBuffers(bool forced = false);
-    void resizeScreenTexture();
-    void releaseGLBuffers();
-    void releaseLUTBuffers();
-    void releaseScreenBuffers();
-    void createGLBuffers();
-    void createLUTBuffers();
-
-    //allocate the largest screen buffer possible up to resX, resY
-    //returns true if full size buffer allocated, false if some other size is allocated
-    bool allocateScreenBuffer(U32 resX, U32 resY);
-
-    typedef enum {
-        FBO_SUCCESS_FULLRES = 0,
-        FBO_SUCCESS_LOWRES,
-        FBO_FAILURE
-    } eFBOStatus;
+	LLPipeline();
+	~LLPipeline();
+
+	void destroyGL();
+	void restoreGL();
+	void resetVertexBuffers();
+	void doResetVertexBuffers(bool forced = false);
+	void resizeScreenTexture();
+	void releaseGLBuffers();
+	void releaseLUTBuffers();
+	void releaseScreenBuffers();
+	void createGLBuffers();
+	void createLUTBuffers();
+
+	//allocate the largest screen buffer possible up to resX, resY
+	//returns true if full size buffer allocated, false if some other size is allocated
+	bool allocateScreenBuffer(U32 resX, U32 resY);
+
+	typedef enum {
+		FBO_SUCCESS_FULLRES = 0,
+		FBO_SUCCESS_LOWRES,
+		FBO_FAILURE
+	} eFBOStatus;
 
 private:
-    //implementation of above, wrapped for easy error handling
-    eFBOStatus doAllocateScreenBuffer(U32 resX, U32 resY);
+	//implementation of above, wrapped for easy error handling
+	eFBOStatus doAllocateScreenBuffer(U32 resX, U32 resY);
 public:
 
-    //attempt to allocate screen buffers at resX, resY
-    //returns true if allocation successful, false otherwise
-    bool allocateScreenBuffer(U32 resX, U32 resY, U32 samples);
-
-    void allocatePhysicsBuffer();
-    
-    void resetVertexBuffers(LLDrawable* drawable);
-    void generateImpostor(LLVOAvatar* avatar);
-    void bindScreenToTexture();
-    void renderBloom(bool for_snapshot, F32 zoom_factor = 1.f, int subfield = 0);
-
-    void init();
-    void cleanup();
-    bool isInit() { return mInitialized; };
-
-    /// @brief Get a draw pool from pool type (POOL_SIMPLE, POOL_MEDIA) and texture.
-    /// @return Draw pool, or NULL if not found.
-    LLDrawPool *findPool(const U32 pool_type, LLViewerTexture *tex0 = NULL);
-
-    /// @brief Get a draw pool for faces of the appropriate type and texture.  Create if necessary.
-    /// @return Always returns a draw pool.
-    LLDrawPool *getPool(const U32 pool_type, LLViewerTexture *tex0 = NULL);
-
-    /// @brief Figures out draw pool type from texture entry. Creates pool if necessary.
-    static LLDrawPool* getPoolFromTE(const LLTextureEntry* te, LLViewerTexture* te_image);
-    static U32 getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* imagep);
-
-    void         addPool(LLDrawPool *poolp);    // Only to be used by LLDrawPool classes for splitting pools!
-    void         removePool( LLDrawPool* poolp );
-
-    void         allocDrawable(LLViewerObject *obj);
-
-    void         unlinkDrawable(LLDrawable*);
-
-    static void removeMutedAVsLights(LLVOAvatar*);
-
-    // Object related methods
-    void        markVisible(LLDrawable *drawablep, LLCamera& camera);
-    void        markOccluder(LLSpatialGroup* group);
-
-    //downsample source to dest, taking the maximum depth value per pixel in source and writing to dest
-    // if source's depth buffer cannot be bound for reading, a scratch space depth buffer must be provided
-    void        downsampleDepthBuffer(LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space = NULL);
-
-    // Downsample depth buffer with gather and find local min/max depth values. Writes to a 16F RG render target.
-    void        downsampleMinMaxDepthBuffer(LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space = NULL);
-
-    void        doOcclusion(LLCamera& camera, LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space = NULL);
-    void        doOcclusion(LLCamera& camera);
-    void        markNotCulled(LLSpatialGroup* group, LLCamera &camera);
-    void        markMoved(LLDrawable *drawablep, bool damped_motion = false);
-    void        markShift(LLDrawable *drawablep);
-    void        markTextured(LLDrawable *drawablep);
-    void        markGLRebuild(LLGLUpdate* glu);
-    void        markRebuild(LLSpatialGroup* group, bool priority = false);
-    void        markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags flag = LLDrawable::REBUILD_ALL, bool priority = false);
-    void        markPartitionMove(LLDrawable* drawablep);
-    void        markMeshDirty(LLSpatialGroup* group);
-
-    //get the object between start and end that's closest to start.
-    LLViewerObject* lineSegmentIntersectInWorld(const LLVector4a& start, const LLVector4a& end,
-                                                bool pick_transparent,
-                                                bool pick_rigged,
-                                                S32* face_hit,                          // return the face hit
-                                                LLVector4a* intersection = NULL,         // return the intersection point
-                                                LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
-                                                LLVector4a* normal = NULL,               // return the surface normal at the intersection point
-                                                LLVector4a* tangent = NULL             // return the surface tangent at the intersection point  
-        );
-
-    //get the closest particle to start between start and end, returns the LLVOPartGroup and particle index
-    LLVOPartGroup* lineSegmentIntersectParticle(const LLVector4a& start, const LLVector4a& end, LLVector4a* intersection,
-                                                        S32* face_hit);
-
-
-    LLViewerObject* lineSegmentIntersectInHUD(const LLVector4a& start, const LLVector4a& end,
-                                              bool pick_transparent,
-                                              S32* face_hit,                          // return the face hit
-                                              LLVector4a* intersection = NULL,         // return the intersection point
-                                              LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
-                                              LLVector4a* normal = NULL,               // return the surface normal at the intersection point
-                                              LLVector4a* tangent = NULL             // return the surface tangent at the intersection point
-        );
-
-    // Something about these textures has changed.  Dirty them.
-    void        dirtyPoolObjectTextures(const std::set<LLViewerFetchedTexture*>& textures);
-
-    void        resetDrawOrders();
-
-    U32         addObject(LLViewerObject *obj);
-
-    void        enableShadows(const bool enable_shadows);
+	//attempt to allocate screen buffers at resX, resY
+	//returns true if allocation successful, false otherwise
+	bool allocateScreenBuffer(U32 resX, U32 resY, U32 samples);
+
+	void allocatePhysicsBuffer();
+	
+	void resetVertexBuffers(LLDrawable* drawable);
+	void generateImpostor(LLVOAvatar* avatar);
+	void bindScreenToTexture();
+	void renderBloom(bool for_snapshot, F32 zoom_factor = 1.f, int subfield = 0);
+
+	void init();
+	void cleanup();
+	bool isInit() { return mInitialized; };
+
+	/// @brief Get a draw pool from pool type (POOL_SIMPLE, POOL_MEDIA) and texture.
+	/// @return Draw pool, or NULL if not found.
+	LLDrawPool *findPool(const U32 pool_type, LLViewerTexture *tex0 = NULL);
+
+	/// @brief Get a draw pool for faces of the appropriate type and texture.  Create if necessary.
+	/// @return Always returns a draw pool.
+	LLDrawPool *getPool(const U32 pool_type, LLViewerTexture *tex0 = NULL);
+
+	/// @brief Figures out draw pool type from texture entry. Creates pool if necessary.
+	static LLDrawPool* getPoolFromTE(const LLTextureEntry* te, LLViewerTexture* te_image);
+	static U32 getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* imagep);
+
+	void		 addPool(LLDrawPool *poolp);	// Only to be used by LLDrawPool classes for splitting pools!
+	void		 removePool( LLDrawPool* poolp );
+
+	void		 allocDrawable(LLViewerObject *obj);
+
+	void		 unlinkDrawable(LLDrawable*);
+
+	static void removeMutedAVsLights(LLVOAvatar*);
+
+	// Object related methods
+	void        markVisible(LLDrawable *drawablep, LLCamera& camera);
+	void		markOccluder(LLSpatialGroup* group);
+
+	//downsample source to dest, taking the maximum depth value per pixel in source and writing to dest
+	// if source's depth buffer cannot be bound for reading, a scratch space depth buffer must be provided
+	void		downsampleDepthBuffer(LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space = NULL);
+
+	// Downsample depth buffer with gather and find local min/max depth values. Writes to a 16F RG render target.
+	void		downsampleMinMaxDepthBuffer(LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space = NULL);
+
+	void		doOcclusion(LLCamera& camera, LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space = NULL);
+	void		doOcclusion(LLCamera& camera);
+	void		markNotCulled(LLSpatialGroup* group, LLCamera &camera);
+	void        markMoved(LLDrawable *drawablep, bool damped_motion = false);
+	void        markShift(LLDrawable *drawablep);
+	void        markTextured(LLDrawable *drawablep);
+	void		markGLRebuild(LLGLUpdate* glu);
+	void		markRebuild(LLSpatialGroup* group, bool priority = false);
+	void        markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags flag = LLDrawable::REBUILD_ALL, bool priority = false);
+	void		markPartitionMove(LLDrawable* drawablep);
+	void		markMeshDirty(LLSpatialGroup* group);
+
+	//get the object between start and end that's closest to start.
+	LLViewerObject* lineSegmentIntersectInWorld(const LLVector4a& start, const LLVector4a& end,
+												bool pick_transparent,
+												bool pick_rigged,
+												S32* face_hit,                          // return the face hit
+												LLVector4a* intersection = NULL,         // return the intersection point
+												LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
+												LLVector4a* normal = NULL,               // return the surface normal at the intersection point
+												LLVector4a* tangent = NULL             // return the surface tangent at the intersection point  
+		);
+
+	//get the closest particle to start between start and end, returns the LLVOPartGroup and particle index
+	LLVOPartGroup* lineSegmentIntersectParticle(const LLVector4a& start, const LLVector4a& end, LLVector4a* intersection,
+														S32* face_hit);
+
+
+	LLViewerObject* lineSegmentIntersectInHUD(const LLVector4a& start, const LLVector4a& end,
+											  bool pick_transparent,
+											  S32* face_hit,                          // return the face hit
+											  LLVector4a* intersection = NULL,         // return the intersection point
+											  LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
+											  LLVector4a* normal = NULL,               // return the surface normal at the intersection point
+											  LLVector4a* tangent = NULL             // return the surface tangent at the intersection point
+		);
+
+	// Something about these textures has changed.  Dirty them.
+	void        dirtyPoolObjectTextures(const std::set<LLViewerFetchedTexture*>& textures);
+
+	void        resetDrawOrders();
+
+	U32         addObject(LLViewerObject *obj);
+
+	void		enableShadows(const bool enable_shadows);
     void        releaseShadowTargets();
     void        releaseShadowTarget(U32 index);
 
-//  void        setLocalLighting(const bool local_lighting);
-//  bool        isLocalLightingEnabled() const;
-    S32         setLightingDetail(S32 level);
-    S32         getLightingDetail() const { return mLightingDetail; }
-    S32         getMaxLightingDetail() const;
-        
-    void        setUseVertexShaders(bool use_shaders);
-    bool        getUseVertexShaders() const { return mVertexShadersEnabled; }
-    bool        canUseVertexShaders();
-    bool        canUseWindLightShaders() const;
-    bool        canUseWindLightShadersOnObjects() const;
-    bool        canUseAntiAliasing() const;
-
-    // phases
-    void resetFrameStats();
-
-    void updateMoveDampedAsync(LLDrawable* drawablep);
-    void updateMoveNormalAsync(LLDrawable* drawablep);
-    void updateMovedList(LLDrawable::drawable_vector_t& move_list);
-    void updateMove();
-    bool visibleObjectsInFrustum(LLCamera& camera);
-    bool getVisibleExtents(LLCamera& camera, LLVector3 &min, LLVector3& max);
-    bool getVisiblePointCloud(LLCamera& camera, LLVector3 &min, LLVector3& max, std::vector<LLVector3>& fp, LLVector3 light_dir = LLVector3(0,0,0));
-    void updateCull(LLCamera& camera, LLCullResult& result, S32 water_clip = 0, LLPlane* plane = NULL);  //if water_clip is 0, ignore water plane, 1, cull to above plane, -1, cull to below plane
-    void createObjects(F32 max_dtime);
-    void createObject(LLViewerObject* vobj);
-    void processPartitionQ();
-    void updateGeom(F32 max_dtime);
-    void updateGL();
-    void rebuildPriorityGroups();
-    void rebuildGroups();
-    void clearRebuildGroups();
-    void clearRebuildDrawables();
-
-    //calculate pixel area of given box from vantage point of given camera
-    static F32 calcPixelArea(LLVector3 center, LLVector3 size, LLCamera& camera);
-    static F32 calcPixelArea(const LLVector4a& center, const LLVector4a& size, LLCamera &camera);
-
-    void stateSort(LLCamera& camera, LLCullResult& result);
-    void stateSort(LLSpatialGroup* group, LLCamera& camera);
-    void stateSort(LLSpatialBridge* bridge, LLCamera& camera, BOOL fov_changed = FALSE);
-    void stateSort(LLDrawable* drawablep, LLCamera& camera);
-    void postSort(LLCamera& camera);
-    void forAllVisibleDrawables(void (*func)(LLDrawable*));
-
-    void renderObjects(U32 type, U32 mask, bool texture = true, bool batch_texture = false);
-    void renderMaskedObjects(U32 type, U32 mask, bool texture = true, bool batch_texture = false);
-
-    void renderGroups(LLRenderPass* pass, U32 type, U32 mask, bool texture);
-
-    void grabReferences(LLCullResult& result);
-    void clearReferences();
-
-    //check references will assert that there are no references in sCullResult to the provided data
-    void checkReferences(LLFace* face);
-    void checkReferences(LLDrawable* drawable);
-    void checkReferences(LLDrawInfo* draw_info);
-    void checkReferences(LLSpatialGroup* group);
-
-
-    void renderGeom(LLCamera& camera, bool forceVBOUpdate = false);
-    void renderGeomDeferred(LLCamera& camera);
-    void renderGeomPostDeferred(LLCamera& camera, bool do_occlusion=true);
-    void renderGeomShadow(LLCamera& camera);
-    void bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_target = nullptr);
-    void setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep);
-
-    void unbindDeferredShader(LLGLSLShader& shader);
-    void renderDeferredLighting(LLRenderTarget* light_target);
-    void postDeferredGammaCorrect(LLRenderTarget* screen_target);
-
-    void generateWaterReflection(LLCamera& camera);
-    void generateSunShadow(LLCamera& camera);
+// 	void		setLocalLighting(const bool local_lighting);
+// 	bool		isLocalLightingEnabled() const;
+	S32			setLightingDetail(S32 level);
+	S32			getLightingDetail() const { return mLightingDetail; }
+	S32			getMaxLightingDetail() const;
+		
+	void		setUseVertexShaders(bool use_shaders);
+	bool		getUseVertexShaders() const { return mVertexShadersEnabled; }
+	bool		canUseVertexShaders();
+	bool		canUseWindLightShaders() const;
+	bool		canUseWindLightShadersOnObjects() const;
+	bool		canUseAntiAliasing() const;
+
+	// phases
+	void resetFrameStats();
+
+	void updateMoveDampedAsync(LLDrawable* drawablep);
+	void updateMoveNormalAsync(LLDrawable* drawablep);
+	void updateMovedList(LLDrawable::drawable_vector_t& move_list);
+	void updateMove();
+	bool visibleObjectsInFrustum(LLCamera& camera);
+	bool getVisibleExtents(LLCamera& camera, LLVector3 &min, LLVector3& max);
+	bool getVisiblePointCloud(LLCamera& camera, LLVector3 &min, LLVector3& max, std::vector<LLVector3>& fp, LLVector3 light_dir = LLVector3(0,0,0));
+	void updateCull(LLCamera& camera, LLCullResult& result, S32 water_clip = 0, LLPlane* plane = NULL);  //if water_clip is 0, ignore water plane, 1, cull to above plane, -1, cull to below plane
+	void createObjects(F32 max_dtime);
+	void createObject(LLViewerObject* vobj);
+	void processPartitionQ();
+	void updateGeom(F32 max_dtime);
+	void updateGL();
+	void rebuildPriorityGroups();
+	void rebuildGroups();
+	void clearRebuildGroups();
+	void clearRebuildDrawables();
+
+	//calculate pixel area of given box from vantage point of given camera
+	static F32 calcPixelArea(LLVector3 center, LLVector3 size, LLCamera& camera);
+	static F32 calcPixelArea(const LLVector4a& center, const LLVector4a& size, LLCamera &camera);
+
+	void stateSort(LLCamera& camera, LLCullResult& result);
+	void stateSort(LLSpatialGroup* group, LLCamera& camera);
+	void stateSort(LLSpatialBridge* bridge, LLCamera& camera, BOOL fov_changed = FALSE);
+	void stateSort(LLDrawable* drawablep, LLCamera& camera);
+	void postSort(LLCamera& camera);
+	void forAllVisibleDrawables(void (*func)(LLDrawable*));
+
+	void renderObjects(U32 type, U32 mask, bool texture = true, bool batch_texture = false);
+	void renderMaskedObjects(U32 type, U32 mask, bool texture = true, bool batch_texture = false);
+
+	void renderGroups(LLRenderPass* pass, U32 type, U32 mask, bool texture);
+
+	void grabReferences(LLCullResult& result);
+	void clearReferences();
+
+	//check references will assert that there are no references in sCullResult to the provided data
+	void checkReferences(LLFace* face);
+	void checkReferences(LLDrawable* drawable);
+	void checkReferences(LLDrawInfo* draw_info);
+	void checkReferences(LLSpatialGroup* group);
+
+
+	void renderGeom(LLCamera& camera, bool forceVBOUpdate = false);
+	void renderGeomDeferred(LLCamera& camera);
+	void renderGeomPostDeferred(LLCamera& camera, bool do_occlusion=true);
+	void renderGeomShadow(LLCamera& camera);
+	void bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_target = nullptr);
+	void setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep);
+
+	void unbindDeferredShader(LLGLSLShader& shader);
+	void renderDeferredLighting(LLRenderTarget* light_target);
+	void postDeferredGammaCorrect(LLRenderTarget* screen_target);
+
+	void generateWaterReflection(LLCamera& camera);
+	void generateSunShadow(LLCamera& camera);
     LLRenderTarget* getShadowTarget(U32 i);
 
-    void generateHighlight(LLCamera& camera);
-    void renderHighlight(const LLViewerObject* obj, F32 fade);
-    void setHighlightObject(LLDrawable* obj) { mHighlightObject = obj; }
-
-
-    void renderShadow(glh::matrix4f& view, glh::matrix4f& proj, LLCamera& camera, LLCullResult& result, bool use_shader, bool use_occlusion, U32 target_width);
-    void renderHighlights();
-    void renderDebug();
-    void renderPhysicsDisplay();
-
-    void rebuildPools(); // Rebuild pools
-
-    void findReferences(LLDrawable *drawablep); // Find the lists which have references to this object
-    bool verify();                      // Verify that all data in the pipeline is "correct"
-
-    S32  getLightCount() const { return mLights.size(); }
-
-    void calcNearbyLights(LLCamera& camera);
-    void setupHWLights(LLDrawPool* pool);
-    void setupAvatarLights(bool for_edit = false);
-    void enableLights(U32 mask);
-    void enableLightsStatic();
-    void enableLightsDynamic();
-    void enableLightsAvatar();
-    void enableLightsPreview();
-    void enableLightsAvatarEdit(const LLColor4& color);
-    void enableLightsFullbright(const LLColor4& color);
-    void disableLights();
-
-    void shiftObjects(const LLVector3 &offset);
-
-    void setLight(LLDrawable *drawablep, bool is_light);
-    
-    bool hasRenderBatches(const U32 type) const;
-    LLCullResult::drawinfo_iterator beginRenderMap(U32 type);
-    LLCullResult::drawinfo_iterator endRenderMap(U32 type);
-    LLCullResult::sg_iterator beginAlphaGroups();
-    LLCullResult::sg_iterator endAlphaGroups();
-    
-
-    void addTrianglesDrawn(S32 index_count, U32 render_type = LLRender::TRIANGLES);
-
-    bool hasRenderDebugFeatureMask(const U32 mask) const    { return bool(mRenderDebugFeatureMask & mask); }
-    bool hasRenderDebugMask(const U64 mask) const           { return bool(mRenderDebugMask & mask); }
-    void setAllRenderDebugFeatures() { mRenderDebugFeatureMask = 0xffffffff; }
-    void clearAllRenderDebugFeatures() { mRenderDebugFeatureMask = 0x0; }
-    void setAllRenderDebugDisplays() { mRenderDebugMask = 0xffffffffffffffff; }
-    void clearAllRenderDebugDisplays() { mRenderDebugMask = 0x0; }
-
-    bool hasRenderType(const U32 type) const;
-    bool hasAnyRenderType(const U32 type, ...) const;
-
-    void setRenderTypeMask(U32 type, ...);
-    // This is equivalent to 'setRenderTypeMask'
-    //void orRenderTypeMask(U32 type, ...);
-    void andRenderTypeMask(U32 type, ...);
-    void clearRenderTypeMask(U32 type, ...);
-    void setAllRenderTypes();
-    void clearAllRenderTypes();
-    
-    void pushRenderTypeMask();
-    void popRenderTypeMask();
-
-    void pushRenderDebugFeatureMask();
-    void popRenderDebugFeatureMask();
-
-    static void toggleRenderType(U32 type);
-
-    // For UI control of render features
-    static bool hasRenderTypeControl(U32 data);
-    static void toggleRenderDebug(U64 data);
-    static void toggleRenderDebugFeature(U32 data);
-    static void toggleRenderTypeControl(U32 data);
-    static bool toggleRenderTypeControlNegated(S32 data);
-    static bool toggleRenderDebugControl(U64 data);
-    static bool toggleRenderDebugFeatureControl(U32 data);
-    static void setRenderDebugFeatureControl(U32 bit, bool value);
-
-    static void setRenderParticleBeacons(bool val);
-    static void toggleRenderParticleBeacons();
-    static bool getRenderParticleBeacons();
-
-    static void setRenderSoundBeacons(bool val);
-    static void toggleRenderSoundBeacons();
-    static bool getRenderSoundBeacons();
-
-    static void setRenderMOAPBeacons(bool val);
-    static void toggleRenderMOAPBeacons();
-    static bool getRenderMOAPBeacons();
-
-    static void setRenderPhysicalBeacons(bool val);
-    static void toggleRenderPhysicalBeacons();
-    static bool getRenderPhysicalBeacons();
-
-    static void setRenderScriptedBeacons(bool val);
-    static void toggleRenderScriptedBeacons();
-    static bool getRenderScriptedBeacons();
-
-    static void setRenderScriptedTouchBeacons(bool val);
-    static void toggleRenderScriptedTouchBeacons();
-    static bool getRenderScriptedTouchBeacons();
-
-    static void setRenderBeacons(bool val);
-    static void toggleRenderBeacons();
-    static bool getRenderBeacons();
-
-    static void setRenderHighlights(bool val);
-    static void toggleRenderHighlights();
-    static bool getRenderHighlights();
-    static void setRenderHighlightTextureChannel(LLRender::eTexIndex channel); // sets which UV setup to display in highlight overlay
-
-    static void updateRenderBump();
-    static void updateRenderDeferred();
-    static void refreshCachedSettings();
-
-    static void throttleNewMemoryAllocation(bool disable);
-
-    
-
-    void addDebugBlip(const LLVector3& position, const LLColor4& color);
-
-    void hidePermanentObjects( std::vector<U32>& restoreList );
-    void restorePermanentObjects( const std::vector<U32>& restoreList );
-    void skipRenderingOfTerrain( bool flag );
-    void hideObject( const LLUUID& id );
-    void restoreHiddenObject( const LLUUID& id );
+	void generateHighlight(LLCamera& camera);
+	void renderHighlight(const LLViewerObject* obj, F32 fade);
+	void setHighlightObject(LLDrawable* obj) { mHighlightObject = obj; }
+
+
+	void renderShadow(glh::matrix4f& view, glh::matrix4f& proj, LLCamera& camera, LLCullResult& result, bool use_shader, bool use_occlusion, U32 target_width);
+	void renderHighlights();
+	void renderDebug();
+	void renderPhysicsDisplay();
+
+	void rebuildPools(); // Rebuild pools
+
+	void findReferences(LLDrawable *drawablep);	// Find the lists which have references to this object
+	bool verify();						// Verify that all data in the pipeline is "correct"
+
+	S32  getLightCount() const { return mLights.size(); }
+
+	void calcNearbyLights(LLCamera& camera);
+	void setupHWLights(LLDrawPool* pool);
+	void setupAvatarLights(bool for_edit = false);
+	void enableLights(U32 mask);
+	void enableLightsStatic();
+	void enableLightsDynamic();
+	void enableLightsAvatar();
+	void enableLightsPreview();
+	void enableLightsAvatarEdit(const LLColor4& color);
+	void enableLightsFullbright(const LLColor4& color);
+	void disableLights();
+
+	void shiftObjects(const LLVector3 &offset);
+
+	void setLight(LLDrawable *drawablep, bool is_light);
+	
+	bool hasRenderBatches(const U32 type) const;
+	LLCullResult::drawinfo_iterator beginRenderMap(U32 type);
+	LLCullResult::drawinfo_iterator endRenderMap(U32 type);
+	LLCullResult::sg_iterator beginAlphaGroups();
+	LLCullResult::sg_iterator endAlphaGroups();
+	
+
+	void addTrianglesDrawn(S32 index_count, U32 render_type = LLRender::TRIANGLES);
+
+	bool hasRenderDebugFeatureMask(const U32 mask) const	{ return bool(mRenderDebugFeatureMask & mask); }
+	bool hasRenderDebugMask(const U64 mask) const			{ return bool(mRenderDebugMask & mask); }
+	void setAllRenderDebugFeatures() { mRenderDebugFeatureMask = 0xffffffff; }
+	void clearAllRenderDebugFeatures() { mRenderDebugFeatureMask = 0x0; }
+	void setAllRenderDebugDisplays() { mRenderDebugMask = 0xffffffffffffffff; }
+	void clearAllRenderDebugDisplays() { mRenderDebugMask = 0x0; }
+
+	bool hasRenderType(const U32 type) const;
+	bool hasAnyRenderType(const U32 type, ...) const;
+
+	void setRenderTypeMask(U32 type, ...);
+	// This is equivalent to 'setRenderTypeMask'
+	//void orRenderTypeMask(U32 type, ...);
+	void andRenderTypeMask(U32 type, ...);
+	void clearRenderTypeMask(U32 type, ...);
+	void setAllRenderTypes();
+	void clearAllRenderTypes();
+	
+	void pushRenderTypeMask();
+	void popRenderTypeMask();
+
+	void pushRenderDebugFeatureMask();
+	void popRenderDebugFeatureMask();
+
+	static void toggleRenderType(U32 type);
+
+	// For UI control of render features
+	static bool hasRenderTypeControl(U32 data);
+	static void toggleRenderDebug(U64 data);
+	static void toggleRenderDebugFeature(U32 data);
+	static void toggleRenderTypeControl(U32 data);
+	static bool toggleRenderTypeControlNegated(S32 data);
+	static bool toggleRenderDebugControl(U64 data);
+	static bool toggleRenderDebugFeatureControl(U32 data);
+	static void setRenderDebugFeatureControl(U32 bit, bool value);
+
+	static void setRenderParticleBeacons(bool val);
+	static void toggleRenderParticleBeacons();
+	static bool getRenderParticleBeacons();
+
+	static void setRenderSoundBeacons(bool val);
+	static void toggleRenderSoundBeacons();
+	static bool getRenderSoundBeacons();
+
+	static void setRenderMOAPBeacons(bool val);
+	static void toggleRenderMOAPBeacons();
+	static bool getRenderMOAPBeacons();
+
+	static void setRenderPhysicalBeacons(bool val);
+	static void toggleRenderPhysicalBeacons();
+	static bool getRenderPhysicalBeacons();
+
+	static void setRenderScriptedBeacons(bool val);
+	static void toggleRenderScriptedBeacons();
+	static bool getRenderScriptedBeacons();
+
+	static void setRenderScriptedTouchBeacons(bool val);
+	static void toggleRenderScriptedTouchBeacons();
+	static bool getRenderScriptedTouchBeacons();
+
+	static void setRenderBeacons(bool val);
+	static void toggleRenderBeacons();
+	static bool getRenderBeacons();
+
+	static void setRenderHighlights(bool val);
+	static void toggleRenderHighlights();
+	static bool getRenderHighlights();
+	static void setRenderHighlightTextureChannel(LLRender::eTexIndex channel); // sets which UV setup to display in highlight overlay
+
+	static void updateRenderBump();
+	static void updateRenderDeferred();
+	static void refreshCachedSettings();
+
+	static void throttleNewMemoryAllocation(bool disable);
+
+	
+
+	void addDebugBlip(const LLVector3& position, const LLColor4& color);
+
+	void hidePermanentObjects( std::vector<U32>& restoreList );
+	void restorePermanentObjects( const std::vector<U32>& restoreList );
+	void skipRenderingOfTerrain( bool flag );
+	void hideObject( const LLUUID& id );
+	void restoreHiddenObject( const LLUUID& id );
 
 private:
-    void unloadShaders();
-    void addToQuickLookup( LLDrawPool* new_poolp );
-    void removeFromQuickLookup( LLDrawPool* poolp );
-    bool updateDrawableGeom(LLDrawable* drawable, bool priority);
-    void assertInitializedDoError();
-    bool assertInitialized() { const bool is_init = isInit(); if (!is_init) assertInitializedDoError(); return is_init; };
-    void connectRefreshCachedSettingsSafe(const std::string name);
-    void hideDrawable( LLDrawable *pDrawable );
-    void unhideDrawable( LLDrawable *pDrawable );
+	void unloadShaders();
+	void addToQuickLookup( LLDrawPool* new_poolp );
+	void removeFromQuickLookup( LLDrawPool* poolp );
+	bool updateDrawableGeom(LLDrawable* drawable, bool priority);
+	void assertInitializedDoError();
+	bool assertInitialized() { const bool is_init = isInit(); if (!is_init) assertInitializedDoError(); return is_init; };
+	void connectRefreshCachedSettingsSafe(const std::string name);
+	void hideDrawable( LLDrawable *pDrawable );
+	void unhideDrawable( LLDrawable *pDrawable );
 public:
-    enum {GPU_CLASS_MAX = 3 };
-
-    enum LLRenderTypeMask
-    {
-        // Following are pool types (some are also object types)
-        RENDER_TYPE_SKY                         = LLDrawPool::POOL_SKY,
-        RENDER_TYPE_WL_SKY                      = LLDrawPool::POOL_WL_SKY,
-        RENDER_TYPE_GROUND                      = LLDrawPool::POOL_GROUND,  
-        RENDER_TYPE_TERRAIN                     = LLDrawPool::POOL_TERRAIN,
-        RENDER_TYPE_SIMPLE                      = LLDrawPool::POOL_SIMPLE,
-        RENDER_TYPE_GRASS                       = LLDrawPool::POOL_GRASS,
-        RENDER_TYPE_ALPHA_MASK                  = LLDrawPool::POOL_ALPHA_MASK,
-        RENDER_TYPE_FULLBRIGHT_ALPHA_MASK       = LLDrawPool::POOL_FULLBRIGHT_ALPHA_MASK,
-        RENDER_TYPE_FULLBRIGHT                  = LLDrawPool::POOL_FULLBRIGHT,
-        RENDER_TYPE_BUMP                        = LLDrawPool::POOL_BUMP,
-        RENDER_TYPE_MATERIALS                   = LLDrawPool::POOL_MATERIALS,
-        RENDER_TYPE_AVATAR                      = LLDrawPool::POOL_AVATAR,
-        RENDER_TYPE_TREE                        = LLDrawPool::POOL_TREE,
-        RENDER_TYPE_INVISIBLE                   = LLDrawPool::POOL_INVISIBLE,
-        RENDER_TYPE_VOIDWATER                   = LLDrawPool::POOL_VOIDWATER,
-        RENDER_TYPE_WATER                       = LLDrawPool::POOL_WATER,
-        RENDER_TYPE_ALPHA                       = LLDrawPool::POOL_ALPHA,
-        RENDER_TYPE_GLOW                        = LLDrawPool::POOL_GLOW,
-        RENDER_TYPE_PASS_SIMPLE                 = LLRenderPass::PASS_SIMPLE,
-        RENDER_TYPE_PASS_GRASS                  = LLRenderPass::PASS_GRASS,
-        RENDER_TYPE_PASS_FULLBRIGHT             = LLRenderPass::PASS_FULLBRIGHT,
-        RENDER_TYPE_PASS_INVISIBLE              = LLRenderPass::PASS_INVISIBLE,
-        RENDER_TYPE_PASS_INVISI_SHINY           = LLRenderPass::PASS_INVISI_SHINY,
-        RENDER_TYPE_PASS_FULLBRIGHT_SHINY       = LLRenderPass::PASS_FULLBRIGHT_SHINY,
-        RENDER_TYPE_PASS_SHINY                  = LLRenderPass::PASS_SHINY,
-        RENDER_TYPE_PASS_BUMP                   = LLRenderPass::PASS_BUMP,
-        RENDER_TYPE_PASS_POST_BUMP              = LLRenderPass::PASS_POST_BUMP,
-        RENDER_TYPE_PASS_GLOW                   = LLRenderPass::PASS_GLOW,
-        RENDER_TYPE_PASS_ALPHA                  = LLRenderPass::PASS_ALPHA,
-        RENDER_TYPE_PASS_ALPHA_MASK             = LLRenderPass::PASS_ALPHA_MASK,
-        RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK  = LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK,
-        RENDER_TYPE_PASS_MATERIAL               = LLRenderPass::PASS_MATERIAL,
-        RENDER_TYPE_PASS_MATERIAL_ALPHA         = LLRenderPass::PASS_MATERIAL_ALPHA,
-        RENDER_TYPE_PASS_MATERIAL_ALPHA_MASK    = LLRenderPass::PASS_MATERIAL_ALPHA_MASK,
-        RENDER_TYPE_PASS_MATERIAL_ALPHA_EMISSIVE= LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE,
-        RENDER_TYPE_PASS_SPECMAP                = LLRenderPass::PASS_SPECMAP,
-        RENDER_TYPE_PASS_SPECMAP_BLEND          = LLRenderPass::PASS_SPECMAP_BLEND,
-        RENDER_TYPE_PASS_SPECMAP_MASK           = LLRenderPass::PASS_SPECMAP_MASK,
-        RENDER_TYPE_PASS_SPECMAP_EMISSIVE       = LLRenderPass::PASS_SPECMAP_EMISSIVE,
-        RENDER_TYPE_PASS_NORMMAP                = LLRenderPass::PASS_NORMMAP,
-        RENDER_TYPE_PASS_NORMMAP_BLEND          = LLRenderPass::PASS_NORMMAP_BLEND,
-        RENDER_TYPE_PASS_NORMMAP_MASK           = LLRenderPass::PASS_NORMMAP_MASK,
-        RENDER_TYPE_PASS_NORMMAP_EMISSIVE       = LLRenderPass::PASS_NORMMAP_EMISSIVE,
-        RENDER_TYPE_PASS_NORMSPEC               = LLRenderPass::PASS_NORMSPEC,
-        RENDER_TYPE_PASS_NORMSPEC_BLEND         = LLRenderPass::PASS_NORMSPEC_BLEND,
-        RENDER_TYPE_PASS_NORMSPEC_MASK          = LLRenderPass::PASS_NORMSPEC_MASK,
-        RENDER_TYPE_PASS_NORMSPEC_EMISSIVE      = LLRenderPass::PASS_NORMSPEC_EMISSIVE,
-        // Following are object types (only used in drawable mRenderType)
-        RENDER_TYPE_HUD = LLRenderPass::NUM_RENDER_TYPES,
-        RENDER_TYPE_VOLUME,
-        RENDER_TYPE_PARTICLES,
-        RENDER_TYPE_CLOUDS,
-        RENDER_TYPE_HUD_PARTICLES,
-        NUM_RENDER_TYPES,
-        END_RENDER_TYPES = NUM_RENDER_TYPES
-    };
-
-    enum LLRenderDebugFeatureMask
-    {
-        RENDER_DEBUG_FEATURE_UI                 = 0x0001,
-        RENDER_DEBUG_FEATURE_SELECTED           = 0x0002,
-        RENDER_DEBUG_FEATURE_HIGHLIGHTED        = 0x0004,
-        RENDER_DEBUG_FEATURE_DYNAMIC_TEXTURES   = 0x0008,
-//      RENDER_DEBUG_FEATURE_HW_LIGHTING        = 0x0010,
-        RENDER_DEBUG_FEATURE_FLEXIBLE           = 0x0010,
-        RENDER_DEBUG_FEATURE_FOG                = 0x0020,
-        RENDER_DEBUG_FEATURE_FR_INFO            = 0x0080,
-        RENDER_DEBUG_FEATURE_FOOT_SHADOWS       = 0x0100,
-    };
-
-    enum LLRenderDebugMask: U64
-    {
-        RENDER_DEBUG_COMPOSITION        =  0x00000001,
-        RENDER_DEBUG_VERIFY             =  0x00000002,
-        RENDER_DEBUG_BBOXES             =  0x00000004,
-        RENDER_DEBUG_OCTREE             =  0x00000008,
-        RENDER_DEBUG_WIND_VECTORS       =  0x00000010,
-        RENDER_DEBUG_OCCLUSION          =  0x00000020,
-        RENDER_DEBUG_POINTS             =  0x00000040,
-        RENDER_DEBUG_TEXTURE_PRIORITY   =  0x00000080,
-        RENDER_DEBUG_TEXTURE_AREA       =  0x00000100,
-        RENDER_DEBUG_FACE_AREA          =  0x00000200,
-        RENDER_DEBUG_PARTICLES          =  0x00000400,
-        RENDER_DEBUG_GLOW               =  0x00000800, // not used
-        RENDER_DEBUG_TEXTURE_ANIM       =  0x00001000,
-        RENDER_DEBUG_LIGHTS             =  0x00002000,
-        RENDER_DEBUG_BATCH_SIZE         =  0x00004000,
-        RENDER_DEBUG_ALPHA_BINS         =  0x00008000, // not used
-        RENDER_DEBUG_RAYCAST            =  0x00010000,
-        RENDER_DEBUG_AVATAR_DRAW_INFO   =  0x00020000,
-        RENDER_DEBUG_SHADOW_FRUSTA      =  0x00040000,
-        RENDER_DEBUG_SCULPTED           =  0x00080000,
-        RENDER_DEBUG_AVATAR_VOLUME      =  0x00100000,
-        RENDER_DEBUG_AVATAR_JOINTS      =  0x00200000,
-        RENDER_DEBUG_BUILD_QUEUE        =  0x00400000,
-        RENDER_DEBUG_AGENT_TARGET       =  0x00800000,
-        RENDER_DEBUG_UPDATE_TYPE        =  0x01000000,
-        RENDER_DEBUG_PHYSICS_SHAPES     =  0x02000000,
-        RENDER_DEBUG_NORMALS            =  0x04000000,
-        RENDER_DEBUG_LOD_INFO           =  0x08000000,
-        RENDER_DEBUG_RENDER_COMPLEXITY  =  0x10000000,
-        RENDER_DEBUG_ATTACHMENT_BYTES   =  0x20000000, // not used
-        RENDER_DEBUG_TEXEL_DENSITY      =  0x40000000,
-        RENDER_DEBUG_TRIANGLE_COUNT     =  0x80000000,
-        RENDER_DEBUG_IMPOSTORS          = 0x100000000,
+	enum {GPU_CLASS_MAX = 3 };
+
+	enum LLRenderTypeMask
+	{
+		// Following are pool types (some are also object types)
+		RENDER_TYPE_SKY							= LLDrawPool::POOL_SKY,
+		RENDER_TYPE_WL_SKY						= LLDrawPool::POOL_WL_SKY,
+		RENDER_TYPE_GROUND						= LLDrawPool::POOL_GROUND,	
+		RENDER_TYPE_TERRAIN						= LLDrawPool::POOL_TERRAIN,
+		RENDER_TYPE_SIMPLE						= LLDrawPool::POOL_SIMPLE,
+		RENDER_TYPE_GRASS						= LLDrawPool::POOL_GRASS,
+		RENDER_TYPE_ALPHA_MASK					= LLDrawPool::POOL_ALPHA_MASK,
+		RENDER_TYPE_FULLBRIGHT_ALPHA_MASK		= LLDrawPool::POOL_FULLBRIGHT_ALPHA_MASK,
+		RENDER_TYPE_FULLBRIGHT					= LLDrawPool::POOL_FULLBRIGHT,
+		RENDER_TYPE_BUMP						= LLDrawPool::POOL_BUMP,
+		RENDER_TYPE_MATERIALS					= LLDrawPool::POOL_MATERIALS,
+		RENDER_TYPE_AVATAR						= LLDrawPool::POOL_AVATAR,
+		RENDER_TYPE_TREE						= LLDrawPool::POOL_TREE,
+		RENDER_TYPE_INVISIBLE					= LLDrawPool::POOL_INVISIBLE,
+		RENDER_TYPE_VOIDWATER					= LLDrawPool::POOL_VOIDWATER,
+		RENDER_TYPE_WATER						= LLDrawPool::POOL_WATER,
+ 		RENDER_TYPE_ALPHA						= LLDrawPool::POOL_ALPHA,
+		RENDER_TYPE_GLOW						= LLDrawPool::POOL_GLOW,
+		RENDER_TYPE_PASS_SIMPLE 				= LLRenderPass::PASS_SIMPLE,
+		RENDER_TYPE_PASS_GRASS					= LLRenderPass::PASS_GRASS,
+		RENDER_TYPE_PASS_FULLBRIGHT				= LLRenderPass::PASS_FULLBRIGHT,
+		RENDER_TYPE_PASS_INVISIBLE				= LLRenderPass::PASS_INVISIBLE,
+		RENDER_TYPE_PASS_INVISI_SHINY			= LLRenderPass::PASS_INVISI_SHINY,
+		RENDER_TYPE_PASS_FULLBRIGHT_SHINY		= LLRenderPass::PASS_FULLBRIGHT_SHINY,
+		RENDER_TYPE_PASS_SHINY					= LLRenderPass::PASS_SHINY,
+		RENDER_TYPE_PASS_BUMP					= LLRenderPass::PASS_BUMP,
+		RENDER_TYPE_PASS_POST_BUMP				= LLRenderPass::PASS_POST_BUMP,
+		RENDER_TYPE_PASS_GLOW					= LLRenderPass::PASS_GLOW,
+		RENDER_TYPE_PASS_ALPHA					= LLRenderPass::PASS_ALPHA,
+		RENDER_TYPE_PASS_ALPHA_MASK				= LLRenderPass::PASS_ALPHA_MASK,
+		RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK	= LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK,
+		RENDER_TYPE_PASS_MATERIAL				= LLRenderPass::PASS_MATERIAL,
+		RENDER_TYPE_PASS_MATERIAL_ALPHA			= LLRenderPass::PASS_MATERIAL_ALPHA,
+		RENDER_TYPE_PASS_MATERIAL_ALPHA_MASK	= LLRenderPass::PASS_MATERIAL_ALPHA_MASK,
+		RENDER_TYPE_PASS_MATERIAL_ALPHA_EMISSIVE= LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE,
+		RENDER_TYPE_PASS_SPECMAP				= LLRenderPass::PASS_SPECMAP,
+		RENDER_TYPE_PASS_SPECMAP_BLEND			= LLRenderPass::PASS_SPECMAP_BLEND,
+		RENDER_TYPE_PASS_SPECMAP_MASK			= LLRenderPass::PASS_SPECMAP_MASK,
+		RENDER_TYPE_PASS_SPECMAP_EMISSIVE		= LLRenderPass::PASS_SPECMAP_EMISSIVE,
+		RENDER_TYPE_PASS_NORMMAP				= LLRenderPass::PASS_NORMMAP,
+		RENDER_TYPE_PASS_NORMMAP_BLEND			= LLRenderPass::PASS_NORMMAP_BLEND,
+		RENDER_TYPE_PASS_NORMMAP_MASK			= LLRenderPass::PASS_NORMMAP_MASK,
+		RENDER_TYPE_PASS_NORMMAP_EMISSIVE		= LLRenderPass::PASS_NORMMAP_EMISSIVE,
+		RENDER_TYPE_PASS_NORMSPEC				= LLRenderPass::PASS_NORMSPEC,
+		RENDER_TYPE_PASS_NORMSPEC_BLEND			= LLRenderPass::PASS_NORMSPEC_BLEND,
+		RENDER_TYPE_PASS_NORMSPEC_MASK			= LLRenderPass::PASS_NORMSPEC_MASK,
+		RENDER_TYPE_PASS_NORMSPEC_EMISSIVE		= LLRenderPass::PASS_NORMSPEC_EMISSIVE,
+		// Following are object types (only used in drawable mRenderType)
+		RENDER_TYPE_HUD = LLRenderPass::NUM_RENDER_TYPES,
+		RENDER_TYPE_VOLUME,
+		RENDER_TYPE_PARTICLES,
+		RENDER_TYPE_CLOUDS,
+		RENDER_TYPE_HUD_PARTICLES,
+		NUM_RENDER_TYPES,
+		END_RENDER_TYPES = NUM_RENDER_TYPES
+	};
+
+	enum LLRenderDebugFeatureMask
+	{
+		RENDER_DEBUG_FEATURE_UI					= 0x0001,
+		RENDER_DEBUG_FEATURE_SELECTED			= 0x0002,
+		RENDER_DEBUG_FEATURE_HIGHLIGHTED		= 0x0004,
+		RENDER_DEBUG_FEATURE_DYNAMIC_TEXTURES	= 0x0008,
+// 		RENDER_DEBUG_FEATURE_HW_LIGHTING		= 0x0010,
+		RENDER_DEBUG_FEATURE_FLEXIBLE			= 0x0010,
+		RENDER_DEBUG_FEATURE_FOG				= 0x0020,
+		RENDER_DEBUG_FEATURE_FR_INFO			= 0x0080,
+		RENDER_DEBUG_FEATURE_FOOT_SHADOWS		= 0x0100,
+	};
+
+	enum LLRenderDebugMask: U64
+	{
+		RENDER_DEBUG_COMPOSITION		=  0x00000001,
+		RENDER_DEBUG_VERIFY				=  0x00000002,
+		RENDER_DEBUG_BBOXES				=  0x00000004,
+		RENDER_DEBUG_OCTREE				=  0x00000008,
+		RENDER_DEBUG_WIND_VECTORS		=  0x00000010,
+		RENDER_DEBUG_OCCLUSION			=  0x00000020,
+		RENDER_DEBUG_POINTS				=  0x00000040,
+		RENDER_DEBUG_TEXTURE_PRIORITY	=  0x00000080,
+		RENDER_DEBUG_TEXTURE_AREA		=  0x00000100,
+		RENDER_DEBUG_FACE_AREA			=  0x00000200,
+		RENDER_DEBUG_PARTICLES			=  0x00000400,
+		RENDER_DEBUG_GLOW				=  0x00000800, // not used
+		RENDER_DEBUG_TEXTURE_ANIM		=  0x00001000,
+		RENDER_DEBUG_LIGHTS				=  0x00002000,
+		RENDER_DEBUG_BATCH_SIZE			=  0x00004000,
+		RENDER_DEBUG_ALPHA_BINS			=  0x00008000, // not used
+		RENDER_DEBUG_RAYCAST            =  0x00010000,
+		RENDER_DEBUG_AVATAR_DRAW_INFO	=  0x00020000,
+		RENDER_DEBUG_SHADOW_FRUSTA		=  0x00040000,
+		RENDER_DEBUG_SCULPTED           =  0x00080000,
+		RENDER_DEBUG_AVATAR_VOLUME      =  0x00100000,
+		RENDER_DEBUG_AVATAR_JOINTS      =  0x00200000,
+		RENDER_DEBUG_BUILD_QUEUE		=  0x00400000,
+		RENDER_DEBUG_AGENT_TARGET       =  0x00800000,
+		RENDER_DEBUG_UPDATE_TYPE		=  0x01000000,
+		RENDER_DEBUG_PHYSICS_SHAPES     =  0x02000000,
+		RENDER_DEBUG_NORMALS	        =  0x04000000,
+		RENDER_DEBUG_LOD_INFO	        =  0x08000000,
+		RENDER_DEBUG_RENDER_COMPLEXITY  =  0x10000000,
+		RENDER_DEBUG_ATTACHMENT_BYTES	=  0x20000000, // not used
+		RENDER_DEBUG_TEXEL_DENSITY		=  0x40000000,
+		RENDER_DEBUG_TRIANGLE_COUNT		=  0x80000000,
+		RENDER_DEBUG_IMPOSTORS			= 0x100000000,
         RENDER_DEBUG_SH                  = 0x200000000,
-    };
+	};
 
 public:
-    
-    LLSpatialPartition* getSpatialPartition(LLViewerObject* vobj);
-
-    void updateCamera(bool reset = false);
-    
-    LLVector3               mFlyCamPosition;
-    LLQuaternion            mFlyCamRotation;
-
-    bool                     mBackfaceCull;
-    S32                      mMatrixOpCount;
-    S32                      mTextureMatrixOps;
-    S32                      mNumVisibleNodes;
-
-    S32                      mDebugTextureUploadCost;
-    S32                      mDebugSculptUploadCost;
-    S32                      mDebugMeshUploadCost;
-
-    S32                      mNumVisibleFaces;
-
-    static S32              sCompiles;
-
-    static bool             sShowHUDAttachments;
-    static bool             sForceOldBakedUpload; // If true will not use capabilities to upload baked textures.
-    static S32              sUseOcclusion;  // 0 = no occlusion, 1 = read only, 2 = read/write
-    static bool             sDelayVBUpdate;
-    static bool             sAutoMaskAlphaDeferred;
-    static bool             sAutoMaskAlphaNonDeferred;
-    static bool             sDisableShaders; // if true, rendering will be done without shaders
-    static bool             sRenderBump;
-    static bool             sBakeSunlight;
-    static bool             sNoAlpha;
-    static bool             sUseTriStrips;
-    static bool             sUseFarClip;
-    static bool             sShadowRender;
-    static bool             sWaterReflections;
-    static bool             sDynamicLOD;
-    static bool             sPickAvatar;
-    static bool             sReflectionRender;
-    static bool             sDistortionRender;
-    static bool             sImpostorRender;
-    static bool             sImpostorRenderAlphaDepthPass;
-    static bool             sUnderWaterRender;
-    static bool             sRenderGlow;
-    static bool             sTextureBindTest;
-    static bool             sRenderFrameTest;
-    static bool             sRenderAttachedLights;
-    static bool             sRenderAttachedParticles;
-    static bool             sRenderDeferred;
-    static bool             sMemAllocationThrottled;
-    static S32              sVisibleLightCount;
-    static F32              sMinRenderSize;
-    static bool             sRenderingHUDs;
+	
+	LLSpatialPartition* getSpatialPartition(LLViewerObject* vobj);
+
+	void updateCamera(bool reset = false);
+	
+	LLVector3				mFlyCamPosition;
+	LLQuaternion			mFlyCamRotation;
+
+	bool					 mBackfaceCull;
+	S32						 mMatrixOpCount;
+	S32						 mTextureMatrixOps;
+	S32						 mNumVisibleNodes;
+
+	S32						 mDebugTextureUploadCost;
+	S32						 mDebugSculptUploadCost;
+	S32						 mDebugMeshUploadCost;
+
+	S32						 mNumVisibleFaces;
+
+	static S32				sCompiles;
+
+	static bool				sShowHUDAttachments;
+	static bool				sForceOldBakedUpload; // If true will not use capabilities to upload baked textures.
+	static S32				sUseOcclusion;  // 0 = no occlusion, 1 = read only, 2 = read/write
+	static bool				sDelayVBUpdate;
+	static bool				sAutoMaskAlphaDeferred;
+	static bool				sAutoMaskAlphaNonDeferred;
+	static bool				sDisableShaders; // if true, rendering will be done without shaders
+	static bool				sRenderBump;
+	static bool				sBakeSunlight;
+	static bool				sNoAlpha;
+	static bool				sUseTriStrips;
+	static bool				sUseFarClip;
+	static bool				sShadowRender;
+	static bool				sWaterReflections;
+	static bool				sDynamicLOD;
+	static bool				sPickAvatar;
+	static bool				sReflectionRender;
+    static bool				sDistortionRender;
+	static bool				sImpostorRender;
+	static bool				sImpostorRenderAlphaDepthPass;
+	static bool				sUnderWaterRender;
+	static bool				sRenderGlow;
+	static bool				sTextureBindTest;
+	static bool				sRenderFrameTest;
+	static bool				sRenderAttachedLights;
+	static bool				sRenderAttachedParticles;
+	static bool				sRenderDeferred;
+	static bool             sMemAllocationThrottled;
+	static S32				sVisibleLightCount;
+	static F32				sMinRenderSize;
+	static bool				sRenderingHUDs;
     static F32              sDistortionWaterClipPlaneMargin;
 
-    static LLTrace::EventStatHandle<S64> sStatBatchSize;
-
-    //screen texture
-    U32                     mScreenWidth;
-    U32                     mScreenHeight;
-    
-    LLRenderTarget          mScreen;
-    LLRenderTarget          mUIScreen;
-    LLRenderTarget          mDeferredScreen;
-    LLRenderTarget          mFXAABuffer;
-    LLRenderTarget          mEdgeMap;
-    LLRenderTarget          mDeferredDepth;
-    LLRenderTarget          mOcclusionDepth;
-    LLRenderTarget          mDeferredLight;
-    LLRenderTarget          mHighlight;
-    LLRenderTarget          mPhysicsDisplay;
+	static LLTrace::EventStatHandle<S64> sStatBatchSize;
+
+	//screen texture
+	U32 					mScreenWidth;
+	U32 					mScreenHeight;
+	
+	LLRenderTarget			mScreen;
+	LLRenderTarget			mUIScreen;
+	LLRenderTarget			mDeferredScreen;
+	LLRenderTarget			mFXAABuffer;
+	LLRenderTarget			mEdgeMap;
+	LLRenderTarget			mDeferredDepth;
+	LLRenderTarget			mOcclusionDepth;
+	LLRenderTarget			mDeferredLight;
+	LLRenderTarget			mHighlight;
+	LLRenderTarget			mPhysicsDisplay;
 
     LLCullResult            mSky;
     LLCullResult            mReflectedObjects;
     LLCullResult            mRefractedObjects;
 
-    //utility buffer for rendering post effects, gets abused by renderDeferredLighting
-    LLPointer<LLVertexBuffer> mDeferredVB;
-
-    //utility buffer for rendering cubes, 8 vertices are corners of a cube [-1, 1]
-    LLPointer<LLVertexBuffer> mCubeVB;
-
-    //sun shadow map
-    LLRenderTarget          mShadow[6];
-    LLRenderTarget          mShadowOcclusion[6];
-
-    std::vector<LLVector3>  mShadowFrustPoints[4];
-    LLVector4               mShadowError;
-    LLVector4               mShadowFOV;
-    LLVector3               mShadowFrustOrigin[4];
-    LLCamera                mShadowCamera[8];
-    LLVector3               mShadowExtents[4][2];
-    glh::matrix4f           mSunShadowMatrix[6];
-    glh::matrix4f           mShadowModelview[6];
-    glh::matrix4f           mShadowProjection[6];
+	//utility buffer for rendering post effects, gets abused by renderDeferredLighting
+	LLPointer<LLVertexBuffer> mDeferredVB;
+
+	//utility buffer for rendering cubes, 8 vertices are corners of a cube [-1, 1]
+	LLPointer<LLVertexBuffer> mCubeVB;
+
+	//sun shadow map
+	LLRenderTarget			mShadow[6];
+	LLRenderTarget			mShadowOcclusion[6];
+
+	std::vector<LLVector3>  mShadowFrustPoints[4];
+	LLVector4			    mShadowError;
+	LLVector4			    mShadowFOV;
+	LLVector3			    mShadowFrustOrigin[4];
+	LLCamera			    mShadowCamera[8];
+	LLVector3			    mShadowExtents[4][2];
+	glh::matrix4f			mSunShadowMatrix[6];
+	glh::matrix4f			mShadowModelview[6];
+	glh::matrix4f			mShadowProjection[6];
     glh::matrix4f           mReflectionModelView;
 
-    LLPointer<LLDrawable>   mShadowSpotLight[2];
-    F32                     mSpotLightFade[2];
-    LLPointer<LLDrawable>   mTargetShadowSpotLight[2];
+	LLPointer<LLDrawable>	mShadowSpotLight[2];
+	F32						mSpotLightFade[2];
+	LLPointer<LLDrawable>	mTargetShadowSpotLight[2];
 
-    LLVector4               mSunClipPlanes;
-    LLVector4               mSunOrthoClipPlanes;
-    LLVector2               mScreenScale;
+	LLVector4				mSunClipPlanes;
+	LLVector4				mSunOrthoClipPlanes;
+	LLVector2				mScreenScale;
 
-    //water reflection texture
-    LLRenderTarget              mWaterRef;
+	//water reflection texture
+	LLRenderTarget				mWaterRef;
 
-    //water distortion texture (refraction)
-    LLRenderTarget              mWaterDis;
+	//water distortion texture (refraction)
+	LLRenderTarget				mWaterDis;
 
-    //texture for making the glow
-    LLRenderTarget              mGlow[3];
+	//texture for making the glow
+	LLRenderTarget				mGlow[3];
 
-    //noise map
-    U32                 mNoiseMap;
-    U32                 mTrueNoiseMap;
-    U32                 mLightFunc;
+	//noise map
+	U32					mNoiseMap;
+	U32					mTrueNoiseMap;
+	U32					mLightFunc;
 
-    LLColor4            mSunDiffuse;
-    LLColor4            mMoonDiffuse;
-    LLVector4           mSunDir;
-    LLVector4           mMoonDir;
+	LLColor4			mSunDiffuse;
+    LLColor4			mMoonDiffuse;
+	LLVector4			mSunDir;
+    LLVector4			mMoonDir;
     bool                mNeedsShadowTargetClear;
 
-    LLVector4           mTransformedSunDir;
-    LLVector4           mTransformedMoonDir;
+	LLVector4			mTransformedSunDir;
+    LLVector4			mTransformedMoonDir;
 
-    bool                    mInitialized;
-    bool                    mVertexShadersEnabled;
-    S32                     mVertexShadersLoaded; // 0 = no, 1 = yes, -1 = failed
+	bool					mInitialized;
+	bool					mVertexShadersEnabled;
+	S32						mVertexShadersLoaded; // 0 = no, 1 = yes, -1 = failed
 
-    U32                     mTransformFeedbackPrimitives; //number of primitives expected to be generated by transform feedback
+	U32						mTransformFeedbackPrimitives; //number of primitives expected to be generated by transform feedback
 protected:
-    bool                    mRenderTypeEnabled[NUM_RENDER_TYPES];
-    std::stack<std::string> mRenderTypeEnableStack;
-
-    U32                     mRenderDebugFeatureMask;
-    U64                     mRenderDebugMask;
-    U64                     mOldRenderDebugMask;
-    std::stack<U32>         mRenderDebugFeatureStack;
-
-    
-    /////////////////////////////////////////////
-    //
-    //
-    LLDrawable::drawable_vector_t   mMovedList;
-    LLDrawable::drawable_vector_t mMovedBridge;
-    LLDrawable::drawable_vector_t   mShiftList;
-
-    /////////////////////////////////////////////
-    //
-    //
-    struct Light
-    {
-        Light(LLDrawable* ptr, F32 d, F32 f = 0.0f)
-            : drawable(ptr),
-              dist(d),
-              fade(f)
-        {}
-        LLPointer<LLDrawable> drawable;
-        F32 dist;
-        F32 fade;
-        struct compare
-        {
-            bool operator()(const Light& a, const Light& b) const
-            {
-                if ( a.dist < b.dist )
-                    return true;
-                else if ( a.dist > b.dist )
-                    return false;
-                else
-                    return a.drawable < b.drawable;
-            }
-        };
-    };
-    typedef std::set< Light, Light::compare > light_set_t;
-    
-    LLDrawable::drawable_set_t      mLights;
-    light_set_t                     mNearbyLights; // lights near camera
-    LLColor4                        mHWLightColors[8];
-    
-    /////////////////////////////////////////////
-    //
-    // Different queues of drawables being processed.
-    //
-    LLDrawable::drawable_list_t     mBuildQ1; // priority
-    LLDrawable::drawable_list_t     mBuildQ2; // non-priority
-    LLSpatialGroup::sg_vector_t     mGroupQ1; //priority
-    LLSpatialGroup::sg_vector_t     mGroupQ2; // non-priority
-
-    LLSpatialGroup::sg_vector_t     mGroupSaveQ1; // a place to save mGroupQ1 until it is safe to unref
-
-    LLSpatialGroup::sg_vector_t     mMeshDirtyGroup; //groups that need rebuildMesh called
-    U32 mMeshDirtyQueryObject;
-
-    LLDrawable::drawable_list_t     mPartitionQ; //drawables that need to update their spatial partition radius 
-
-    bool mGroupQ2Locked;
-    bool mGroupQ1Locked;
-
-    bool mResetVertexBuffers; //if true, clear vertex buffers on next update
-
-    LLViewerObject::vobj_list_t     mCreateQ;
-        
-    LLDrawable::drawable_set_t      mRetexturedList;
-
-    class HighlightItem
-    {
-    public:
-        const LLPointer<LLDrawable> mItem;
-        mutable F32 mFade;
-
-        HighlightItem(LLDrawable* item)
-        : mItem(item), mFade(0)
-        {
-        }
-
-        bool operator<(const HighlightItem& rhs) const
-        {
-            return mItem < rhs.mItem;
-        }
-
-        bool operator==(const HighlightItem& rhs) const
-        {
-            return mItem == rhs.mItem;
-        }
-
-        void incrFade(F32 val) const
-        {
-            mFade = llclamp(mFade+val, 0.f, 1.f);
-        }
-    };
-
-    std::set<HighlightItem> mHighlightSet;
-    LLPointer<LLDrawable> mHighlightObject;
-
-    //////////////////////////////////////////////////
-    //
-    // Draw pools are responsible for storing all rendered data,
-    // and performing the actual rendering of objects.
-    //
-    struct compare_pools
-    {
-        bool operator()(const LLDrawPool* a, const LLDrawPool* b) const
-        {
-            if (!a)
-                return true;
-            else if (!b)
-                return false;
-            else
-            {
-                S32 atype = a->getType();
-                S32 btype = b->getType();
-                if (atype < btype)
-                    return true;
-                else if (atype > btype)
-                    return false;
-                else
-                    return a->getId() < b->getId();
-            }
-        }
-    };
-    typedef std::set<LLDrawPool*, compare_pools > pool_set_t;
-    pool_set_t mPools;
-    LLDrawPool* mLastRebuildPool;
-    
-    // For quick-lookups into mPools (mapped by texture pointer)
-    std::map<uintptr_t, LLDrawPool*>    mTerrainPools;
-    std::map<uintptr_t, LLDrawPool*>    mTreePools;
-    LLDrawPoolAlpha*            mAlphaPool;
-    LLDrawPool*                 mSkyPool;
-    LLDrawPool*                 mTerrainPool;
-    LLDrawPool*                 mWaterPool;
-    LLDrawPool*                 mGroundPool;
-    LLRenderPass*               mSimplePool;
-    LLRenderPass*               mGrassPool;
-    LLRenderPass*               mAlphaMaskPool;
-    LLRenderPass*               mFullbrightAlphaMaskPool;
-    LLRenderPass*               mFullbrightPool;
-    LLDrawPool*                 mInvisiblePool;
-    LLDrawPool*                 mGlowPool;
-    LLDrawPool*                 mBumpPool;
-    LLDrawPool*                 mMaterialsPool;
-    LLDrawPool*                 mWLSkyPool;
-    // Note: no need to keep an quick-lookup to avatar pools, since there's only one per avatar
-    
+	bool					mRenderTypeEnabled[NUM_RENDER_TYPES];
+	std::stack<std::string> mRenderTypeEnableStack;
+
+	U32						mRenderDebugFeatureMask;
+	U64						mRenderDebugMask;
+	U64						mOldRenderDebugMask;
+	std::stack<U32>			mRenderDebugFeatureStack;
+
+	
+	/////////////////////////////////////////////
+	//
+	//
+	LLDrawable::drawable_vector_t	mMovedList;
+	LLDrawable::drawable_vector_t mMovedBridge;
+	LLDrawable::drawable_vector_t	mShiftList;
+
+	/////////////////////////////////////////////
+	//
+	//
+	struct Light
+	{
+		Light(LLDrawable* ptr, F32 d, F32 f = 0.0f)
+			: drawable(ptr),
+			  dist(d),
+			  fade(f)
+		{}
+		LLPointer<LLDrawable> drawable;
+		F32 dist;
+		F32 fade;
+		struct compare
+		{
+			bool operator()(const Light& a, const Light& b) const
+			{
+				if ( a.dist < b.dist )
+					return true;
+				else if ( a.dist > b.dist )
+					return false;
+				else
+					return a.drawable < b.drawable;
+			}
+		};
+	};
+	typedef std::set< Light, Light::compare > light_set_t;
+	
+	LLDrawable::drawable_set_t		mLights;
+	light_set_t						mNearbyLights; // lights near camera
+	LLColor4						mHWLightColors[8];
+	
+	/////////////////////////////////////////////
+	//
+	// Different queues of drawables being processed.
+	//
+	LLDrawable::drawable_list_t 	mBuildQ1; // priority
+	LLDrawable::drawable_list_t 	mBuildQ2; // non-priority
+	LLSpatialGroup::sg_vector_t		mGroupQ1; //priority
+	LLSpatialGroup::sg_vector_t		mGroupQ2; // non-priority
+
+	LLSpatialGroup::sg_vector_t		mGroupSaveQ1; // a place to save mGroupQ1 until it is safe to unref
+
+	LLSpatialGroup::sg_vector_t		mMeshDirtyGroup; //groups that need rebuildMesh called
+	U32 mMeshDirtyQueryObject;
+
+	LLDrawable::drawable_list_t		mPartitionQ; //drawables that need to update their spatial partition radius 
+
+	bool mGroupQ2Locked;
+	bool mGroupQ1Locked;
+
+	bool mResetVertexBuffers; //if true, clear vertex buffers on next update
+
+	LLViewerObject::vobj_list_t		mCreateQ;
+		
+	LLDrawable::drawable_set_t		mRetexturedList;
+
+	class HighlightItem
+	{
+	public:
+		const LLPointer<LLDrawable> mItem;
+		mutable F32 mFade;
+
+		HighlightItem(LLDrawable* item)
+		: mItem(item), mFade(0)
+		{
+		}
+
+		bool operator<(const HighlightItem& rhs) const
+		{
+			return mItem < rhs.mItem;
+		}
+
+		bool operator==(const HighlightItem& rhs) const
+		{
+			return mItem == rhs.mItem;
+		}
+
+		void incrFade(F32 val) const
+		{
+			mFade = llclamp(mFade+val, 0.f, 1.f);
+		}
+	};
+
+	std::set<HighlightItem> mHighlightSet;
+	LLPointer<LLDrawable> mHighlightObject;
+
+	//////////////////////////////////////////////////
+	//
+	// Draw pools are responsible for storing all rendered data,
+	// and performing the actual rendering of objects.
+	//
+	struct compare_pools
+	{
+		bool operator()(const LLDrawPool* a, const LLDrawPool* b) const
+		{
+			if (!a)
+				return true;
+			else if (!b)
+				return false;
+			else
+			{
+				S32 atype = a->getType();
+				S32 btype = b->getType();
+				if (atype < btype)
+					return true;
+				else if (atype > btype)
+					return false;
+				else
+					return a->getId() < b->getId();
+			}
+		}
+	};
+ 	typedef std::set<LLDrawPool*, compare_pools > pool_set_t;
+	pool_set_t mPools;
+	LLDrawPool*	mLastRebuildPool;
+	
+	// For quick-lookups into mPools (mapped by texture pointer)
+	std::map<uintptr_t, LLDrawPool*>	mTerrainPools;
+	std::map<uintptr_t, LLDrawPool*>	mTreePools;
+	LLDrawPoolAlpha*			mAlphaPool;
+	LLDrawPool*					mSkyPool;
+	LLDrawPool*					mTerrainPool;
+	LLDrawPool*					mWaterPool;
+	LLDrawPool*					mGroundPool;
+	LLRenderPass*				mSimplePool;
+	LLRenderPass*				mGrassPool;
+	LLRenderPass*				mAlphaMaskPool;
+	LLRenderPass*				mFullbrightAlphaMaskPool;
+	LLRenderPass*				mFullbrightPool;
+	LLDrawPool*					mInvisiblePool;
+	LLDrawPool*					mGlowPool;
+	LLDrawPool*					mBumpPool;
+	LLDrawPool*					mMaterialsPool;
+	LLDrawPool*					mWLSkyPool;
+	// Note: no need to keep an quick-lookup to avatar pools, since there's only one per avatar
+	
 public:
-    std::vector<LLFace*>        mHighlightFaces;    // highlight faces on physical objects
+	std::vector<LLFace*>		mHighlightFaces;	// highlight faces on physical objects
 protected:
-    std::vector<LLFace*>        mSelectedFaces;
-
-    class DebugBlip
-    {
-    public:
-        LLColor4 mColor;
-        LLVector3 mPosition;
-        F32 mAge;
-
-        DebugBlip(const LLVector3& position, const LLColor4& color)
-            : mColor(color), mPosition(position), mAge(0.f)
-        { }
-    };
-
-    std::list<DebugBlip> mDebugBlips;
-
-    LLPointer<LLViewerFetchedTexture>   mFaceSelectImagep;
-    
-    U32                     mLightMask;
-    U32                     mLightMovingMask;
-    S32                     mLightingDetail;
-        
-    static bool             sRenderPhysicalBeacons;
-    static bool             sRenderMOAPBeacons;
-    static bool             sRenderScriptedTouchBeacons;
-    static bool             sRenderScriptedBeacons;
-    static bool             sRenderParticleBeacons;
-    static bool             sRenderSoundBeacons;
+	std::vector<LLFace*>		mSelectedFaces;
+
+	class DebugBlip
+	{
+	public:
+		LLColor4 mColor;
+		LLVector3 mPosition;
+		F32 mAge;
+
+		DebugBlip(const LLVector3& position, const LLColor4& color)
+			: mColor(color), mPosition(position), mAge(0.f)
+		{ }
+	};
+
+	std::list<DebugBlip> mDebugBlips;
+
+	LLPointer<LLViewerFetchedTexture>	mFaceSelectImagep;
+	
+	U32						mLightMask;
+	U32						mLightMovingMask;
+	S32						mLightingDetail;
+		
+	static bool				sRenderPhysicalBeacons;
+	static bool				sRenderMOAPBeacons;
+	static bool				sRenderScriptedTouchBeacons;
+	static bool				sRenderScriptedBeacons;
+	static bool				sRenderParticleBeacons;
+	static bool				sRenderSoundBeacons;
 public:
-    static bool             sRenderBeacons;
-    static bool             sRenderHighlight;
-
-    // Determines which set of UVs to use in highlight display
-    //
-    static LLRender::eTexIndex sRenderHighlightTextureChannel;
-
-    //debug use
-    static U32              sCurRenderPoolType ;
-
-    //cached settings
-    static bool WindLightUseAtmosShaders;
-    static bool VertexShaderEnable;
-    static bool RenderAvatarVP;
-    static bool RenderDeferred;
-    static F32 RenderDeferredSunWash;
-    static U32 RenderFSAASamples;
-    static U32 RenderResolutionDivisor;
-    static bool RenderUIBuffer;
-    static S32 RenderShadowDetail;
-    static bool RenderDeferredSSAO;
-    static F32 RenderShadowResolutionScale;
-    static bool RenderLocalLights;
-    static bool RenderDelayCreation;
-    static bool RenderAnimateRes;
-    static bool FreezeTime;
-    static S32 DebugBeaconLineWidth;
-    static F32 RenderHighlightBrightness;
-    static LLColor4 RenderHighlightColor;
-    static F32 RenderHighlightThickness;
-    static bool RenderSpotLightsInNondeferred;
-    static LLColor4 PreviewAmbientColor;
-    static LLColor4 PreviewDiffuse0;
-    static LLColor4 PreviewSpecular0;
-    static LLColor4 PreviewDiffuse1;
-    static LLColor4 PreviewSpecular1;
-    static LLColor4 PreviewDiffuse2;
-    static LLColor4 PreviewSpecular2;
-    static LLVector3 PreviewDirection0;
-    static LLVector3 PreviewDirection1;
-    static LLVector3 PreviewDirection2;
-    static F32 RenderGlowMinLuminance;
-    static F32 RenderGlowMaxExtractAlpha;
-    static F32 RenderGlowWarmthAmount;
-    static LLVector3 RenderGlowLumWeights;
-    static LLVector3 RenderGlowWarmthWeights;
-    static S32 RenderGlowResolutionPow;
-    static S32 RenderGlowIterations;
-    static F32 RenderGlowWidth;
-    static F32 RenderGlowStrength;
-    static bool RenderDepthOfField;
-    static bool RenderDepthOfFieldInEditMode;
-    static F32 CameraFocusTransitionTime;
-    static F32 CameraFNumber;
-    static F32 CameraFocalLength;
-    static F32 CameraFieldOfView;
-    static F32 RenderShadowNoise;
-    static F32 RenderShadowBlurSize;
-    static F32 RenderSSAOScale;
-    static U32 RenderSSAOMaxScale;
-    static F32 RenderSSAOFactor;
-    static LLVector3 RenderSSAOEffect;
-    static F32 RenderShadowOffsetError;
-    static F32 RenderShadowBiasError;
-    static F32 RenderShadowOffset;
-    static F32 RenderShadowBias;
-    static F32 RenderSpotShadowOffset;
-    static F32 RenderSpotShadowBias;
-    static F32 RenderEdgeDepthCutoff;
-    static F32 RenderEdgeNormCutoff;
-    static LLVector3 RenderShadowGaussian;
-    static F32 RenderShadowBlurDistFactor;
-    static bool RenderDeferredAtmospheric;
-    static S32 RenderReflectionDetail;
-    static F32 RenderHighlightFadeTime;
-    static LLVector3 RenderShadowClipPlanes;
-    static LLVector3 RenderShadowOrthoClipPlanes;
-    static LLVector3 RenderShadowNearDist;
-    static F32 RenderFarClip;
-    static LLVector3 RenderShadowSplitExponent;
-    static F32 RenderShadowErrorCutoff;
-    static F32 RenderShadowFOVCutoff;
-    static bool CameraOffset;
-    static F32 CameraMaxCoF;
-    static F32 CameraDoFResScale;
-    static F32 RenderAutoHideSurfaceAreaLimit;
+	static bool				sRenderBeacons;
+	static bool				sRenderHighlight;
+
+	// Determines which set of UVs to use in highlight display
+	//
+	static LLRender::eTexIndex sRenderHighlightTextureChannel;
+
+	//debug use
+	static U32              sCurRenderPoolType ;
+
+	//cached settings
+	static bool WindLightUseAtmosShaders;
+	static bool VertexShaderEnable;
+	static bool RenderAvatarVP;
+	static bool RenderDeferred;
+	static F32 RenderDeferredSunWash;
+	static U32 RenderFSAASamples;
+	static U32 RenderResolutionDivisor;
+	static bool RenderUIBuffer;
+	static S32 RenderShadowDetail;
+	static bool RenderDeferredSSAO;
+	static F32 RenderShadowResolutionScale;
+	static bool RenderLocalLights;
+	static bool RenderDelayCreation;
+	static bool RenderAnimateRes;
+	static bool FreezeTime;
+	static S32 DebugBeaconLineWidth;
+	static F32 RenderHighlightBrightness;
+	static LLColor4 RenderHighlightColor;
+	static F32 RenderHighlightThickness;
+	static bool RenderSpotLightsInNondeferred;
+	static LLColor4 PreviewAmbientColor;
+	static LLColor4 PreviewDiffuse0;
+	static LLColor4 PreviewSpecular0;
+	static LLColor4 PreviewDiffuse1;
+	static LLColor4 PreviewSpecular1;
+	static LLColor4 PreviewDiffuse2;
+	static LLColor4 PreviewSpecular2;
+	static LLVector3 PreviewDirection0;
+	static LLVector3 PreviewDirection1;
+	static LLVector3 PreviewDirection2;
+	static F32 RenderGlowMinLuminance;
+	static F32 RenderGlowMaxExtractAlpha;
+	static F32 RenderGlowWarmthAmount;
+	static LLVector3 RenderGlowLumWeights;
+	static LLVector3 RenderGlowWarmthWeights;
+	static S32 RenderGlowResolutionPow;
+	static S32 RenderGlowIterations;
+	static F32 RenderGlowWidth;
+	static F32 RenderGlowStrength;
+	static bool RenderDepthOfField;
+	static bool RenderDepthOfFieldInEditMode;
+	static F32 CameraFocusTransitionTime;
+	static F32 CameraFNumber;
+	static F32 CameraFocalLength;
+	static F32 CameraFieldOfView;
+	static F32 RenderShadowNoise;
+	static F32 RenderShadowBlurSize;
+	static F32 RenderSSAOScale;
+	static U32 RenderSSAOMaxScale;
+	static F32 RenderSSAOFactor;
+	static LLVector3 RenderSSAOEffect;
+	static F32 RenderShadowOffsetError;
+	static F32 RenderShadowBiasError;
+	static F32 RenderShadowOffset;
+	static F32 RenderShadowBias;
+	static F32 RenderSpotShadowOffset;
+	static F32 RenderSpotShadowBias;
+	static F32 RenderEdgeDepthCutoff;
+	static F32 RenderEdgeNormCutoff;
+	static LLVector3 RenderShadowGaussian;
+	static F32 RenderShadowBlurDistFactor;
+	static bool RenderDeferredAtmospheric;
+	static S32 RenderReflectionDetail;
+	static F32 RenderHighlightFadeTime;
+	static LLVector3 RenderShadowClipPlanes;
+	static LLVector3 RenderShadowOrthoClipPlanes;
+	static LLVector3 RenderShadowNearDist;
+	static F32 RenderFarClip;
+	static LLVector3 RenderShadowSplitExponent;
+	static F32 RenderShadowErrorCutoff;
+	static F32 RenderShadowFOVCutoff;
+	static bool CameraOffset;
+	static F32 CameraMaxCoF;
+	static F32 CameraDoFResScale;
+	static F32 RenderAutoHideSurfaceAreaLimit;
 };
 
 void render_bbox(const LLVector3 &min, const LLVector3 &max);