Use LLStaticHashedString for faster uniform lookup.

2013-10-26 16:26:46 -05:00
parent 8e94c43a54
commit 8441bc80a4
20 changed files with 579 additions and 322 deletions
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -231,6 +231,7 @@ set(llcommon_HEADER_FILES
    llstrider.h
    llstring.h
    llstringtable.h
+    llstaticstringtable.h
    llsys.h
    llthread.h
    llthreadsafequeue.h
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -91,11 +91,22 @@ LLShaderFeatures::LLShaderFeatures()
 // LLGLSL Shader implementation
 //===============================
 LLGLSLShader::LLGLSLShader(S32 shader_class)
-: mProgramObject(0), mShaderClass(shader_class), mActiveTextureChannels(0), mShaderLevel(0), mShaderGroup(SG_DEFAULT), mUniformsDirty(FALSE)
+	: mProgramObject(0),
+	  mShaderClass(shader_class),
+	  mAttributeMask(0),
+	  mTotalUniformSize(0),
+	  mActiveTextureChannels(0),
+	  mShaderLevel(0),
+	  mShaderGroup(SG_DEFAULT),
+	  mUniformsDirty(FALSE)
 {
 	LLShaderMgr::getGlobalShaderList().push_back(this);
 }

+LLGLSLShader::~LLGLSLShader()
+{
+	
+}
 void LLGLSLShader::unload()
 {
 	stop_glerror();
@@ -103,6 +114,7 @@ void LLGLSLShader::unload()
 	mTexture.clear();
 	mUniform.clear();
 	mShaderFiles.clear();
+	mDefines.clear();

 	if (mProgramObject)
 	{
@@ -127,8 +139,8 @@ void LLGLSLShader::unload()
 	stop_glerror();
 }

-BOOL LLGLSLShader::createShader(vector<string> * attributes,
-								vector<string> * uniforms,
+BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString> * attributes,
+								std::vector<LLStaticHashedString> * uniforms,
 								U32 varying_count,
 								const char** varyings)
 {
@@ -151,7 +163,7 @@ BOOL LLGLSLShader::createShader(vector<string> * attributes,
 	vector< pair<string,GLenum> >::iterator fileIter = mShaderFiles.begin();
 	for ( ; fileIter != mShaderFiles.end(); fileIter++ )
 	{
-		GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second, mFeatures.mIndexedTextureChannels);
+		GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second, &mDefines, mFeatures.mIndexedTextureChannels);
 		LL_DEBUGS("ShaderLoading") << "SHADER FILE: " << (*fileIter).first << " mShaderLevel=" << mShaderLevel << LL_ENDL;
 		if (shaderhandle > 0)
 		{
@@ -217,7 +229,8 @@ BOOL LLGLSLShader::createShader(vector<string> * attributes,

 		for (S32 i = 0; i < channel_count; i++)
 		{
-			uniform1i(llformat("tex%d", i), i);
+			LLStaticHashedString uniName(llformat("tex%d", i));
+			uniform1i(uniName, i);
 		}

 		S32 cur_tex = channel_count; //adjust any texture channels that might have been overwritten
@@ -290,7 +303,7 @@ void LLGLSLShader::attachObjects(GLhandleARB* objects, S32 count)
 	}
 }

-BOOL LLGLSLShader::mapAttributes(const vector<string> * attributes)
+BOOL LLGLSLShader::mapAttributes(const std::vector<LLStaticHashedString> * attributes)
 {
 	//before linking, make sure reserved attributes always have consistent locations
 	for (U32 i = 0; i < LLShaderMgr::instance()->mReservedAttribs.size(); i++)
@@ -309,6 +322,8 @@ BOOL LLGLSLShader::mapAttributes(const vector<string> * attributes)
 	if (res)
 	{ //read back channel locations

+		mAttributeMask = 0;
+
 		//read back reserved channels first
 		for (U32 i = 0; i < (S32) LLShaderMgr::instance()->mReservedAttribs.size(); i++)
 		{
@@ -317,6 +332,7 @@ BOOL LLGLSLShader::mapAttributes(const vector<string> * attributes)
 			if (index != -1)
 			{
 				mAttribute[i] = index;
+				mAttributeMask |= 1 << i;
 				LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
 			}
 		}
@@ -324,7 +340,7 @@ BOOL LLGLSLShader::mapAttributes(const vector<string> * attributes)
 		{
 			for (U32 i = 0; i < numAttributes; i++)
 			{
-				const char* name = (*attributes)[i].c_str();
+				const char* name = (*attributes)[i].String().c_str();
 				S32 index = glGetAttribLocationARB(mProgramObject, name);
 				if (index != -1)
 				{
@@ -340,7 +356,7 @@ BOOL LLGLSLShader::mapAttributes(const vector<string> * attributes)
 	return FALSE;
 }

-void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
+void LLGLSLShader::mapUniform(GLint index, const vector<LLStaticHashedString> * uniforms)
 {
 	if (index == -1)
 	{
@@ -349,11 +365,55 @@ void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)

 	GLenum type;
 	GLsizei length;
-	GLint size;
+	GLint size = -1;
 	char name[1024];		/* Flawfinder: ignore */
 	name[0] = 0;

 	glGetActiveUniformARB(mProgramObject, index, 1024, &length, &size, &type, (GLcharARB *)name);
+#if !LL_DARWIN
+	if (size > 0)
+	{
+		switch(type)
+		{
+			case GL_FLOAT_VEC2: size *= 2; break;
+			case GL_FLOAT_VEC3: size *= 3; break;
+			case GL_FLOAT_VEC4: size *= 4; break;
+			case GL_DOUBLE: size *= 2; break;
+			case GL_DOUBLE_VEC2: size *= 2; break;
+			case GL_DOUBLE_VEC3: size *= 6; break;
+			case GL_DOUBLE_VEC4: size *= 8; break;
+			case GL_INT_VEC2: size *= 2; break;
+			case GL_INT_VEC3: size *= 3; break;
+			case GL_INT_VEC4: size *= 4; break;
+			case GL_UNSIGNED_INT_VEC2: size *= 2; break;
+			case GL_UNSIGNED_INT_VEC3: size *= 3; break;
+			case GL_UNSIGNED_INT_VEC4: size *= 4; break;
+			case GL_BOOL_VEC2: size *= 2; break;
+			case GL_BOOL_VEC3: size *= 3; break;
+			case GL_BOOL_VEC4: size *= 4; break;
+			case GL_FLOAT_MAT2: size *= 4; break;
+			case GL_FLOAT_MAT3: size *= 9; break;
+			case GL_FLOAT_MAT4: size *= 16; break;
+			case GL_FLOAT_MAT2x3: size *= 6; break;
+			case GL_FLOAT_MAT2x4: size *= 8; break;
+			case GL_FLOAT_MAT3x2: size *= 6; break;
+			case GL_FLOAT_MAT3x4: size *= 12; break;
+			case GL_FLOAT_MAT4x2: size *= 8; break;
+			case GL_FLOAT_MAT4x3: size *= 12; break;
+			case GL_DOUBLE_MAT2: size *= 8; break;
+			case GL_DOUBLE_MAT3: size *= 18; break;
+			case GL_DOUBLE_MAT4: size *= 32; break;
+			case GL_DOUBLE_MAT2x3: size *= 12; break;
+			case GL_DOUBLE_MAT2x4: size *= 16; break;
+			case GL_DOUBLE_MAT3x2: size *= 12; break;
+			case GL_DOUBLE_MAT3x4: size *= 24; break;
+			case GL_DOUBLE_MAT4x2: size *= 16; break;
+			case GL_DOUBLE_MAT4x3: size *= 24; break;
+		}
+		mTotalUniformSize += size;
+	}
+#endif
+
 	S32 location = glGetUniformLocationARB(mProgramObject, name);
 	if (location != -1)
 	{
@@ -365,7 +425,10 @@ void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
 			is_array[0] = 0;
 		}

-		mUniformMap[name] = location;
+		LLStaticHashedString hashedName(name);
+		mUniformNameMap[location] = name;
+		mUniformMap[hashedName] = location;
+
 		LL_DEBUGS("ShaderLoading") << "Uniform " << name << " is at location " << location << LL_ENDL;
 	
 		//find the index of this uniform
@@ -386,7 +449,7 @@ void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
 			for (U32 i = 0; i < uniforms->size(); i++)
 			{
 				if ( (mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] == -1)
-					&& ((*uniforms)[i] == name))
+					&& ((*uniforms)[i].String() == name))
 				{
 					//found it
 					mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] = location;
@@ -396,7 +459,17 @@ void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
 			}
 		}
 	}
- }
+}
+
+void LLGLSLShader::addPermutation(std::string name, std::string value)
+{
+	mDefines[name] = value;
+}
+
+void LLGLSLShader::removePermutation(std::string name)
+{
+	mDefines[name].erase();
+}

 GLint LLGLSLShader::mapUniformTextureChannel(GLint location, GLenum type)
 {
@@ -410,13 +483,15 @@ GLint LLGLSLShader::mapUniformTextureChannel(GLint location, GLenum type)
 	return -1;
 }

-BOOL LLGLSLShader::mapUniforms(const vector<string> * uniforms)
+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
@@ -437,6 +512,7 @@ BOOL LLGLSLShader::mapUniforms(const vector<string> * uniforms)

 	unbind();

+	LL_DEBUGS("ShaderLoading") << "Total Uniform Size: " << mTotalUniformSize << llendl;
 	return res;
 }

@@ -495,6 +571,58 @@ void LLGLSLShader::bindNoShader(void)
 	}
 }

+S32 LLGLSLShader::bindTexture(const std::string &uniform, LLTexture *texture, LLTexUnit::eTextureType mode)
+{
+	S32 channel = 0;
+	channel = getUniformLocation(uniform);
+	
+	return bindTexture(channel, texture, mode);
+}
+
+S32 LLGLSLShader::bindTexture(S32 uniform, LLTexture *texture, LLTexUnit::eTextureType mode)
+{
+	if (uniform < 0 || uniform >= (S32)mTexture.size())
+	{
+		UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
+		return -1;
+	}
+	
+	uniform = mTexture[uniform];
+	
+	if (uniform > -1)
+	{
+		gGL.getTexUnit(uniform)->bind(texture, mode);
+	}
+	
+	return uniform;
+}
+
+S32 LLGLSLShader::unbindTexture(const std::string &uniform, LLTexUnit::eTextureType mode)
+{
+	S32 channel = 0;
+	channel = getUniformLocation(uniform);
+	
+	return unbindTexture(channel);
+}
+
+S32 LLGLSLShader::unbindTexture(S32 uniform, LLTexUnit::eTextureType mode)
+{
+	if (uniform < 0 || uniform >= (S32)mTexture.size())
+	{
+		UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
+		return -1;
+	}
+	
+	uniform = mTexture[uniform];
+	
+	if (uniform > -1)
+	{
+		gGL.getTexUnit(uniform)->unbind(mode);
+	}
+	
+	return uniform;
+}
+
 S32 LLGLSLShader::enableTexture(S32 uniform, LLTexUnit::eTextureType mode)
 {
 	if (uniform < 0 || uniform >= (S32)mTexture.size())
@@ -817,18 +945,18 @@ void LLGLSLShader::uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, c
 	}
 }

