Automated merge with file:///F:%5Cviewer-bear

15 files changed, 357 insertions, 211 deletions

diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index c3005f1722..00de61a8cc 100755
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -59,6 +59,7 @@ BOOL gDebugGL = FALSE;
 BOOL gClothRipple = FALSE;
 BOOL gHeadlessClient = FALSE;
 BOOL gGLActive = FALSE;
+BOOL gGLDebugLoggingEnabled = TRUE;
 
 static const std::string HEADLESS_VENDOR_STRING("Linden Lab");
 static const std::string HEADLESS_RENDERER_STRING("Headless");
@@ -72,6 +73,7 @@ std::ofstream gFailLog;
 #define APIENTRY
 #endif
 
+
 void APIENTRY gl_debug_callback(GLenum source,
                                 GLenum type,
                                 GLuint id,
@@ -80,22 +82,25 @@ void APIENTRY gl_debug_callback(GLenum source,
                                 const GLchar* message,
                                 GLvoid* userParam)
 {
-	if (severity == GL_DEBUG_SEVERITY_HIGH_ARB)
-	{
-		llwarns << "----- GL ERROR --------" << llendl;
-	}
-	else
+	if (gGLDebugLoggingEnabled)
 	{
-		llwarns << "----- GL WARNING -------" << llendl;
-	}
-	llwarns << "Type: " << std::hex << type << llendl;
-	llwarns << "ID: " << std::hex << id << llendl;
-	llwarns << "Severity: " << std::hex << severity << llendl;
-	llwarns << "Message: " << message << llendl;
-	llwarns << "-----------------------" << llendl;
-	if (severity == GL_DEBUG_SEVERITY_HIGH_ARB)
-	{
-		llerrs << "Halting on GL Error" << llendl;
+		if (severity == GL_DEBUG_SEVERITY_HIGH_ARB)
+		{
+			llwarns << "----- GL ERROR --------" << llendl;
+		}
+		else
+		{
+			llwarns << "----- GL WARNING -------" << llendl;
+		}
+		llwarns << "Type: " << std::hex << type << llendl;
+		llwarns << "ID: " << std::hex << id << llendl;
+		llwarns << "Severity: " << std::hex << severity << llendl;
+		llwarns << "Message: " << message << llendl;
+		llwarns << "-----------------------" << llendl;
+		if (severity == GL_DEBUG_SEVERITY_HIGH_ARB)
+		{
+			llerrs << "Halting on GL Error" << llendl;
+		}
 	}
 }
 #endif
@@ -258,6 +263,7 @@ PFNGLBEGINTRANSFORMFEEDBACKPROC glBeginTransformFeedback = NULL;
 PFNGLENDTRANSFORMFEEDBACKPROC glEndTransformFeedback = NULL;
 PFNGLTRANSFORMFEEDBACKVARYINGSPROC glTransformFeedbackVaryings = NULL;
 PFNGLBINDBUFFERRANGEPROC glBindBufferRange = NULL;
+PFNGLBINDBUFFERBASEPROC glBindBufferBase = NULL;
 
 //GL_ARB_debug_output
 PFNGLDEBUGMESSAGECONTROLARBPROC glDebugMessageControlARB = NULL;
@@ -745,7 +751,7 @@ bool LLGLManager::initGL()
 #if LL_WINDOWS
 	if (mHasDebugOutput && gDebugGL)
 	{ //setup debug output callback
-		//glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW_ARB, 0, NULL, GL_TRUE);
+		glDebugMessageControlARB(GL_DONT_CARE, GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB, GL_DEBUG_SEVERITY_LOW_ARB, 0, NULL, GL_TRUE);
 		glDebugMessageCallbackARB((GLDEBUGPROCARB) gl_debug_callback, NULL);
 		glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
 	}
@@ -1246,6 +1252,7 @@ void LLGLManager::initExtensions()
 		glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC) GLH_EXT_GET_PROC_ADDRESS("glEndTransformFeedback");
 		glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC) GLH_EXT_GET_PROC_ADDRESS("glTransformFeedbackVaryings");
 		glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC) GLH_EXT_GET_PROC_ADDRESS("glBindBufferRange");
