33 files changed, 1058 insertions, 940 deletions

diff --git a/indra/newview/lldrawable.cpp b/indra/newview/lldrawable.cpp
index d041baea90..119b8d24d0 100644
--- a/indra/newview/lldrawable.cpp
+++ b/indra/newview/lldrawable.cpp
@@ -577,6 +577,12 @@ F32 LLDrawable::updateXform(BOOL undamped)
 			mVObjp->dirtySpatialGroup();
 		}
 	}
+	else if (!isRoot()
+		&& (   dist_vec_squared(old_pos, target_pos) > 0.f
+			|| (1.f - dot(old_rot, target_rot)) > 0.f))
+        { // update child prims moved from LSL
+                gPipeline.markRebuild(this, LLDrawable::REBUILD_POSITION, TRUE);
+        }
 	else if (!getVOVolume() && !isAvatar())
 	{
 		movePartition();
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index 6d02ad2b96..3cf96a9054 100644
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -1165,85 +1165,85 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
 	{ //render rigged attachments
 		if (!avatarp->isVisuallyMuted())
 		{
-			if (pass == 3)
-			{
-				if (is_deferred_render)
-				{
-					renderDeferredRiggedSimple(avatarp);
-				}
-				else
-				{
-					renderRiggedSimple(avatarp);
-				}
-			}
+	if (pass == 3)
+	{
+		if (is_deferred_render)
+		{
+			renderDeferredRiggedSimple(avatarp);
+		}
+		else
+		{
+			renderRiggedSimple(avatarp);
+		}
+	}
 			else if (pass == 4)
-			{
-				if (is_deferred_render)
-				{
-					renderDeferredRiggedBump(avatarp);
-				}
-				else
-				{
-					renderRiggedFullbright(avatarp);
-				}
-			}
+	{
+		if (is_deferred_render)
+		{
+			renderDeferredRiggedBump(avatarp);
+		}
+		else
+		{
+			renderRiggedFullbright(avatarp);
+		}
+	}
 			else if (pass == 5)
-			{
-				renderRiggedShinySimple(avatarp);
-			}
+	{
+		renderRiggedShinySimple(avatarp);
+	}
 			else if (pass == 6)
-			{
-				renderRiggedFullbrightShiny(avatarp);
-			}
+	{
+		renderRiggedFullbrightShiny(avatarp);
+	}
 			else if (pass >= 7 && pass < 9)
-			{
-				if (pass == 7)
-				{
-					renderRiggedAlpha(avatarp);
-				}
+	{
+		if (pass == 7)
+		{
+			renderRiggedAlpha(avatarp);
+		}
 				else if (pass == 8)
-				{
-					renderRiggedFullbrightAlpha(avatarp);
-				}
-			}
+		{
+			renderRiggedFullbrightAlpha(avatarp);
+		}
+	}
 			else if (pass == 9)
-			{
-				renderRiggedGlow(avatarp);
-			}
+	{
+		renderRiggedGlow(avatarp);
+	}
 		}
 	}
 	else
 	{
-		if ((sShaderLevel >= SHADER_LEVEL_CLOTH))
-		{
-			LLMatrix4 rot_mat;
-			LLViewerCamera::getInstance()->getMatrixToLocal(rot_mat);
-			LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
-			rot_mat *= cfr;
+	if ((sShaderLevel >= SHADER_LEVEL_CLOTH))
+	{
+		LLMatrix4 rot_mat;
+		LLViewerCamera::getInstance()->getMatrixToLocal(rot_mat);
+		LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
+		rot_mat *= cfr;
 		
-			LLVector4 wind;
-			wind.setVec(avatarp->mWindVec);
-			wind.mV[VW] = 0;
-			wind = wind * rot_mat;
-			wind.mV[VW] = avatarp->mWindVec.mV[VW];
-
-			sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_WIND, 1, wind.mV);
-			F32 phase = -1.f * (avatarp->mRipplePhase);
-
-			F32 freq = 7.f + (noise1(avatarp->mRipplePhase) * 2.f);
-			LLVector4 sin_params(freq, freq, freq, phase);
-			sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_SINWAVE, 1, sin_params.mV);
-
-			LLVector4 gravity(0.f, 0.f, -CLOTHING_GRAVITY_EFFECT, 0.f);
-			gravity = gravity * rot_mat;
-			sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_GRAVITY, 1, gravity.mV);
-		}
+		LLVector4 wind;
+		wind.setVec(avatarp->mWindVec);
+		wind.mV[VW] = 0;
+		wind = wind * rot_mat;
+		wind.mV[VW] = avatarp->mWindVec.mV[VW];
 
-		if( !single_avatar || (avatarp == single_avatar) )
-		{
-			avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
-		}
+		sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_WIND, 1, wind.mV);
+		F32 phase = -1.f * (avatarp->mRipplePhase);
+
+		F32 freq = 7.f + (noise1(avatarp->mRipplePhase) * 2.f);
+		LLVector4 sin_params(freq, freq, freq, phase);
+		sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_SINWAVE, 1, sin_params.mV);
+
+		LLVector4 gravity(0.f, 0.f, -CLOTHING_GRAVITY_EFFECT, 0.f);
+		gravity = gravity * rot_mat;
+		sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_GRAVITY, 1, gravity.mV);
 	}
+
+	if( !single_avatar || (avatarp == single_avatar) )
+	{
+		avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
+	}
+}
 }
 
 void LLDrawPoolAvatar::getRiggedGeometry(LLFace* face, LLPointer<LLVertexBuffer>& buffer, U32 data_mask, const LLMeshSkinInfo* skin, LLVolume* volume, const LLVolumeFace& vol_face)
@@ -1505,7 +1505,8 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 				
 				stop_glerror();
 