-GLint LLGLSLShader::getUniformLocation(const string& uniform)
+GLint LLGLSLShader::getUniformLocation(const LLStaticHashedString& uniform)
 {
 	GLint ret = -1;
 	if (mProgramObject > 0)
 	{
-		std::map<string, GLint>::iterator iter = mUniformMap.find(uniform);
+		LLStaticStringTable<GLint>::iterator iter = mUniformMap.find(uniform);
 		if (iter != mUniformMap.end())
 		{
 			if (gDebugGL)
 			{
 				stop_glerror();
-				if (iter->second != glGetUniformLocationARB(mProgramObject, uniform.c_str()))
+				if (iter->second != glGetUniformLocationARB(mProgramObject, uniform.String().c_str()))
 				{
 					llerrs << "Uniform does not match." << llendl;
 				}
@@ -865,7 +993,7 @@ GLint LLGLSLShader::getAttribLocation(U32 attrib)
 	}
 }

-void LLGLSLShader::uniform1i(const string& uniform, GLint v)
+void LLGLSLShader::uniform1i(const LLStaticHashedString& uniform, GLint v)
 {
 	GLint location = getUniformLocation(uniform);
 				
@@ -881,7 +1009,24 @@ void LLGLSLShader::uniform1i(const string& uniform, GLint v)
 	}
 }

-void LLGLSLShader::uniform1f(const string& uniform, GLfloat v)
+void LLGLSLShader::uniform2i(const LLStaticHashedString& uniform, GLint i, GLint j)
+{
+	GLint location = getUniformLocation(uniform);
+				
+	if (location >= 0)
+	{
+		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+		LLVector4 vec(i,j,0.f,0.f);
+		if (iter == mValue.end() || shouldChange(iter->second,vec))
+		{
+			glUniform2iARB(location, i, j);
+			mValue[location] = vec;
+		}
+	}
+}
+
+
+void LLGLSLShader::uniform1f(const LLStaticHashedString& uniform, GLfloat v)
 {
 	GLint location = getUniformLocation(uniform);
 				
@@ -897,7 +1042,7 @@ void LLGLSLShader::uniform1f(const string& uniform, GLfloat v)
 	}
 }

-void LLGLSLShader::uniform2f(const string& uniform, GLfloat x, GLfloat y)
+void LLGLSLShader::uniform2f(const LLStaticHashedString& uniform, GLfloat x, GLfloat y)
 {
 	GLint location = getUniformLocation(uniform);
 				
@@ -914,7 +1059,7 @@ void LLGLSLShader::uniform2f(const string& uniform, GLfloat x, GLfloat y)

 }

-void LLGLSLShader::uniform3f(const string& uniform, GLfloat x, GLfloat y, GLfloat z)
+void LLGLSLShader::uniform3f(const LLStaticHashedString& uniform, GLfloat x, GLfloat y, GLfloat z)
 {
 	GLint location = getUniformLocation(uniform);
 				
@@ -930,23 +1075,7 @@ void LLGLSLShader::uniform3f(const string& uniform, GLfloat x, GLfloat y, GLfloa
 	}
 }

-void LLGLSLShader::uniform4f(const string& uniform, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-	GLint location = getUniformLocation(uniform);
-
-	if (location >= 0)
-	{
-		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
-		LLVector4 vec(x,y,z,w);
-		if (iter == mValue.end() || shouldChange(iter->second,vec))
-		{
-			glUniform4fARB(location, x,y,z,w);
-			mValue[location] = vec;
-		}
-	}
-}
-
-void LLGLSLShader::uniform1fv(const string& uniform, U32 count, const GLfloat* v)
+void LLGLSLShader::uniform1fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v)
 {
 	GLint location = getUniformLocation(uniform);

@@ -962,7 +1091,7 @@ void LLGLSLShader::uniform1fv(const string& uniform, U32 count, const GLfloat* v
 	}
 }

-void LLGLSLShader::uniform2fv(const string& uniform, U32 count, const GLfloat* v)
+void LLGLSLShader::uniform2fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v)
 {
 	GLint location = getUniformLocation(uniform);
 				
@@ -978,7 +1107,7 @@ void LLGLSLShader::uniform2fv(const string& uniform, U32 count, const GLfloat* v
 	}
 }

-void LLGLSLShader::uniform3fv(const string& uniform, U32 count, const GLfloat* v)
+void LLGLSLShader::uniform3fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v)
 {
 	GLint location = getUniformLocation(uniform);
 				
@@ -994,7 +1123,7 @@ void LLGLSLShader::uniform3fv(const string& uniform, U32 count, const GLfloat* v
 	}
 }

-void LLGLSLShader::uniform4fv(const string& uniform, U32 count, const GLfloat* v)
+void LLGLSLShader::uniform4fv(const LLStaticHashedString& uniform, U32 count, const GLfloat* v)
 {
 	GLint location = getUniformLocation(uniform);

@@ -1012,27 +1141,7 @@ void LLGLSLShader::uniform4fv(const string& uniform, U32 count, const GLfloat* v
 	}
 }

-void LLGLSLShader::uniformMatrix2fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
-{
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		glUniformMatrix2fvARB(location, count, transpose, v);
-	}
-}
-
-void LLGLSLShader::uniformMatrix3fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
-{
-	GLint location = getUniformLocation(uniform);
-				
-	if (location >= 0)
-	{
-		glUniformMatrix3fvARB(location, count, transpose, v);
-	}
-}
-
-void LLGLSLShader::uniformMatrix4fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
+void LLGLSLShader::uniformMatrix4fv(const LLStaticHashedString& uniform, U32 count, GLboolean transpose, const GLfloat* v)
 {
 	GLint location = getUniformLocation(uniform);
 				
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -29,6 +29,7 @@

 #include "llgl.h"
 #include "llrender.h"
+#include "llstaticstringtable.h"

 class LLShaderFeatures
 {
@@ -68,6 +69,7 @@ public:
 	};
 	
 	LLGLSLShader(S32 shader_class);
+	~LLGLSLShader();

 	static GLhandleARB sCurBoundShader;
 	static LLGLSLShader* sCurBoundShaderPtr;
@@ -75,16 +77,16 @@ public:
 	static bool sNoFixedFunction;

 	void unload();
-	BOOL createShader(std::vector<std::string> * attributes,
-						std::vector<std::string> * uniforms,
+	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<std::string> * attributes);
-	BOOL mapUniforms(const std::vector<std::string> * uniforms);
-	void mapUniform(GLint index, const std::vector<std::string> * uniforms);
+	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);
@@ -95,34 +97,35 @@ public:
 	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 uniform1i(const std::string& uniform, GLint i);
-	void uniform1f(const std::string& uniform, GLfloat v);
-	void uniform2f(const std::string& uniform, GLfloat x, GLfloat y);
-	void uniform3f(const std::string& uniform, GLfloat x, GLfloat y, GLfloat z);
-	void uniform4f(const std::string& uniform, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-	void uniform1iv(const std::string& uniform, U32 count, const GLint* i);
-	void uniform1fv(const std::string& uniform, U32 count, const GLfloat* v);
-	void uniform2fv(const std::string& uniform, U32 count, const GLfloat* v);
-	void uniform3fv(const std::string& uniform, U32 count, const GLfloat* v);
-	void uniform4fv(const std::string& uniform, 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 uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
-	void uniformMatrix2fv(const std::string& uniform, U32 count, GLboolean transpose, const GLfloat *v);
-	void uniformMatrix3fv(const std::string& uniform, U32 count, GLboolean transpose, const GLfloat *v);
-	void uniformMatrix4fv(const std::string& uniform, 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 std::string& uniform);
+	GLint getUniformLocation(const LLStaticHashedString& uniform);	
 	GLint getUniformLocation(U32 index);

 	GLint getAttribLocation(U32 attrib);
 	GLint mapUniformTextureChannel(GLint location, GLenum type);
 	
+	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
@@ -130,6 +133,13 @@ public:
 	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();
@@ -142,10 +152,13 @@ public:

 	GLhandleARB mProgramObject;
 	std::vector<GLint> mAttribute; //lookup table of attribute enum to attribute channel
+	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
-	std::map<std::string, GLint> mUniformMap;  //lookup map of uniform name 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 mShaderClass;
 	S32 mShaderLevel;
@@ -154,6 +167,7 @@ public:
 	LLShaderFeatures mFeatures;
 	std::vector< std::pair< std::string, GLenum > > mShaderFiles;
 	std::string mName;
+	std::map<std::string, std::string> mDefines;
 };

 //UI shader (declared here so llui_libtest will link properly)
--- a/indra/llrender/llpostprocess.cpp
+++ b/indra/llrender/llpostprocess.cpp
@@ -51,6 +51,28 @@ extern LLGLSLShader			gPostPosterizeProgram;
 extern LLGLSLShader			gPostMotionBlurProgram;
 extern LLGLSLShader			gPostVignetteProgram;

+static LLStaticHashedString sGamma("gamma");
+static LLStaticHashedString sBrightness("brightness");
+static LLStaticHashedString sContrast("contrast");
+static LLStaticHashedString sContrastBase("contrastBase");
+static LLStaticHashedString sSaturation("saturation");
+static LLStaticHashedString sBrightMult("brightMult");
+static LLStaticHashedString sNoiseStrength("noiseStrength");
+static LLStaticHashedString sLayerCount("layerCount");
+
+static LLStaticHashedString sVignetteStrength("vignette_strength");
+static LLStaticHashedString sVignettRadius("vignette_radius");
+static LLStaticHashedString sVignetteDarkness("vignette_darkness");
+static LLStaticHashedString sVignetteDesaturation("vignette_desaturation");
+static LLStaticHashedString sVignetteChromaticAberration("vignette_chromatic_aberration");
+static LLStaticHashedString sScreenRes("screen_res");
+
+static LLStaticHashedString sHorizontalPass("horizontalPass");
+
+static LLStaticHashedString sPrevProj("prev_proj");
+static LLStaticHashedString sInvProj("inv_proj");
+static LLStaticHashedString sBlurStrength("blur_strength");
+
 static const unsigned int NOISE_SIZE = 512;

 static const char * const XML_FILENAME = "postprocesseffects.xml";
@@ -155,16 +177,16 @@ public:

 	/*virtual*/ QuadType preDraw()
 	{
-		getShader().uniform1f("gamma", mGamma);
-		getShader().uniform1f("brightness", mBrightness);
-		getShader().uniform1f("contrast", mContrast);
+		getShader().uniform1f(sGamma, mGamma);
+		getShader().uniform1f(sBrightness, mBrightness);
+		getShader().uniform1f(sContrast, mContrast);
 		float baseI = (mContrastBase.get()[VX] + mContrastBase.get()[VY] + mContrastBase.get()[VZ]) / 3.0f;
 		baseI = mContrastBase.get()[VW] / llmax(baseI,0.001f);
 		float baseR = mContrastBase.get()[VX] * baseI;
 		float baseG = mContrastBase.get()[VY] * baseI;
 		float baseB = mContrastBase.get()[VZ] * baseI;
-		getShader().uniform3fv("contrastBase", 1, LLVector3(baseR, baseG, baseB).mV);
-		getShader().uniform1f("saturation", mSaturation);
+		getShader().uniform3fv(sContrastBase, 1, LLVector3(baseR, baseG, baseB).mV);
+		getShader().uniform1f(sSaturation, mSaturation);

 		return QUAD_NORMAL;
 	}
@@ -187,8 +209,8 @@ public:
 	{
 		LLPostProcess::getInstance()->bindNoise(1);

-		getShader().uniform1f("brightMult", mBrightnessMult);
-		getShader().uniform1f("noiseStrength", mNoiseStrength);
+		getShader().uniform1f(sBrightMult, mBrightnessMult);
+		getShader().uniform1f(sNoiseStrength, mNoiseStrength);

 		return QUAD_NOISE;
 	}
@@ -206,7 +228,7 @@ public:
 	}
 	/*virtual*/ QuadType preDraw()
 	{
-		getShader().uniform1i("layerCount", mNumLayers);
+		getShader().uniform1i(sLayerCount, mNumLayers);
 		return QUAD_NORMAL;
 	}
 };