+		glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) GLH_EXT_GET_PROC_ADDRESS("glBindBufferBase");
 	}
 	if (mHasDebugOutput)
 	{
@@ -1500,7 +1507,7 @@ void do_assert_glerror()
 
 void assert_glerror()
 {
-	if (!gGLActive)
+/*	if (!gGLActive)
 	{
 		//llwarns << "GL used while not active!" << llendl;
 
@@ -1509,8 +1516,13 @@ void assert_glerror()
 			//ll_fail("GL used while not active");
 		}
 	}
+*/
 
-	if (gDebugGL) 
+	if (!gDebugGL) 
+	{
+		//funny looking if for branch prediction -- gDebugGL is almost always false and assert_glerror is called often
+	}
+	else
 	{
 		do_assert_glerror();
 	}
diff --git a/indra/llrender/llglheaders.h b/indra/llrender/llglheaders.h
index dace572953..4a4153ece8 100755
--- a/indra/llrender/llglheaders.h
+++ b/indra/llrender/llglheaders.h
@@ -543,6 +543,7 @@ extern PFNGLBEGINTRANSFORMFEEDBACKPROC glBeginTransformFeedback;
 extern PFNGLENDTRANSFORMFEEDBACKPROC glEndTransformFeedback;
 extern PFNGLTRANSFORMFEEDBACKVARYINGSPROC glTransformFeedbackVaryings;
 extern PFNGLBINDBUFFERRANGEPROC glBindBufferRange;
+extern PFNGLBINDBUFFERBASEPROC glBindBufferBase;
 
 
 #elif LL_WINDOWS
@@ -787,6 +788,7 @@ extern PFNGLBEGINTRANSFORMFEEDBACKPROC glBeginTransformFeedback;
 extern PFNGLENDTRANSFORMFEEDBACKPROC glEndTransformFeedback;
 extern PFNGLTRANSFORMFEEDBACKVARYINGSPROC glTransformFeedbackVaryings;
 extern PFNGLBINDBUFFERRANGEPROC glBindBufferRange;
+extern PFNGLBINDBUFFERBASEPROC glBindBufferBase;
 
 //GL_ARB_debug_output
 extern PFNGLDEBUGMESSAGECONTROLARBPROC glDebugMessageControlARB;
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 62191b4c1a..6a654bdd82 100755
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -309,8 +309,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)
 {
@@ -392,7 +392,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
@@ -449,7 +450,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++)
@@ -486,7 +487,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)
 				{
@@ -502,7 +503,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)
 	{
@@ -572,7 +573,8 @@ void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
 			is_array[0] = 0;
 		}
 
-		mUniformMap[name] = location;
+		LLStaticHashedString hashedName(name);
+		mUniformMap[hashedName] = location;
 		LL_DEBUGS("ShaderLoading") << "Uniform " << name << " is at location " << location << LL_ENDL;
 	
 		//find the index of this uniform
@@ -593,7 +595,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;
@@ -627,7 +629,7 @@ 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;
 	
@@ -1088,18 +1090,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;
 				}
@@ -1136,10 +1138,10 @@ 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);
-				
+
 	if (location >= 0)
 	{
 		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
@@ -1152,10 +1154,10 @@ void LLGLSLShader::uniform1i(const string& uniform, GLint v)
 	}
 }
 
-void LLGLSLShader::uniform1f(const string& uniform, GLfloat v)
+void LLGLSLShader::uniform1f(const LLStaticHashedString& uniform, GLfloat v)
 {
 	GLint location = getUniformLocation(uniform);
-				
+
 	if (location >= 0)
 	{
 		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
@@ -1168,10 +1170,10 @@ 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);
-				
+
 	if (location >= 0)
 	{
 		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
@@ -1185,10 +1187,10 @@ 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);
-				
+
 	if (location >= 0)
 	{
 		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
@@ -1201,23 +1203,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);
 
@@ -1233,10 +1219,10 @@ 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);
-				
+
 	if (location >= 0)
 	{
 		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
@@ -1249,10 +1235,10 @@ 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);
-				
+
 	if (location >= 0)
 	{
 		std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
@@ -1265,7 +1251,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);
 
@@ -1283,27 +1269,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);
 				
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 3c775cde27..22f91cd6a2 100755
--- 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
 {
@@ -90,16 +91,16 @@ public:
 	void placeProfileQuery();
 	void readProfileQuery(U32 count, U32 mode);
 
-	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);
@@ -110,29 +111,26 @@ 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 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);
@@ -169,7 +167,7 @@ public:
 	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, LLVector4> mValue; //lookup map of uniform location to last known value
 	std::vector<GLint> mTexture;
 	S32 mTotalUniformSize;
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index 38764eba23..6a37d31415 100755
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -715,9 +715,9 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
 
 					mMipLevels = wpo2(llmax(w, h));
 
-					//use legacy mipmap generation mode
+					//use legacy mipmap generation mode (note: making this condional can cause rendering issues)
 					glTexParameteri(mTarget, GL_GENERATE_MIPMAP, GL_TRUE);