-				LLDrawPoolAvatar::sVertexProgram->uniformMatrix4fv("matrixPalette", 
+				static LLStaticHashedString sMatPalette("matrixPalette");
+				LLDrawPoolAvatar::sVertexProgram->uniformMatrix4fv(sMatPalette, 
 					skin->mJointNames.size(),
 					FALSE,
 					(GLfloat*) mat[0].mMatrix);
diff --git a/indra/newview/lldrawpoolbump.cpp b/indra/newview/lldrawpoolbump.cpp
index 5a4f9591f7..7e95046479 100644
--- 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(sStepY, 1.f/bump->getHeight());
 
 					LLVector2 v((F32) bump->getWidth()/gPipeline.mScreen.getWidth(),
 								(F32) bump->getHeight()/gPipeline.mScreen.getHeight());
diff --git a/indra/newview/lldrawpoolterrain.cpp b/indra/newview/lldrawpoolterrain.cpp
index 9bc32fddbd..3805348b6b 100644
--- a/indra/newview/lldrawpoolterrain.cpp
+++ b/indra/newview/lldrawpoolterrain.cpp
@@ -49,6 +49,9 @@
 #include "llviewershadermgr.h"
 #include "llrender.h"
 
+static LLStaticHashedString sObjectPlaneS("object_plane_s");
+static LLStaticHashedString sObjectPlaneT("object_plane_t");
+
 const F32 DETAIL_SCALE = 1.f/16.f;
 int DebugDetailMap = 0;
 
@@ -352,8 +355,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(sObjectPlaneS, 1, tp0.mV);
+	shader->uniform4fv(sObjectPlaneT, 1, tp1.mV);
 
 	gGL.matrixMode(LLRender::MM_TEXTURE);
 	gGL.loadIdentity();
@@ -862,8 +865,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(sObjectPlaneS, 1, tp0.mV);
+		sShader->uniform4fv(sObjectPlaneT, 1, tp1.mV);
 	}
 	else
 	{
diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp
index 4f6eaa5a5b..ffe438eb27 100644
--- a/indra/newview/lldrawpoolwater.cpp
+++ b/indra/newview/lldrawpoolwater.cpp
@@ -1,725 +1,736 @@
-/** 
- * @file lldrawpoolwater.cpp
- * @brief LLDrawPoolWater class implementation
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-#include "llfeaturemanager.h"
-#include "lldrawpoolwater.h"
-
-#include "llviewercontrol.h"
-#include "lldir.h"
-#include "llerror.h"
-#include "m3math.h"
-#include "llrender.h"
-
-#include "llagent.h"		// for gAgent for getRegion for getWaterHeight
-#include "llcubemap.h"
-#include "lldrawable.h"
-#include "llface.h"
-#include "llsky.h"
-#include "llviewertexturelist.h"
-#include "llviewerregion.h"
-#include "llvosky.h"
-#include "llvowater.h"
-#include "llworld.h"
-#include "pipeline.h"
-#include "llviewershadermgr.h"
-#include "llwaterparammanager.h"
-
-const LLUUID TRANSPARENT_WATER_TEXTURE("2bfd3884-7e27-69b9-ba3a-3e673f680004");
-const LLUUID OPAQUE_WATER_TEXTURE("43c32285-d658-1793-c123-bf86315de055");
-
-static float sTime;
-
-BOOL deferred_render = FALSE;
-
-BOOL LLDrawPoolWater::sSkipScreenCopy = FALSE;
-BOOL LLDrawPoolWater::sNeedsReflectionUpdate = TRUE;
-BOOL LLDrawPoolWater::sNeedsDistortionUpdate = TRUE;
-LLColor4 LLDrawPoolWater::sWaterFogColor = LLColor4(0.2f, 0.5f, 0.5f, 0.f);
-F32 LLDrawPoolWater::sWaterFogEnd = 0.f;
-
-LLVector3 LLDrawPoolWater::sLightDir;
-
-LLDrawPoolWater::LLDrawPoolWater() :
-	LLFacePool(POOL_WATER)
-{
-	mHBTex[0] = LLViewerTextureManager::getFetchedTexture(gSunTextureID, TRUE, LLViewerTexture::BOOST_UI);
-	gGL.getTexUnit(0)->bind(mHBTex[0]) ;
-	mHBTex[0]->setAddressMode(LLTexUnit::TAM_CLAMP);
-
-	mHBTex[1] = LLViewerTextureManager::getFetchedTexture(gMoonTextureID, TRUE, LLViewerTexture::BOOST_UI);
-	gGL.getTexUnit(0)->bind(mHBTex[1]);
-	mHBTex[1]->setAddressMode(LLTexUnit::TAM_CLAMP);
-
-
-	mWaterImagep = LLViewerTextureManager::getFetchedTexture(TRANSPARENT_WATER_TEXTURE);
-	llassert(mWaterImagep);
-	mWaterImagep->setNoDelete();
-	mOpaqueWaterImagep = LLViewerTextureManager::getFetchedTexture(OPAQUE_WATER_TEXTURE);
-	llassert(mOpaqueWaterImagep);
-	mWaterNormp = LLViewerTextureManager::getFetchedTexture(DEFAULT_WATER_NORMAL);
-	mWaterNormp->setNoDelete();
-
-	restoreGL();
-}
-
-LLDrawPoolWater::~LLDrawPoolWater()
-{
-}
-
-//static
-void LLDrawPoolWater::restoreGL()
-{
-	
-}
-
-LLDrawPool *LLDrawPoolWater::instancePool()
-{
-	llerrs << "Should never be calling instancePool on a water pool!" << llendl;
-	return NULL;
-}
-
-
-void LLDrawPoolWater::prerender()
-{
-	mVertexShaderLevel = (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps) ?
-		LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_WATER) : 0;
-
-	// got rid of modulation by light color since it got a little too
-	// green at sunset and sl-57047 (underwater turns black at 8:00)
-	sWaterFogColor = LLWaterParamManager::instance().getFogColor();
-	sWaterFogColor.mV[3] = 0;
-
-}
-
-S32 LLDrawPoolWater::getNumPasses()
-{
-	if (LLViewerCamera::getInstance()->getOrigin().mV[2] < 1024.f)
-	{
-		return 1;
-	}
-
-	return 0;
-}
-
-void LLDrawPoolWater::beginPostDeferredPass(S32 pass)
-{
-	beginRenderPass(pass);
-	deferred_render = TRUE;
-}
-
-void LLDrawPoolWater::endPostDeferredPass(S32 pass)
-{
-	endRenderPass(pass);
-	deferred_render = FALSE;
-}
-
-//===============================
-//DEFERRED IMPLEMENTATION
-//===============================
-void LLDrawPoolWater::renderDeferred(S32 pass)
-{
-	LLFastTimer t(FTM_RENDER_WATER);
-	deferred_render = TRUE;
-	shade();
-	deferred_render = FALSE;
-}
-
-//=========================================
-
-void LLDrawPoolWater::render(S32 pass)
-{
-	LLFastTimer ftm(FTM_RENDER_WATER);
-	if (mDrawFace.empty() || LLDrawable::getCurrentFrame() <= 1)
-	{
-		return;
-	}
-
-	//do a quick 'n dirty depth sort
-	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-			 iter != mDrawFace.end(); iter++)
-	{
-		LLFace* facep = *iter;
-		facep->mDistance = -facep->mCenterLocal.mV[2];
-	}
-
-	std::sort(mDrawFace.begin(), mDrawFace.end(), LLFace::CompareDistanceGreater());
-
-	// See if we are rendering water as opaque or not
-	if (!gSavedSettings.getBOOL("RenderTransparentWater"))
-	{
-		// render water for low end hardware
-		renderOpaqueLegacyWater();
-		return;
-	}
-
-	LLGLEnable blend(GL_BLEND);
-
-	if ((mVertexShaderLevel > 0) && !sSkipScreenCopy)
-	{
-		shade();
-		return;
-	}
-
-	LLVOSky *voskyp = gSky.mVOSkyp;
-
-	stop_glerror();
-
-	if (!gGLManager.mHasMultitexture)
-	{
-		// Ack!  No multitexture!  Bail!
-		return;
-	}
-
-	LLFace* refl_face = voskyp->getReflFace();
-
-	gPipeline.disableLights();
-	
-	LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
-
-	LLGLDisable cullFace(GL_CULL_FACE);
-	
-	// Set up second pass first
-	mWaterImagep->addTextureStats(1024.f*1024.f);
-	gGL.getTexUnit(1)->activate();
-	gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(1)->bind(mWaterImagep) ;
-
-	LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
-	F32 up_dot = camera_up * LLVector3::z_axis;
-
-	LLColor4 water_color;
-	if (LLViewerCamera::getInstance()->cameraUnderWater())
-	{
-		water_color.setVec(1.f, 1.f, 1.f, 0.4f);
-	}
-	else
-	{
-		water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));
-	}
-
-	gGL.diffuseColor4fv(water_color.mV);
-
-	// Automatically generate texture coords for detail map
-	glEnable(GL_TEXTURE_GEN_S); //texture unit 1
-	glEnable(GL_TEXTURE_GEN_T); //texture unit 1
-	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
-	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
-
-	// Slowly move over time.
-	F32 offset = fmod(gFrameTimeSeconds*2.f, 100.f);
-	F32 tp0[4] = {16.f/256.f, 0.0f, 0.0f, offset*0.01f};
-	F32 tp1[4] = {0.0f, 16.f/256.f, 0.0f, offset*0.01f};
-	glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);
-	glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);
-
-	gGL.getTexUnit(1)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_PREV_COLOR);
-	gGL.getTexUnit(1)->setTextureAlphaBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_ALPHA);
-
-	gGL.getTexUnit(0)->activate();
-	
-	glClearStencil(1);
-	glClear(GL_STENCIL_BUFFER_BIT);
-	LLGLEnable gls_stencil(GL_STENCIL_TEST);
-	glStencilOp(GL_KEEP, GL_REPLACE, GL_KEEP);
-	glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFF);
-
-	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-		 iter != mDrawFace.end(); iter++)
-	{
-		LLFace *face = *iter;
-		if (voskyp->isReflFace(face))
-		{
-			continue;
-		}
-		gGL.getTexUnit(0)->bind(face->getTexture());
-		face->renderIndexed();
-	}
-
-	// Now, disable texture coord generation on texture state 1
-	gGL.getTexUnit(1)->activate();
-	gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(1)->disable();
-	glDisable(GL_TEXTURE_GEN_S); //texture unit 1
-	glDisable(GL_TEXTURE_GEN_T); //texture unit 1
-
-	// Disable texture coordinate and color arrays
-	gGL.getTexUnit(0)->activate();
-	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
-	stop_glerror();
-	
-	if (gSky.mVOSkyp->getCubeMap())
-	{
-		gSky.mVOSkyp->getCubeMap()->enable(0);
-		gSky.mVOSkyp->getCubeMap()->bind();
-
-		gGL.matrixMode(LLRender::MM_TEXTURE);
-		gGL.loadIdentity();
-		LLMatrix4 camera_mat = LLViewerCamera::getInstance()->getModelview();
-		LLMatrix4 camera_rot(camera_mat.getMat3());
-		camera_rot.invert();
-
-		gGL.loadMatrix((F32 *)camera_rot.mMatrix);
-
-		gGL.matrixMode(LLRender::MM_MODELVIEW);
-		LLOverrideFaceColor overrid(this, 1.f, 1.f, 1.f,  0.5f*up_dot);
-
-		gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
-
-		for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-			 iter != mDrawFace.end(); iter++)
-		{
-			LLFace *face = *iter;
-			if (voskyp->isReflFace(face))
-			{
-				//refl_face = face;
-				continue;
-			}
-
-			if (face->getGeomCount() > 0)
-			{					
-				face->renderIndexed();
-			}
-		}
-
-		gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
-
-		gSky.mVOSkyp->getCubeMap()->disable();
-		
-		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-		gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
-		gGL.matrixMode(LLRender::MM_TEXTURE);
-		gGL.loadIdentity();
-		gGL.matrixMode(LLRender::MM_MODELVIEW);
-		
-	}
-
-	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
-
-    if (refl_face)
-	{
-		glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
-		renderReflection(refl_face);
-	}
-
-	gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
-}
-
-// for low end hardware
-void LLDrawPoolWater::renderOpaqueLegacyWater()
-{
-	LLVOSky *voskyp = gSky.mVOSkyp;
-
-	LLGLSLShader* shader = NULL;
-	if (LLGLSLShader::sNoFixedFunction)
-	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			shader = &gObjectSimpleNonIndexedTexGenWaterProgram;
-		}
-		else
-		{
-			shader = &gObjectSimpleNonIndexedTexGenProgram;
-		}
-
-		shader->bind();
-	}
-
-	stop_glerror();
-
-	// Depth sorting and write to depth buffer
-	// since this is opaque, we should see nothing
-	// behind the water.  No blending because
-	// of no transparency.  And no face culling so
-	// that the underside of the water is also opaque.
-	LLGLDepthTest gls_depth(GL_TRUE, GL_TRUE);
-	LLGLDisable no_cull(GL_CULL_FACE);
-	LLGLDisable no_blend(GL_BLEND);
-
-	gPipeline.disableLights();
-
-	mOpaqueWaterImagep->addTextureStats(1024.f*1024.f);
-
-	// Activate the texture binding and bind one
-	// texture since all images will have the same texture
-	gGL.getTexUnit(0)->activate();
-	gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(0)->bind(mOpaqueWaterImagep);
-
-	// Automatically generate texture coords for water texture
-	if (!shader)
-	{
-		glEnable(GL_TEXTURE_GEN_S); //texture unit 0
-		glEnable(GL_TEXTURE_GEN_T); //texture unit 0
-		glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
-		glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
-	}
-
-	// Use the fact that we know all water faces are the same size
-	// to save some computation
-
-	// Slowly move texture coordinates over time so the watter appears
-	// to be moving.
-	F32 movement_period_secs = 50.f;
-
-	F32 offset = fmod(gFrameTimeSeconds, movement_period_secs);
-
-	if (movement_period_secs != 0)
-	{
-	 	offset /= movement_period_secs;
-	}
-	else
-	{
-		offset = 0;
-	}
-
-	F32 tp0[4] = { 16.f / 256.f, 0.0f, 0.0f, offset };
-	F32 tp1[4] = { 0.0f, 16.f / 256.f, 0.0f, offset };
-
-	if (!shader)
-	{
-		glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);
-		glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);
-	}
-	else
-	{
-		shader->uniform4fv("object_plane_s", 1, tp0);
-		shader->uniform4fv("object_plane_t", 1, tp1);
-	}
-
-	gGL.diffuseColor3f(1.f, 1.f, 1.f);
-
-	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-		 iter != mDrawFace.end(); iter++)
-	{
-		LLFace *face = *iter;
-		if (voskyp->isReflFace(face))
-		{
-			continue;
-		}
-
-		face->renderIndexed();
-	}
-
-	stop_glerror();
-
-	if (!shader)
-	{
-		// Reset the settings back to expected values
-		glDisable(GL_TEXTURE_GEN_S); //texture unit 0
-		glDisable(GL_TEXTURE_GEN_T); //texture unit 0
-	}
-
-	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
-}
-
-
-void LLDrawPoolWater::renderReflection(LLFace* face)
-{
-	LLVOSky *voskyp = gSky.mVOSkyp;
-
-	if (!voskyp)
-	{
-		return;
-	}
-
-	if (!face->getGeomCount())
-	{
-		return;
-	}
-	
-	S8 dr = voskyp->getDrawRefl();
-	if (dr < 0)
-	{
-		return;
-	}
-
-	LLGLSNoFog noFog;
-
-	gGL.getTexUnit(0)->bind(mHBTex[dr]);
-
-	LLOverrideFaceColor override(this, face->getFaceColor().mV);
-	face->renderIndexed();
-}
-
-void LLDrawPoolWater::shade()
-{
-	if (!deferred_render)
-	{
-		gGL.setColorMask(true, true);
-	}
-
-	LLVOSky *voskyp = gSky.mVOSkyp;
-
-	if(voskyp == NULL) 
-	{
-		return;
-	}
-
-	LLGLDisable blend(GL_BLEND);
-
-	LLColor3 light_diffuse(0,0,0);
-	F32 light_exp = 0.0f;
-	LLVector3 light_dir;
-	LLColor3 light_color;
-
-	if (gSky.getSunDirection().mV[2] > LLSky::NIGHTTIME_ELEVATION_COS) 	 
-    { 	 
-        light_dir  = gSky.getSunDirection(); 	 
-        light_dir.normVec(); 	
-		light_color = gSky.getSunDiffuseColor();
-		if(gSky.mVOSkyp) {
-	        light_diffuse = gSky.mVOSkyp->getSun().getColorCached(); 	 
-			light_diffuse.normVec(); 	 
-		}
-        light_exp = light_dir * LLVector3(light_dir.mV[0], light_dir.mV[1], 0); 	 
-        light_diffuse *= light_exp + 0.25f; 	 
-    } 	 
-    else  	 
-    { 	 
-        light_dir       = gSky.getMoonDirection(); 	 
-        light_dir.normVec(); 	 
-		light_color = gSky.getMoonDiffuseColor();
-        light_diffuse   = gSky.mVOSkyp->getMoon().getColorCached(); 	 
-        light_diffuse.normVec(); 	 
-        light_diffuse *= 0.5f; 	 
-        light_exp = light_dir * LLVector3(light_dir.mV[0], light_dir.mV[1], 0); 	 
-    }
-
-	light_exp *= light_exp;
-	light_exp *= light_exp;
-	light_exp *= light_exp;
-	light_exp *= light_exp;
-	light_exp *= 256.f;
-	light_exp = light_exp > 32.f ? light_exp : 32.f;
-
-	LLGLSLShader* shader;
-
-	F32 eyedepth = LLViewerCamera::getInstance()->getOrigin().mV[2] - gAgent.getRegion()->getWaterHeight();
-	
-	if (deferred_render)
-	{
-		shader = &gDeferredWaterProgram;
-	}
-	else if (eyedepth < 0.f && LLPipeline::sWaterReflections)
-	{
-		shader = &gUnderWaterProgram;
-	}
-	else
-	{
-		shader = &gWaterProgram;
-	}
-
-	if (deferred_render)
-	{
-		gPipeline.bindDeferredShader(*shader);
-	}
-	else
-	{
-		shader->bind();
-	}
-
-	sTime = (F32)LLFrameTimer::getElapsedSeconds()*0.5f;
-	
-	S32 reftex = shader->enableTexture(LLViewerShaderMgr::WATER_REFTEX);
-		
-	if (reftex > -1)
-	{
-		gGL.getTexUnit(reftex)->activate();
-		gGL.getTexUnit(reftex)->bind(&gPipeline.mWaterRef);
-		gGL.getTexUnit(0)->activate();
-	}	
-
-	//bind normal map
-	S32 bumpTex = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP);
-
-	LLWaterParamManager * param_mgr = &LLWaterParamManager::instance();
-
-	// change mWaterNormp if needed
-	if (mWaterNormp->getID() != param_mgr->getNormalMapID())
-	{
-		mWaterNormp = LLViewerTextureManager::getFetchedTexture(param_mgr->getNormalMapID());
-	}
-
-	mWaterNormp->addTextureStats(1024.f*1024.f);
-	gGL.getTexUnit(bumpTex)->bind(mWaterNormp) ;
-	if (gSavedSettings.getBOOL("RenderWaterMipNormal"))
-	{
-		mWaterNormp->setFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
-	}
-	else 
-	{
-		mWaterNormp->setFilteringOption(LLTexUnit::TFO_POINT);
-	}
-	
-	S32 screentex = shader->enableTexture(LLViewerShaderMgr::WATER_SCREENTEX);	
-		
-	if (screentex > -1)
-	{
-		shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
-		shader->uniform1f(LLViewerShaderMgr::WATER_FOGDENSITY, 
-			param_mgr->getFogDensity());
-		gPipeline.mWaterDis.bindTexture(0, screentex);
-	}
-	
-	stop_glerror();
-	
-	gGL.getTexUnit(screentex)->bind(&gPipeline.mWaterDis);	
-
-	if (mVertexShaderLevel == 1)
-	{
-		sWaterFogColor.mV[3] = param_mgr->mDensitySliderValue;
-		shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
-	}
-
-	F32 screenRes[] = 
-	{
-		1.f/gGLViewport[2],
-		1.f/gGLViewport[3]
-	};
-	shader->uniform2fv("screenRes", 1, screenRes);
-	stop_glerror();
-	
-	S32 diffTex = shader->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
-	stop_glerror();
-	
-	light_dir.normVec();
-	sLightDir = light_dir;
-	
-	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->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());
-
-	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);
-
-	LLColor4 water_color;
-	LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
-	F32 up_dot = camera_up * LLVector3::z_axis;
-	if (LLViewerCamera::getInstance()->cameraUnderWater())
-	{
-		water_color.setVec(1.f, 1.f, 1.f, 0.4f);
-		shader->uniform1f(LLViewerShaderMgr::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());
-	}
-
-	if (water_color.mV[3] > 0.9f)
-	{
-		water_color.mV[3] = 0.9f;
-	}
-
-	{
-		LLGLEnable depth_clamp(gGLManager.mHasDepthClamp ? GL_DEPTH_CLAMP : 0);
-		LLGLDisable cullface(GL_CULL_FACE);
-		for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-			iter != mDrawFace.end(); iter++)
-		{
-			LLFace *face = *iter;
-
-			if (voskyp->isReflFace(face))
-			{
-				continue;
-			}
-
-			LLVOWater* water = (LLVOWater*) face->getViewerObject();
-			gGL.getTexUnit(diffTex)->bind(face->getTexture());
-
-			sNeedsReflectionUpdate = TRUE;
-			
-			if (water->getUseTexture() || !water->getIsEdgePatch())
-			{
-				sNeedsDistortionUpdate = TRUE;
-				face->renderIndexed();
-			}
-			else if (gGLManager.mHasDepthClamp || deferred_render)
-			{
-				face->renderIndexed();
-			}
-			else
-			{
-				LLGLSquashToFarClip far_clip(glh_get_current_projection());
-				face->renderIndexed();
-			}
-		}
-	}
-	
-	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);
-
-	if (deferred_render)
-	{
-		gPipeline.unbindDeferredShader(*shader);
-	}
-	else
-	{
-		shader->unbind();
-	}
-
-	gGL.getTexUnit(0)->activate();
-	gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
-	if (!deferred_render)
-	{
-		gGL.setColorMask(true, false);
-	}
-
-}
-
-LLViewerTexture *LLDrawPoolWater::getDebugTexture()
-{
-	return LLViewerFetchedTexture::sSmokeImagep;
-}
-
-LLColor3 LLDrawPoolWater::getDebugColor() const
-{
-	return LLColor3(0.f, 1.f, 1.f);
-}
+/** 

+ * @file lldrawpoolwater.cpp

+ * @brief LLDrawPoolWater class implementation

+ *

+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$

+ * Second Life Viewer Source Code

+ * Copyright (C) 2010, Linden Research, Inc.

+ * 

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation;

+ * version 2.1 of the License only.

+ * 

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ * 

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+ * 

+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

+ * $/LicenseInfo$

+ */

+

+#include "llviewerprecompiledheaders.h"

+#include "llfeaturemanager.h"

+#include "lldrawpoolwater.h"

+

+#include "llviewercontrol.h"

+#include "lldir.h"

+#include "llerror.h"

+#include "m3math.h"

+#include "llrender.h"

+

+#include "llagent.h"		// for gAgent for getRegion for getWaterHeight

+#include "llcubemap.h"

+#include "lldrawable.h"

+#include "llface.h"

+#include "llsky.h"

+#include "llviewertexturelist.h"

+#include "llviewerregion.h"

+#include "llvosky.h"

+#include "llvowater.h"

+#include "llworld.h"

+#include "pipeline.h"

+#include "llviewershadermgr.h"

+#include "llwaterparammanager.h"

+

+const LLUUID TRANSPARENT_WATER_TEXTURE("2bfd3884-7e27-69b9-ba3a-3e673f680004");

+const LLUUID OPAQUE_WATER_TEXTURE("43c32285-d658-1793-c123-bf86315de055");

+

+static LLStaticHashedString sObjectPlaneS("object_plane_s");

+static LLStaticHashedString sObjectPlaneT("object_plane_t");

+static LLStaticHashedString sScreenRes("screenRes");

+static LLStaticHashedString sNormScale("normScale");

+static LLStaticHashedString sFresnelScale("fresnelScale");

+static LLStaticHashedString sFresnelOffset("fresnelOffset");

+static LLStaticHashedString sBlurMultiplier("blurMultiplier");

+static LLStaticHashedString sSunAngle("sunAngle");

+static LLStaticHashedString sScaledAngle("scaledAngle");

+static LLStaticHashedString sSunAngle2("sunAngle2");

+

+static float sTime;

+

+BOOL deferred_render = FALSE;

+

+BOOL LLDrawPoolWater::sSkipScreenCopy = FALSE;

+BOOL LLDrawPoolWater::sNeedsReflectionUpdate = TRUE;

+BOOL LLDrawPoolWater::sNeedsDistortionUpdate = TRUE;

+LLColor4 LLDrawPoolWater::sWaterFogColor = LLColor4(0.2f, 0.5f, 0.5f, 0.f);

+F32 LLDrawPoolWater::sWaterFogEnd = 0.f;

+

+LLVector3 LLDrawPoolWater::sLightDir;

+

+LLDrawPoolWater::LLDrawPoolWater() :

+	LLFacePool(POOL_WATER)

+{

+	mHBTex[0] = LLViewerTextureManager::getFetchedTexture(gSunTextureID, TRUE, LLViewerTexture::BOOST_UI);

+	gGL.getTexUnit(0)->bind(mHBTex[0]) ;

+	mHBTex[0]->setAddressMode(LLTexUnit::TAM_CLAMP);

+

+	mHBTex[1] = LLViewerTextureManager::getFetchedTexture(gMoonTextureID, TRUE, LLViewerTexture::BOOST_UI);

+	gGL.getTexUnit(0)->bind(mHBTex[1]);

+	mHBTex[1]->setAddressMode(LLTexUnit::TAM_CLAMP);

+

+

+	mWaterImagep = LLViewerTextureManager::getFetchedTexture(TRANSPARENT_WATER_TEXTURE);

+	llassert(mWaterImagep);

+	mWaterImagep->setNoDelete();

+	mOpaqueWaterImagep = LLViewerTextureManager::getFetchedTexture(OPAQUE_WATER_TEXTURE);

+	llassert(mOpaqueWaterImagep);

+	mWaterNormp = LLViewerTextureManager::getFetchedTexture(DEFAULT_WATER_NORMAL);

+	mWaterNormp->setNoDelete();

+

+	restoreGL();

+}

+

+LLDrawPoolWater::~LLDrawPoolWater()

+{

+}

+

+//static

+void LLDrawPoolWater::restoreGL()

+{

+	

+}

+

+LLDrawPool *LLDrawPoolWater::instancePool()

+{

+	llerrs << "Should never be calling instancePool on a water pool!" << llendl;

+	return NULL;

+}

+

+

+void LLDrawPoolWater::prerender()

+{

+	mVertexShaderLevel = (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps) ?

+		LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_WATER) : 0;

+

+	// got rid of modulation by light color since it got a little too

+	// green at sunset and sl-57047 (underwater turns black at 8:00)

+	sWaterFogColor = LLWaterParamManager::instance().getFogColor();

+	sWaterFogColor.mV[3] = 0;

+

+}