@@ -232,12 +254,13 @@ public:
 	/*virtual*/ QuadType preDraw()
 	{
 		LLVector2 screen_rect = LLPostProcess::getInstance()->getDimensions();
-		getShader().uniform1f("vignette_strength", mStrength);
-		getShader().uniform1f("vignette_radius", mRadius);
-		getShader().uniform1f("vignette_darkness", mDarkness);
-		getShader().uniform1f("vignette_desaturation", mDesaturation);
-		getShader().uniform1f("vignette_chromatic_aberration", mChromaticAberration);
-		getShader().uniform2fv("screen_res", 1, screen_rect.mV);
+
+		getShader().uniform1f(sVignetteStrength, mStrength);
+		getShader().uniform1f(sVignettRadius, mRadius);
+		getShader().uniform1f(sVignetteDarkness, mDarkness);
+		getShader().uniform1f(sVignetteDesaturation, mDesaturation);
+		getShader().uniform1f(sVignetteChromaticAberration, mChromaticAberration);
+		getShader().uniform2fv(sScreenRes, 1, screen_rect.mV);
 		return QUAD_NORMAL;
 	}
 };
@@ -259,7 +282,7 @@ public:
 	/*virtual*/ S32 getDepthChannel()	const	{ return -1; }
 	/*virtual*/ QuadType preDraw()
 	{
-		mPassLoc = getShader().getUniformLocation("horizontalPass");
+		mPassLoc = getShader().getUniformLocation(sHorizontalPass);
 		return QUAD_NORMAL;
 	}
 	/*virtual*/ bool draw(U32 pass) 
@@ -295,10 +318,10 @@ public:

 		LLVector2 screen_rect = LLPostProcess::getInstance()->getDimensions();

-		getShader().uniformMatrix4fv("prev_proj", 1, GL_FALSE, prev_proj.m);
-		getShader().uniformMatrix4fv("inv_proj", 1, GL_FALSE, inv_proj.m);
-		getShader().uniform2fv("screen_res", 1, screen_rect.mV);
-		getShader().uniform1i("blur_strength", mStrength);
+		getShader().uniformMatrix4fv(sPrevProj, 1, GL_FALSE, prev_proj.m);
+		getShader().uniformMatrix4fv(sInvProj, 1, GL_FALSE, inv_proj.m);
+		getShader().uniform2fv(sScreenRes, 1, screen_rect.mV);
+		getShader().uniform1i(sBlurStrength, mStrength);
 		
 		return QUAD_NORMAL;
 	}
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -528,7 +528,7 @@ void LLShaderMgr::dumpObjectLog(GLhandleARB ret, BOOL warns)
 	}
 }

-GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, S32 texture_index_channels)
+GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, std::map<std::string, std::string>* defines, S32 texture_index_channels)
 {
 	std::pair<std::multimap<std::string, CachedObjectInfo >::iterator, std::multimap<std::string, CachedObjectInfo>::iterator> range;
 	range = mShaderObjects.equal_range(filename);
@@ -669,8 +669,9 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	if(SHPackDeferredNormals)
 		text[count++] = strdup("#define PACK_NORMALS\n");

-	//copy preprocessor definitions into buffer
-	for (std::map<std::string,std::string>::iterator iter = mDefinitions.begin(); iter != mDefinitions.end(); ++iter)
+	if(defines)
+	{
+		for (std::map<std::string,std::string>::iterator iter = defines->begin(); iter != defines->end(); ++iter)
 	{
 		std::string define = "#define " + iter->first + " " + iter->second + "\n";
 		text[count++] = (GLcharARB *) strdup(define.c_str());
@@ -924,7 +925,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		if (shader_level > 1)
 		{
 			shader_level--;
-			return loadShaderFile(filename,shader_level,type,texture_index_channels);
+			return loadShaderFile(filename,shader_level,type, defines, texture_index_channels);
 		}
 		LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;	
 	}
@@ -1044,7 +1045,9 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("texture_matrix1");
 	mReservedUniforms.push_back("texture_matrix2");
 	mReservedUniforms.push_back("texture_matrix3");
-	llassert(mReservedUniforms.size() == LLShaderMgr::TEXTURE_MATRIX3+1);
+	mReservedUniforms.push_back("object_plane_s");
+	mReservedUniforms.push_back("object_plane_t");
+	llassert(mReservedUniforms.size() == LLShaderMgr::OBJECT_PLANE_T+1);

 	mReservedUniforms.push_back("viewport");

@@ -1185,7 +1188,47 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("lightMap");
 	mReservedUniforms.push_back("bloomMap");
 	mReservedUniforms.push_back("projectionMap");
+	mReservedUniforms.push_back("norm_mat");

+	mReservedUniforms.push_back("matrixPalette");
+	
+	mReservedUniforms.push_back("screenTex");
+	mReservedUniforms.push_back("screenDepth");
+	mReservedUniforms.push_back("refTex");
+	mReservedUniforms.push_back("eyeVec");
+	mReservedUniforms.push_back("time");
+	mReservedUniforms.push_back("d1");
+	mReservedUniforms.push_back("d2");
+	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");
 	llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);

 	std::set<std::string> dupe_check;
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -47,6 +47,8 @@ public:
 		TEXTURE_MATRIX1,
 		TEXTURE_MATRIX2,
 		TEXTURE_MATRIX3,
+		OBJECT_PLANE_S,
+		OBJECT_PLANE_T,
 		VIEWPORT,
 		LIGHT_POSITION,
 		LIGHT_DIRECTION,
@@ -164,6 +166,45 @@ public:
 		DEFERRED_LIGHT,
 		DEFERRED_BLOOM,
 		DEFERRED_PROJECTION,
+		DEFERRED_NORM_MATRIX,
+
+		AVATAR_MATRIX,
+		WATER_SCREENTEX,
+		WATER_SCREENDEPTH,
+		WATER_REFTEX,
+		WATER_EYEVEC,
+		WATER_TIME,
+		WATER_WAVE_DIR1,
+		WATER_WAVE_DIR2,
+		WATER_LIGHT_DIR,
+		WATER_SPECULAR,
+		WATER_SPECULAR_EXP,
+		WATER_FOGCOLOR,
+		WATER_FOGDENSITY,
+		WATER_FOGKS,
+		WATER_REFSCALE,
+		WATER_WATERHEIGHT,
+		WATER_WATERPLANE,
+		WATER_NORM_SCALE,
+		WATER_FRESNEL_SCALE,
+		WATER_FRESNEL_OFFSET,
+		WATER_BLUR_MULTIPLIER,
+		WATER_SUN_ANGLE,
+		WATER_SCALED_ANGLE,
+		WATER_SUN_ANGLE2,
+		
+		WL_CAMPOSLOCAL,
+
+		AVATAR_WIND,
+		AVATAR_SINWAVE,
+		AVATAR_GRAVITY,
+
+		TERRAIN_DETAIL0,
+		TERRAIN_DETAIL1,
+		TERRAIN_DETAIL2,
+		TERRAIN_DETAIL3,
+		TERRAIN_ALPHARAMP,
+		SHINY_ORIGIN,
 		END_RESERVED_UNIFORMS
 	} eGLSLReservedUniforms;

@@ -176,7 +217,7 @@ public:
 	void dumpObjectLog(GLhandleARB ret, BOOL warns = TRUE);
 	BOOL	linkProgramObject(GLhandleARB obj, BOOL suppress_errors = FALSE);
 	BOOL	validateProgramObject(GLhandleARB obj);
-	GLhandleARB loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, S32 texture_index_channels = -1);
+	GLhandleARB loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, std::map<std::string, std::string>* defines = NULL, S32 texture_index_channels = -1);

 	// Implemented in the application to actually point to the shader directory.
 	virtual std::string getShaderDirPrefix(void) = 0; // Pure Virtual
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -1509,7 +1509,7 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 				
 				stop_glerror();