-					
+
 					LLImageGL::setManualImage(mTarget, 0, mFormatInternal,
 								 w, h, 
 								 mFormatPrimary, mFormatType,
@@ -1089,6 +1089,16 @@ void LLImageGL::generateTextures(LLTexUnit::eTextureType type, U32 format, S32 n
 	LLFastTimer t(FTM_GENERATE_TEXTURES);
 	bool empty = true;
 
+	if (LLRender::sGLCoreProfile)
+	{
+		switch (format)
+		{
+			case GL_LUMINANCE8: format = GL_RGB8; break;
+			case GL_LUMINANCE8_ALPHA8:
+			case GL_ALPHA8: format = GL_RGBA8; break;
+		}
+	}
+
 	dead_texturelist_t::iterator iter = sDeadTextureList[type].find(format);
 	
 	if (iter != sDeadTextureList[type].end())
diff --git a/indra/llrender/llpostprocess.cpp b/indra/llrender/llpostprocess.cpp
index c0045c8044..4c36185b08 100755
--- a/indra/llrender/llpostprocess.cpp
+++ b/indra/llrender/llpostprocess.cpp
@@ -31,6 +31,21 @@
 #include "llsdserialize.h"
 #include "llrender.h"
 
+static LLStaticHashedString sRenderTexture("RenderTexture");
+static LLStaticHashedString sBrightness("brightness");
+static LLStaticHashedString sContrast("contrast");
+static LLStaticHashedString sContrastBase("contrastBase");
+static LLStaticHashedString sSaturation("saturation");
+static LLStaticHashedString sLumWeights("lumWeights");
+static LLStaticHashedString sNoiseTexture("NoiseTexture");
+static LLStaticHashedString sBrightMult("brightMult");
+static LLStaticHashedString sNoiseStrength("noiseStrength");
+static LLStaticHashedString sExtractLow("extractLow");
+static LLStaticHashedString sExtractHigh("extractHigh");
+static LLStaticHashedString sBloomStrength("bloomStrength");
+static LLStaticHashedString sTexelSize("texelSize");
+static LLStaticHashedString sBlurDirection("blurDirection");
+static LLStaticHashedString sBlurWidth("blurWidth");
 
 LLPostProcess * gPostProcess = NULL;
 
@@ -258,12 +273,12 @@ void LLPostProcess::applyColorFilterShader(void)
 void LLPostProcess::createColorFilterShader(void)
 {
 	/// Define uniform names
-	colorFilterUniforms["RenderTexture"] = 0;
-	colorFilterUniforms["brightness"] = 0;
-	colorFilterUniforms["contrast"] = 0;
-	colorFilterUniforms["contrastBase"] = 0;
-	colorFilterUniforms["saturation"] = 0;
-	colorFilterUniforms["lumWeights"] = 0;
+	colorFilterUniforms[sRenderTexture] = 0;
+	colorFilterUniforms[sBrightness] = 0;
+	colorFilterUniforms[sContrast] = 0;
+	colorFilterUniforms[sContrastBase] = 0;
+	colorFilterUniforms[sSaturation] = 0;
+	colorFilterUniforms[sLumWeights] = 0;
 }
 
 void LLPostProcess::applyNightVisionShader(void)
@@ -307,11 +322,11 @@ void LLPostProcess::applyNightVisionShader(void)
 void LLPostProcess::createNightVisionShader(void)
 {
 	/// Define uniform names
-	nightVisionUniforms["RenderTexture"] = 0;
-	nightVisionUniforms["NoiseTexture"] = 0;
-	nightVisionUniforms["brightMult"] = 0;	
-	nightVisionUniforms["noiseStrength"] = 0;
-	nightVisionUniforms["lumWeights"] = 0;	
+	nightVisionUniforms[sRenderTexture] = 0;
+	nightVisionUniforms[sNoiseTexture] = 0;
+	nightVisionUniforms[sBrightMult] = 0;	
+	nightVisionUniforms[sNoiseStrength] = 0;
+	nightVisionUniforms[sLumWeights] = 0;	
 
 	createNoiseTexture(mNoiseTexture);
 }
@@ -326,25 +341,25 @@ void LLPostProcess::createBloomShader(void)
 	createTexture(mTempBloomTexture, unsigned(screenW * 0.5), unsigned(screenH * 0.5));
 
 	/// Create Bloom Extract Shader
-	bloomExtractUniforms["RenderTexture"] = 0;
-	bloomExtractUniforms["extractLow"] = 0;
-	bloomExtractUniforms["extractHigh"] = 0;	
-	bloomExtractUniforms["lumWeights"] = 0;	
+	bloomExtractUniforms[sRenderTexture] = 0;
+	bloomExtractUniforms[sExtractLow] = 0;
+	bloomExtractUniforms[sExtractHigh] = 0;	
+	bloomExtractUniforms[sLumWeights] = 0;	
 	
 	/// Create Bloom Blur Shader
-	bloomBlurUniforms["RenderTexture"] = 0;
-	bloomBlurUniforms["bloomStrength"] = 0;	
-	bloomBlurUniforms["texelSize"] = 0;
-	bloomBlurUniforms["blurDirection"] = 0;
-	bloomBlurUniforms["blurWidth"] = 0;
+	bloomBlurUniforms[sRenderTexture] = 0;
+	bloomBlurUniforms[sBloomStrength] = 0;	
+	bloomBlurUniforms[sTexelSize] = 0;
+	bloomBlurUniforms[sBlurDirection] = 0;
+	bloomBlurUniforms[sBlurWidth] = 0;
 }
 
 void LLPostProcess::getShaderUniforms(glslUniforms & uniforms, GLhandleARB & prog)
 {
 	/// Find uniform locations and insert into map	
-	std::map<const char *, GLuint>::iterator i;
+	glslUniforms::iterator i;
 	for (i  = uniforms.begin(); i != uniforms.end(); ++i){
-		i->second = glGetUniformLocationARB(prog, i->first);
+		i->second = glGetUniformLocationARB(prog, i->first.String().c_str());
 	}
 }
 
diff --git a/indra/llrender/llpostprocess.h b/indra/llrender/llpostprocess.h
index e19de44c60..ce17b6693d 100755
--- a/indra/llrender/llpostprocess.h
+++ b/indra/llrender/llpostprocess.h
@@ -31,6 +31,7 @@
 #include <fstream>
 #include "llgl.h"
 #include "llglheaders.h"
+#include "llstaticstringtable.h"
 
 class LLPostProcess 
 {
@@ -44,7 +45,7 @@ public:
 	} QuadType;
 
 	/// GLSL Shader Encapsulation Struct
-	typedef std::map<const char *, GLuint> glslUniforms;
+	typedef LLStaticStringTable<GLuint> glslUniforms;
 
 	struct PostProcessTweaks : public LLSD {
 		inline PostProcessTweaks() : LLSD(LLSD::emptyMap())
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index c60eb8d9d9..18ca5b35f0 100755
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -225,26 +225,15 @@ void LLTexUnit::disable(void)
 bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
 {
 	stop_glerror();
-	if (mIndex < 0) return false;
-
+	if (mIndex >= 0)
+	{
 	gGL.flush();
 
 	LLImageGL* gl_tex = NULL ;
-	if (texture == NULL || !(gl_tex = texture->getGLTexture()))
+		if (texture != NULL && (gl_tex = texture->getGLTexture()))
 	{
-		llwarns << "NULL LLTexUnit::bind texture" << llendl;
-		return false;
-	}
-
-	if (!gl_tex->getTexName()) //if texture does not exist
+			if (gl_tex->getTexName()) //if texture exists
 	{
-		//if deleted, will re-generate it immediately
-		texture->forceImmediateUpdate() ;
-
-		gl_tex->forceUpdateBindStats() ;
-		return texture->bindDefaultImage(mIndex);
-	}
-
 	//in audit, replace the selected texture by the default one.
 	if ((mCurrTexture != gl_tex->getTexName()) || forceBind)
 	{
@@ -265,6 +254,27 @@ bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind)
 			setTextureFilteringOption(gl_tex->mFilterOption);
 		}
 	}
+			}
+			else
+			{
+				//if deleted, will re-generate it immediately
+				texture->forceImmediateUpdate() ;
+
+				gl_tex->forceUpdateBindStats() ;
+				return texture->bindDefaultImage(mIndex);
+			}
+		}
+		else
+		{
+			llwarns << "NULL LLTexUnit::bind texture" << llendl;
+			return false;
+		}
+	}
+	else
+	{ // mIndex < 0
+		return false;
+	}
+
 	return true;
 }
 