+

+S32 LLDrawPoolWater::getNumPasses()

+{

+	if (LLViewerCamera::getInstance()->getOrigin().mV[2] < 1024.f)

+	{

+		return 1;

+	}

+

+	return 0;

+}

+

+void LLDrawPoolWater::beginPostDeferredPass(S32 pass)

+{

+	beginRenderPass(pass);

+	deferred_render = TRUE;

+}

+

+void LLDrawPoolWater::endPostDeferredPass(S32 pass)

+{

+	endRenderPass(pass);

+	deferred_render = FALSE;

+}

+

+//===============================

+//DEFERRED IMPLEMENTATION

+//===============================

+void LLDrawPoolWater::renderDeferred(S32 pass)

+{

+	LLFastTimer t(FTM_RENDER_WATER);

+	deferred_render = TRUE;

+	shade();

+	deferred_render = FALSE;

+}

+

+//=========================================

+

+void LLDrawPoolWater::render(S32 pass)

+{

+	LLFastTimer ftm(FTM_RENDER_WATER);

+	if (mDrawFace.empty() || LLDrawable::getCurrentFrame() <= 1)

+	{

+		return;

+	}

+

+	//do a quick 'n dirty depth sort

+	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();

+			 iter != mDrawFace.end(); iter++)

+	{

+		LLFace* facep = *iter;

+		facep->mDistance = -facep->mCenterLocal.mV[2];

+	}