-				LLDrawPoolAvatar::sVertexProgram->uniformMatrix4fv("matrixPalette", 
+				LLDrawPoolAvatar::sVertexProgram->uniformMatrix4fv(LLViewerShaderMgr::AVATAR_MATRIX, 
 					maxJoints,
 					FALSE,
 					(GLfloat*) mat[0].mMatrix);
--- a/indra/newview/lldrawpoolbump.cpp
+++ b/indra/newview/lldrawpoolbump.cpp
@@ -1370,9 +1370,14 @@ void LLBumpImageList::onSourceLoaded( BOOL success, LLViewerTexture *src_vi, LLI
 					LLGLDisable blend(GL_BLEND);
 					gGL.setColorMask(TRUE, TRUE);
 					gNormalMapGenProgram.bind();
-					gNormalMapGenProgram.uniform1f("norm_scale", gSavedSettings.getF32("RenderNormalMapScale"));
-					gNormalMapGenProgram.uniform1f("stepX", 1.f/bump->getWidth());
-					gNormalMapGenProgram.uniform1f("stepY", 1.f/bump->getHeight());
+
+					static LLStaticHashedString sNormScale("norm_scale");
+					static LLStaticHashedString sStepX("stepX");
+					static LLStaticHashedString sStepY("stepY");
+
+					gNormalMapGenProgram.uniform1f(sNormScale, gSavedSettings.getF32("RenderNormalMapScale"));
+					gNormalMapGenProgram.uniform1f(sStepX, 1.f/bump->getWidth());
+					gNormalMapGenProgram.uniform1f(sStepX, 1.f/bump->getHeight());

 					LLVector2 v((F32) bump->getWidth()/gPipeline.mScreen.getWidth(),
 								(F32) bump->getHeight()/gPipeline.mScreen.getHeight());
--- a/indra/newview/lldrawpoolterrain.cpp
+++ b/indra/newview/lldrawpoolterrain.cpp
@@ -362,8 +362,8 @@ void LLDrawPoolTerrain::renderFullShader()
 	LLGLSLShader* shader = LLGLSLShader::sCurBoundShaderPtr;
 	llassert(shader);
 		
-	shader->uniform4fv("object_plane_s", 1, tp0.mV);
-	shader->uniform4fv("object_plane_t", 1, tp1.mV);
+	shader->uniform4fv(LLShaderMgr::OBJECT_PLANE_S, 1, tp0.mV);
+	shader->uniform4fv(LLShaderMgr::OBJECT_PLANE_T, 1, tp1.mV);

 	gGL.matrixMode(LLRender::MM_TEXTURE);
 	gGL.loadIdentity();
@@ -873,8 +873,8 @@ void LLDrawPoolTerrain::renderSimple()
 	
 	if (LLGLSLShader::sNoFixedFunction)
 	{
-		sShader->uniform4fv("object_plane_s", 1, tp0.mV);
-		sShader->uniform4fv("object_plane_t", 1, tp1.mV);
+		sShader->uniform4fv(LLShaderMgr::OBJECT_PLANE_S, 1, tp0.mV);
+		sShader->uniform4fv(LLShaderMgr::OBJECT_PLANE_T, 1, tp1.mV);
 	}
 	else
 	{
--- a/indra/newview/lldrawpoolwater.cpp
+++ b/indra/newview/lldrawpoolwater.cpp
@@ -449,8 +449,8 @@ void LLDrawPoolWater::renderOpaqueLegacyWater()
 	}
 	else
 	{
-		shader->uniform4fv("object_plane_s", 1, tp0);
-		shader->uniform4fv("object_plane_t", 1, tp1);
+		shader->uniform4fv(LLShaderMgr::OBJECT_PLANE_S, 1, tp0);
+		shader->uniform4fv(LLShaderMgr::OBJECT_PLANE_T, 1, tp1);
 	}

 	gGL.diffuseColor3f(1.f, 1.f, 1.f);
@@ -624,12 +624,12 @@ void LLDrawPoolWater::shade()
 		mWaterNormp->setFilteringOption(LLTexUnit::TFO_POINT);
 	}
 	
-	S32 screentex = shader->enableTexture(LLViewerShaderMgr::WATER_SCREENTEX);	
+	S32 screentex = shader->enableTexture(LLShaderMgr::WATER_SCREENTEX);	
 		
 	if (screentex > -1)
 	{
-		shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
-		shader->uniform1f(LLViewerShaderMgr::WATER_FOGDENSITY, 
+		shader->uniform4fv(LLShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
+		shader->uniform1f(LLShaderMgr::WATER_FOGDENSITY, 
 			param_mgr->getFogDensity());
 		gPipeline.mWaterDis.bindTexture(0, screentex);
 	}
@@ -641,7 +641,7 @@ void LLDrawPoolWater::shade()
 	if (mVertexShaderLevel == 1)
 	{
 		sWaterFogColor.mV[3] = param_mgr->mDensitySliderValue;
-		shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
+		shader->uniform4fv(LLShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
 	}

 	F32 screenRes[] = 
@@ -649,10 +649,10 @@ void LLDrawPoolWater::shade()
 		1.f/gGLViewport[2],
 		1.f/gGLViewport[3]
 	};
-	shader->uniform2fv("screenRes", 1, screenRes);
+	shader->uniform2fv(LLShaderMgr::DEFERRED_SCREEN_RES, 1, screenRes);
 	stop_glerror();
 	
-	S32 diffTex = shader->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
+	S32 diffTex = shader->enableTexture(LLShaderMgr::DIFFUSE_MAP);
 	stop_glerror();
 	
 	light_dir.normVec();
@@ -661,26 +661,26 @@ void LLDrawPoolWater::shade()
 	light_diffuse *= 6.f;

 	//shader->uniformMatrix4fv("inverse_ref", 1, GL_FALSE, (GLfloat*) gGLObliqueProjectionInverse.mMatrix);
-	shader->uniform1f(LLViewerShaderMgr::WATER_WATERHEIGHT, eyedepth);
-	shader->uniform1f(LLViewerShaderMgr::WATER_TIME, sTime);
-	shader->uniform3fv(LLViewerShaderMgr::WATER_EYEVEC, 1, LLViewerCamera::getInstance()->getOrigin().mV);
-	shader->uniform3fv(LLViewerShaderMgr::WATER_SPECULAR, 1, light_diffuse.mV);
-	shader->uniform1f(LLViewerShaderMgr::WATER_SPECULAR_EXP, light_exp);
-	shader->uniform2fv(LLViewerShaderMgr::WATER_WAVE_DIR1, 1, param_mgr->getWave1Dir().mV);
-	shader->uniform2fv(LLViewerShaderMgr::WATER_WAVE_DIR2, 1, param_mgr->getWave2Dir().mV);
-	shader->uniform3fv(LLViewerShaderMgr::WATER_LIGHT_DIR, 1, light_dir.mV);
+	shader->uniform1f(LLShaderMgr::WATER_WATERHEIGHT, eyedepth);
+	shader->uniform1f(LLShaderMgr::WATER_TIME, sTime);
+	shader->uniform3fv(LLShaderMgr::WATER_EYEVEC, 1, LLViewerCamera::getInstance()->getOrigin().mV);
+	shader->uniform3fv(LLShaderMgr::WATER_SPECULAR, 1, light_diffuse.mV);
+	shader->uniform1f(LLShaderMgr::WATER_SPECULAR_EXP, light_exp);
+	shader->uniform2fv(LLShaderMgr::WATER_WAVE_DIR1, 1, param_mgr->getWave1Dir().mV);
+	shader->uniform2fv(LLShaderMgr::WATER_WAVE_DIR2, 1, param_mgr->getWave2Dir().mV);
+	shader->uniform3fv(LLShaderMgr::WATER_LIGHT_DIR, 1, light_dir.mV);

-	shader->uniform3fv("normScale", 1, param_mgr->getNormalScale().mV);
-	shader->uniform1f("fresnelScale", param_mgr->getFresnelScale());
-	shader->uniform1f("fresnelOffset", param_mgr->getFresnelOffset());
-	shader->uniform1f("blurMultiplier", param_mgr->getBlurMultiplier());
+	shader->uniform3fv(LLShaderMgr::WATER_NORM_SCALE, 1, param_mgr->getNormalScale().mV);
+	shader->uniform1f(LLShaderMgr::WATER_FRESNEL_SCALE, param_mgr->getFresnelScale());
+	shader->uniform1f(LLShaderMgr::WATER_FRESNEL_OFFSET, param_mgr->getFresnelOffset());
+	shader->uniform1f(LLShaderMgr::WATER_BLUR_MULTIPLIER, param_mgr->getBlurMultiplier());

 	F32 sunAngle = llmax(0.f, light_dir.mV[2]);
 	F32 scaledAngle = 1.f - sunAngle;

-	shader->uniform1f("sunAngle", sunAngle);
-	shader->uniform1f("scaledAngle", scaledAngle);
-	shader->uniform1f("sunAngle2", 0.1f + 0.2f*sunAngle);
+	shader->uniform1f(LLShaderMgr::WATER_SUN_ANGLE, sunAngle);
+	shader->uniform1f(LLShaderMgr::WATER_SCALED_ANGLE, scaledAngle);
+	shader->uniform1f(LLShaderMgr::WATER_SUN_ANGLE2, 0.1f + 0.2f*sunAngle);

 	LLColor4 water_color;
 	LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
@@ -688,12 +688,12 @@ void LLDrawPoolWater::shade()
 	if (LLViewerCamera::getInstance()->cameraUnderWater())
 	{
 		water_color.setVec(1.f, 1.f, 1.f, 0.4f);
-		shader->uniform1f(LLViewerShaderMgr::WATER_REFSCALE, param_mgr->getScaleBelow());
+		shader->uniform1f(LLShaderMgr::WATER_REFSCALE, param_mgr->getScaleBelow());
 	}
 	else
 	{
 		water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));
-		shader->uniform1f(LLViewerShaderMgr::WATER_REFSCALE, param_mgr->getScaleAbove());
+		shader->uniform1f(LLShaderMgr::WATER_REFSCALE, param_mgr->getScaleAbove());
 	}

 	if (water_color.mV[3] > 0.9f)
@@ -739,12 +739,12 @@ void LLDrawPoolWater::shade()
 		}
 	}
 	