@@ -1058,6 +1068,16 @@ LLRender::~LLRender()
 
 void LLRender::init()
 {
+	if (sGLCoreProfile && !LLVertexBuffer::sUseVAO)
+	{ //bind a dummy vertex array object so we're core profile compliant
+#ifdef GL_ARB_vertex_array_object
+		U32 ret;
+		glGenVertexArrays(1, &ret);
+		glBindVertexArray(ret);
+#endif
+	}
+
+
 	llassert_always(mBuffer.isNull()) ;
 	stop_glerror();
 	mBuffer = new LLVertexBuffer(immediate_mask, 0);
@@ -2280,6 +2300,22 @@ void LLRender::diffuseColor4ubv(const U8* c)
 	}
 }
 
+void LLRender::diffuseColor4ub(U8 r, U8 g, U8 b, U8 a)
+{
+	LLGLSLShader* shader = LLGLSLShader::sCurBoundShaderPtr;
+	llassert(!LLGLSLShader::sNoFixedFunction || shader != NULL);
+
+	if (shader)
+	{
+		shader->uniform4f(LLShaderMgr::DIFFUSE_COLOR, r/255.f, g/255.f, b/255.f, a/255.f);
+	}
+	else
+	{
+		glColor4ub(r,g,b,a);
+	}
+}
+
+
 void LLRender::debugTexUnits(void)
 {
 	LL_INFOS("TextureUnit") << "Active TexUnit: " << mCurrTextureUnitIndex << LL_ENDL;
diff --git a/indra/llrender/llrender.h b/indra/llrender/llrender.h
index 98222939e7..42b02a8159 100755
--- a/indra/llrender/llrender.h
+++ b/indra/llrender/llrender.h
@@ -396,6 +396,7 @@ public:
 	void diffuseColor4f(F32 r, F32 g, F32 b, F32 a);
 	void diffuseColor4fv(const F32* c);
 	void diffuseColor4ubv(const U8* c);
+	void diffuseColor4ub(U8 r, U8 g, U8 b, U8 a);
 
 	void vertexBatchPreTransformed(LLVector3* verts, S32 vert_count);
 	void vertexBatchPreTransformed(LLVector3* verts, LLVector2* uvs, S32 vert_count);
diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp
index 25109268e8..4a4f6a7a2f 100755
--- a/indra/llrender/llrendertarget.cpp
+++ b/indra/llrender/llrendertarget.cpp
@@ -458,6 +458,12 @@ U32 LLRenderTarget::getTexture(U32 attachment) const
 	return mTex[attachment];
 }
 