+

+	std::sort(mDrawFace.begin(), mDrawFace.end(), LLFace::CompareDistanceGreater());

+

+	// See if we are rendering water as opaque or not

+	if (!gSavedSettings.getBOOL("RenderTransparentWater"))

+	{

+		// render water for low end hardware

+		renderOpaqueLegacyWater();

+		return;

+	}

+

+	LLGLEnable blend(GL_BLEND);

+

+	if ((mVertexShaderLevel > 0) && !sSkipScreenCopy)

+	{

+		shade();

+		return;

+	}

+

+	LLVOSky *voskyp = gSky.mVOSkyp;

+

+	stop_glerror();

+

+	if (!gGLManager.mHasMultitexture)

+	{

+		// Ack!  No multitexture!  Bail!

+		return;

+	}

+

+	LLFace* refl_face = voskyp->getReflFace();

+

+	gPipeline.disableLights();

+	

+	LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);

+

+	LLGLDisable cullFace(GL_CULL_FACE);

+	

+	// Set up second pass first

+	mWaterImagep->addTextureStats(1024.f*1024.f);

+	gGL.getTexUnit(1)->activate();

+	gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);

+	gGL.getTexUnit(1)->bind(mWaterImagep) ;

+

+	LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();

+	F32 up_dot = camera_up * LLVector3::z_axis;

+

+	LLColor4 water_color;

+	if (LLViewerCamera::getInstance()->cameraUnderWater())

+	{

+		water_color.setVec(1.f, 1.f, 1.f, 0.4f);

+	}

+	else

+	{

+		water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));

+	}

+

+	gGL.diffuseColor4fv(water_color.mV);

+

+	// Automatically generate texture coords for detail map

+	glEnable(GL_TEXTURE_GEN_S); //texture unit 1

+	glEnable(GL_TEXTURE_GEN_T); //texture unit 1

+	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

+	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

+

+	// Slowly move over time.

+	F32 offset = fmod(gFrameTimeSeconds*2.f, 100.f);

+	F32 tp0[4] = {16.f/256.f, 0.0f, 0.0f, offset*0.01f};

+	F32 tp1[4] = {0.0f, 16.f/256.f, 0.0f, offset*0.01f};

+	glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);

+	glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);

+

+	gGL.getTexUnit(1)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_PREV_COLOR);

+	gGL.getTexUnit(1)->setTextureAlphaBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_ALPHA);

+

+	gGL.getTexUnit(0)->activate();

+	

+	glClearStencil(1);

+	glClear(GL_STENCIL_BUFFER_BIT);

+	LLGLEnable gls_stencil(GL_STENCIL_TEST);

+	glStencilOp(GL_KEEP, GL_REPLACE, GL_KEEP);

+	glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFF);

+

+	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();

+		 iter != mDrawFace.end(); iter++)

+	{

+		LLFace *face = *iter;

+		if (voskyp->isReflFace(face))

+		{

+			continue;

+		}

+		gGL.getTexUnit(0)->bind(face->getTexture());

+		face->renderIndexed();

+	}

+

+	// Now, disable texture coord generation on texture state 1

+	gGL.getTexUnit(1)->activate();

+	gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);

+	gGL.getTexUnit(1)->disable();

+	glDisable(GL_TEXTURE_GEN_S); //texture unit 1

+	glDisable(GL_TEXTURE_GEN_T); //texture unit 1

+

+	// Disable texture coordinate and color arrays

+	gGL.getTexUnit(0)->activate();

+	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+

+	stop_glerror();

+	

+	if (gSky.mVOSkyp->getCubeMap())

+	{

+		gSky.mVOSkyp->getCubeMap()->enable(0);

+		gSky.mVOSkyp->getCubeMap()->bind();

+

+		gGL.matrixMode(LLRender::MM_TEXTURE);

+		gGL.loadIdentity();

+		LLMatrix4 camera_mat = LLViewerCamera::getInstance()->getModelview();

+		LLMatrix4 camera_rot(camera_mat.getMat3());

+		camera_rot.invert();

+

+		gGL.loadMatrix((F32 *)camera_rot.mMatrix);

+

+		gGL.matrixMode(LLRender::MM_MODELVIEW);

+		LLOverrideFaceColor overrid(this, 1.f, 1.f, 1.f,  0.5f*up_dot);

+

+		gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);

+

+		for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();

+			 iter != mDrawFace.end(); iter++)

+		{

+			LLFace *face = *iter;

+			if (voskyp->isReflFace(face))

+			{

+				//refl_face = face;

+				continue;

+			}

+

+			if (face->getGeomCount() > 0)

+			{					

+				face->renderIndexed();

+			}

+		}

+

+		gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);

+

+		gSky.mVOSkyp->getCubeMap()->disable();

+		

+		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+		gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);

+		gGL.matrixMode(LLRender::MM_TEXTURE);

+		gGL.loadIdentity();

+		gGL.matrixMode(LLRender::MM_MODELVIEW);

+		

+	}

+

+	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

+

+    if (refl_face)

+	{

+		glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);

+		renderReflection(refl_face);

+	}

+

+	gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);

+}

+

+// for low end hardware

+void LLDrawPoolWater::renderOpaqueLegacyWater()

+{

+	LLVOSky *voskyp = gSky.mVOSkyp;

+

+	LLGLSLShader* shader = NULL;

+	if (LLGLSLShader::sNoFixedFunction)

+	{

+		if (LLPipeline::sUnderWaterRender)

+		{

+			shader = &gObjectSimpleNonIndexedTexGenWaterProgram;

+		}

+		else

+		{

+			shader = &gObjectSimpleNonIndexedTexGenProgram;

+		}

+

+		shader->bind();

+	}

+

+	stop_glerror();

+

+	// Depth sorting and write to depth buffer

+	// since this is opaque, we should see nothing

+	// behind the water.  No blending because

+	// of no transparency.  And no face culling so

+	// that the underside of the water is also opaque.

+	LLGLDepthTest gls_depth(GL_TRUE, GL_TRUE);

+	LLGLDisable no_cull(GL_CULL_FACE);

+	LLGLDisable no_blend(GL_BLEND);

+

+	gPipeline.disableLights();

+

+	mOpaqueWaterImagep->addTextureStats(1024.f*1024.f);

+

+	// Activate the texture binding and bind one

+	// texture since all images will have the same texture

+	gGL.getTexUnit(0)->activate();

+	gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);

+	gGL.getTexUnit(0)->bind(mOpaqueWaterImagep);

+

+	// Automatically generate texture coords for water texture

+	if (!shader)

+	{

+		glEnable(GL_TEXTURE_GEN_S); //texture unit 0

+		glEnable(GL_TEXTURE_GEN_T); //texture unit 0

+		glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

+		glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

+	}

+

+	// Use the fact that we know all water faces are the same size

+	// to save some computation

+

+	// Slowly move texture coordinates over time so the watter appears

+	// to be moving.

+	F32 movement_period_secs = 50.f;

+

+	F32 offset = fmod(gFrameTimeSeconds, movement_period_secs);

+

+	if (movement_period_secs != 0)

+	{

+	 	offset /= movement_period_secs;

+	}

+	else

+	{

+		offset = 0;

+	}

+

+	F32 tp0[4] = { 16.f / 256.f, 0.0f, 0.0f, offset };

+	F32 tp1[4] = { 0.0f, 16.f / 256.f, 0.0f, offset };

+

+	if (!shader)

+	{

+		glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);

+		glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);

+	}

+	else

+	{

+		shader->uniform4fv(sObjectPlaneS, 1, tp0);

+		shader->uniform4fv(sObjectPlaneT, 1, tp1);

+	}

+

+	gGL.diffuseColor3f(1.f, 1.f, 1.f);

+

+	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();

+		 iter != mDrawFace.end(); iter++)

+	{

+		LLFace *face = *iter;

+		if (voskyp->isReflFace(face))

+		{

+			continue;

+		}

+

+		face->renderIndexed();

+	}

+

+	stop_glerror();

+

+	if (!shader)

+	{

+		// Reset the settings back to expected values

+		glDisable(GL_TEXTURE_GEN_S); //texture unit 0

+		glDisable(GL_TEXTURE_GEN_T); //texture unit 0

+	}

+

+	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+	gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);

+}

+

+

+void LLDrawPoolWater::renderReflection(LLFace* face)

+{

+	LLVOSky *voskyp = gSky.mVOSkyp;

+

+	if (!voskyp)

+	{

+		return;

+	}

+

+	if (!face->getGeomCount())

+	{

+		return;

+	}

+	

+	S8 dr = voskyp->getDrawRefl();

+	if (dr < 0)

+	{

+		return;

+	}

+

+	LLGLSNoFog noFog;

+

+	gGL.getTexUnit(0)->bind(mHBTex[dr]);

+

+	LLOverrideFaceColor override(this, face->getFaceColor().mV);

+	face->renderIndexed();

+}

+

+void LLDrawPoolWater::shade()

+{

+	if (!deferred_render)

+	{

+		gGL.setColorMask(true, true);

+	}

+

+	LLVOSky *voskyp = gSky.mVOSkyp;

+

+	if(voskyp == NULL) 

+	{

+		return;

+	}

+

+	LLGLDisable blend(GL_BLEND);

+

+	LLColor3 light_diffuse(0,0,0);

+	F32 light_exp = 0.0f;

+	LLVector3 light_dir;

+	LLColor3 light_color;

+

+	if (gSky.getSunDirection().mV[2] > LLSky::NIGHTTIME_ELEVATION_COS) 	 

+    { 	 

+        light_dir  = gSky.getSunDirection(); 	 

+        light_dir.normVec(); 	

+		light_color = gSky.getSunDiffuseColor();

+		if(gSky.mVOSkyp) {

+	        light_diffuse = gSky.mVOSkyp->getSun().getColorCached(); 	 

+			light_diffuse.normVec(); 	 

+		}

+        light_exp = light_dir * LLVector3(light_dir.mV[0], light_dir.mV[1], 0); 	 

+        light_diffuse *= light_exp + 0.25f; 	 

+    } 	 

+    else  	 

+    { 	 

+        light_dir       = gSky.getMoonDirection(); 	 

+        light_dir.normVec(); 	 

+		light_color = gSky.getMoonDiffuseColor();

+        light_diffuse   = gSky.mVOSkyp->getMoon().getColorCached(); 	 

+        light_diffuse.normVec(); 	 

+        light_diffuse *= 0.5f; 	 

+        light_exp = light_dir * LLVector3(light_dir.mV[0], light_dir.mV[1], 0); 	 

+    }

+

+	light_exp *= light_exp;

+	light_exp *= light_exp;

+	light_exp *= light_exp;

+	light_exp *= light_exp;

+	light_exp *= 256.f;

+	light_exp = light_exp > 32.f ? light_exp : 32.f;

+

+	LLGLSLShader* shader;

+

+	F32 eyedepth = LLViewerCamera::getInstance()->getOrigin().mV[2] - gAgent.getRegion()->getWaterHeight();

+	

+	if (deferred_render)

+	{

+		shader = &gDeferredWaterProgram;

+	}

+	else if (eyedepth < 0.f && LLPipeline::sWaterReflections)

+	{

+		shader = &gUnderWaterProgram;

+	}

+	else

+	{

+		shader = &gWaterProgram;

+	}

+

+	if (deferred_render)

+	{

+		gPipeline.bindDeferredShader(*shader);

+	}

+	else

+	{

+		shader->bind();

+	}

+

+	sTime = (F32)LLFrameTimer::getElapsedSeconds()*0.5f;

+	

+	S32 reftex = shader->enableTexture(LLViewerShaderMgr::WATER_REFTEX);

+		

+	if (reftex > -1)

+	{

+		gGL.getTexUnit(reftex)->activate();

+		gGL.getTexUnit(reftex)->bind(&gPipeline.mWaterRef);

+		gGL.getTexUnit(0)->activate();

+	}	

+

+	//bind normal map

+	S32 bumpTex = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP);