-	shader->disableTexture(LLViewerShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
-	shader->disableTexture(LLViewerShaderMgr::WATER_SCREENTEX);	
-	shader->disableTexture(LLViewerShaderMgr::BUMP_MAP);
-	shader->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
-	shader->disableTexture(LLViewerShaderMgr::WATER_REFTEX);
-	shader->disableTexture(LLViewerShaderMgr::WATER_SCREENDEPTH);
+	shader->disableTexture(LLShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
+	shader->disableTexture(LLShaderMgr::WATER_SCREENTEX);	
+	shader->disableTexture(LLShaderMgr::BUMP_MAP);
+	shader->disableTexture(LLShaderMgr::DIFFUSE_MAP);
+	shader->disableTexture(LLShaderMgr::WATER_REFTEX);
+	shader->disableTexture(LLShaderMgr::WATER_SCREENDEPTH);

 	if (deferred_render)
 	{
--- a/indra/newview/lldrawpoolwlsky.cpp
+++ b/indra/newview/lldrawpoolwlsky.cpp
@@ -161,7 +161,8 @@ void LLDrawPoolWLSky::renderDome(F32 camHeightLocal, LLGLSLShader * shader) cons
 	gGL.translatef(0.f,-camHeightLocal, 0.f);
 	
 	// Draw WL Sky	
-	shader->uniform3f("camPosLocal", 0.f, camHeightLocal, 0.f);
+	static LLStaticHashedString sCamPosLocal("camPosLocal");
+	shader->uniform3f(sCamPosLocal, 0.f, camHeightLocal, 0.f);

 	gSky.mVOWLSkyp->drawDome();

@@ -219,7 +220,8 @@ void LLDrawPoolWLSky::renderStars(void) const

 	if (gPipeline.canUseVertexShaders())
 	{
-		star_shader->uniform1f("custom_alpha", star_alpha.mV[3]);
+		static LLStaticHashedString sCustomAlpha("custom_alpha");
+		star_shader->uniform1f(sCustomAlpha, star_alpha.mV[3]);
 	}
 	else
 	{
@@ -294,7 +296,8 @@ void LLDrawPoolWLSky::renderHeavenlyBodies()
 		if (gPipeline.canUseVertexShaders())
 		{
 			// Okay, so the moon isn't a star, but it's close enough.
-			star_shader->uniform1f("custom_alpha", color.mV[VW]);
+			static LLStaticHashedString sCustomAlpha("custom_alpha");
+			star_shader->uniform1f(sCustomAlpha, color.mV[VW]);
 		}
 		else
 		{
--- a/indra/newview/llface.cpp
+++ b/indra/newview/llface.cpp
@@ -60,6 +60,9 @@

 #define LL_MAX_INDICES_COUNT 1000000

+static LLStaticHashedString sTextureIndexIn("texture_index_in");
+static LLStaticHashedString sColorIn("color_in");
+
 BOOL LLFace::sSafeRenderSelect = TRUE; // FALSE

 #define DOTVEC(a,b) (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1] + a.mV[2]*b.mV[2])
@@ -1414,7 +1417,7 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume,
 			vp[2] = 0;
 			vp[3] = 0;
 			
-			gTransformPositionProgram.uniform1i("texture_index_in", val);
+			gTransformPositionProgram.uniform1i(sTextureIndexIn, val);
 			glBeginTransformFeedback(GL_POINTS);
 			buff->setBuffer(LLVertexBuffer::MAP_VERTEX);

@@ -1432,7 +1435,7 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume,

 			S32 val = *((S32*) color.mV);

-			gTransformColorProgram.uniform1i("color_in", val);
+			gTransformColorProgram.uniform1i(sColorIn, val);
 			glBeginTransformFeedback(GL_POINTS);
 			buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
 			push_for_transform(buff, vf.mNumVertices, mGeomCount);
@@ -1453,7 +1456,7 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume,
 						 (glow << 16) |
 						 (glow << 24);

-			gTransformColorProgram.uniform1i("color_in", glow32);
+			gTransformColorProgram.uniform1i(sColorIn, glow32);
 			glBeginTransformFeedback(GL_POINTS);
 			buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
 			push_for_transform(buff, vf.mNumVertices, mGeomCount);
--- a/indra/newview/llmaniptranslate.cpp
+++ b/indra/newview/llmaniptranslate.cpp
@@ -1696,7 +1696,8 @@ void LLManipTranslate::highlightIntersection(LLVector3 normal,

 		gGL.getModelviewMatrix().inverse().mult_vec_matrix(plane);

-		gClipProgram.uniform4fv("clip_plane", 1, plane.v);
+		static LLStaticHashedString sClipPlane("clip_plane");
+		gClipProgram.uniform4fv(sClipPlane, 1, plane.v);
 		
 		BOOL particles = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES);
 #if ENABLE_CLASSIC_CLOUDS
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -57,6 +57,13 @@
 #define UNIFORM_ERRS LL_ERRS("Shader")
 #endif

+static LLStaticHashedString sTexture0("texture0");
+static LLStaticHashedString sTexture1("texture1");
+static LLStaticHashedString sTex0("tex0");
+static LLStaticHashedString sTex1("tex1");
+static LLStaticHashedString sGlowMap("glowMap");
+static LLStaticHashedString sScreenMap("screenMap");
+
 // Lots of STL stuff in here, using namespace std to keep things more readable
 using std::vector;
 using std::pair;
@@ -331,11 +338,6 @@ void LLViewerShaderMgr::setShaders()
 		}
 	}
 	
-	//setup preprocessor definitions
-	LLShaderMgr::instance()->mDefinitions.clear();
-	LLShaderMgr::instance()->mDefinitions["samples"] = llformat("%d", gSavedSettings.getU32("RenderFSAASamples"));
-	LLShaderMgr::instance()->mDefinitions["NUM_TEX_UNITS"] = llformat("%d", gGLManager.mNumTextureImageUnits);
-
 	initAttribsAndUniforms();
 	gPipeline.releaseGLBuffers();

@@ -724,7 +726,7 @@ BOOL LLViewerShaderMgr::loadBasicShaders()
 	for (U32 i = 0; i < shaders.size(); i++)
 	{
 		// Note usage of GL_FRAGMENT_SHADER_ARB
-		if (loadShaderFile(shaders[i].first, shaders[i].second, GL_FRAGMENT_SHADER_ARB, index_channels[i]) == 0)
+		if (loadShaderFile(shaders[i].first, shaders[i].second, GL_FRAGMENT_SHADER_ARB, NULL, index_channels[i]) == 0)
 		{
 			return FALSE;
 		}
@@ -756,7 +758,7 @@ BOOL LLViewerShaderMgr::loadShadersEnvironment()
 		gTerrainProgram.mShaderFiles.push_back(make_pair("environment/terrainV.glsl", GL_VERTEX_SHADER_ARB));
 		gTerrainProgram.mShaderFiles.push_back(make_pair("environment/terrainF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gTerrainProgram.mShaderLevel = mVertexShaderLevel[SHADER_ENVIRONMENT];
-		success = gTerrainProgram.createShader(NULL, &mTerrainUniforms);
+		success = gTerrainProgram.createShader(NULL, NULL);
 	}

 	if (!success)
@@ -792,7 +794,7 @@ BOOL LLViewerShaderMgr::loadShadersWater()
 		gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterV.glsl", GL_VERTEX_SHADER_ARB));
 		gWaterProgram.mShaderFiles.push_back(make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_WATER];
-		success = gWaterProgram.createShader(NULL, &mWaterUniforms);
+		success = gWaterProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -806,7 +808,7 @@ BOOL LLViewerShaderMgr::loadShadersWater()
 		gUnderWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_WATER];
 		gUnderWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		
-		success = gUnderWaterProgram.createShader(NULL, &mWaterUniforms);
+		success = gUnderWaterProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -824,7 +826,7 @@ BOOL LLViewerShaderMgr::loadShadersWater()
 		gTerrainWaterProgram.mShaderFiles.push_back(make_pair("environment/terrainWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gTerrainWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_ENVIRONMENT];
 		gTerrainWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		terrainWaterSuccess = gTerrainWaterProgram.createShader(NULL, &mTerrainUniforms);
+		terrainWaterSuccess = gTerrainWaterProgram.createShader(NULL, NULL);
 	}	

 	/// Keep track of water shader levels
@@ -872,7 +874,7 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 			gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowV.glsl", GL_VERTEX_SHADER_ARB));
 			gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowF.glsl", GL_FRAGMENT_SHADER_ARB));
 			gGlowProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
-			success = gGlowProgram.createShader(NULL, &mGlowUniforms);
+			success = gGlowProgram.createShader(NULL, NULL);
 			LLPipeline::sRenderGlow = success;
 		}
 		
@@ -883,7 +885,7 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 			gGlowExtractProgram.mShaderFiles.push_back(make_pair("effects/glowExtractV.glsl", GL_VERTEX_SHADER_ARB));
 			gGlowExtractProgram.mShaderFiles.push_back(make_pair("effects/glowExtractF.glsl", GL_FRAGMENT_SHADER_ARB));
 			gGlowExtractProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
-			success = gGlowExtractProgram.createShader(NULL, &mGlowExtractUniforms);
+			success = gGlowExtractProgram.createShader(NULL, NULL);
 			LLPipeline::sRenderGlow = success;
 		}
 	}
@@ -895,13 +897,16 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 	//load Color Filter Shader
 	//if (success)
 	{
-		vector<string> shaderUniforms;
-		shaderUniforms.reserve(6);
-		shaderUniforms.push_back("gamma");
-		shaderUniforms.push_back("brightness");
-		shaderUniforms.push_back("contrast");
-		shaderUniforms.push_back("contrastBase");
-		shaderUniforms.push_back("saturation");
+		static std::vector<LLStaticHashedString> shaderUniforms;
+		if(shaderUniforms.empty())
+		{
+			shaderUniforms.reserve(6);
+			shaderUniforms.push_back(LLStaticHashedString("gamma"));
+			shaderUniforms.push_back(LLStaticHashedString("brightness"));
+			shaderUniforms.push_back(LLStaticHashedString("contrast"));
+			shaderUniforms.push_back(LLStaticHashedString("contrastBase"));
+			shaderUniforms.push_back(LLStaticHashedString("saturation"));
+		}

 		gPostColorFilterProgram.mName = "Color Filter Shader (Post)";
 		gPostColorFilterProgram.mShaderFiles.clear();
@@ -911,36 +916,41 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 		if(gPostColorFilterProgram.createShader(NULL, &shaderUniforms))
 		{
 			gPostColorFilterProgram.bind();
-			gPostColorFilterProgram.uniform1i("tex0", 0);
+			gPostColorFilterProgram.uniform1i(sTex0, 0);
 		}
 	}

 	//load Night Vision Shader
 	//if (success)
 	{
-		vector<string> shaderUniforms;
-		shaderUniforms.reserve(3);
-		shaderUniforms.push_back("brightMult");
-		shaderUniforms.push_back("noiseStrength");
-
+		static std::vector<LLStaticHashedString> shaderUniforms;
+		if(shaderUniforms.empty())
+		{
+			shaderUniforms.reserve(3);
+			shaderUniforms.push_back(LLStaticHashedString("brightMult"));
+			shaderUniforms.push_back(LLStaticHashedString("noiseStrength"));
+		}
 		gPostNightVisionProgram.mName = "Night Vision Shader (Post)";
 		gPostNightVisionProgram.mShaderFiles.clear();
 		gPostNightVisionProgram.mShaderFiles.push_back(make_pair("effects/nightVisionF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gPostNightVisionProgram.mShaderFiles.push_back(make_pair("interface/twotextureaddV.glsl", GL_VERTEX_SHADER_ARB));
+		gPostNightVisionProgram.mShaderFiles.push_back(make_pair("interface/onetexturenocolorV.glsl", GL_VERTEX_SHADER_ARB));
 		gPostNightVisionProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
 		if(gPostNightVisionProgram.createShader(NULL, &shaderUniforms))
 		{
 			gPostNightVisionProgram.bind();
-			gPostNightVisionProgram.uniform1i("tex0", 0);
-			gPostNightVisionProgram.uniform1i("tex1", 1);
+			gPostNightVisionProgram.uniform1i(sTex0, 0);
+			gPostNightVisionProgram.uniform1i(sTex1, 1);
 		}
 	}

 	//if (success)
 	{
-		vector<string> shaderUniforms;
-		shaderUniforms.reserve(1);
-		shaderUniforms.push_back("horizontalPass");
+		static std::vector<LLStaticHashedString> shaderUniforms;
+		if(shaderUniforms.empty())
+		{
+			shaderUniforms.reserve(1);
+			shaderUniforms.push_back(LLStaticHashedString("horizontalPass"));
+		}

 		gPostGaussianBlurProgram.mName = "Gaussian Blur Shader (Post)";
 		gPostGaussianBlurProgram.mShaderFiles.clear();
@@ -950,14 +960,17 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 		if(gPostGaussianBlurProgram.createShader(NULL, &shaderUniforms))
 		{
 			gPostGaussianBlurProgram.bind();
-			gPostGaussianBlurProgram.uniform1i("tex0", 0);
+			gPostGaussianBlurProgram.uniform1i(sTex0, 0);
 		}
 	}

 	{
-		vector<string> shaderUniforms;
-		shaderUniforms.reserve(1);
-		shaderUniforms.push_back("layerCount");
+		static std::vector<LLStaticHashedString> shaderUniforms;
+		if(shaderUniforms.empty())
+		{
+			shaderUniforms.reserve(1);
+			shaderUniforms.push_back(LLStaticHashedString("layerCount"));
+		}

 		gPostPosterizeProgram.mName = "Posterize Shader (Post)";
 		gPostPosterizeProgram.mShaderFiles.clear();
@@ -967,16 +980,19 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 		if(gPostPosterizeProgram.createShader(NULL, &shaderUniforms))
 		{
 			gPostPosterizeProgram.bind();
-			gPostPosterizeProgram.uniform1i("tex0", 0);
+			gPostPosterizeProgram.uniform1i(sTex0, 0);
 		}
 	}

 	{
-		vector<string> shaderUniforms;
-		shaderUniforms.reserve(3);
-		shaderUniforms.push_back("inv_proj");
-		shaderUniforms.push_back("prev_proj");
-		shaderUniforms.push_back("screen_res");
+		static std::vector<LLStaticHashedString> shaderUniforms;
+		if(shaderUniforms.empty())
+		{
+			shaderUniforms.reserve(3);
+			shaderUniforms.push_back(LLStaticHashedString("inv_proj"));
+			shaderUniforms.push_back(LLStaticHashedString("prev_proj"));
+			shaderUniforms.push_back(LLStaticHashedString("screen_res"));
+		}

 		gPostMotionBlurProgram.mName = "Motion Blur Shader (Post)";
 		gPostMotionBlurProgram.mShaderFiles.clear();
@@ -986,17 +1002,20 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 		if(gPostMotionBlurProgram.createShader(NULL, &shaderUniforms))
 		{
 			gPostMotionBlurProgram.bind();
-			gPostMotionBlurProgram.uniform1i("tex0", 0);
-			gPostMotionBlurProgram.uniform1i("tex1", 1);
+			gPostMotionBlurProgram.uniform1i(sTex0, 0);
+			gPostMotionBlurProgram.uniform1i(sTex1, 1);
 		}
 	}

 	{
-		vector<string> shaderUniforms;
-		shaderUniforms.reserve(3);
-		shaderUniforms.push_back("vignette_darkness");
-		shaderUniforms.push_back("vignette_radius");
-		shaderUniforms.push_back("screen_res");
+		static std::vector<LLStaticHashedString> shaderUniforms;
+		if(shaderUniforms.empty())
+		{
+			shaderUniforms.reserve(3);
+			shaderUniforms.push_back(LLStaticHashedString("vignette_darkness"));
+			shaderUniforms.push_back(LLStaticHashedString("vignette_radius"));
+			shaderUniforms.push_back(LLStaticHashedString("screen_res"));
+		}

 		gPostVignetteProgram.mName = "Vignette Shader (Post)";
 		gPostVignetteProgram.mShaderFiles.clear();
@@ -1006,7 +1025,7 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 		if(gPostVignetteProgram.createShader(NULL, &shaderUniforms))
 		{
 			gPostVignetteProgram.bind();
-			gPostVignetteProgram.uniform1i("tex0", 0);
+			gPostVignetteProgram.uniform1i(sTex0, 0);
 		}
 	}

@@ -1314,7 +1333,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredWaterProgram.mShaderFiles.push_back(make_pair("deferred/waterV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredWaterProgram.mShaderFiles.push_back(make_pair("deferred/waterF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
-		success = gDeferredWaterProgram.createShader(NULL, &mWaterUniforms);
+		success = gDeferredWaterProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -1373,7 +1392,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarShadowV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredAvatarShadowProgram.mShaderFiles.push_back(make_pair("deferred/avatarShadowF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredAvatarShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
-		success = gDeferredAvatarShadowProgram.createShader(NULL, &mAvatarUniforms);
+		success = gDeferredAvatarShadowProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -1394,7 +1413,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredTerrainProgram.mShaderFiles.push_back(make_pair("deferred/terrainV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredTerrainProgram.mShaderFiles.push_back(make_pair("deferred/terrainF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredTerrainProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
-		success = gDeferredTerrainProgram.createShader(NULL, &mTerrainUniforms);
+		success = gDeferredTerrainProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -1405,7 +1424,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarProgram.mShaderFiles.push_back(make_pair("deferred/avatarV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredAvatarProgram.mShaderFiles.push_back(make_pair("deferred/avatarF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredAvatarProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
-		success = gDeferredAvatarProgram.createShader(NULL, &mAvatarUniforms);
+		success = gDeferredAvatarProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -1425,7 +1444,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarAlphaProgram.mShaderFiles.push_back(make_pair("deferred/alphaNonIndexedNoColorF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredAvatarAlphaProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];

-		success = gDeferredAvatarAlphaProgram.createShader(NULL, &mAvatarUniforms);
+		success = gDeferredAvatarAlphaProgram.createShader(NULL, NULL);

 		gDeferredAvatarAlphaProgram.mFeatures.calculatesLighting = true;
 		gDeferredAvatarAlphaProgram.mFeatures.hasLighting = true;
@@ -1490,7 +1509,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredWLSkyProgram.mShaderFiles.push_back(make_pair("deferred/skyF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredWLSkyProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredWLSkyProgram.mShaderGroup = LLGLSLShader::SG_SKY;
-		success = gDeferredWLSkyProgram.createShader(NULL, &mWLUniforms);
+		success = gDeferredWLSkyProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -1501,14 +1520,19 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredWLCloudProgram.mShaderFiles.push_back(make_pair("deferred/cloudsF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredWLCloudProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredWLCloudProgram.mShaderGroup = LLGLSLShader::SG_SKY;
-		success = gDeferredWLCloudProgram.createShader(NULL, &mWLUniforms);
+		success = gDeferredWLCloudProgram.createShader(NULL, NULL);
 	}

 	if (success)
 	{
 		gDeferredStarProgram.mName = "Deferred Star Program";
-		vector<string> shaderUniforms(mWLUniforms);
-		shaderUniforms.push_back("custom_alpha");
+		static std::vector<LLStaticHashedString> shaderUniforms;
+		static bool bUniformsInitted = false;
+		if(!bUniformsInitted)
+		{
+			bUniformsInitted = true;
+			shaderUniforms.push_back(LLStaticHashedString("custom_alpha"));
+		}
 		gDeferredStarProgram.mShaderFiles.clear();
 		gDeferredStarProgram.mShaderFiles.push_back(make_pair("deferred/starsV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredStarProgram.mShaderFiles.push_back(make_pair("deferred/starsF.glsl", GL_FRAGMENT_SHADER_ARB));
@@ -1819,7 +1843,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectShinyNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
 		gObjectShinyNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER_ARB));		
 		gObjectShinyNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectShinyNonIndexedProgram.createShader(NULL, &mShinyUniforms);
+		success = gObjectShinyNonIndexedProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -1836,7 +1860,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectShinyNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
 		gObjectShinyNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectShinyNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectShinyNonIndexedWaterProgram.createShader(NULL, &mShinyUniforms);
+		success = gObjectShinyNonIndexedWaterProgram.createShader(NULL, NULL);
 	}
 	
 	if (success)
@@ -1852,7 +1876,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER_ARB));
 		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gObjectFullbrightShinyNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectFullbrightShinyNonIndexedProgram.createShader(NULL, &mShinyUniforms);
+		success = gObjectFullbrightShinyNonIndexedProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -1870,7 +1894,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectFullbrightShinyNonIndexedWaterProgram.createShader(NULL, &mShinyUniforms);
+		success = gObjectFullbrightShinyNonIndexedWaterProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -1949,12 +1973,11 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectBumpProgram.mShaderFiles.push_back(make_pair("objects/bumpF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gObjectBumpProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectBumpProgram.createShader(NULL, NULL);
-
 		if (success)
 		{ //lldrawpoolbump assumes "texture0" has channel 0 and "texture1" has channel 1
 			gObjectBumpProgram.bind();
-			gObjectBumpProgram.uniform1i("texture0", 0);
-			gObjectBumpProgram.uniform1i("texture1", 1);
+			gObjectBumpProgram.uniform1i(sTexture0, 0);
+			gObjectBumpProgram.uniform1i(sTexture1, 1);
 			gObjectBumpProgram.unbind();
 		}
 	}
@@ -2103,7 +2126,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectShinyProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
 		gObjectShinyProgram.mShaderFiles.push_back(make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER_ARB));		
 		gObjectShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectShinyProgram.createShader(NULL, &mShinyUniforms);
+		success = gObjectShinyProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -2120,7 +2143,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
 		gObjectShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectShinyWaterProgram.createShader(NULL, &mShinyUniforms);
+		success = gObjectShinyWaterProgram.createShader(NULL, NULL);
 	}
 	
 	if (success)
@@ -2136,7 +2159,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER_ARB));
 		gObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gObjectFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectFullbrightShinyProgram.createShader(NULL, &mShinyUniforms);
+		success = gObjectFullbrightShinyProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -2154,7 +2177,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gObjectFullbrightShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectFullbrightShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectFullbrightShinyWaterProgram.createShader(NULL, &mShinyUniforms);
+		success = gObjectFullbrightShinyWaterProgram.createShader(NULL, NULL);
 	}

 	if (mVertexShaderLevel[SHADER_AVATAR] > 0)
@@ -2239,7 +2262,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER_ARB));
 			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER_ARB));
 			gSkinnedObjectFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectFullbrightShinyProgram.createShader(NULL, &mShinyUniforms);
+			success = gSkinnedObjectFullbrightShinyProgram.createShader(NULL, NULL);
 		}

 		if (success)
@@ -2256,7 +2279,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectShinySimpleProgram.mShaderFiles.push_back(make_pair("objects/shinySimpleSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
 			gSkinnedObjectShinySimpleProgram.mShaderFiles.push_back(make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER_ARB));
 			gSkinnedObjectShinySimpleProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectShinySimpleProgram.createShader(NULL, &mShinyUniforms);
+			success = gSkinnedObjectShinySimpleProgram.createShader(NULL, NULL);
 		}

 		if (success)
@@ -2313,7 +2336,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER_ARB));
 			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
 			gSkinnedObjectFullbrightShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectFullbrightShinyWaterProgram.createShader(NULL, &mShinyUniforms);
+			success = gSkinnedObjectFullbrightShinyWaterProgram.createShader(NULL, NULL);
 		}

 		if (success)
@@ -2332,7 +2355,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/shinySimpleSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
 			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
 			gSkinnedObjectShinySimpleWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectShinySimpleWaterProgram.createShader(NULL, &mShinyUniforms);
+			success = gSkinnedObjectShinySimpleWaterProgram.createShader(NULL, NULL);
 		}
 	}

@@ -2370,7 +2393,7 @@ BOOL LLViewerShaderMgr::loadShadersAvatar()
 		gAvatarProgram.mShaderFiles.push_back(make_pair("avatar/avatarV.glsl", GL_VERTEX_SHADER_ARB));
 		gAvatarProgram.mShaderFiles.push_back(make_pair("avatar/avatarF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gAvatarProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
-		success = gAvatarProgram.createShader(NULL, &mAvatarUniforms);
+		success = gAvatarProgram.createShader(NULL, NULL);
 			
 		if (success)
 		{
@@ -2389,7 +2412,7 @@ BOOL LLViewerShaderMgr::loadShadersAvatar()
 			// Note: no cloth under water:
 			gAvatarWaterProgram.mShaderLevel = llmin(mVertexShaderLevel[SHADER_AVATAR], 1);	
 			gAvatarWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;				
-			success = gAvatarWaterProgram.createShader(NULL, &mAvatarUniforms);
+			success = gAvatarWaterProgram.createShader(NULL, NULL);
 		}

 		/// Keep track of avatar levels
@@ -2408,7 +2431,7 @@ BOOL LLViewerShaderMgr::loadShadersAvatar()
 		gAvatarPickProgram.mShaderFiles.push_back(make_pair("avatar/pickAvatarV.glsl", GL_VERTEX_SHADER_ARB));
 		gAvatarPickProgram.mShaderFiles.push_back(make_pair("avatar/pickAvatarF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gAvatarPickProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
-		success = gAvatarPickProgram.createShader(NULL, &mAvatarUniforms);
+		success = gAvatarPickProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -2490,7 +2513,7 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gSplatTextureRectProgram.bind();
-			gSplatTextureRectProgram.uniform1i("screenMap", 0);
+			gSplatTextureRectProgram.uniform1i(sScreenMap, 0);
 			gSplatTextureRectProgram.unbind();
 		}
 	}
@@ -2506,8 +2529,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gGlowCombineProgram.bind();
-			gGlowCombineProgram.uniform1i("glowMap", 0);
-			gGlowCombineProgram.uniform1i("screenMap", 1);
+			gGlowCombineProgram.uniform1i(sGlowMap, 0);
+			gGlowCombineProgram.uniform1i(sScreenMap, 1);
 			gGlowCombineProgram.unbind();
 		}
 	}
@@ -2523,8 +2546,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gGlowCombineFXAAProgram.bind();
-			gGlowCombineFXAAProgram.uniform1i("glowMap", 0);
-			gGlowCombineFXAAProgram.uniform1i("screenMap", 1);
+			gGlowCombineFXAAProgram.uniform1i(sGlowMap, 0);
+			gGlowCombineFXAAProgram.uniform1i(sScreenMap, 1);
 			gGlowCombineFXAAProgram.unbind();
 		}
 	}