+U32 LLRenderTarget::getNumTextures() const
+{
+	return mTex.size();
+}
+
+
 void LLRenderTarget::bindTexture(U32 index, S32 channel)
 {
 	gGL.getTexUnit(channel)->bindManual(mUsage, getTexture(index));
diff --git a/indra/llrender/llrendertarget.h b/indra/llrender/llrendertarget.h
index 765a727b5b..a7bc4e1385 100755
--- a/indra/llrender/llrendertarget.h
+++ b/indra/llrender/llrendertarget.h
@@ -112,6 +112,7 @@ public:
 	LLTexUnit::eTextureType getUsage(void) const { return mUsage; }
 
 	U32 getTexture(U32 attachment = 0) const;
+	U32 getNumTextures() const;
 
 	U32 getDepth(void) const { return mDepth; }
 	bool hasStencil() const { return mStencil; }
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index fea4ee2819..d1afd2ed28 100755
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -993,7 +993,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");
 
@@ -1142,6 +1144,46 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("specular_color");
 	mReservedUniforms.push_back("env_intensity");
 
+	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;
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index c049e935b8..ba781036eb 100755
--- 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,
@@ -172,7 +174,48 @@ public:
 		SPECULAR_COLOR,
 		ENVIRONMENT_INTENSITY,
 		
+		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;
 
 	// singleton pattern implementation
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index 01541026b1..83ea6fabbb 100755
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -85,6 +85,7 @@ const U32 LL_VBO_POOL_SEED_COUNT = vbo_block_index(LL_VBO_POOL_MAX_SEED_SIZE);
 //static
 LLVBOPool LLVertexBuffer::sStreamVBOPool(GL_STREAM_DRAW_ARB, GL_ARRAY_BUFFER_ARB);
 LLVBOPool LLVertexBuffer::sDynamicVBOPool(GL_DYNAMIC_DRAW_ARB, GL_ARRAY_BUFFER_ARB);
+LLVBOPool LLVertexBuffer::sDynamicCopyVBOPool(GL_DYNAMIC_COPY_ARB, GL_ARRAY_BUFFER_ARB);
 LLVBOPool LLVertexBuffer::sStreamIBOPool(GL_STREAM_DRAW_ARB, GL_ELEMENT_ARRAY_BUFFER_ARB);
 LLVBOPool LLVertexBuffer::sDynamicIBOPool(GL_DYNAMIC_DRAW_ARB, GL_ELEMENT_ARRAY_BUFFER_ARB);
 
@@ -199,7 +200,10 @@ volatile U8* LLVBOPool::allocate(U32& name, U32 size, bool for_seed)
 		if (LLVertexBuffer::sDisableVBOMapping || mUsage != GL_DYNAMIC_DRAW_ARB)
 		{
 			glBufferDataARB(mType, size, 0, mUsage);
-			ret = (U8*) ll_aligned_malloc_16(size);
+			if (mUsage != GL_DYNAMIC_COPY_ARB)
+			{ //data will be provided by application
+				ret = (U8*) ll_aligned_malloc(size, 64);
+			}
 		}
 		else
 		{ //always use a true hint of static draw when allocating non-client-backed buffers
@@ -252,7 +256,7 @@ void LLVBOPool::release(U32 name, volatile U8* buffer, U32 size)
 	llassert(vbo_block_size(size) == size);
 
 	deleteBuffer(name);
-	ll_aligned_free_16((U8*) buffer);
+	ll_aligned_free((U8*) buffer);
 
 	if (mType == GL_ARRAY_BUFFER_ARB)
 	{
@@ -306,7 +310,7 @@ void LLVBOPool::cleanup()
 			
 			if (r.mClientData)
 			{
-				ll_aligned_free_16((void*) r.mClientData);
+				ll_aligned_free((void*) r.mClientData);
 			}
 
 			l.pop_front();
@@ -412,6 +416,7 @@ void LLVertexBuffer::seedPools()
 {
 	sStreamVBOPool.seedPool();
 	sDynamicVBOPool.seedPool();
+	sDynamicCopyVBOPool.seedPool();
 	sStreamIBOPool.seedPool();
 	sDynamicIBOPool.seedPool();
 }
@@ -910,6 +915,7 @@ void LLVertexBuffer::cleanupClass()
 	sDynamicIBOPool.cleanup();
 	sStreamVBOPool.cleanup();
 	sDynamicVBOPool.cleanup();
+	sDynamicCopyVBOPool.cleanup();
 
 	if(sPrivatePoolp)
 	{
@@ -946,13 +952,16 @@ S32 LLVertexBuffer::determineUsage(S32 usage)
 	
 	if (ret_usage && ret_usage != GL_STREAM_DRAW_ARB)
 	{ //only stream_draw and dynamic_draw are supported when using VBOs, dynamic draw is the default
-		if (sDisableVBOMapping)
-		{ //always use stream draw if VBO mapping is disabled
-			ret_usage = GL_STREAM_DRAW_ARB;
-		}
-		else
+		if (ret_usage != GL_DYNAMIC_COPY_ARB)
 		{
-			ret_usage = GL_DYNAMIC_DRAW_ARB;
+			if (sDisableVBOMapping)
+			{ //always use stream draw if VBO mapping is disabled
+				ret_usage = GL_STREAM_DRAW_ARB;
+			}
+			else
+			{
+				ret_usage = GL_DYNAMIC_DRAW_ARB;
+			}
 		}
 	}
 	
@@ -1102,10 +1111,15 @@ void LLVertexBuffer::genBuffer(U32 size)
 	{
 		mMappedData = sStreamVBOPool.allocate(mGLBuffer, mSize);
 	}
-	else
+	else if (mUsage == GL_DYNAMIC_DRAW_ARB)
 	{
 		mMappedData = sDynamicVBOPool.allocate(mGLBuffer, mSize);
 	}
+	else
+	{
+		mMappedData = sDynamicCopyVBOPool.allocate(mGLBuffer, mSize);
+	}
+
 	
 	sGLCount++;
 }
@@ -1319,7 +1333,7 @@ void LLVertexBuffer::allocateBuffer(S32 nverts, S32 nindices, bool create)
 		//actually allocate space for the vertex buffer if using VBO mapping
 		flush();
 
-		if (gGLManager.mHasVertexArrayObject && useVBOs() && (LLRender::sGLCoreProfile || sUseVAO))
+		if (gGLManager.mHasVertexArrayObject && useVBOs() && (sUseVAO))
 		{
 #if GL_ARB_vertex_array_object
 			mGLArray = getVAOName();
@@ -1475,21 +1489,18 @@ bool LLVertexBuffer::useVBOs() const
 
 //----------------------------------------------------------------------------
 
-bool expand_region(LLVertexBuffer::MappedRegion& region, S32 index, S32 count)
+bool expand_region(LLVertexBuffer::MappedRegion& region, S32 start, S32 end)
 {
-	S32 end = index+count;
-	S32 region_end = region.mIndex+region.mCount;
-	
 	if (end < region.mIndex ||
-		index > region_end)
+		start > region.mEnd)
 	{ //gap exists, do not merge
 		return false;
 	}
 
-	S32 new_end = llmax(end, region_end);
-	S32 new_index = llmin(index, region.mIndex);
-	region.mIndex = new_index;
-	region.mCount = new_end-new_index;
+	region.mEnd = llmax(end, region.mEnd);
+	region.mIndex = llmin(start, region.mIndex);
+	region.mCount = region.mEnd-region.mIndex;
+
 	return true;
 }
 
@@ -1499,7 +1510,6 @@ static LLFastTimer::DeclareTimer FTM_VBO_MAP_BUFFER("VBO Map");
 // Map for data access
 volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, bool map_range)
 {
-	bindGLBuffer(true);
 	if (mFinal)
 	{
 		llerrs << "LLVertexBuffer::mapVeretxBuffer() called on a finalized buffer." << llendl;
@@ -1520,23 +1530,23 @@ volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, boo
 
 			bool mapped = false;
 			//see if range is already mapped
-			for (U32 i = 0; i < mMappedVertexRegions.size(); ++i)
+			S32 start_index = mOffsets[type]+index*sTypeSize[type];
+			S32 end_index = start_index+count*sTypeSize[type];
+
+			for (std::vector<MappedRegion>::iterator iter = mMappedVertexRegions.begin(), end = mMappedVertexRegions.end(); iter != end; ++iter)
 			{
-				MappedRegion& region = mMappedVertexRegions[i];
-				if (region.mType == type)
+				MappedRegion& region = *iter;
+				if (expand_region(region, index, end_index))
 				{
-					if (expand_region(region, index, count))
-					{
-						mapped = true;
-						break;
-					}
+					mapped = true;
+					break;
 				}
 			}
 
 			if (!mapped)
 			{
 				//not already mapped, map new region
-				MappedRegion region(type, mMappable && map_range ? -1 : index, count);
+				MappedRegion region(mMappable && map_range ? -1 : start_index, end_index-start_index);
 				mMappedVertexRegions.push_back(region);
 			}
 		}
@@ -1560,6 +1570,7 @@ volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, boo
 			{
 				volatile U8* src = NULL;
 				waitFence();
+				bindGLBuffer();
 				if (gGLManager.mHasMapBufferRange)
 				{
 					if (map_range)
@@ -1680,7 +1691,6 @@ static LLFastTimer::DeclareTimer FTM_VBO_MAP_INDEX("IBO Map");
 
 volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range)
 {
-	bindGLIndices(true);
 	if (mFinal)
 	{
 		llerrs << "LLVertexBuffer::mapIndexBuffer() called on a finalized buffer." << llendl;
@@ -1699,12 +1709,14 @@ volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range
 				count = mNumIndices-index;
 			}
 
+			S32 end = index+count;
+
 			bool mapped = false;
 			//see if range is already mapped
 			for (U32 i = 0; i < mMappedIndexRegions.size(); ++i)
 			{
 				MappedRegion& region = mMappedIndexRegions[i];
-				if (expand_region(region, index, count))
+				if (expand_region(region, index, end))
 				{
 					mapped = true;
 					break;
@@ -1714,7 +1726,7 @@ volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range
 			if (!mapped)
 			{
 				//not already mapped, map new region
-				MappedRegion region(TYPE_INDEX, mMappable && map_range ? -1 : index, count);
+				MappedRegion region(mMappable && map_range ? -1 : index, count);
 				mMappedIndexRegions.push_back(region);
 			}
 		}
@@ -1730,23 +1742,23 @@ volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range
 			sMappedCount++;
 			stop_glerror();	
 
-			if (gDebugGL && useVBOs())
-			{
-				GLint elem = 0;
-				glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, &elem);
-
-				if (elem != mGLIndices)
-				{
-					llerrs << "Wrong index buffer bound!" << llendl;
-				}
-			}
-
 			if(!mMappable)
 			{
 				map_range = false;
 			}
 			else
 			{
+				bindGLIndices();
+				if (gDebugGL && useVBOs())
+				{
+					GLint elem = 0;
+					glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, &elem);
+
+					if (elem != mGLIndices)
+					{
+						llerrs << "Wrong index buffer bound!" << llendl;
+					}
+				}
 				volatile U8* src = NULL;
 				waitFence();
 				if (gGLManager.mHasMapBufferRange)
@@ -1859,8 +1871,10 @@ void LLVertexBuffer::unmapBuffer()
 
 	if (mMappedData && mVertexLocked)
 	{
+		llassert(mUsage != GL_DYNAMIC_COPY_ARB);
+		
 		LLFastTimer t(FTM_VBO_UNMAP);
-		bindGLBuffer(true);
+		bindGLBuffer();
 		updated_all = mIndexLocked; //both vertex and index buffers done updating
 
 		if(!mMappable)
@@ -1871,8 +1885,8 @@ void LLVertexBuffer::unmapBuffer()
 				for (U32 i = 0; i < mMappedVertexRegions.size(); ++i)
 				{
 					const MappedRegion& region = mMappedVertexRegions[i];
-					S32 offset = region.mIndex >= 0 ? mOffsets[region.mType]+sTypeSize[region.mType]*region.mIndex : 0;
-					S32 length = sTypeSize[region.mType]*region.mCount;
+					S32 offset = region.mIndex;
+					S32 length = region.mCount;
 					glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, offset, length, (U8*) mMappedData+offset);
 					stop_glerror();
 				}
@@ -1896,8 +1910,8 @@ void LLVertexBuffer::unmapBuffer()
 					for (U32 i = 0; i < mMappedVertexRegions.size(); ++i)
 					{
 						const MappedRegion& region = mMappedVertexRegions[i];
-						S32 offset = region.mIndex >= 0 ? mOffsets[region.mType]+sTypeSize[region.mType]*region.mIndex : 0;
-						S32 length = sTypeSize[region.mType]*region.mCount;
+						S32 offset = region.mIndex;
+						S32 length = region.mCount;
 						if (gGLManager.mHasMapBufferRange)
 						{
 							LLFastTimer t(FTM_VBO_FLUSH_RANGE);
@@ -2117,7 +2131,6 @@ bool LLVertexBuffer::bindGLArray()
 	if (mGLArray && sGLRenderArray != mGLArray)
 	{
 		{
-			LLFastTimer t(FTM_BIND_GL_ARRAY);
 #if GL_ARB_vertex_array_object
 			glBindVertexArray(mGLArray);
 #endif
@@ -2144,22 +2157,15 @@ bool LLVertexBuffer::bindGLBuffer(bool force_bind)
 
 	if (useVBOs() && (force_bind || (mGLBuffer && (mGLBuffer != sGLRenderBuffer || !sVBOActive))))
 	{
-		LLFastTimer t(FTM_BIND_GL_BUFFER);
-		/*if (sMapped)
-		{
-			llerrs << "VBO bound while another VBO mapped!" << llendl;
-		}*/
+		//LLFastTimer t(FTM_BIND_GL_BUFFER); <-- this timer is showing up as a hotspot (irony)
+		
 		glBindBufferARB(GL_ARRAY_BUFFER_ARB, mGLBuffer);
 		sGLRenderBuffer = mGLBuffer;
 		sBindCount++;
 		sVBOActive = true;
 
-		if (mGLArray)
-		{
-			llassert(sGLRenderArray == mGLArray);
-			//mCachedRenderBuffer = mGLBuffer;
-		}
-
+		llassert(!mGLArray || sGLRenderArray == mGLArray);
+		
 		ret = true;
 	}
 
@@ -2409,7 +2415,8 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask)
 		if (data_mask & MAP_COLOR)
 		{
 			S32 loc = TYPE_COLOR;
-			void* ptr = (void*)(base + mOffsets[TYPE_COLOR]);
+			//bind emissive instead of color pointer if emissive is present
+			void* ptr = (data_mask & MAP_EMISSIVE) ? (void*)(base + mOffsets[TYPE_EMISSIVE]) : (void*)(base + mOffsets[TYPE_COLOR]);
 			glVertexAttribPointerARB(loc, 4, GL_UNSIGNED_BYTE, GL_TRUE, LLVertexBuffer::sTypeSize[TYPE_COLOR], ptr);
 		}
 		if (data_mask & MAP_EMISSIVE)
@@ -2417,6 +2424,12 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask)
 			S32 loc = TYPE_EMISSIVE;
 			void* ptr = (void*)(base + mOffsets[TYPE_EMISSIVE]);
 			glVertexAttribPointerARB(loc, 4, GL_UNSIGNED_BYTE, GL_TRUE, LLVertexBuffer::sTypeSize[TYPE_EMISSIVE], ptr);
+
+			if (!(data_mask & MAP_COLOR))
+			{ //map emissive to color channel when color is not also being bound to avoid unnecessary shader swaps
+				loc = TYPE_COLOR;
+				glVertexAttribPointerARB(loc, 4, GL_UNSIGNED_BYTE, GL_TRUE, LLVertexBuffer::sTypeSize[TYPE_EMISSIVE], ptr);
+			}
 		}
 		if (data_mask & MAP_WEIGHT)
 		{
@@ -2499,11 +2512,10 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask)
 	llglassertok();
 }
 
-LLVertexBuffer::MappedRegion::MappedRegion(S32 type, S32 index, S32 count)
-: mType(type), mIndex(index), mCount(count)
+LLVertexBuffer::MappedRegion::MappedRegion(S32 index, S32 count)
+: mIndex(index), mCount(count)
 { 
-	llassert(mType == LLVertexBuffer::TYPE_INDEX || 
-			mType < LLVertexBuffer::TYPE_TEXTURE_INDEX);
+	mEnd = mIndex+mCount;	
 }	
 
 
diff --git a/indra/llrender/llvertexbuffer.h b/indra/llrender/llvertexbuffer.h
index 04806c1d8c..b7597cf60e 100755
--- a/indra/llrender/llvertexbuffer.h
+++ b/indra/llrender/llvertexbuffer.h
@@ -104,11 +104,11 @@ public:
 	class MappedRegion
 	{
 	public:
-		S32 mType;
 		S32 mIndex;
 		S32 mCount;
+		S32 mEnd;
 		
-		MappedRegion(S32 type, S32 index, S32 count);
+		MappedRegion(S32 index, S32 count);
 	};
 
 	LLVertexBuffer(const LLVertexBuffer& rhs)
@@ -125,9 +125,10 @@ public:
 
 	static LLVBOPool sStreamVBOPool;
 	static LLVBOPool sDynamicVBOPool;
+	static LLVBOPool sDynamicCopyVBOPool;
 	static LLVBOPool sStreamIBOPool;
 	static LLVBOPool sDynamicIBOPool;
-
+	
 	static std::list<U32> sAvailableVAOName;
 	static U32 sCurVAOName;