+

+	LLWaterParamManager * param_mgr = &LLWaterParamManager::instance();

+

+	// change mWaterNormp if needed

+	if (mWaterNormp->getID() != param_mgr->getNormalMapID())

+	{

+		mWaterNormp = LLViewerTextureManager::getFetchedTexture(param_mgr->getNormalMapID());

+	}

+

+	mWaterNormp->addTextureStats(1024.f*1024.f);

+	gGL.getTexUnit(bumpTex)->bind(mWaterNormp) ;

+	if (gSavedSettings.getBOOL("RenderWaterMipNormal"))

+	{

+		mWaterNormp->setFilteringOption(LLTexUnit::TFO_ANISOTROPIC);

+	}

+	else 

+	{

+		mWaterNormp->setFilteringOption(LLTexUnit::TFO_POINT);

+	}

+	

+	S32 screentex = shader->enableTexture(LLViewerShaderMgr::WATER_SCREENTEX);	

+		

+	if (screentex > -1)

+	{

+		shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);

+		shader->uniform1f(LLViewerShaderMgr::WATER_FOGDENSITY, 

+			param_mgr->getFogDensity());

+		gPipeline.mWaterDis.bindTexture(0, screentex);

+	}

+	

+	stop_glerror();

+	

+	gGL.getTexUnit(screentex)->bind(&gPipeline.mWaterDis);	

+

+	if (mVertexShaderLevel == 1)

+	{

+		sWaterFogColor.mV[3] = param_mgr->mDensitySliderValue;

+		shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);

+	}

+

+	F32 screenRes[] = 

+	{

+		1.f/gGLViewport[2],

+		1.f/gGLViewport[3]

+	};

+	shader->uniform2fv(sScreenRes, 1, screenRes);

+	stop_glerror();

+	

+	S32 diffTex = shader->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);

+	stop_glerror();

+	

+	light_dir.normVec();

+	sLightDir = light_dir;

+	

+	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->uniform3fv(sNormScale, 1, param_mgr->getNormalScale().mV);

+	shader->uniform1f(sFresnelScale, param_mgr->getFresnelScale());

+	shader->uniform1f(sFresnelOffset, param_mgr->getFresnelOffset());

+	shader->uniform1f(sBlurMultiplier, param_mgr->getBlurMultiplier());

+

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

+	F32 scaledAngle = 1.f - sunAngle;

+

+	shader->uniform1f(sSunAngle, sunAngle);

+	shader->uniform1f(sScaledAngle, scaledAngle);

+	shader->uniform1f(sSunAngle2, 0.1f + 0.2f*sunAngle);

+

+	LLColor4 water_color;

+	LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();

+	F32 up_dot = camera_up * LLVector3::z_axis;

+	if (LLViewerCamera::getInstance()->cameraUnderWater())

+	{

+		water_color.setVec(1.f, 1.f, 1.f, 0.4f);

+		shader->uniform1f(LLViewerShaderMgr::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());

+	}

+

+	if (water_color.mV[3] > 0.9f)

+	{

+		water_color.mV[3] = 0.9f;

+	}

+

+	{

+		LLGLEnable depth_clamp(gGLManager.mHasDepthClamp ? GL_DEPTH_CLAMP : 0);

+		LLGLDisable cullface(GL_CULL_FACE);

+		for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();

+			iter != mDrawFace.end(); iter++)

+		{

+			LLFace *face = *iter;

+

+			if (voskyp->isReflFace(face))

+			{

+				continue;

+			}

+

+			LLVOWater* water = (LLVOWater*) face->getViewerObject();

+			gGL.getTexUnit(diffTex)->bind(face->getTexture());

+

+			sNeedsReflectionUpdate = TRUE;

+			

+			if (water->getUseTexture() || !water->getIsEdgePatch())

+			{

+				sNeedsDistortionUpdate = TRUE;

+				face->renderIndexed();

+			}

+			else if (gGLManager.mHasDepthClamp || deferred_render)

+			{

+				face->renderIndexed();

+			}

+			else

+			{

+				LLGLSquashToFarClip far_clip(glh_get_current_projection());

+				face->renderIndexed();

+			}

+		}

+	}

+	

+	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);

+

+	if (deferred_render)

+	{

+		gPipeline.unbindDeferredShader(*shader);

+	}

+	else

+	{

+		shader->unbind();

+	}

+

+	gGL.getTexUnit(0)->activate();

+	gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);

+	if (!deferred_render)

+	{

+		gGL.setColorMask(true, false);

+	}

+

+}

+

+LLViewerTexture *LLDrawPoolWater::getDebugTexture()

+{

+	return LLViewerFetchedTexture::sSmokeImagep;

+}

+

+LLColor3 LLDrawPoolWater::getDebugColor() const

+{

+	return LLColor3(0.f, 1.f, 1.f);

+}

diff --git a/indra/newview/lldrawpoolwlsky.cpp b/indra/newview/lldrawpoolwlsky.cpp
index b5faff7968..b0e69aa9b5 100644
--- a/indra/newview/lldrawpoolwlsky.cpp
+++ b/indra/newview/lldrawpoolwlsky.cpp
@@ -152,7 +152,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();
 
@@ -207,7 +208,8 @@ void LLDrawPoolWLSky::renderStars(void) const
 	if (LLGLSLShader::sNoFixedFunction)
 	{
 		gCustomAlphaProgram.bind();
-		gCustomAlphaProgram.uniform1f("custom_alpha", star_alpha.mV[3]);
+		static LLStaticHashedString sCustomAlpha("custom_alpha");
+		gCustomAlphaProgram.uniform1f(sCustomAlpha, star_alpha.mV[3]);
 	}
 	else
 	{
diff --git a/indra/newview/llface.cpp b/indra/newview/llface.cpp
index 6b3127decf..43d21137b5 100755
--- a/indra/newview/llface.cpp
+++ b/indra/newview/llface.cpp
@@ -57,6 +57,9 @@ extern BOOL gGLDebugLoggingEnabled;
 
 #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])
@@ -1437,7 +1440,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);
 
@@ -1455,7 +1458,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);
@@ -1476,7 +1479,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);
diff --git a/indra/newview/llfloaterwebcontent.cpp b/indra/newview/llfloaterwebcontent.cpp
index 3fe2518de6..94c3f4149c 100644
--- a/indra/newview/llfloaterwebcontent.cpp
+++ b/indra/newview/llfloaterwebcontent.cpp
@@ -54,7 +54,7 @@ LLFloaterWebContent::_Params::_Params()
 
 LLFloaterWebContent::LLFloaterWebContent( const Params& params )
 :	LLFloater( params ),
-	LLInstanceTracker<LLFloaterWebContent, std::string>(params.id()),
+	INSTANCE_TRACKER_KEYED(LLFloaterWebContent, std::string)(params.id()),
 	mWebBrowser(NULL),
 	mAddressCombo(NULL),
 	mSecureLockIcon(NULL),
diff --git a/indra/newview/llfloaterwebcontent.h b/indra/newview/llfloaterwebcontent.h
index cfc87e9015..409c15fb0b 100644
--- a/indra/newview/llfloaterwebcontent.h
+++ b/indra/newview/llfloaterwebcontent.h
@@ -40,10 +40,11 @@ class LLIconCtrl;
 class LLFloaterWebContent :
 	public LLFloater,
 	public LLViewerMediaObserver,
-	public LLInstanceTracker<LLFloaterWebContent, std::string>
+	public INSTANCE_TRACKER_KEYED(LLFloaterWebContent, std::string)
 {
 public:
-	typedef LLInstanceTracker<LLFloaterWebContent, std::string> instance_tracker_t;
+
+	typedef INSTANCE_TRACKER_KEYED(LLFloaterWebContent, std::string) instance_tracker_t;
     LOG_CLASS(LLFloaterWebContent);
 
 	struct _Params : public LLInitParam::Block<_Params>
diff --git a/indra/newview/llmaniptranslate.cpp b/indra/newview/llmaniptranslate.cpp
index 362308c176..0228807dc8 100644
--- a/indra/newview/llmaniptranslate.cpp
+++ b/indra/newview/llmaniptranslate.cpp
@@ -1698,7 +1698,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);
 		BOOL clouds = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS);
diff --git a/indra/newview/llmediactrl.cpp b/indra/newview/llmediactrl.cpp
index 99b4707158..48730f0f20 100644
--- a/indra/newview/llmediactrl.cpp
+++ b/indra/newview/llmediactrl.cpp
@@ -81,7 +81,7 @@ LLMediaCtrl::Params::Params()
 
 LLMediaCtrl::LLMediaCtrl( const Params& p) :
 	LLPanel( p ),
-	LLInstanceTracker<LLMediaCtrl, LLUUID>(LLUUID::generateNewID()),
+	INSTANCE_TRACKER_KEYED(LLMediaCtrl, LLUUID)(LLUUID::generateNewID()),
 	mTextureDepthBytes( 4 ),
 	mBorder(NULL),
 	mFrequentUpdates( true ),
diff --git a/indra/newview/llmediactrl.h b/indra/newview/llmediactrl.h
index 7f2a5e1642..4fed21bf22 100644
--- a/indra/newview/llmediactrl.h
+++ b/indra/newview/llmediactrl.h
@@ -42,10 +42,11 @@ class LLMediaCtrl :
 	public LLPanel,
 	public LLViewerMediaObserver,
 	public LLViewerMediaEventEmitter,