@@ -2541,8 +2564,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gTwoTextureAddProgram.bind();
-			gTwoTextureAddProgram.uniform1i("tex0", 0);
-			gTwoTextureAddProgram.uniform1i("tex1", 1);
+			gTwoTextureAddProgram.uniform1i(sTex0, 0);
+			gTwoTextureAddProgram.uniform1i(sTex1, 1);
 		}
 	}

@@ -2557,7 +2580,7 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gOneTextureNoColorProgram.bind();
-			gOneTextureNoColorProgram.uniform1i("tex0", 0);
+			gOneTextureNoColorProgram.uniform1i(sTex0, 0);
 		}
 	}

@@ -2577,7 +2600,7 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gSolidColorProgram.bind();
-			gSolidColorProgram.uniform1i("tex0", 0);
+			gSolidColorProgram.uniform1i(sTex0, 0);
 			gSolidColorProgram.unbind();
 		}
 	}
@@ -2660,7 +2683,7 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
 		gWLSkyProgram.mShaderFiles.push_back(make_pair("windlight/skyF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gWLSkyProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
 		gWLSkyProgram.mShaderGroup = LLGLSLShader::SG_SKY;
-		success = gWLSkyProgram.createShader(NULL, &mWLUniforms);
+		success = gWLSkyProgram.createShader(NULL, NULL);
 	}

 	if (success)
@@ -2672,7 +2695,7 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
 		gWLCloudProgram.mShaderFiles.push_back(make_pair("windlight/cloudsF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gWLCloudProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
 		gWLCloudProgram.mShaderGroup = LLGLSLShader::SG_SKY;
-		success = gWLCloudProgram.createShader(NULL, &mWLUniforms);
+		success = gWLCloudProgram.createShader(NULL, NULL);
 	}

 	return success;
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -80,57 +80,6 @@ public:
 		SHADER_COUNT
 	};

-	typedef enum
-	{
-		SHINY_ORIGIN = END_RESERVED_UNIFORMS
-	} eShinyUniforms;
-
-	typedef enum
-	{
-		WATER_SCREENTEX = END_RESERVED_UNIFORMS,
-		WATER_SCREENDEPTH,
-		WATER_REFTEX,
-		WATER_EYEVEC,
-		WATER_TIME,
-		WATER_WAVE_DIR1,
-		WATER_WAVE_DIR2,
-		WATER_LIGHT_DIR,
-		WATER_SPECULAR,
-		WATER_SPECULAR_EXP,
-		WATER_FOGCOLOR,
-		WATER_FOGDENSITY,
-		WATER_REFSCALE,
-		WATER_WATERHEIGHT,
-	} eWaterUniforms;
-
-	typedef enum
-	{
-		WL_CAMPOSLOCAL = END_RESERVED_UNIFORMS,
-		WL_WATERHEIGHT
-	} eWLUniforms;
-
-	typedef enum
-	{
-		TERRAIN_DETAIL0 = END_RESERVED_UNIFORMS,
-		TERRAIN_DETAIL1,
-		TERRAIN_DETAIL2,
-		TERRAIN_DETAIL3,
-		TERRAIN_ALPHARAMP
-	} eTerrainUniforms;
-
-	typedef enum
-	{
-		GLOW_DELTA = END_RESERVED_UNIFORMS
-	} eGlowUniforms;
-
-	typedef enum
-	{
-		AVATAR_MATRIX = END_RESERVED_UNIFORMS,
-		AVATAR_WIND,
-		AVATAR_SINWAVE,
-		AVATAR_GRAVITY,
-	} eAvatarUniforms;
-
 	// simple model of forward iterator
 	// http://www.sgi.com/tech/stl/ForwardIterator.html
 	class shader_iter
--- a/indra/newview/llwaterparammanager.cpp
+++ b/indra/newview/llwaterparammanager.cpp
@@ -320,12 +320,12 @@ void LLWaterParamManager::updateShaderUniforms(LLGLSLShader * shader)
 	if (shader->mShaderGroup == LLGLSLShader::SG_WATER)
 	{
 		shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, LLWLParamManager::getInstance()->getRotatedLightDir().mV);
-		shader->uniform3fv("camPosLocal", 1, LLViewerCamera::getInstance()->getOrigin().mV);
-		shader->uniform4fv("waterFogColor", 1, LLDrawPoolWater::sWaterFogColor.mV);
-		shader->uniform4fv("waterPlane", 1, mWaterPlane.mV);
-		shader->uniform1f("waterFogDensity", getFogDensity());
-		shader->uniform1f("waterFogKS", mWaterFogKS);
-		shader->uniform1f("distance_multiplier", 0);
+		shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
+		shader->uniform4fv(LLShaderMgr::WATER_FOGCOLOR, 1, LLDrawPoolWater::sWaterFogColor.mV);
+		shader->uniform4fv(LLShaderMgr::WATER_WATERPLANE, 1, mWaterPlane.mV);
+		shader->uniform1f(LLShaderMgr::WATER_FOGDENSITY, getFogDensity());
+		shader->uniform1f(LLShaderMgr::WATER_FOGKS, mWaterFogKS);
+		shader->uniform1f(LLViewerShaderMgr::DISTANCE_MULTIPLIER, 0);
 	}
 }

--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -373,8 +373,8 @@ void LLWLParamManager::updateShaderUniforms(LLGLSLShader * shader)

 	if (shader->mShaderGroup == LLGLSLShader::SG_DEFAULT)
 	{
-		shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, mRotatedLightDir.mV);
-		shader->uniform3fv("camPosLocal", 1, LLViewerCamera::getInstance()->getOrigin().mV);
+		shader->uniform4fv(LLShaderMgr::LIGHTNORM, 1, mRotatedLightDir.mV);
+		shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
 	} 

 	else if (shader->mShaderGroup == LLGLSLShader::SG_SKY)
@@ -382,7 +382,7 @@ void LLWLParamManager::updateShaderUniforms(LLGLSLShader * shader)
 		shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, mClampedLightDir.mV);
 	}

-	shader->uniform1f("scene_light_strength", mSceneLightStrength);
+	shader->uniform1f(LLShaderMgr::SCENE_LIGHT_STRENGTH, mSceneLightStrength);
 	
 }

--- a/indra/newview/llwlparamset.cpp
+++ b/indra/newview/llwlparamset.cpp
@@ -44,6 +44,22 @@

 #include <sstream>

+static LLStaticHashedString sStarBrightness("star_brightness");
+static LLStaticHashedString sPresetNum("preset_num");
+static LLStaticHashedString sSunAngle("sun_angle");
+static LLStaticHashedString sEastAngle("east_angle");
+static LLStaticHashedString sEnableCloudScroll("enable_cloud_scroll");
+static LLStaticHashedString sCloudScrollRate("cloud_scroll_rate");
+static LLStaticHashedString sLightNorm("lightnorm");
+static LLStaticHashedString sCloudDensity("cloud_pos_density1");
+static LLStaticHashedString sCloudScale("cloud_scale");
+static LLStaticHashedString sCloudShadow("cloud_shadow");
+static LLStaticHashedString sDensityMultiplier("density_multiplier");
+static LLStaticHashedString sDistanceMultiplier("distance_multiplier");
+static LLStaticHashedString sHazeDensity("haze_density");
+static LLStaticHashedString sHazeHorizon("haze_horizon");
+static LLStaticHashedString sMaxY("max_y");
+
 LLWLParamSet::LLWLParamSet(void) :
 	mName("Unnamed Preset"),
 	mCloudScrollXOffset(0.f), mCloudScrollYOffset(0.f)	