-	public LLInstanceTracker<LLMediaCtrl, LLUUID>
+	public INSTANCE_TRACKER_KEYED(LLMediaCtrl, LLUUID)
 {
 	LOG_CLASS(LLMediaCtrl);
 public:
+
 	struct Params : public LLInitParam::Block<Params, LLPanel::Params> 
 	{
 		Optional<std::string>	start_url;
diff --git a/indra/newview/llnamelistctrl.h b/indra/newview/llnamelistctrl.h
index 09c3d49fe7..103806a1bd 100644
--- a/indra/newview/llnamelistctrl.h
+++ b/indra/newview/llnamelistctrl.h
@@ -64,9 +64,10 @@ private:
 
 
 class LLNameListCtrl
-:	public LLScrollListCtrl, public LLInstanceTracker<LLNameListCtrl>
+:	public LLScrollListCtrl, public INSTANCE_TRACKER(LLNameListCtrl)
 {
 public:
+
 	typedef enum e_name_type
 	{
 		INDIVIDUAL,
diff --git a/indra/newview/lltoast.cpp b/indra/newview/lltoast.cpp
index 9dfb29b905..49debe67f6 100644
--- a/indra/newview/lltoast.cpp
+++ b/indra/newview/lltoast.cpp
@@ -572,7 +572,7 @@ S32	LLToast::notifyParent(const LLSD& info)
 //static
 void LLToast::updateClass()
 {
-	for (LLInstanceTracker<LLToast>::instance_iter iter = LLInstanceTracker<LLToast>::beginInstances(); iter != LLInstanceTracker<LLToast>::endInstances(); ) 
+	for (INSTANCE_TRACKER(LLToast)::instance_iter iter = INSTANCE_TRACKER(LLToast)::beginInstances(); iter != INSTANCE_TRACKER(LLToast)::endInstances(); ) 
 	{
 		LLToast& toast = *iter++;
 		
diff --git a/indra/newview/lltoast.h b/indra/newview/lltoast.h
index e1d99b1bcb..8f77e7b78b 100644
--- a/indra/newview/lltoast.h
+++ b/indra/newview/lltoast.h
@@ -69,10 +69,11 @@ private :
  * Represents toast pop-up.
  * This is a parent view for all toast panels.
  */
-class LLToast : public LLModalDialog, public LLInstanceTracker<LLToast>
+class LLToast : public LLModalDialog, public INSTANCE_TRACKER(LLToast)
 {
 	friend class LLToastLifeTimer;
 public:
+
 	typedef boost::function<void (LLToast* toast)> toast_callback_t;
 	typedef boost::signals2::signal<void (LLToast* toast)> toast_signal_t;
 	typedef boost::signals2::signal<void (LLToast* toast, bool mouse_enter)> toast_hover_check_signal_t;
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index ba9818946c..fc7e51d06c 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -52,6 +52,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;
@@ -305,46 +312,46 @@ void LLViewerShaderMgr::initAttribsAndUniforms(void)
 	{
 		LLShaderMgr::initAttribsAndUniforms();
 
-		mAvatarUniforms.push_back("matrixPalette");
-		mAvatarUniforms.push_back("gWindDir");
-		mAvatarUniforms.push_back("gSinWaveParams");
-		mAvatarUniforms.push_back("gGravity");
+		mAvatarUniforms.push_back(LLStaticHashedString("matrixPalette"));
+		mAvatarUniforms.push_back(LLStaticHashedString("gWindDir"));
+		mAvatarUniforms.push_back(LLStaticHashedString("gSinWaveParams"));
+		mAvatarUniforms.push_back(LLStaticHashedString("gGravity"));
 
-		mWLUniforms.push_back("camPosLocal");
+		mWLUniforms.push_back(LLStaticHashedString("camPosLocal"));
 
 		mTerrainUniforms.reserve(5);
-		mTerrainUniforms.push_back("detail_0");
-		mTerrainUniforms.push_back("detail_1");
-		mTerrainUniforms.push_back("detail_2");
-		mTerrainUniforms.push_back("detail_3");
-		mTerrainUniforms.push_back("alpha_ramp");
+		mTerrainUniforms.push_back(LLStaticHashedString("detail_0"));
+		mTerrainUniforms.push_back(LLStaticHashedString("detail_1"));
+		mTerrainUniforms.push_back(LLStaticHashedString("detail_2"));
+		mTerrainUniforms.push_back(LLStaticHashedString("detail_3"));
+		mTerrainUniforms.push_back(LLStaticHashedString("alpha_ramp"));
 
-		mGlowUniforms.push_back("glowDelta");
-		mGlowUniforms.push_back("glowStrength");
+		mGlowUniforms.push_back(LLStaticHashedString("glowDelta"));
+		mGlowUniforms.push_back(LLStaticHashedString("glowStrength"));
 
-		mGlowExtractUniforms.push_back("minLuminance");
-		mGlowExtractUniforms.push_back("maxExtractAlpha");
-		mGlowExtractUniforms.push_back("lumWeights");
-		mGlowExtractUniforms.push_back("warmthWeights");
-		mGlowExtractUniforms.push_back("warmthAmount");
+		mGlowExtractUniforms.push_back(LLStaticHashedString("minLuminance"));
+		mGlowExtractUniforms.push_back(LLStaticHashedString("maxExtractAlpha"));
+		mGlowExtractUniforms.push_back(LLStaticHashedString("lumWeights"));
+		mGlowExtractUniforms.push_back(LLStaticHashedString("warmthWeights"));
+		mGlowExtractUniforms.push_back(LLStaticHashedString("warmthAmount"));
 
-		mShinyUniforms.push_back("origin");
+		mShinyUniforms.push_back(LLStaticHashedString("origin"));
 
 		mWaterUniforms.reserve(12);
-		mWaterUniforms.push_back("screenTex");
-		mWaterUniforms.push_back("screenDepth");
-		mWaterUniforms.push_back("refTex");
-		mWaterUniforms.push_back("eyeVec");
-		mWaterUniforms.push_back("time");
-		mWaterUniforms.push_back("d1");
-		mWaterUniforms.push_back("d2");
-		mWaterUniforms.push_back("lightDir");
-		mWaterUniforms.push_back("specular");
-		mWaterUniforms.push_back("lightExp");
-		mWaterUniforms.push_back("fogCol");
-		mWaterUniforms.push_back("kd");
-		mWaterUniforms.push_back("refScale");
-		mWaterUniforms.push_back("waterHeight");
+		mWaterUniforms.push_back(LLStaticHashedString("screenTex"));
+		mWaterUniforms.push_back(LLStaticHashedString("screenDepth"));
+		mWaterUniforms.push_back(LLStaticHashedString("refTex"));
+		mWaterUniforms.push_back(LLStaticHashedString("eyeVec"));
+		mWaterUniforms.push_back(LLStaticHashedString("time"));
+		mWaterUniforms.push_back(LLStaticHashedString("d1"));
+		mWaterUniforms.push_back(LLStaticHashedString("d2"));
+		mWaterUniforms.push_back(LLStaticHashedString("lightDir"));
+		mWaterUniforms.push_back(LLStaticHashedString("specular"));
+		mWaterUniforms.push_back(LLStaticHashedString("lightExp"));
+		mWaterUniforms.push_back(LLStaticHashedString("fogCol"));
+		mWaterUniforms.push_back(LLStaticHashedString("kd"));
+		mWaterUniforms.push_back(LLStaticHashedString("refScale"));
+		mWaterUniforms.push_back(LLStaticHashedString("waterHeight"));
 	}	
 }
 	
@@ -2091,8 +2098,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		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();
 		}
 	}
@@ -2651,7 +2658,7 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gSplatTextureRectProgram.bind();
-			gSplatTextureRectProgram.uniform1i("screenMap", 0);
+			gSplatTextureRectProgram.uniform1i(sScreenMap, 0);
 			gSplatTextureRectProgram.unbind();
 		}
 	}
@@ -2667,8 +2674,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();
 		}
 	}
@@ -2684,8 +2691,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();
 		}
 	}
@@ -2702,8 +2709,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gTwoTextureAddProgram.bind();
-			gTwoTextureAddProgram.uniform1i("tex0", 0);
-			gTwoTextureAddProgram.uniform1i("tex1", 1);
+			gTwoTextureAddProgram.uniform1i(sTex0, 0);
+			gTwoTextureAddProgram.uniform1i(sTex1, 1);
 		}
 	}
 
@@ -2718,7 +2725,7 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gOneTextureNoColorProgram.bind();
-			gOneTextureNoColorProgram.uniform1i("tex0", 0);
+			gOneTextureNoColorProgram.uniform1i(sTex0, 0);
 		}
 	}
 
@@ -2733,7 +2740,7 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		if (success)
 		{
 			gSolidColorProgram.bind();
-			gSolidColorProgram.uniform1i("tex0", 0);
+			gSolidColorProgram.uniform1i(sTex0, 0);
 			gSolidColorProgram.unbind();
 		}
 	}
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index d6dd645e8c..999baa0ad0 100644
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -177,22 +177,24 @@ public:
 
 private:
 	
-	std::vector<std::string> mShinyUniforms;
+	typedef std::vector< LLStaticHashedString > UniformVec;
+
+	UniformVec mShinyUniforms;
 
 	//water parameters
-	std::vector<std::string> mWaterUniforms;
+	UniformVec mWaterUniforms;
 
-	std::vector<std::string> mWLUniforms;
+	UniformVec mWLUniforms;
 
 	//terrain parameters
-	std::vector<std::string> mTerrainUniforms;
+	UniformVec mTerrainUniforms;
 
 	//glow parameters
-	std::vector<std::string> mGlowUniforms;
+	UniformVec mGlowUniforms;
 
-	std::vector<std::string> mGlowExtractUniforms;
+	UniformVec mGlowExtractUniforms;
 
-	std::vector<std::string> mAvatarUniforms;
+	UniformVec mAvatarUniforms;
 
 	// the list of shaders we need to propagate parameters to.
 	std::vector<LLGLSLShader *> mShaderList;
diff --git a/indra/newview/llwaterparammanager.cpp b/indra/newview/llwaterparammanager.cpp
index 4f52ff9778..376715a2d6 100644
--- a/indra/newview/llwaterparammanager.cpp
+++ b/indra/newview/llwaterparammanager.cpp
@@ -57,6 +57,14 @@
 
 #include "curl/curl.h"
 
+static LLStaticHashedString sCamPosLocal("camPosLocal");

+static LLStaticHashedString sWaterFogColor("waterFogColor");

+static LLStaticHashedString sWaterFogEnd("waterFogEnd");

+static LLStaticHashedString sWaterPlane("waterPlane");

+static LLStaticHashedString sWaterFogDensity("waterFogDensity");

+static LLStaticHashedString sWaterFogKS("waterFogKS");

+static LLStaticHashedString sDistanceMultiplier("distance_multiplier");
+
 LLWaterParamManager::LLWaterParamManager() :
 	mFogColor(22.f/255.f, 43.f/255.f, 54.f/255.f, 0.0f, 0.0f, "waterFogColor", "WaterFogColor"),
 	mFogDensity(4, "waterFogDensity", 2),
@@ -188,13 +196,13 @@ 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->uniform1f("waterFogEnd", LLDrawPoolWater::sWaterFogEnd);
-		shader->uniform4fv("waterPlane", 1, mWaterPlane.mV);
-		shader->uniform1f("waterFogDensity", getFogDensity());
-		shader->uniform1f("waterFogKS", mWaterFogKS);
-		shader->uniform1f("distance_multiplier", 0);
+		shader->uniform3fv(sCamPosLocal, 1, LLViewerCamera::getInstance()->getOrigin().mV);
+		shader->uniform4fv(sWaterFogColor, 1, LLDrawPoolWater::sWaterFogColor.mV);
+		shader->uniform1f(sWaterFogEnd, LLDrawPoolWater::sWaterFogEnd);
+		shader->uniform4fv(sWaterPlane, 1, mWaterPlane.mV);
+		shader->uniform1f(sWaterFogDensity, getFogDensity());
+		shader->uniform1f(sWaterFogKS, mWaterFogKS);
+		shader->uniform1f(sDistanceMultiplier, 0);
 	}
 }
 
diff --git a/indra/newview/llwaterparamset.h b/indra/newview/llwaterparamset.h
index b28585af59..368cb0ccba 100644
--- a/indra/newview/llwaterparamset.h
+++ b/indra/newview/llwaterparamset.h
@@ -33,6 +33,7 @@
 #include "v4math.h"
 #include "v4color.h"
 #include "llviewershadermgr.h"
+#include "llstringtable.h"
 
 class LLWaterParamSet;
 
@@ -47,6 +48,9 @@ public:
 private:
 
 	LLSD mParamValues;
+	std::vector<LLStaticHashedString> mParamHashedNames;
+
+	void updateHashedNames();
 
 public:
 
@@ -140,6 +144,17 @@ inline void LLWaterParamSet::setAll(const LLSD& val)
 			mParamValues[mIt->first] = mIt->second;
 		}
 	}