@@ -54,21 +70,24 @@ static LLFastTimer::DeclareTimer FTM_WL_PARAM_UPDATE("WL Param Update");
 void LLWLParamSet::update(LLGLSLShader * shader) const 
 {	
 	LLFastTimer t(FTM_WL_PARAM_UPDATE);
-
-	for(LLSD::map_const_iterator i = mParamValues.beginMap();
-		i != mParamValues.endMap();
-		++i)
+	LLSD::map_const_iterator i = mParamValues.beginMap();
+	std::vector<LLStaticHashedString>::const_iterator n = mParamHashedNames.begin();
+	for(;(i != mParamValues.endMap()) && (n != mParamHashedNames.end());++i, n++)
 	{
-		const std::string& param = i->first;
+		const LLStaticHashedString& param = *n;
 		
-		if(	param == "star_brightness" || param == "preset_num" || param == "sun_angle" ||
-			param == "east_angle" || param == "enable_cloud_scroll" ||
-			param == "cloud_scroll_rate" || param == "lightnorm" ) 
+		// check that our pre-hashed names are still tracking the mParamValues map correctly
+		//
+		llassert(param.String() == i->first);
+
+		if (param == sStarBrightness || param == sPresetNum || param == sSunAngle ||
+			param == sEastAngle || param == sEnableCloudScroll ||
+			param == sCloudScrollRate || param == sLightNorm ) 
 		{
 			continue;
 		}
 		
-		if(param == "cloud_pos_density1") 
+		if (param == sCloudDensity)
 		{
 			LLVector4 val;
 			val.mV[0] = F32(i->second[0].asReal()) + mCloudScrollXOffset;
@@ -80,10 +99,10 @@ void LLWLParamSet::update(LLGLSLShader * shader) const
 			shader->uniform4fv(param, 1, val.mV);
 			stop_glerror();
 		}
-		else if (param == "cloud_scale" || param == "cloud_shadow" ||
-				 param == "density_multiplier" || param == "distance_multiplier" ||
-				 param == "haze_density" || param == "haze_horizon" ||
-				 param == "max_y" )
+		else if (param == sCloudScale || param == sCloudShadow ||
+				 param == sDensityMultiplier || param == sDistanceMultiplier ||
+				 param == sHazeDensity || param == sHazeHorizon ||
+				 param == sMaxY )
 		{
 			F32 val = (F32) i->second[0].asReal();

@@ -384,3 +403,14 @@ void LLWLParamSet::updateCloudScrolling(void)
 		mCloudScrollYOffset += F32(delta_t * (getCloudScrollY() - 10.f) / 100.f);
 	}
 }
+
+void LLWLParamSet::updateHashedNames()
+{
+	mParamHashedNames.clear();
+	// Iterate through values
+	for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
+	{
+		mParamHashedNames.push_back(LLStaticHashedString(iter->first));
+	}
+}
+
--- a/indra/newview/llwlparamset.h
+++ b/indra/newview/llwlparamset.h
@@ -38,6 +38,7 @@

 #include "v4math.h"
 #include "v4color.h"
+#include "llstaticstringtable.h"

 class LLWLParamSet;
 class LLGLSLShader;
@@ -54,9 +55,12 @@ public:
 private:

 	LLSD mParamValues;
-	
+	std::vector<LLStaticHashedString> mParamHashedNames;
+
 	float mCloudScrollXOffset, mCloudScrollYOffset;

+	void updateHashedNames();
+
 public:

 	LLWLParamSet();
@@ -184,6 +188,8 @@ inline void LLWLParamSet::setAll(const LLSD& val)
 	if(val.isMap()) {
 		mParamValues = val;
 	}
+
+	updateHashedNames();
 }

 inline const LLSD& LLWLParamSet::getAll()
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -204,6 +204,12 @@ LLFastTimer::DeclareTimer FTM_RENDER_DEFERRED("Deferred Shading");
 static LLFastTimer::DeclareTimer FTM_STATESORT_DRAWABLE("Sort Drawables");
 static LLFastTimer::DeclareTimer FTM_STATESORT_POSTSORT("Post Sort");

+static LLStaticHashedString sNormMat("norm_mat");
+static LLStaticHashedString sOffset("offset");
+static LLStaticHashedString sDelta("delta");
+static LLStaticHashedString sDistFactor("dist_factor");
+static LLStaticHashedString sKern("kern");
+static LLStaticHashedString sKernScale("kern_scale");
 //----------------------------------------
 std::string gPoolNames[] = 
 {
@@ -7478,10 +7484,10 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, U32 light_index, U32 n
 	shader.uniform1f(LLShaderMgr::DEFERRED_NORM_CUTOFF, RenderEdgeNormCutoff);
 	

-	if (shader.getUniformLocation("norm_mat") >= 0)
+	if (shader.getUniformLocation(LLShaderMgr::DEFERRED_NORM_MATRIX) >= 0)
 	{
 		glh::matrix4f norm_mat = glh_get_current_modelview().inverse().transpose();
-		shader.uniformMatrix4fv("norm_mat", 1, FALSE, norm_mat.m);
+		shader.uniformMatrix4fv(LLShaderMgr::DEFERRED_NORM_MATRIX, 1, FALSE, norm_mat.m);
 	}
 }

@@ -7617,8 +7623,8 @@ void LLPipeline::renderDeferredLighting()
 					}
 				}

-				gDeferredSunProgram.uniform3fv("offset", slice, offset);
-				gDeferredSunProgram.uniform2f("screenRes", mDeferredLight.getWidth(), mDeferredLight.getHeight());
+				gDeferredSunProgram.uniform3fv(sOffset, slice, offset);
+				gDeferredSunProgram.uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, mDeferredLight.getWidth(), mDeferredLight.getHeight());
 				
 				{
 					LLGLDisable blend(GL_BLEND);
@@ -7662,10 +7668,10 @@ void LLPipeline::renderDeferredLighting()
 				x += 1.f;
 			}

-			gDeferredBlurLightProgram.uniform2f("delta", 1.f, 0.f);
-			gDeferredBlurLightProgram.uniform1f("dist_factor", dist_factor);
-			gDeferredBlurLightProgram.uniform3fv("kern", kern_length, gauss[0].mV);
-			gDeferredBlurLightProgram.uniform1f("kern_scale", blur_size * (kern_length/2.f - 0.5f));
+			gDeferredBlurLightProgram.uniform2f(sDelta, 1.f, 0.f);
+			gDeferredBlurLightProgram.uniform1f(sDistFactor, dist_factor);
+			gDeferredBlurLightProgram.uniform3fv(sKern, kern_length, gauss[0].mV);
+			gDeferredBlurLightProgram.uniform1f(sKernScale, blur_size * (kern_length/2.f - 0.5f));
 		
 			{
 				LLGLDisable blend(GL_BLEND);
@@ -7682,7 +7688,7 @@ void LLPipeline::renderDeferredLighting()
 			mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
 			mDeferredLight.bindTarget();

-			gDeferredBlurLightProgram.uniform2f("delta", 0.f, 1.f);
+			gDeferredBlurLightProgram.uniform2f(sDelta, 0.f, 1.f);

 			{
 				LLGLDisable blend(GL_BLEND);