+	updateHashedNames();
+}
+
+inline void LLWaterParamSet::updateHashedNames()
+{
+	mParamHashedNames.clear();
+	// Iterate through values
+	for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
+	{
+		mParamHashedNames.push_back(LLStaticHashedString(iter->first));
+	}
 }
 
 inline const LLSD& LLWaterParamSet::getAll()
diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
index 6077208799..65cb80c3e7 100644
--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -61,6 +61,9 @@
 #include "curl/curl.h"
 #include "llstreamtools.h"
 
+static LLStaticHashedString sCamPosLocal("camPosLocal");
+static LLStaticHashedString sSceneLightStrength("scene_light_strength");
+
 LLWLParamManager::LLWLParamManager() :
 
 	//set the defaults for the controls
@@ -352,7 +355,7 @@ 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->uniform3fv(sCamPosLocal, 1, LLViewerCamera::getInstance()->getOrigin().mV);
 	} 
 
 	else if (shader->mShaderGroup == LLGLSLShader::SG_SKY)
@@ -360,7 +363,7 @@ void LLWLParamManager::updateShaderUniforms(LLGLSLShader * shader)
 		shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, mClampedLightDir.mV);
 	}
 
-	shader->uniform1f("scene_light_strength", mSceneLightStrength);
+	shader->uniform1f(sSceneLightStrength, mSceneLightStrength);
 	
 }
 
diff --git a/indra/newview/llwlparamset.cpp b/indra/newview/llwlparamset.cpp
index b04d30db55..745cdae441 100644
--- a/indra/newview/llwlparamset.cpp
+++ b/indra/newview/llwlparamset.cpp
@@ -38,6 +38,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)	
@@ -48,21 +64,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;
@@ -74,10 +93,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();
 
@@ -378,3 +397,13 @@ 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));
+	}
+}
\ No newline at end of file
diff --git a/indra/newview/llwlparamset.h b/indra/newview/llwlparamset.h
index b087119dd5..3e9f77ba6c 100644
--- a/indra/newview/llwlparamset.h
+++ b/indra/newview/llwlparamset.h
@@ -29,9 +29,11 @@
 
 #include <string>
 #include <map>
+#include <vector>
 
 #include "v4math.h"
 #include "v4color.h"
+#include "llstaticstringtable.h"
 
 class LLWLParamSet;
 class LLGLSLShader;
@@ -47,9 +49,12 @@ public:
 private:
 
 	LLSD mParamValues;
-	
+	std::vector<LLStaticHashedString> mParamHashedNames;
+
 	float mCloudScrollXOffset, mCloudScrollYOffset;
 
+	void updateHashedNames();
+
 public:
 
 	LLWLParamSet();
@@ -177,6 +182,8 @@ inline void LLWLParamSet::setAll(const LLSD& val)
 	if(val.isMap()) {
 		mParamValues = val;
 	}
+
+	updateHashedNames();
 }
 
 inline const LLSD& LLWLParamSet::getAll()
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 45d6d23b51..690bf64798 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -253,6 +253,17 @@ 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 sTint("tint");
+static LLStaticHashedString sAmbiance("ambiance");
+static LLStaticHashedString sAlphaScale("alpha_scale");
+static LLStaticHashedString sNormMat("norm_mat");
+static LLStaticHashedString sOffset("offset");
+static LLStaticHashedString sScreenRes("screenRes");
+static LLStaticHashedString sDelta("delta");
+static LLStaticHashedString sDistFactor("dist_factor");
+static LLStaticHashedString sKern("kern");
+static LLStaticHashedString sKernScale("kern_scale");
+
 //----------------------------------------
 std::string gPoolNames[] = 
 {
@@ -4621,9 +4632,9 @@ void LLPipeline::renderDebug()
 					if (LLGLSLShader::sNoFixedFunction)
 					{					
 						gPathfindingProgram.bind();			
-						gPathfindingProgram.uniform1f("tint", 1.f);
-						gPathfindingProgram.uniform1f("ambiance", 1.f);
-						gPathfindingProgram.uniform1f("alpha_scale", 1.f);
+						gPathfindingProgram.uniform1f(sTint, 1.f);
+						gPathfindingProgram.uniform1f(sAmbiance, 1.f);
+						gPathfindingProgram.uniform1f(sAlphaScale, 1.f);
 					}
 
 					//Requried character physics capsule render parameters
@@ -4640,7 +4651,7 @@ void LLPipeline::renderDebug()
 							llPathingLibInstance->renderSimpleShapeCapsuleID( gGL, id, pos, rot );				
 							gGL.setColorMask(true, false);
 							LLGLEnable blend(GL_BLEND);
-							gPathfindingProgram.uniform1f("alpha_scale", 0.90f);
+							gPathfindingProgram.uniform1f(sAlphaScale, 0.90f);
 							llPathingLibInstance->renderSimpleShapeCapsuleID( gGL, id, pos, rot );
 							gPathfindingProgram.bind();
 						}
@@ -4667,9 +4678,9 @@ void LLPipeline::renderDebug()
 					{					
 						gPathfindingProgram.bind();
 			
-						gPathfindingProgram.uniform1f("tint", 1.f);
-						gPathfindingProgram.uniform1f("ambiance", ambiance);
-						gPathfindingProgram.uniform1f("alpha_scale", 1.f);
+						gPathfindingProgram.uniform1f(sTint, 1.f);
+						gPathfindingProgram.uniform1f(sAmbiance, ambiance);
+						gPathfindingProgram.uniform1f(sAlphaScale, 1.f);
 					}
 
 					if ( !pathfindingConsole->isRenderWorld() )
@@ -4693,7 +4704,7 @@ void LLPipeline::renderDebug()
 						if ( pathfindingConsole->isRenderWorld() )
 						{					
 							LLGLEnable blend(GL_BLEND);
-							gPathfindingProgram.uniform1f("alpha_scale", 0.66f);
+							gPathfindingProgram.uniform1f(sAlphaScale, 0.66f);
 							llPathingLibInstance->renderNavMesh();
 						}
 						else
@@ -4705,8 +4716,8 @@ void LLPipeline::renderDebug()
 						if (LLGLSLShader::sNoFixedFunction)
 						{
 							gPathfindingNoNormalsProgram.bind();
-							gPathfindingNoNormalsProgram.uniform1f("tint", 1.f);
-							gPathfindingNoNormalsProgram.uniform1f("alpha_scale", 1.f);
+							gPathfindingNoNormalsProgram.uniform1f(sTint, 1.f);
+							gPathfindingNoNormalsProgram.uniform1f(sAlphaScale, 1.f);
 							llPathingLibInstance->renderNavMeshEdges();
 							gPathfindingProgram.bind();
 						}
@@ -4746,7 +4757,7 @@ void LLPipeline::renderDebug()
 							gGL.setColorMask(true, false);
 							//render the bookends
 							LLGLEnable blend(GL_BLEND);
-							gPathfindingProgram.uniform1f("alpha_scale", 0.90f);
+							gPathfindingProgram.uniform1f(sAlphaScale, 0.90f);
 							llPathingLibInstance->renderPathBookend( gGL, LLPathingLib::LLPL_START );
 							llPathingLibInstance->renderPathBookend( gGL, LLPathingLib::LLPL_END );
 							gPathfindingProgram.bind();
@@ -4764,7 +4775,7 @@ void LLPipeline::renderDebug()
 						if (LLGLSLShader::sNoFixedFunction)
 						{
 							LLGLEnable blend(GL_BLEND);
-							gPathfindingProgram.uniform1f("alpha_scale", 0.90f);
+							gPathfindingProgram.uniform1f(sAlphaScale, 0.90f);
 							llPathingLibInstance->renderSimpleShapes( gGL, gAgent.getRegion()->getWaterHeight() );
 						}
 						else
@@ -4812,7 +4823,7 @@ void LLPipeline::renderDebug()
 							LLGLEnable blend(GL_BLEND);
 				
 							{
-								gPathfindingProgram.uniform1f("ambiance", ambiance);
+								gPathfindingProgram.uniform1f(sAmbiance, ambiance);
 
 								{ //draw solid overlay
 									LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_LEQUAL);
@@ -4827,8 +4838,8 @@ void LLPipeline::renderDebug()
 
 								if (pathfindingConsole->isRenderXRay())
 								{
-									gPathfindingProgram.uniform1f("tint", gSavedSettings.getF32("PathfindingXRayTint"));
-									gPathfindingProgram.uniform1f("alpha_scale", gSavedSettings.getF32("PathfindingXRayOpacity"));
+									gPathfindingProgram.uniform1f(sTint, gSavedSettings.getF32("PathfindingXRayTint"));
+									gPathfindingProgram.uniform1f(sAlphaScale, gSavedSettings.getF32("PathfindingXRayOpacity"));
 									LLGLEnable blend(GL_BLEND);
 									LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_GREATER);
 								
@@ -4836,13 +4847,13 @@ void LLPipeline::renderDebug()
 								
 									if (gSavedSettings.getBOOL("PathfindingXRayWireframe"))
 									{ //draw hidden wireframe as darker and less opaque
-										gPathfindingProgram.uniform1f("ambiance", 1.f);
+										gPathfindingProgram.uniform1f(sAmbiance, 1.f);
 										llPathingLibInstance->renderNavMeshShapesVBO( render_order[i] );				
 									}
 									else
 									{
 										glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );	
-										gPathfindingProgram.uniform1f("ambiance", ambiance);
+										gPathfindingProgram.uniform1f(sAmbiance, ambiance);
 										llPathingLibInstance->renderNavMeshShapesVBO( render_order[i] );				
 										glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 									}
@@ -4850,9 +4861,9 @@ void LLPipeline::renderDebug()
 
 								{ //draw visible wireframe as brighter, thicker and more opaque
 									glPolygonOffset(offset, offset);
-									gPathfindingProgram.uniform1f("ambiance", 1.f);
-									gPathfindingProgram.uniform1f("tint", 1.f);
-									gPathfindingProgram.uniform1f("alpha_scale", 1.f);
+									gPathfindingProgram.uniform1f(sAmbiance, 1.f);
+									gPathfindingProgram.uniform1f(sTint, 1.f);
+									gPathfindingProgram.uniform1f(sAlphaScale, 1.f);
 
 									glLineWidth(gSavedSettings.getF32("PathfindingLineWidth"));
 									LLGLDisable blendOut(GL_BLEND);
@@ -4884,19 +4895,19 @@ void LLPipeline::renderDebug()
 						glLineWidth(2.0f);	
 						LLGLEnable cull(GL_CULL_FACE);
 																		
-						gPathfindingProgram.uniform1f("tint", gSavedSettings.getF32("PathfindingXRayTint"));
-						gPathfindingProgram.uniform1f("alpha_scale", gSavedSettings.getF32("PathfindingXRayOpacity"));
+						gPathfindingProgram.uniform1f(sTint, gSavedSettings.getF32("PathfindingXRayTint"));
+						gPathfindingProgram.uniform1f(sAlphaScale, gSavedSettings.getF32("PathfindingXRayOpacity"));
 								
 						if (gSavedSettings.getBOOL("PathfindingXRayWireframe"))
 						{ //draw hidden wireframe as darker and less opaque
 							glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );	
-							gPathfindingProgram.uniform1f("ambiance", 1.f);
+							gPathfindingProgram.uniform1f(sAmbiance, 1.f);
 							llPathingLibInstance->renderNavMesh();
 							glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );	
 						}	
 						else
 						{
-							gPathfindingProgram.uniform1f("ambiance", ambiance);
+							gPathfindingProgram.uniform1f(sAmbiance, ambiance);
 							llPathingLibInstance->renderNavMesh();
 						}
 
@@ -4904,8 +4915,8 @@ void LLPipeline::renderDebug()
 						if (LLGLSLShader::sNoFixedFunction)
 						{
 							gPathfindingNoNormalsProgram.bind();
-							gPathfindingNoNormalsProgram.uniform1f("tint", gSavedSettings.getF32("PathfindingXRayTint"));
-							gPathfindingNoNormalsProgram.uniform1f("alpha_scale", gSavedSettings.getF32("PathfindingXRayOpacity"));
+							gPathfindingNoNormalsProgram.uniform1f(sTint, gSavedSettings.getF32("PathfindingXRayTint"));
+							gPathfindingNoNormalsProgram.uniform1f(sAlphaScale, gSavedSettings.getF32("PathfindingXRayOpacity"));
 							llPathingLibInstance->renderNavMeshEdges();
 							gPathfindingProgram.bind();
 						}
@@ -7858,11 +7869,11 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, U32 light_index, U32 n
 	shader.uniform1f(LLShaderMgr::DEFERRED_DEPTH_CUTOFF, RenderEdgeDepthCutoff);
 	shader.uniform1f(LLShaderMgr::DEFERRED_NORM_CUTOFF, RenderEdgeNormCutoff);
 	
-
-	if (shader.getUniformLocation("norm_mat") >= 0)
+	static LLStaticHashedString sNormMat("norm_mat");
+	if (shader.getUniformLocation(sNormMat) >= 0)
 	{
 		glh::matrix4f norm_mat = glh_get_current_modelview().inverse().transpose();
-		shader.uniformMatrix4fv("norm_mat", 1, FALSE, norm_mat.m);
+		shader.uniformMatrix4fv(sNormMat, 1, FALSE, norm_mat.m);
 	}
 }
 
@@ -7972,8 +7983,8 @@ void LLPipeline::renderDeferredLighting()
 					}
 				}
 
-				gDeferredSunProgram.uniform3fv("offset", slice, offset);
-				gDeferredSunProgram.uniform2f("screenRes", mDeferredLight.getWidth(), mDeferredLight.getHeight());
+				gDeferredSunProgram.uniform3fv(sOffset, slice, offset);
+				gDeferredSunProgram.uniform2f(sScreenRes, mDeferredLight.getWidth(), mDeferredLight.getHeight());
 				
 				{
 					LLGLDisable blend(GL_BLEND);
@@ -8017,10 +8028,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);
@@ -8037,7 +8048,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);
@@ -10267,7 +10278,7 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 		avatar->mImpostor.clear();
 		renderGeom(camera);
 	}
-
+	
 	LLDrawPoolAvatar::sMinimumAlpha = old_alpha;
 		
 	{ //create alpha mask based on depth buffer (grey out if muted)
@@ -10320,13 +10331,13 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 		}
 
 		{
-			gGL.begin(LLRender::QUADS);
-			gGL.vertex3f(-1, -1, clip_plane);
-			gGL.vertex3f(1, -1, clip_plane);
-			gGL.vertex3f(1, 1, clip_plane);
-			gGL.vertex3f(-1, 1, clip_plane);
-			gGL.end();
-			gGL.flush();
+		gGL.begin(LLRender::QUADS);
+		gGL.vertex3f(-1, -1, clip_plane);
+		gGL.vertex3f(1, -1, clip_plane);
+		gGL.vertex3f(1, 1, clip_plane);
+		gGL.vertex3f(-1, 1, clip_plane);
+		gGL.end();
+		gGL.flush();
 		}
 
 		if (LLGLSLShader::sNoFixedFunction)
diff --git a/indra/newview/tests/llagentaccess_test.cpp b/indra/newview/tests/llagentaccess_test.cpp
index 3ba25f3c10..426ad40342 100644
--- a/indra/newview/tests/llagentaccess_test.cpp
+++ b/indra/newview/tests/llagentaccess_test.cpp
@@ -40,7 +40,7 @@
 static U32 test_preferred_maturity = SIM_ACCESS_PG;
 
 LLControlGroup::LLControlGroup(const std::string& name)
-	: LLInstanceTracker<LLControlGroup, std::string>(name)
+	: INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name)
 {
 }
 
diff --git a/indra/newview/tests/lllogininstance_test.cpp b/indra/newview/tests/lllogininstance_test.cpp
index 7705b4c567..25da5939f1 100644
--- a/indra/newview/tests/lllogininstance_test.cpp
+++ b/indra/newview/tests/lllogininstance_test.cpp
@@ -167,7 +167,7 @@ std::string LLGridManager::getAppSLURLBase(const std::string& grid_name)
 LLControlGroup gSavedSettings("Global");
 
 LLControlGroup::LLControlGroup(const std::string& name) :
-	LLInstanceTracker<LLControlGroup, std::string>(name){}
+	INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name){}
 LLControlGroup::~LLControlGroup() {}
 void LLControlGroup::setBOOL(const std::string& name, BOOL val) {}
 BOOL LLControlGroup::getBOOL(const std::string& name) { return FALSE; }
diff --git a/indra/newview/tests/llremoteparcelrequest_test.cpp b/indra/newview/tests/llremoteparcelrequest_test.cpp
index ed66066b0a..da273132db 100644
--- a/indra/newview/tests/llremoteparcelrequest_test.cpp
+++ b/indra/newview/tests/llremoteparcelrequest_test.cpp
@@ -69,7 +69,7 @@ void LLAgent::sendReliableMessage(void) { }
 LLUUID gAgentSessionID;
 LLUUID gAgentID;
 LLUIColor::LLUIColor(void) { }
-LLControlGroup::LLControlGroup(std::string const & name) : LLInstanceTracker<LLControlGroup, std::string>(name) { }
+LLControlGroup::LLControlGroup(std::string const & name) : INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name) { }
 LLControlGroup::~LLControlGroup(void) { }
 void LLUrlEntryParcel::processParcelInfo(const LLUrlEntryParcel::LLParcelData& parcel_data) { }
 
diff --git a/indra/newview/tests/llsecapi_test.cpp b/indra/newview/tests/llsecapi_test.cpp
index 703603e2db..83a4149971 100644
--- a/indra/newview/tests/llsecapi_test.cpp
+++ b/indra/newview/tests/llsecapi_test.cpp
@@ -37,7 +37,7 @@
 // Mock objects for the dependencies of the code we're testing                               
 
 LLControlGroup::LLControlGroup(const std::string& name)
-: LLInstanceTracker<LLControlGroup, std::string>(name) {}
+: INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name) {}
 LLControlGroup::~LLControlGroup() {}
 BOOL LLControlGroup::declareString(const std::string& name,
                                    const std::string& initial_val,
diff --git a/indra/newview/tests/llsechandler_basic_test.cpp b/indra/newview/tests/llsechandler_basic_test.cpp
index 0235400976..814010028f 100644
--- a/indra/newview/tests/llsechandler_basic_test.cpp
+++ b/indra/newview/tests/llsechandler_basic_test.cpp
@@ -69,7 +69,7 @@ extern bool _cert_hostname_wildcard_match(const std::string& hostname, const std
 std::string gFirstName;
 std::string gLastName;
 LLControlGroup::LLControlGroup(const std::string& name)
-: LLInstanceTracker<LLControlGroup, std::string>(name) {}
+: INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name) {}
 LLControlGroup::~LLControlGroup() {}
 BOOL LLControlGroup::declareString(const std::string& name,
                                    const std::string& initial_val,
diff --git a/indra/newview/tests/llslurl_test.cpp b/indra/newview/tests/llslurl_test.cpp
index 09343ef227..d7debd6c67 100644
--- a/indra/newview/tests/llslurl_test.cpp
+++ b/indra/newview/tests/llslurl_test.cpp
@@ -35,7 +35,7 @@
 // Mock objects for the dependencies of the code we're testing
 
 LLControlGroup::LLControlGroup(const std::string& name)
-: LLInstanceTracker<LLControlGroup, std::string>(name) {}
+: INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name) {}
 LLControlGroup::~LLControlGroup() {}
 BOOL LLControlGroup::declareString(const std::string& name,
                                    const std::string& initial_val,
diff --git a/indra/newview/tests/lltranslate_test.cpp b/indra/newview/tests/lltranslate_test.cpp
index fd9527d631..c13660332d 100644
--- a/indra/newview/tests/lltranslate_test.cpp
+++ b/indra/newview/tests/lltranslate_test.cpp
@@ -295,7 +295,7 @@ LLControlGroup gSavedSettings("test");
 std::string LLUI::getLanguage() { return "en"; }
 std::string LLTrans::getString(const std::string &xml_desc, const LLStringUtil::format_map_t& args) { return "dummy"; }
 
-LLControlGroup::LLControlGroup(const std::string& name) : LLInstanceTracker<LLControlGroup, std::string>(name) {}
+LLControlGroup::LLControlGroup(const std::string& name) : INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name) {}
 std::string LLControlGroup::getString(const std::string& name) { return "dummy"; }
 LLControlGroup::~LLControlGroup() {}
 
diff --git a/indra/newview/tests/llviewerhelputil_test.cpp b/indra/newview/tests/llviewerhelputil_test.cpp
index 710881d811..102cad8852 100644
--- a/indra/newview/tests/llviewerhelputil_test.cpp
+++ b/indra/newview/tests/llviewerhelputil_test.cpp
@@ -47,7 +47,7 @@ static std::string gOS;
 // Mock objects for the dependencies of the code we're testing
 
 LLControlGroup::LLControlGroup(const std::string& name)
-	: LLInstanceTracker<LLControlGroup, std::string>(name) {}
+	: INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name) {}
 LLControlGroup::~LLControlGroup() {}
 BOOL LLControlGroup::declareString(const std::string& name,
 				   const std::string& initial_val,
diff --git a/indra/newview/tests/llviewernetwork_test.cpp b/indra/newview/tests/llviewernetwork_test.cpp
index a1e97ea17e..725b5122fb 100644
--- a/indra/newview/tests/llviewernetwork_test.cpp
+++ b/indra/newview/tests/llviewernetwork_test.cpp
@@ -35,7 +35,7 @@
 // Mock objects for the dependencies of the code we're testing
 
 LLControlGroup::LLControlGroup(const std::string& name)
-: LLInstanceTracker<LLControlGroup, std::string>(name) {}
+: INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name) {}
 LLControlGroup::~LLControlGroup() {}
 BOOL LLControlGroup::declareString(const std::string& name,
                                    const std::string& initial_val,
diff --git a/indra/newview/tests/llworldmipmap_test.cpp b/indra/newview/tests/llworldmipmap_test.cpp
index e7ef017760..47453a1b1a 100644
--- a/indra/newview/tests/llworldmipmap_test.cpp
+++ b/indra/newview/tests/llworldmipmap_test.cpp
@@ -46,7 +46,7 @@ void LLViewerTexture::setBoostLevel(S32 ) { }
 LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTextureFromUrl(const std::string&, BOOL, LLViewerTexture::EBoostLevel, S8, 
 																		 LLGLint, LLGLenum, const LLUUID& ) { return NULL; }
 
-LLControlGroup::LLControlGroup(const std::string& name) : LLInstanceTracker<LLControlGroup, std::string>(name) { }
+LLControlGroup::LLControlGroup(const std::string& name) : INSTANCE_TRACKER_KEYED(LLControlGroup, std::string)(name) { }
 LLControlGroup::~LLControlGroup() { }
 std::string LLControlGroup::getString(const std::string& ) { return std::string("test_url"); }
 LLControlGroup gSavedSettings("test_settings");