merged .hgtags & BuildParams

15 files changed, 952 insertions, 535 deletions

diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp
index a460912e70..a3aed4dd8a 100644
--- a/indra/llrender/llgl.cpp
+++ b/indra/llrender/llgl.cpp
@@ -127,6 +127,11 @@ PFNGLUNMAPBUFFERARBPROC				glUnmapBufferARB = NULL;
 PFNGLGETBUFFERPARAMETERIVARBPROC	glGetBufferParameterivARB = NULL;
 PFNGLGETBUFFERPOINTERVARBPROC		glGetBufferPointervARB = NULL;
 
+// GL_ARB_map_buffer_range
+PFNGLMAPBUFFERRANGEPROC			glMapBufferRange;
+PFNGLFLUSHMAPPEDBUFFERRANGEPROC	glFlushMappedBufferRange;
+
+
 // vertex object prototypes
 PFNGLNEWOBJECTBUFFERATIPROC			glNewObjectBufferATI = NULL;
 PFNGLISOBJECTBUFFERATIPROC			glIsObjectBufferATI = NULL;
@@ -178,6 +183,12 @@ PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer = NULL;
 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample = NULL;
 PFNGLFRAMEBUFFERTEXTURELAYERPROC glFramebufferTextureLayer = NULL;
 
+//GL_ARB_texture_multisample
+PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample;
+PFNGLTEXIMAGE3DMULTISAMPLEPROC glTexImage3DMultisample;
+PFNGLGETMULTISAMPLEFVPROC glGetMultisamplefv;
+PFNGLSAMPLEMASKIPROC glSampleMaski;
+
 // GL_EXT_blend_func_separate
 PFNGLBLENDFUNCSEPARATEEXTPROC glBlendFuncSeparateEXT = NULL;
 
@@ -321,9 +332,11 @@ LLGLManager::LLGLManager() :
 	mHasMipMapGeneration(FALSE),
 	mHasCompressedTextures(FALSE),
 	mHasFramebufferObject(FALSE),
+	mMaxSamples(0),
 	mHasBlendFuncSeparate(FALSE),
 
 	mHasVertexBufferObject(FALSE),
+	mHasMapBufferRange(FALSE),
 	mHasPBuffer(FALSE),
 	mHasShaderObjects(FALSE),
 	mHasVertexShader(FALSE),
@@ -334,6 +347,11 @@ LLGLManager::LLGLManager() :
 	mHasPointParameters(FALSE),
 	mHasDrawBuffers(FALSE),
 	mHasTextureRectangle(FALSE),
+	mHasTextureMultisample(FALSE),
+	mMaxSampleMaskWords(0),
+	mMaxColorTextureSamples(0),
+	mMaxDepthTextureSamples(0),
+	mMaxIntegerSamples(0),
 
 	mHasAnisotropic(FALSE),
 	mHasARBEnvCombine(FALSE),
@@ -539,7 +557,20 @@ bool LLGLManager::initGL()
 	{
 		GLint num_tex_image_units;
 		glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &num_tex_image_units);
-		mNumTextureImageUnits = num_tex_image_units;
+		mNumTextureImageUnits = llmin(num_tex_image_units, 32);
+	}
+
+	if (mHasTextureMultisample)
+	{
+		glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &mMaxColorTextureSamples);
+		glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &mMaxDepthTextureSamples);
+		glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &mMaxIntegerSamples);
+		glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &mMaxSampleMaskWords);
+	}
+
+	if (mHasFramebufferObject)
+	{
+		glGetIntegerv(GL_MAX_SAMPLES, &mMaxSamples);
 	}
 	
 	setToDebugGPU();
@@ -648,6 +679,14 @@ std::string LLGLManager::getRawGLString()
 	return gl_string;
 }
 
+U32 LLGLManager::getNumFBOFSAASamples(U32 samples)
+{
+	samples = llmin(samples, (U32) mMaxColorTextureSamples);
+	samples = llmin(samples, (U32) mMaxDepthTextureSamples);
+	samples = llmin(samples, (U32) 4);
+	return samples;
+}
+
 void LLGLManager::shutdownGL()
 {
 	if (mInited)
@@ -728,6 +767,7 @@ void LLGLManager::initExtensions()
 	mHasOcclusionQuery = ExtensionExists("GL_ARB_occlusion_query", gGLHExts.mSysExts);
 	mHasOcclusionQuery2 = ExtensionExists("GL_ARB_occlusion_query2", gGLHExts.mSysExts);
 	mHasVertexBufferObject = ExtensionExists("GL_ARB_vertex_buffer_object", gGLHExts.mSysExts);
+	mHasMapBufferRange = ExtensionExists("GL_ARB_map_buffer_range", gGLHExts.mSysExts);
 	mHasDepthClamp = ExtensionExists("GL_ARB_depth_clamp", gGLHExts.mSysExts) || ExtensionExists("GL_NV_depth_clamp", gGLHExts.mSysExts);
 	// mask out FBO support when packed_depth_stencil isn't there 'cause we need it for LLRenderTarget -Brad
 #ifdef GL_ARB_framebuffer_object
@@ -742,6 +782,7 @@ void LLGLManager::initExtensions()
 	mHasDrawBuffers = ExtensionExists("GL_ARB_draw_buffers", gGLHExts.mSysExts);
 	mHasBlendFuncSeparate = ExtensionExists("GL_EXT_blend_func_separate", gGLHExts.mSysExts);
 	mHasTextureRectangle = ExtensionExists("GL_ARB_texture_rectangle", gGLHExts.mSysExts);
+	mHasTextureMultisample = ExtensionExists("GL_ARB_texture_multisample", gGLHExts.mSysExts);
 #if !LL_DARWIN
 	mHasPointParameters = !mIsATI && ExtensionExists("GL_ARB_point_parameters", gGLHExts.mSysExts);
 #endif
@@ -921,6 +962,11 @@ void LLGLManager::initExtensions()
 			mHasVertexBufferObject = FALSE;
 		}
 	}
+	if (mHasMapBufferRange)
+	{
+		glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC) GLH_EXT_GET_PROC_ADDRESS("glMapBufferRange");
+		glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC) GLH_EXT_GET_PROC_ADDRESS("glFlushMappedBufferRange");
+	}
 	if (mHasFramebufferObject)
 	{
 		llinfos << "initExtensions() FramebufferObject-related procs..." << llendl;
@@ -953,6 +999,13 @@ void LLGLManager::initExtensions()
 	{
 		glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBlendFuncSeparateEXT");
 	}
+	if (mHasTextureMultisample)
+	{
+		glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC) GLH_EXT_GET_PROC_ADDRESS("glTexImage2DMultisample");
+		glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC) GLH_EXT_GET_PROC_ADDRESS("glTexImage3DMultisample");
+		glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC) GLH_EXT_GET_PROC_ADDRESS("glGetMultisamplefv");
+		glSampleMaski = (PFNGLSAMPLEMASKIPROC) GLH_EXT_GET_PROC_ADDRESS("glSampleMaski");
+	}	
 #if (!LL_LINUX && !LL_SOLARIS) || LL_LINUX_NV_GL_HEADERS
 	// This is expected to be a static symbol on Linux GL implementations, except if we use the nvidia headers - bah
 	glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)GLH_EXT_GET_PROC_ADDRESS("glDrawRangeElements");
@@ -1370,10 +1423,6 @@ void LLGLState::checkTextureChannels(const std::string& msg)
 		}
 	}
 
-	GLint maxTextureUnits = 0;
-	glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
-	stop_glerror();
-
 	static const char* label[] =
 	{
 		"GL_TEXTURE_2D",
@@ -1384,7 +1433,8 @@ void LLGLState::checkTextureChannels(const std::string& msg)
 		"GL_TEXTURE_GEN_T",
 		"GL_TEXTURE_GEN_Q",
 		"GL_TEXTURE_GEN_R",
-		"GL_TEXTURE_RECTANGLE_ARB"
+		"GL_TEXTURE_RECTANGLE_ARB",
+		"GL_TEXTURE_2D_MULTISAMPLE"
 	};
 
 	static GLint value[] =
@@ -1397,7 +1447,8 @@ void LLGLState::checkTextureChannels(const std::string& msg)
 		GL_TEXTURE_GEN_T,
 		GL_TEXTURE_GEN_Q,
 		GL_TEXTURE_GEN_R,
-		GL_TEXTURE_RECTANGLE_ARB
+		GL_TEXTURE_RECTANGLE_ARB,
+		GL_TEXTURE_2D_MULTISAMPLE
 	};
 
 	GLint stackDepth = 0;
@@ -1406,68 +1457,96 @@ void LLGLState::checkTextureChannels(const std::string& msg)
 	glh::matrix4f identity;
 	identity.identity();
 
-	for (GLint i = 1; i < maxTextureUnits; i++)
+	for (GLint i = 1; i < gGLManager.mNumTextureUnits; i++)
 	{
 		gGL.getTexUnit(i)->activate();
-		glClientActiveTextureARB(GL_TEXTURE0_ARB+i);
-		stop_glerror();
-		glGetIntegerv(GL_TEXTURE_STACK_DEPTH, &stackDepth);
-		stop_glerror();
 
-		if (stackDepth != 1)
+		if (i < gGLManager.mNumTextureUnits)
 		{
-			error = TRUE;
-			LL_WARNS("RenderState") << "Texture matrix stack corrupted." << LL_ENDL;
+			glClientActiveTextureARB(GL_TEXTURE0_ARB+i);
+			stop_glerror();
+			glGetIntegerv(GL_TEXTURE_STACK_DEPTH, &stackDepth);
+			stop_glerror();
 
-			if (gDebugSession)
+			if (stackDepth != 1)
 			{
-				gFailLog << "Texture matrix stack corrupted." << std::endl;
+				error = TRUE;
+				LL_WARNS("RenderState") << "Texture matrix stack corrupted." << LL_ENDL;
+
+				if (gDebugSession)
+				{
+					gFailLog << "Texture matrix stack corrupted." << std::endl;
+				}
 			}
-		}
 
-		glGetFloatv(GL_TEXTURE_MATRIX, (GLfloat*) mat.m);
-		stop_glerror();
+			glGetFloatv(GL_TEXTURE_MATRIX, (GLfloat*) mat.m);
+			stop_glerror();
 
-		if (mat != identity)
-		{
-			error = TRUE;
-			LL_WARNS("RenderState") << "Texture matrix in channel " << i << " corrupt." << LL_ENDL;
-			if (gDebugSession)
+			if (mat != identity)
 			{
-				gFailLog << "Texture matrix in channel " << i << " corrupt." << std::endl;
+				error = TRUE;
+				LL_WARNS("RenderState") << "Texture matrix in channel " << i << " corrupt." << LL_ENDL;
+				if (gDebugSession)
+				{
+					gFailLog << "Texture matrix in channel " << i << " corrupt." << std::endl;
+				}
+			}
+				
+			for (S32 j = (i == 0 ? 1 : 0); 
+				j < 9; j++)
+			{
+				if (j == 8 && !gGLManager.mHasTextureRectangle ||
+					j == 9 && !gGLManager.mHasTextureMultisample)
+				{
+					continue;
+				}
+				
+				if (glIsEnabled(value[j]))
+				{
+					error = TRUE;
+					LL_WARNS("RenderState") << "Texture channel " << i << " still has " << label[j] << " enabled." << LL_ENDL;
+					if (gDebugSession)
+					{
+						gFailLog << "Texture channel " << i << " still has " << label[j] << " enabled." << std::endl;
+					}
+				}
+				stop_glerror();
 			}
-		}
 
-		
-		for (S32 j = (i == 0 ? 1 : 0); 
-			j < (gGLManager.mHasTextureRectangle ? 9 : 8); j++)
-		{
-			if (glIsEnabled(value[j]))
+			glGetFloatv(GL_TEXTURE_MATRIX, mat.m);
+			stop_glerror();
+
+			if (mat != identity)
 			{
 				error = TRUE;
-				LL_WARNS("RenderState") << "Texture channel " << i << " still has " << label[j] << " enabled." << LL_ENDL;
+				LL_WARNS("RenderState") << "Texture matrix " << i << " is not identity." << LL_ENDL;
 				if (gDebugSession)
 				{
-					gFailLog << "Texture channel " << i << " still has " << label[j] << " enabled." << std::endl;
+					gFailLog << "Texture matrix " << i << " is not identity." << std::endl;
 				}
 			}
-			stop_glerror();
 		}
 
-		glGetFloatv(GL_TEXTURE_MATRIX, mat.m);
-		stop_glerror();
-
-		if (mat != identity)
 		{
-			error = TRUE;
-			LL_WARNS("RenderState") << "Texture matrix " << i << " is not identity." << LL_ENDL;
-			if (gDebugSession)
+			GLint tex = 0;
+			stop_glerror();
+			glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);
+			stop_glerror();
+
+			if (tex != 0)
 			{
-				gFailLog << "Texture matrix " << i << " is not identity." << std::endl;
+				error = TRUE;
+				LL_WARNS("RenderState") << "Texture channel " << i << " still has texture " << tex << " bound." << llendl;
+
+				if (gDebugSession)
+				{
+					gFailLog << "Texture channel " << i << " still has texture " << tex << " bound." << std::endl;
+				}
 			}
 		}
 	}
 
+	stop_glerror();
 	gGL.getTexUnit(0)->activate();
 	glClientActiveTextureARB(GL_TEXTURE0_ARB);
 	stop_glerror();
diff --git a/indra/llrender/llgl.h b/indra/llrender/llgl.h
index 1d7ab188fc..d1bee00161 100644
--- a/indra/llrender/llgl.h
+++ b/indra/llrender/llgl.h
@@ -83,10 +83,12 @@ public:
 	BOOL mHasMipMapGeneration;
 	BOOL mHasCompressedTextures;
 	BOOL mHasFramebufferObject;
+	S32 mMaxSamples;
 	BOOL mHasBlendFuncSeparate;
-	
+		
 	// ARB Extensions
 	BOOL mHasVertexBufferObject;
+	BOOL mHasMapBufferRange;
 	BOOL mHasPBuffer;
 	BOOL mHasShaderObjects;
 	BOOL mHasVertexShader;
@@ -98,6 +100,11 @@ public:
 	BOOL mHasDrawBuffers;
 	BOOL mHasDepthClamp;
 	BOOL mHasTextureRectangle;
+	BOOL mHasTextureMultisample;
+	S32 mMaxSampleMaskWords;
+	S32 mMaxColorTextureSamples;
+	S32 mMaxDepthTextureSamples;
+	S32 mMaxIntegerSamples;
 
 	// Other extensions.
 	BOOL mHasAnisotropic;
@@ -139,6 +146,7 @@ public:
 	void printGLInfoString();
 	void getGLInfo(LLSD& info);
 
+	U32 getNumFBOFSAASamples(U32 desired_samples = 32);
 	// In ALL CAPS
 	std::string mGLVendor;
 	std::string mGLVendorShort;
diff --git a/indra/llrender/llglheaders.h b/indra/llrender/llglheaders.h
index d8140a124d..f35f329f00 100644
--- a/indra/llrender/llglheaders.h
+++ b/indra/llrender/llglheaders.h
@@ -68,6 +68,10 @@ extern PFNGLUNMAPBUFFERARBPROC		glUnmapBufferARB;
 extern PFNGLGETBUFFERPARAMETERIVARBPROC	glGetBufferParameterivARB;
 extern PFNGLGETBUFFERPOINTERVARBPROC	glGetBufferPointervARB;
 
+// GL_ARB_map_buffer_range
+extern PFNGLMAPBUFFERRANGEPROC			glMapBufferRange;
+extern PFNGLFLUSHMAPPEDBUFFERRANGEPROC	glFlushMappedBufferRange;
+
 // GL_ATI_vertex_array_object
 extern PFNGLNEWOBJECTBUFFERATIPROC			glNewObjectBufferATI;
 extern PFNGLISOBJECTBUFFERATIPROC			glIsObjectBufferATI;
@@ -306,6 +310,10 @@ extern PFNGLUNMAPBUFFERARBPROC		glUnmapBufferARB;
 extern PFNGLGETBUFFERPARAMETERIVARBPROC	glGetBufferParameterivARB;
 extern PFNGLGETBUFFERPOINTERVARBPROC	glGetBufferPointervARB;
 
+// GL_ARB_map_buffer_range
+extern PFNGLMAPBUFFERRANGEPROC			glMapBufferRange;
+extern PFNGLFLUSHMAPPEDBUFFERRANGEPROC	glFlushMappedBufferRange;
+
 // GL_ATI_vertex_array_object
 extern PFNGLNEWOBJECTBUFFERATIPROC			glNewObjectBufferATI;
 extern PFNGLISOBJECTBUFFERATIPROC			glIsObjectBufferATI;
@@ -474,6 +482,11 @@ extern PFNGLFRAMEBUFFERTEXTURELAYERPROC glFramebufferTextureLayer;
 //GL_ARB_draw_buffers
 extern PFNGLDRAWBUFFERSARBPROC glDrawBuffersARB;
 
+//GL_ARB_texture_multisample
+extern PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample;
+extern PFNGLTEXIMAGE3DMULTISAMPLEPROC glTexImage3DMultisample;
+extern PFNGLGETMULTISAMPLEFVPROC glGetMultisamplefv;
+extern PFNGLSAMPLEMASKIPROC glSampleMaski;
 
 #elif LL_WINDOWS
 //----------------------------------------------------------------------------
@@ -506,6 +519,10 @@ extern PFNGLUNMAPBUFFERARBPROC		glUnmapBufferARB;
 extern PFNGLGETBUFFERPARAMETERIVARBPROC	glGetBufferParameterivARB;
 extern PFNGLGETBUFFERPOINTERVARBPROC	glGetBufferPointervARB;
 
+// GL_ARB_map_buffer_range
+extern PFNGLMAPBUFFERRANGEPROC			glMapBufferRange;
+extern PFNGLFLUSHMAPPEDBUFFERRANGEPROC	glFlushMappedBufferRange;
+
 // GL_ATI_vertex_array_object
 extern PFNGLNEWOBJECTBUFFERATIPROC			glNewObjectBufferATI;
 extern PFNGLISOBJECTBUFFERATIPROC			glIsObjectBufferATI;
@@ -673,6 +690,11 @@ extern PFNGLFRAMEBUFFERTEXTURELAYERPROC glFramebufferTextureLayer;
 //GL_ARB_draw_buffers
 extern PFNGLDRAWBUFFERSARBPROC glDrawBuffersARB;
 
+//GL_ARB_texture_multisample
+extern PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample;
+extern PFNGLTEXIMAGE3DMULTISAMPLEPROC glTexImage3DMultisample;
+extern PFNGLGETMULTISAMPLEFVPROC glGetMultisamplefv;
+extern PFNGLSAMPLEMASKIPROC glSampleMaski;
 
 #elif LL_DARWIN
 //----------------------------------------------------------------------------
@@ -714,13 +736,55 @@ extern void glGenerateMipmapEXT(GLenum target) AVAILABLE_MAC_OS_X_VERSION_10_4_A
 
 #ifndef GL_ARB_framebuffer_object
 #define glGenerateMipmap glGenerateMipmapEXT
+#define GL_MAX_SAMPLES	0x8D57
 #endif
+
 // GL_ARB_draw_buffers
 extern void glDrawBuffersARB(GLsizei n, const GLenum* bufs) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
+
+//
+// Define map buffer range headers on Mac
+//
+#ifndef GL_ARB_map_buffer_range
+#define GL_MAP_READ_BIT                   0x0001
+#define GL_MAP_WRITE_BIT                  0x0002
+#define GL_MAP_INVALIDATE_RANGE_BIT       0x0004
+#define GL_MAP_INVALIDATE_BUFFER_BIT      0x0008
+#define GL_MAP_FLUSH_EXPLICIT_BIT         0x0010
+#define GL_MAP_UNSYNCHRONIZED_BIT         0x0020
+#endif
+
+//
+// Define multisample headers on Mac
+//
+#ifndef GL_ARB_texture_multisample
+#define GL_SAMPLE_POSITION                0x8E50
+#define GL_SAMPLE_MASK                    0x8E51
+#define GL_SAMPLE_MASK_VALUE              0x8E52
+#define GL_MAX_SAMPLE_MASK_WORDS          0x8E59
+#define GL_TEXTURE_2D_MULTISAMPLE         0x9100
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE   0x9101
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY   0x9102
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_TEXTURE_SAMPLES                0x9106
+#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
+#define GL_SAMPLER_2D_MULTISAMPLE         0x9108
+#define GL_INT_SAMPLER_2D_MULTISAMPLE     0x9109
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY   0x910B
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
+#define GL_MAX_COLOR_TEXTURE_SAMPLES      0x910E
+#define GL_MAX_DEPTH_TEXTURE_SAMPLES      0x910F
+#define GL_MAX_INTEGER_SAMPLES            0x9110
+#endif
+
 //
 // Define vertex buffer object headers on Mac
 //
@@ -757,7 +821,7 @@ extern "C" {
 #define GL_DYNAMIC_READ_ARB               0x88E9
 #define GL_DYNAMIC_COPY_ARB               0x88EA
 #endif
-
+	
 
 
 #ifndef GL_ARB_vertex_buffer_object
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 257bcd9380..8e99f62de6 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -48,6 +48,8 @@ using std::pair;
 using std::make_pair;
 using std::string;
 
+GLhandleARB LLGLSLShader::sCurBoundShader = 0;
+
 BOOL shouldChange(const LLVector4& v1, const LLVector4& v2)
 {
 	return v1 != v2;
@@ -56,7 +58,7 @@ BOOL shouldChange(const LLVector4& v1, const LLVector4& v2)
 LLShaderFeatures::LLShaderFeatures()
 : calculatesLighting(false), isShiny(false), isFullbright(false), hasWaterFog(false),
 hasTransport(false), hasSkinning(false), hasObjectSkinning(false), hasAtmospherics(false), isSpecular(false),
-hasGamma(false), hasLighting(false), calculatesAtmospherics(false)
+hasGamma(false), hasLighting(false), calculatesAtmospherics(false), mIndexedTextureChannels(0), disableTextureIndex(false)
 {
 }
 
@@ -107,16 +109,11 @@ BOOL LLGLSLShader::createShader(vector<string> * attributes,
 	// Create program
 	mProgramObject = glCreateProgramObjectARB();
 	
-	// Attach existing objects
-	if (!LLShaderMgr::instance()->attachShaderFeatures(this))
-	{
-		return FALSE;
-	}
-
+	//compile new source
 	vector< pair<string,GLenum> >::iterator fileIter = mShaderFiles.begin();
 	for ( ; fileIter != mShaderFiles.end(); fileIter++ )
 	{
-		GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second);
+		GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second, mFeatures.mIndexedTextureChannels);
 		LL_DEBUGS("ShaderLoading") << "SHADER FILE: " << (*fileIter).first << " mShaderLevel=" << mShaderLevel << LL_ENDL;
 		if (shaderhandle > 0)
 		{
@@ -128,6 +125,12 @@ BOOL LLGLSLShader::createShader(vector<string> * attributes,
 		}
 	}
 
+	// Attach existing objects
+	if (!LLShaderMgr::instance()->attachShaderFeatures(this))
+	{
+		return FALSE;
+	}
+
 	// Map attributes and uniforms
 	if (success)
 	{
@@ -149,6 +152,29 @@ BOOL LLGLSLShader::createShader(vector<string> * attributes,
 			return createShader(attributes,uniforms);
 		}
 	}
+	else if (mFeatures.mIndexedTextureChannels > 0)
+	{ //override texture channels for indexed texture rendering
+		bind();
+		S32 channel_count = mFeatures.mIndexedTextureChannels;
+
+		for (S32 i = 0; i < channel_count; i++)
+		{
+			uniform1i(llformat("tex%d", i), i);
+		}
+
+		S32 cur_tex = channel_count; //adjust any texture channels that might have been overwritten
+		for (U32 i = 0; i < mTexture.size(); i++)
+		{
+			if (mTexture[i] > -1 && mTexture[i] < channel_count)
+			{
+				llassert(cur_tex < gGLManager.mNumTextureImageUnits);
+				uniform1i(i, cur_tex);
+				mTexture[i] = cur_tex++;
+			}
+		}
+		unbind();
+	}
+
 	return success;
 }
 
@@ -293,7 +319,8 @@ void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
 
 GLint LLGLSLShader::mapUniformTextureChannel(GLint location, GLenum type)
 {
-	if (type >= GL_SAMPLER_1D_ARB && type <= GL_SAMPLER_2D_RECT_SHADOW_ARB)
+	if (type >= GL_SAMPLER_1D_ARB && type <= GL_SAMPLER_2D_RECT_SHADOW_ARB ||
+		type == GL_SAMPLER_2D_MULTISAMPLE)
 	{	//this here is a texture
 		glUniform1iARB(location, mActiveTextureChannels);
 		LL_DEBUGS("ShaderLoading") << "Assigned to texture channel " << mActiveTextureChannels << LL_ENDL;
@@ -342,7 +369,7 @@ void LLGLSLShader::bind()
 	if (gGLManager.mHasShaderObjects)
 	{
 		glUseProgramObjectARB(mProgramObject);
-
+		sCurBoundShader = mProgramObject;
 		if (mUniformsDirty)
 		{
 			LLShaderMgr::instance()->updateShaderUniforms(this);
@@ -365,6 +392,7 @@ void LLGLSLShader::unbind()
 			}
 		}
 		glUseProgramObjectARB(0);
+		sCurBoundShader = 0;
 		stop_glerror();
 	}
 }
@@ -372,6 +400,7 @@ void LLGLSLShader::unbind()
 void LLGLSLShader::bindNoShader(void)
 {
 	glUseProgramObjectARB(0);
+	sCurBoundShader = 0;
 }
 
 S32 LLGLSLShader::enableTexture(S32 uniform, LLTexUnit::eTextureType mode)
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index d46ddbbe18..4922eb6d67 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -45,6 +45,8 @@ public:
 	bool hasObjectSkinning;
 	bool hasAtmospherics;
 	bool hasGamma;
+	S32 mIndexedTextureChannels;
+	bool disableTextureIndex;
 
 	// char numLights;
 	
@@ -64,6 +66,8 @@ public:
 	
 	LLGLSLShader();
 
+	static GLhandleARB sCurBoundShader;
+
 	void unload();
 	BOOL createShader(std::vector<std::string> * attributes,
 						std::vector<std::string> * uniforms);
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index d408077c68..60a5962234 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -1083,12 +1083,17 @@ void LLImageGL::generateTextures(S32 numTextures, U32 *textures)
 }
 
 // static
-void LLImageGL::deleteTextures(S32 numTextures, U32 *textures)
+void LLImageGL::deleteTextures(S32 numTextures, U32 *textures, bool immediate)
 {
 	for (S32 i = 0; i < numTextures; i++)
 	{
 		sDeadTextureList.push_back(textures[i]);
 	}
+
+	if (immediate)
+	{
+		LLImageGL::deleteDeadTextures();
+	}
 }
 
 // static
@@ -1413,11 +1418,13 @@ void LLImageGL::deleteDeadTextures()
 	{
 		GLuint tex = sDeadTextureList.front();
 		sDeadTextureList.pop_front();
-		for (int i = 0; i < gGLManager.mNumTextureUnits; i++)
+		for (int i = 0; i < gGLManager.mNumTextureImageUnits; i++)
 		{
-			if (sCurrentBoundTextures[i] == tex)
+			LLTexUnit* tex_unit = gGL.getTexUnit(i);
+
+			if (tex_unit->getCurrTexture() == tex)
 			{
-				gGL.getTexUnit(i)->unbind(LLTexUnit::TT_TEXTURE);
+				tex_unit->unbind(tex_unit->getCurrType());
 				stop_glerror();
 			}
 		}
diff --git a/indra/llrender/llimagegl.h b/indra/llrender/llimagegl.h
index 6c980984c0..2cfb15b0d9 100644
--- a/indra/llrender/llimagegl.h
+++ b/indra/llrender/llimagegl.h
@@ -98,7 +98,7 @@ public:
 	// These 3 functions currently wrap glGenTextures(), glDeleteTextures(), and glTexImage2D() 
 	// for tracking purposes and will be deprecated in the future
 	static void generateTextures(S32 numTextures, U32 *textures);
-	static void deleteTextures(S32 numTextures, U32 *textures);
+	static void deleteTextures(S32 numTextures, U32 *textures, bool immediate = false);
 	static void setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels);
 
 	BOOL createGLTexture() ;
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index c37139ac4c..6a3f186531 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -30,6 +30,7 @@
 
 #include "llvertexbuffer.h"
 #include "llcubemap.h"
+#include "llglslshader.h"
 #include "llimagegl.h"
 #include "llrendertarget.h"
 #include "lltexture.h"
@@ -46,14 +47,15 @@ S32	gGLViewport[4];
 U32 LLRender::sUICalls = 0;
 U32 LLRender::sUIVerts = 0;
 
-static const U32 LL_NUM_TEXTURE_LAYERS = 16; 
+static const U32 LL_NUM_TEXTURE_LAYERS = 32; 
 static const U32 LL_NUM_LIGHT_UNITS = 8;
 
 static GLenum sGLTextureType[] =
 {
 	GL_TEXTURE_2D,
 	GL_TEXTURE_RECTANGLE_ARB,
-	GL_TEXTURE_CUBE_MAP_ARB
+	GL_TEXTURE_CUBE_MAP_ARB,
+	GL_TEXTURE_2D_MULTISAMPLE
 };
 
 static GLint sGLAddressMode[] =
@@ -124,7 +126,7 @@ void LLTexUnit::refreshState(void)
 	// Per apple spec, don't call glEnable/glDisable when index exceeds max texture units
 	// http://www.mailinglistarchive.com/html/mac-opengl@lists.apple.com/2008-07/msg00653.html
 	//
-	bool enableDisable = (mIndex < gGLManager.mNumTextureUnits);
+	bool enableDisable = (mIndex < gGLManager.mNumTextureUnits) && mCurrTexType != LLTexUnit::TT_MULTISAMPLE_TEXTURE;
 		
 	if (mCurrTexType != TT_NONE)
 	{
@@ -182,8 +184,8 @@ void LLTexUnit::enable(eTextureType type)
 		mCurrTexType = type;
 
 		gGL.flush();
-		
-		if (mIndex < gGLManager.mNumTextureUnits)
+		if (type != LLTexUnit::TT_MULTISAMPLE_TEXTURE &&
+			mIndex < gGLManager.mNumTextureUnits)
 		{
 			glEnable(sGLTextureType[type]);
 		}
@@ -199,8 +201,8 @@ void LLTexUnit::disable(void)
 		activate();
 		unbind(mCurrTexType);
 		gGL.flush();
-		
-		if (mIndex < gGLManager.mNumTextureUnits)
+		if (mCurrTexType != LLTexUnit::TT_MULTISAMPLE_TEXTURE &&
+			mIndex < gGLManager.mNumTextureUnits)
 		{
 			glDisable(sGLTextureType[mCurrTexType]);
 		}
@@ -292,7 +294,7 @@ bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind)
 		glBindTexture(sGLTextureType[texture->getTarget()], mCurrTexture);
 		texture->updateBindStats(texture->mTextureMemory);		
 		mHasMipMaps = texture->mHasMipMaps;
-		if (texture->mTexOptionsDirty)
+		if (mIndex == 0 && texture->mTexOptionsDirty)
 		{
 			texture->mTexOptionsDirty = false;
 			setTextureAddressMode(texture->mAddressMode);
@@ -402,6 +404,7 @@ void LLTexUnit::unbind(eTextureType type)
 		activate();
 		mCurrTexture = 0;
 		glBindTexture(sGLTextureType[type], 0);
+		stop_glerror();
 	}
 }
 
@@ -423,7 +426,7 @@ void LLTexUnit::setTextureAddressMode(eTextureAddressMode mode)
 
 void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions option)
 {
-	if (mIndex < 0 || mCurrTexture == 0) return;
+	if (mIndex < 0 || mCurrTexture == 0 || mCurrTexType == LLTexUnit::TT_MULTISAMPLE_TEXTURE) return;
 
 	gGL.flush();
 
diff --git a/indra/llrender/llrender.h b/indra/llrender/llrender.h
index 7ba14f7b40..41e7b35341 100644
--- a/indra/llrender/llrender.h
+++ b/indra/llrender/llrender.h
@@ -57,6 +57,7 @@ public:
 		TT_TEXTURE = 0,			// Standard 2D Texture
 		TT_RECT_TEXTURE,	// Non power of 2 texture
 		TT_CUBE_MAP,		// 6-sided cube map texture
+		TT_MULTISAMPLE_TEXTURE, // see GL_ARB_texture_multisample
 		TT_NONE 		// No texture type is currently enabled
 	} eTextureType;
 
diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp
index da1e94df64..b6463309e1 100644
--- a/indra/llrender/llrendertarget.cpp
+++ b/indra/llrender/llrendertarget.cpp
@@ -63,8 +63,7 @@ LLRenderTarget::LLRenderTarget() :
 	mUseDepth(false),
 	mRenderDepth(false),
 	mUsage(LLTexUnit::TT_TEXTURE),
-	mSamples(0),
-	mSampleBuffer(NULL)
+	mSamples(0)
 {
 }
 
@@ -73,23 +72,32 @@ LLRenderTarget::~LLRenderTarget()
 	release();
 }
 
-
-void LLRenderTarget::setSampleBuffer(LLMultisampleBuffer* buffer)
-{
-	mSampleBuffer = buffer;
-}
-
-void LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil, LLTexUnit::eTextureType usage, bool use_fbo)
+void LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil, LLTexUnit::eTextureType usage, bool use_fbo, S32 samples)
 {
 	stop_glerror();
+	
+	release();
+
 	mResX = resx;
 	mResY = resy;
 
 	mStencil = stencil;
 	mUsage = usage;
 	mUseDepth = depth;
+	mSamples = samples;
 
-	release();
+	mSamples = gGLManager.getNumFBOFSAASamples(mSamples);
+	
+	if (mSamples > 1 && gGLManager.mHasTextureMultisample)
+	{
+		mUsage = LLTexUnit::TT_MULTISAMPLE_TEXTURE;
+		//no support for multisampled stencil targets yet
+		mStencil = false;
+	}
+	else
+	{
+		mSamples = 0;
+	}
 
 	if ((sUseFBO || use_fbo) && gGLManager.mHasFramebufferObject)
 	{
@@ -146,29 +154,51 @@ void LLRenderTarget::addColorAttachment(U32 color_fmt)
 
 	stop_glerror();
 
-	LLImageGL::setManualImage(LLTexUnit::getInternalType(mUsage), 0, color_fmt, mResX, mResY, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-
-	stop_glerror();
 
-	if (offset == 0)
+#ifdef GL_ARB_texture_multisample
+	if (mSamples > 1)
 	{
-		gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
+		glTexImage2DMultisample(LLTexUnit::getInternalType(mUsage), mSamples, color_fmt, mResX, mResY, GL_TRUE);
 	}
 	else
-	{ //don't filter data attachments
-		gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
-	}
-	if (mUsage != LLTexUnit::TT_RECT_TEXTURE)
+#else
+	llassert_always(mSamples <= 1);
+#endif
 	{
-		gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_MIRROR);
+		LLImageGL::setManualImage(LLTexUnit::getInternalType(mUsage), 0, color_fmt, mResX, mResY, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 	}
-	else
-	{
-		// ATI doesn't support mirrored repeat for rectangular textures.
-		gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
+	
+	stop_glerror();
+
+	if (mSamples == 0)
+	{ 
+		if (offset == 0)
+		{ //use bilinear filtering on single texture render targets that aren't multisampled
+			gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
+			stop_glerror();
+		}
+		else
+		{ //don't filter data attachments
+			gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
+			stop_glerror();
+		}
+
+		if (mUsage != LLTexUnit::TT_RECT_TEXTURE)
+		{
+			gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_MIRROR);
+			stop_glerror();
+		}
+		else
+		{
+			// ATI doesn't support mirrored repeat for rectangular textures.
+			gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
+			stop_glerror();
+		}
 	}
+		
 	if (mFBO)
 	{
+		stop_glerror();
 		glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
 		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+offset,
 			LLTexUnit::getInternalType(mUsage), tex, 0);
@@ -181,6 +211,12 @@ void LLRenderTarget::addColorAttachment(U32 color_fmt)
 
 	mTex.push_back(tex);
 
+	if (gDebugGL)
+	{ //bind and unbind to validate target
+		bindTarget();
+		flush();
+	}
+
 }
 
 void LLRenderTarget::allocateDepth()
@@ -197,9 +233,20 @@ void LLRenderTarget::allocateDepth()
 	{
 		LLImageGL::generateTextures(1, &mDepth);
 		gGL.getTexUnit(0)->bindManual(mUsage, mDepth);
-		U32 internal_type = LLTexUnit::getInternalType(mUsage);
-		gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
-		LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT32, mResX, mResY, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+		if (mSamples == 0)
+		{
+			U32 internal_type = LLTexUnit::getInternalType(mUsage);
+			gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
+			LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT32, mResX, mResY, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+		}
+#ifdef GL_ARB_texture_multisample
+		else
+		{
+			glTexImage2DMultisample(LLTexUnit::getInternalType(mUsage), mSamples, GL_DEPTH_COMPONENT32, mResX, mResY, GL_TRUE);
+		}
+#else
+		llassert_always(mSamples <= 1);
+#endif
 	}
 }
 
@@ -239,6 +286,9 @@ void LLRenderTarget::shareDepthBuffer(LLRenderTarget& target)
 			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
 			stop_glerror();
 		}
+
+		check_framebuffer_status();
+
 		glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
 		target.mUseDepth = true;
@@ -256,7 +306,7 @@ void LLRenderTarget::release()
 		}
 		else
 		{
-			LLImageGL::deleteTextures(1, &mDepth);
+			LLImageGL::deleteTextures(1, &mDepth, true);
 			stop_glerror();
 		}
 		mDepth = 0;
@@ -285,11 +335,12 @@ void LLRenderTarget::release()
 
 	if (mTex.size() > 0)
 	{
-		LLImageGL::deleteTextures(mTex.size(), &mTex[0]);
+		LLImageGL::deleteTextures(mTex.size(), &mTex[0], true);
 		mTex.clear();
 	}
+	
+	mResX = mResY = 0;
 
-	mSampleBuffer = NULL;
 	sBoundTarget = NULL;
 }
 
@@ -298,34 +349,27 @@ void LLRenderTarget::bindTarget()
 	if (mFBO)
 	{
 		stop_glerror();
-		if (mSampleBuffer)
-		{
-			mSampleBuffer->bindTarget(this);
-			stop_glerror();
+		
+		glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
+		stop_glerror();
+		if (gGLManager.mHasDrawBuffers)
+		{ //setup multiple render targets
+			GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0,
+									GL_COLOR_ATTACHMENT1,
+									GL_COLOR_ATTACHMENT2,
+									GL_COLOR_ATTACHMENT3};
+			glDrawBuffersARB(mTex.size(), drawbuffers);
 		}
-		else
-		{
-			glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-			stop_glerror();
-			if (gGLManager.mHasDrawBuffers)
-			{ //setup multiple render targets
-				GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0,
-										GL_COLOR_ATTACHMENT1,
-										GL_COLOR_ATTACHMENT2,
-										GL_COLOR_ATTACHMENT3};
-				glDrawBuffersARB(mTex.size(), drawbuffers);
-			}
 			
-			if (mTex.empty())
-			{ //no color buffer to draw to
-				glDrawBuffer(GL_NONE);
-				glReadBuffer(GL_NONE);
-			}
+		if (mTex.empty())
+		{ //no color buffer to draw to
+			glDrawBuffer(GL_NONE);
+			glReadBuffer(GL_NONE);
+		}
 
-			check_framebuffer_status();
+		check_framebuffer_status();
 
-			stop_glerror();
-		}
+		stop_glerror();
 	}
 
 	glViewport(0, 0, mResX, mResY);
@@ -407,50 +451,8 @@ void LLRenderTarget::flush(bool fetch_depth)
 	else
 	{
 		stop_glerror();
-
 		glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
 		stop_glerror();
-	
-		if (mSampleBuffer)
-		{
-			LLGLEnable multisample(GL_MULTISAMPLE);
-			stop_glerror();
-			glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-			stop_glerror();
-			check_framebuffer_status();
-			glBindFramebuffer(GL_READ_FRAMEBUFFER, mSampleBuffer->mFBO);
-			check_framebuffer_status();
-			
-			stop_glerror();
-			glBlitFramebuffer(0, 0, mResX, mResY, 0, 0, mResX, mResY, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_NEAREST);
-			stop_glerror();		
-
-			if (mTex.size() > 1)
-			{		
-				for (U32 i = 1; i < mTex.size(); ++i)
-				{
-					glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-										LLTexUnit::getInternalType(mUsage), mTex[i], 0);
-					stop_glerror();
-					glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, mSampleBuffer->mTex[i]);
-					stop_glerror();
-					glBlitFramebuffer(0, 0, mResX, mResY, 0, 0, mResX, mResY, GL_COLOR_BUFFER_BIT, GL_NEAREST);		
-					stop_glerror();
-				}
-
-				for (U32 i = 0; i < mTex.size(); ++i)
-				{
-					glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+i,
-										LLTexUnit::getInternalType(mUsage), mTex[i], 0);
-					stop_glerror();
-					glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+i, GL_RENDERBUFFER, mSampleBuffer->mTex[i]);
-					stop_glerror();
-				}
-			}
-		}
-
-		glBindFramebuffer(GL_FRAMEBUFFER, 0);
 	}
 }
 
@@ -467,37 +469,36 @@ void LLRenderTarget::copyContents(LLRenderTarget& source, S32 srcX0, S32 srcY0,
 		llerrs << "Cannot copy framebuffer contents for non FBO render targets." << llendl;
 	}
 
-	if (mSampleBuffer)
+	
+	if (mask == GL_DEPTH_BUFFER_BIT && source.mStencil != mStencil)
 	{
-		mSampleBuffer->copyContents(source, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+		stop_glerror();
+		
+		glBindFramebuffer(GL_FRAMEBUFFER, source.mFBO);
+		check_framebuffer_status();
+		gGL.getTexUnit(0)->bind(this, true);
+		stop_glerror();
+		glCopyTexSubImage2D(LLTexUnit::getInternalType(mUsage), 0, srcX0, srcY0, dstX0, dstY0, dstX1, dstY1);
+		stop_glerror();
+		glBindFramebuffer(GL_FRAMEBUFFER, 0);
+		stop_glerror();
 	}
 	else
 	{
-		if (mask == GL_DEPTH_BUFFER_BIT && source.mStencil != mStencil)
-		{
-			stop_glerror();
-		
-			glBindFramebuffer(GL_FRAMEBUFFER, source.mFBO);
-			gGL.getTexUnit(0)->bind(this, true);
-			stop_glerror();
-			glCopyTexSubImage2D(LLTexUnit::getInternalType(mUsage), 0, srcX0, srcY0, dstX0, dstY0, dstX1, dstY1);
-			stop_glerror();
-			glBindFramebuffer(GL_FRAMEBUFFER, 0);
-			stop_glerror();
-		}
-		else
-		{
-			glBindFramebuffer(GL_READ_FRAMEBUFFER, source.mFBO);
-			stop_glerror();
-			glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mFBO);
-			stop_glerror();
-			check_framebuffer_status();
-			stop_glerror();
-			glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-			stop_glerror();
-			glBindFramebuffer(GL_FRAMEBUFFER, 0);
-			stop_glerror();
-		}
+		glBindFramebuffer(GL_READ_FRAMEBUFFER, source.mFBO);
+		stop_glerror();
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mFBO);
+		stop_glerror();
+		check_framebuffer_status();
+		stop_glerror();
+		glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+		stop_glerror();
+		glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
+		stop_glerror();
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+		stop_glerror();
+		glBindFramebuffer(GL_FRAMEBUFFER, 0);
+		stop_glerror();
 	}
 }
 
@@ -540,179 +541,3 @@ void LLRenderTarget::getViewport(S32* viewport)
 	viewport[3] = mResY;
 }
 
-//==================================================
-// LLMultisampleBuffer implementation
-//==================================================
-LLMultisampleBuffer::LLMultisampleBuffer()
-{
-
-}
-
-LLMultisampleBuffer::~LLMultisampleBuffer()
-{
-	release();
-}
-
-void LLMultisampleBuffer::release()
-{
-	if (mFBO)
-	{
-		glDeleteFramebuffers(1, (GLuint *) &mFBO);
-		mFBO = 0;
-	}
-
-	if (mTex.size() > 0)
-	{
-		glDeleteRenderbuffers(mTex.size(), (GLuint *) &mTex[0]);
-		mTex.clear();
-	}
-
-	if (mDepth)
-	{
-		glDeleteRenderbuffers(1, (GLuint *) &mDepth);
-		mDepth = 0;
-	}
-}
-
-void LLMultisampleBuffer::bindTarget()
-{
-	bindTarget(this);
-}
-
-void LLMultisampleBuffer::bindTarget(LLRenderTarget* ref)
-{
-	if (!ref)
-	{
-		ref = this;
-	}
-
-	glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-	if (gGLManager.mHasDrawBuffers)
-	{ //setup multiple render targets
-		GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0,
-								GL_COLOR_ATTACHMENT1,
-								GL_COLOR_ATTACHMENT2,
-								GL_COLOR_ATTACHMENT3};
-		glDrawBuffersARB(ref->mTex.size(), drawbuffers);
-	}
-
-	check_framebuffer_status();
-
-	glViewport(0, 0, mResX, mResY);
-
-	sBoundTarget = this;
-}
-
-void LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil,  LLTexUnit::eTextureType usage, bool use_fbo )
-{
-	allocate(resx,resy,color_fmt,depth,stencil,usage,use_fbo,2);
-}
-
-void LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil,  LLTexUnit::eTextureType usage, bool use_fbo, U32 samples )
-{
-	stop_glerror();
-	mResX = resx;
-	mResY = resy;
-
-	mUsage = usage;
-	mUseDepth = depth;
-	mStencil = stencil;
-
-	release();
-
-	mSamples = samples;
-	
-	if (mSamples <= 1)
-	{
-		llerrs << "Cannot create a multisample buffer with less than 2 samples." << llendl;
-	}
-
-	stop_glerror();
-
-	if ((sUseFBO || use_fbo) && gGLManager.mHasFramebufferObject)
-	{
-
-		if (depth)
-		{
-			stop_glerror();
-			allocateDepth();
-			stop_glerror();
-		}
-
-		glGenFramebuffers(1, (GLuint *) &mFBO);
-
-		glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-
-		if (mDepth)
-		{
-			glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mDepth);
-			if (mStencil)
-			{
-				glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, mDepth);			
-			}
-		}
-	
-		stop_glerror();
-		glBindFramebuffer(GL_FRAMEBUFFER, 0);
-		stop_glerror();
-	}
-
-	addColorAttachment(color_fmt);
-}
-
-void LLMultisampleBuffer::addColorAttachment(U32 color_fmt)
-{
-	if (color_fmt == 0)
-	{
-		return;
-	}
-
-	U32 offset = mTex.size();
-	if (offset >= 4 ||
-		(offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
-	{
-		llerrs << "Too many color attachments!" << llendl;
-	}
-
-	U32 tex;
-	glGenRenderbuffers(1, &tex);
-	
-	glBindRenderbuffer(GL_RENDERBUFFER, tex);
-	glRenderbufferStorageMultisample(GL_RENDERBUFFER, mSamples, color_fmt, mResX, mResY);
-	stop_glerror();
-
-	if (mFBO)
-	{
-		glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
-		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+offset, GL_RENDERBUFFER, tex);
-		stop_glerror();
-		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-		switch (status)
-		{
-		case GL_FRAMEBUFFER_COMPLETE:
-			break;
-		default:
-			llerrs << "WTF? " << std::hex << status << llendl;
-			break;
-		}
-
-		glBindFramebuffer(GL_FRAMEBUFFER, 0);
-	}
-
-	mTex.push_back(tex);
-}
-
-void LLMultisampleBuffer::allocateDepth()
-{
-	glGenRenderbuffers(1, (GLuint* ) &mDepth);
-	glBindRenderbuffer(GL_RENDERBUFFER, mDepth);
-	if (mStencil)
-	{
-		glRenderbufferStorageMultisample(GL_RENDERBUFFER, mSamples, GL_DEPTH24_STENCIL8, mResX, mResY);	
-	}
-	else
-	{
-		glRenderbufferStorageMultisample(GL_RENDERBUFFER, mSamples, GL_DEPTH_COMPONENT16, mResX, mResY);	
-	}
-}
-
diff --git a/indra/llrender/llrendertarget.h b/indra/llrender/llrendertarget.h
index 12dd1c8b90..094b58b562 100644
--- a/indra/llrender/llrendertarget.h
+++ b/indra/llrender/llrendertarget.h
@@ -71,10 +71,7 @@ public:
 	//allocate resources for rendering
 	//must be called before use
 	//multiple calls will release previously allocated resources
-	void allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil, LLTexUnit::eTextureType usage = LLTexUnit::TT_TEXTURE, bool use_fbo = FALSE);
-
-	//provide this render target with a multisample resource.
-	void setSampleBuffer(LLMultisampleBuffer* buffer);
+	void allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil, LLTexUnit::eTextureType usage = LLTexUnit::TT_TEXTURE, bool use_fbo = false, S32 samples = 0);
 
 	//add color buffer attachment
 	//limit of 4 color attachments per render target
@@ -141,7 +138,6 @@ public:
 	static LLRenderTarget* getCurrentBoundTarget() { return sBoundTarget; }
 
 protected:
-	friend class LLMultisampleBuffer;
 	U32 mResX;
 	U32 mResY;
 	std::vector<U32> mTex;
@@ -152,26 +148,8 @@ protected:
 	bool mRenderDepth;
 	LLTexUnit::eTextureType mUsage;
 	U32 mSamples;
-	LLMultisampleBuffer* mSampleBuffer;
-
-	static LLRenderTarget* sBoundTarget;
 	
-};
-
-class LLMultisampleBuffer : public LLRenderTarget
-{
-public:
-	LLMultisampleBuffer();
-	virtual ~LLMultisampleBuffer();
-
-	virtual void release();
-
-	virtual void bindTarget();
-	void bindTarget(LLRenderTarget* ref);
-	virtual void allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil, LLTexUnit::eTextureType usage, bool use_fbo);
-	void allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil, LLTexUnit::eTextureType usage, bool use_fbo, U32 samples);
-	virtual void addColorAttachment(U32 color_fmt);
-	virtual void allocateDepth();
+	static LLRenderTarget* sBoundTarget;
 };
 
 #endif //!LL_MESA_HEADLESS
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 98a0a93084..bdc103b917 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -209,17 +209,39 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	
 		if (features->hasWaterFog)
 		{
-			if (!shader->attachObject("lighting/lightWaterF.glsl"))
+			if (features->disableTextureIndex)
 			{
-				return FALSE;
+				if (!shader->attachObject("lighting/lightWaterNonIndexedF.glsl"))
+				{
+					return FALSE;
+				}
+			}
+			else 
+			{
+				if (!shader->attachObject("lighting/lightWaterF.glsl"))
+				{
+					return FALSE;
+				}
+				shader->mFeatures.mIndexedTextureChannels = gGLManager.mNumTextureImageUnits-1;
 			}
 		}
 		
 		else
 		{
-			if (!shader->attachObject("lighting/lightF.glsl"))
+			if (features->disableTextureIndex)
 			{
-				return FALSE;
+				if (!shader->attachObject("lighting/lightNonIndexedF.glsl"))
+				{
+					return FALSE;
+				}
+			}
+			else 
+			{
+				if (!shader->attachObject("lighting/lightF.glsl"))
+				{
+					return FALSE;
+				}
+				shader->mFeatures.mIndexedTextureChannels = gGLManager.mNumTextureImageUnits-1;
 			}
 		}		
 	}
@@ -230,32 +252,76 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	
 		if (features->isShiny && features->hasWaterFog)
 		{
-			if (!shader->attachObject("lighting/lightFullbrightShinyWaterF.glsl"))
+			if (features->disableTextureIndex)
 			{
-				return FALSE;
+				if (!shader->attachObject("lighting/lightFullbrightShinyWaterNonIndexedF.glsl"))
+				{
+					return FALSE;
+				}
+			}
+			else 
+			{
+				if (!shader->attachObject("lighting/lightFullbrightShinyWaterF.glsl"))
+				{
+					return FALSE;
+				}
+				shader->mFeatures.mIndexedTextureChannels = gGLManager.mNumTextureImageUnits-1;
 			}
 		}
 		else if (features->hasWaterFog)
 		{
-			if (!shader->attachObject("lighting/lightFullbrightWaterF.glsl"))
+			if (features->disableTextureIndex)
 			{
-				return FALSE;
+				if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedF.glsl"))
+				{
+					return FALSE;
+				}
+			}
+			else 
+			{
+				if (!shader->attachObject("lighting/lightFullbrightWaterF.glsl"))
+				{
+					return FALSE;
+				}
+				shader->mFeatures.mIndexedTextureChannels = gGLManager.mNumTextureImageUnits-1;
 			}
 		}
 		
 		else if (features->isShiny)
 		{
-			if (!shader->attachObject("lighting/lightFullbrightShinyF.glsl"))
+			if (features->disableTextureIndex)
 			{
-				return FALSE;
+				if (!shader->attachObject("lighting/lightFullbrightShinyNonIndexedF.glsl"))
+				{
+					return FALSE;
+				}
+			}
+			else 
+			{
+				if (!shader->attachObject("lighting/lightFullbrightShinyF.glsl"))
+				{
+					return FALSE;
+				}
+				shader->mFeatures.mIndexedTextureChannels = gGLManager.mNumTextureImageUnits-1;
 			}
 		}
 		
 		else
 		{
-			if (!shader->attachObject("lighting/lightFullbrightF.glsl"))
+			if (features->disableTextureIndex)
 			{
-				return FALSE;
+				if (!shader->attachObject("lighting/lightFullbrightNonIndexedF.glsl"))
+				{
+					return FALSE;
+				}
+			}
+			else 
+			{
+				if (!shader->attachObject("lighting/lightFullbrightF.glsl"))
+				{
+					return FALSE;
+				}
+				shader->mFeatures.mIndexedTextureChannels = gGLManager.mNumTextureImageUnits-1;
 			}
 		}
 	}
@@ -266,17 +332,39 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	
 		if (features->hasWaterFog)
 		{
-			if (!shader->attachObject("lighting/lightShinyWaterF.glsl"))
+			if (features->disableTextureIndex)
 			{
-				return FALSE;
+				if (!shader->attachObject("lighting/lightShinyWaterNonIndexedF.glsl"))
+				{
+					return FALSE;
+				}
+			}
+			else 
+			{
+				if (!shader->attachObject("lighting/lightShinyWaterF.glsl"))
+				{
+					return FALSE;
+				}
+				shader->mFeatures.mIndexedTextureChannels = gGLManager.mNumTextureImageUnits-1;
 			}
 		}
 		
 		else 
 		{
-			if (!shader->attachObject("lighting/lightShinyF.glsl"))
+			if (features->disableTextureIndex)
 			{
-				return FALSE;
+				if (!shader->attachObject("lighting/lightShinyNonIndexedF.glsl"))
+				{
+					return FALSE;
+				}
+			}
+			else 
+			{
+				if (!shader->attachObject("lighting/lightShinyF.glsl"))
+				{
+					return FALSE;
+				}
+				shader->mFeatures.mIndexedTextureChannels = gGLManager.mNumTextureImageUnits-1;
 			}
 		}
 	}
@@ -315,12 +403,12 @@ void LLShaderMgr::dumpObjectLog(GLhandleARB ret, BOOL warns)
 		}
 		else
 		{
-			LL_INFOS("ShaderLoading") << log << LL_ENDL;
+			LL_DEBUGS("ShaderLoading") << log << LL_ENDL;
 		}
 	}
 }
 
-GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type)
+GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, S32 texture_index_channels)
 {
 	GLenum error = GL_NO_ERROR;
 	if (gDebugGL)
@@ -374,6 +462,106 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	GLcharARB* text[1024];
 	GLuint count = 0;
 
+	if (gGLManager.mGLVersion < 3.f)
+	{
+		//set version to 1.20
+		text[count++] = strdup("#version 120\n");
+	}
+	else
+	{  //set version to 1.30
+		text[count++] = strdup("#version 130\n");
+	}
+
+	//copy preprocessor definitions into buffer
+	for (std::map<std::string,std::string>::iterator iter = mDefinitions.begin(); iter != mDefinitions.end(); ++iter)
+	{
+		std::string define = "#define " + iter->first + " " + iter->second + "\n";
+		text[count++] = (GLcharARB *) strdup(define.c_str());
+	}
+
+	if (texture_index_channels > 0 && type == GL_FRAGMENT_SHADER_ARB)
+	{
+		//use specified number of texture channels for indexed texture rendering
+
+		/* prepend shader code that looks like this:
+
+		uniform sampler2D tex0;
+		uniform sampler2D tex1;
+		uniform sampler2D tex2;
+		.
+		.
+		.
+		uniform sampler2D texN;
+		
+		varying float vary_texture_index;
+
+		vec4 diffuseLookup(vec2 texcoord)
+		{
+			switch (int(vary_texture_index+0.25))
+			{
+				case 0: return texture2D(tex0, texcoord);
+				case 1: return texture2D(tex1, texcoord);
+				case 2: return texture2D(tex2, texcoord);
+				.
+				.
+				.
+				case N: return texture2D(texN, texcoord);
+			}
+
+			return vec4(0,0,0,0);
+		}
+		*/
+
+		//uniform declartion
+		for (S32 i = 0; i < texture_index_channels; ++i)
+		{
+			std::string decl = llformat("uniform sampler2D tex%d;\n", i);
+			text[count++] = strdup(decl.c_str());
+		}
+
+		text[count++] = strdup("varying float vary_texture_index;\n");
+		text[count++] = strdup("vec4 diffuseLookup(vec2 texcoord)\n");
+		text[count++] = strdup("{\n");
+		
+		
+		if (gGLManager.mGLVersion >= 3.f)
+		{ 
+			text[count++] = strdup("\tswitch (int(vary_texture_index+0.25))\n");
+			text[count++] = strdup("\t{\n");
+		
+			//switch body
+			for (S32 i = 0; i < texture_index_channels; ++i)
+			{
+				std::string case_str = llformat("\t\tcase %d: return texture2D(tex%d, texcoord);\n", i, i);
+				text[count++] = strdup(case_str.c_str());
+			}
+
+			text[count++] = strdup("\t}\n");
+		}
+		else
+		{
+			//switches aren't supported, make block that looks like:
+			/*
+				int ti = int(vary_texture_index+0.25);
+				if (ti == 0) return texture2D(tex0, texcoord);
+				if (ti == 1) return texture2D(tex1, texcoord);
+				.
+				.
+				.
+				if (ti == N) return texture2D(texN, texcoord);
+			*/
+				
+			text[count++] = strdup("int ti = int(vary_texture_index+0.25);\n");
+			for (S32 i = 0; i < texture_index_channels; ++i)
+			{
+				std::string if_str = llformat("if (ti == %d) return texture2D(tex%d, texcoord);\n", i, i);
+				text[count++] = strdup(if_str.c_str());
+			}
+		}			
+
+		text[count++] = strdup("\treturn vec4(0,0,0,0);\n");
+		text[count++] = strdup("}\n");
+	}
 
 	//copy file into memory
 	while( fgets((char *)buff, 1024, file) != NULL && count < LL_ARRAY_SIZE(buff) ) 
@@ -457,7 +645,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		if (shader_level > 1)
 		{
 			shader_level--;
-			return loadShaderFile(filename,shader_level,type);
+			return loadShaderFile(filename,shader_level,type,texture_index_channels);
 		}
 		LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;	
 	}
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index c54c4608d7..2f30103811 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -43,7 +43,7 @@ public:
 	void dumpObjectLog(GLhandleARB ret, BOOL warns = TRUE);
 	BOOL	linkProgramObject(GLhandleARB obj, BOOL suppress_errors = FALSE);
 	BOOL	validateProgramObject(GLhandleARB obj);
-	GLhandleARB loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type);
+	GLhandleARB loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, S32 texture_index_channels = -1);
 
 	// Implemented in the application to actually point to the shader directory.
 	virtual std::string getShaderDirPrefix(void) = 0; // Pure Virtual
@@ -60,6 +60,9 @@ public:
 
 	std::vector<std::string> mReservedUniforms;
 
+	//preprocessor definitions (name/value)
+	std::map<std::string, std::string> mDefinitions;
+
 protected:
 
 	// our parameter manager singleton instance
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index 8c9171ccf4..4a0b964e61 100644
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -934,8 +934,26 @@ void LLVertexBuffer::allocateClientIndexBuffer()
 	}
 }
 
+bool expand_region(LLVertexBuffer::MappedRegion& region, S32 index, S32 count)
+{
+	S32 end = index+count;
+	S32 region_end = region.mIndex+region.mCount;
+	
+	if (end < region.mIndex ||
+		index > region_end)
+	{ //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;
+	return true;
+}
+
 // Map for data access
-U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 access)
+U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, bool map_range)
 {
 	LLMemType mt2(LLMemType::MTYPE_VERTEX_MAP_BUFFER);
 	if (mFinal)
@@ -947,8 +965,45 @@ U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 access)
 		llerrs << "LLVertexBuffer::mapVertexBuffer() called on unallocated buffer." << llendl;
 	}
 		
-	if (!mVertexLocked && useVBOs())
+	if (useVBOs())
 	{
+
+		if (sDisableVBOMapping || gGLManager.mHasMapBufferRange)
+		{
+			if (count == -1)
+			{
+				count = mNumVerts-index;
+			}
+
+			bool mapped = false;
+			//see if range is already mapped
+			for (U32 i = 0; i < mMappedVertexRegions.size(); ++i)
+			{
+				MappedRegion& region = mMappedVertexRegions[i];
+				if (region.mType == type)
+				{
+					if (expand_region(region, index, count))
+					{
+						mapped = true;
+						break;
+					}
+				}
+			}
+
+			if (!mapped)
+			{
+				//not already mapped, map new region
+				MappedRegion region(type, !sDisableVBOMapping && map_range ? -1 : index, count);
+				mMappedVertexRegions.push_back(region);
+			}
+		}
+
+		if (mVertexLocked && map_range)
+		{
+			llerrs << "Attempted to map a specific range of a buffer that was already mapped." << llendl;
+		}
+
+		if (!mVertexLocked)
 		{
 			LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_VERTICES);
 			setBuffer(0, type);
@@ -957,61 +1012,95 @@ U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 access)
 
 			if(sDisableVBOMapping)
 			{
+				map_range = false;
 				allocateClientVertexBuffer() ;
 			}
 			else
 			{
-				U8* src = (U8*) glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
+				U8* src = NULL;
+#ifdef GL_ARB_map_buffer_range
+				if (gGLManager.mHasMapBufferRange)
+				{
+					if (map_range)
+					{
+						S32 offset = mOffsets[type] + sTypeSize[type]*index;
+						S32 length = (sTypeSize[type]*count+0xF) & ~0xF;
+						src = (U8*) glMapBufferRange(GL_ARRAY_BUFFER_ARB, offset, length, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
+					}
+					else
+					{
+						src = (U8*) glMapBufferRange(GL_ARRAY_BUFFER_ARB, 0, mSize, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
+					}
+				}
+				else
+#else
+				llassert_always(!gGLManager.mHasMapBufferRange);
+#endif
+				{
+					map_range = false;
+					src = (U8*) glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
+				}
+
 				mMappedData = LL_NEXT_ALIGNED_ADDRESS<U8>(src);
 				mAlignedOffset = mMappedData - src;
 			
 				stop_glerror();
 			}
-		}
-		
-		
-		if (!mMappedData)
-		{
-			log_glerror();
-
-			//check the availability of memory
-			U32 avail_phy_mem, avail_vir_mem;
-			LLMemoryInfo::getAvailableMemoryKB(avail_phy_mem, avail_vir_mem) ;
-			llinfos << "Available physical mwmory(KB): " << avail_phy_mem << llendl ; 
-			llinfos << "Available virtual memory(KB): " << avail_vir_mem << llendl;
-
-			if(!sDisableVBOMapping)
-			{			
-				//--------------------
-				//print out more debug info before crash
-				llinfos << "vertex buffer size: (num verts : num indices) = " << getNumVerts() << " : " << getNumIndices() << llendl ;
-				GLint size ;
-				glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_SIZE_ARB, &size) ;
-				llinfos << "GL_ARRAY_BUFFER_ARB size is " << size << llendl ;
-				//--------------------
+				
+			if (!mMappedData)
+			{
+				log_glerror();
+
+				//check the availability of memory
+				U32 avail_phy_mem, avail_vir_mem;
+				LLMemoryInfo::getAvailableMemoryKB(avail_phy_mem, avail_vir_mem) ;
+				llinfos << "Available physical mwmory(KB): " << avail_phy_mem << llendl ; 
+				llinfos << "Available virtual memory(KB): " << avail_vir_mem << llendl;
+
+				if(!sDisableVBOMapping)
+				{			
+					//--------------------
+					//print out more debug info before crash
+					llinfos << "vertex buffer size: (num verts : num indices) = " << getNumVerts() << " : " << getNumIndices() << llendl ;
+					GLint size ;
+					glGetBufferParameterivARB(GL_ARRAY_BUFFER_ARB, GL_BUFFER_SIZE_ARB, &size) ;
+					llinfos << "GL_ARRAY_BUFFER_ARB size is " << size << llendl ;
+					//--------------------
+
+					GLint buff;
+					glGetIntegerv(GL_ARRAY_BUFFER_BINDING_ARB, &buff);
+					if ((GLuint)buff != mGLBuffer)
+					{
+						llerrs << "Invalid GL vertex buffer bound: " << buff << llendl;
+					}
 
-				GLint buff;
-				glGetIntegerv(GL_ARRAY_BUFFER_BINDING_ARB, &buff);
-				if ((GLuint)buff != mGLBuffer)
+							
+					llerrs << "glMapBuffer returned NULL (no vertex data)" << llendl;
+				}
+				else
 				{
-					llerrs << "Invalid GL vertex buffer bound: " << buff << llendl;
+					llerrs << "memory allocation for vertex data failed." << llendl ;
 				}
-
-							
-				llerrs << "glMapBuffer returned NULL (no vertex data)" << llendl;
-			}
-			else
-			{
-				llerrs << "memory allocation for vertex data failed." << llendl ;
 			}
+			sMappedCount++;
 		}
-		sMappedCount++;
+	}
+	else
+	{
+		map_range = false;
 	}
 	
-	return mMappedData;
+	if (map_range && !sDisableVBOMapping)
+	{
+		return mMappedData;
+	}
+	else
+	{
+		return mMappedData+mOffsets[type]+sTypeSize[type]*index;
+	}
 }
 
-U8* LLVertexBuffer::mapIndexBuffer(S32 access)
+U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range)
 {
 	LLMemType mt2(LLMemType::MTYPE_VERTEX_MAP_BUFFER);
 	if (mFinal)
@@ -1023,8 +1112,41 @@ U8* LLVertexBuffer::mapIndexBuffer(S32 access)
 		llerrs << "LLVertexBuffer::mapIndexBuffer() called on unallocated buffer." << llendl;
 	}
 
-	if (!mIndexLocked && useVBOs())
+	if (useVBOs())
 	{
+		if (sDisableVBOMapping || gGLManager.mHasMapBufferRange)
+		{
+			if (count == -1)
+			{
+				count = mNumIndices-index;
+			}
+
+			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))
+				{
+					mapped = true;
+					break;
+				}
+			}
+
+			if (!mapped)
+			{
+				//not already mapped, map new region
+				MappedRegion region(TYPE_INDEX, !sDisableVBOMapping && map_range ? -1 : index, count);
+				mMappedIndexRegions.push_back(region);
+			}
+		}
+
+		if (mIndexLocked && map_range)
+		{
+			llerrs << "Attempted to map a specific range of a buffer that was already mapped." << llendl;
+		}
+
+		if (!mIndexLocked)
 		{
 			LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_INDICES);
 
@@ -1034,12 +1156,36 @@ U8* LLVertexBuffer::mapIndexBuffer(S32 access)
 
 			if(sDisableVBOMapping)
 			{
+				map_range = false;
 				allocateClientIndexBuffer() ;
 			}
 			else
 			{
-				U8* src = (U8*) glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
-				mMappedIndexData = LL_NEXT_ALIGNED_ADDRESS<U8>(src);
+				U8* src = NULL;
+#ifdef GL_ARB_map_buffer_range
+				if (gGLManager.mHasMapBufferRange)
+				{
+					if (map_range)
+					{
+						S32 offset = sizeof(U16)*index;
+						S32 length = sizeof(U16)*count;
+						src = (U8*) glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER_ARB, offset, length, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
+					}
+					else
+					{
+						src = (U8*) glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER_ARB, 0, sizeof(U16)*mNumIndices, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
+					}
+				}
+				else
+#else
+				llassert_always(!gGLManager.mHasMapBufferRange);
+#endif
+				{
+					map_range = false;
+					src = (U8*) glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
+				}
+
+				mMappedIndexData = src; //LL_NEXT_ALIGNED_ADDRESS<U8>(src);
 				mAlignedIndexOffset = mMappedIndexData - src;
 				stop_glerror();
 			}
@@ -1068,31 +1214,81 @@ U8* LLVertexBuffer::mapIndexBuffer(S32 access)
 
 		sMappedCount++;
 	}
+	else
+	{
+		map_range = false;
+	}
 
-	return mMappedIndexData ;
+	if (map_range && !sDisableVBOMapping)
+	{
+		return mMappedIndexData;
+	}
+	else
+	{
+		return mMappedIndexData + sizeof(U16)*index;
+	}
 }
 
 void LLVertexBuffer::unmapBuffer(S32 type)
 {
 	LLMemType mt2(LLMemType::MTYPE_VERTEX_UNMAP_BUFFER);
-	if (!useVBOs())
+	if (!useVBOs() || type == -2)
 	{
 		return ; //nothing to unmap
 	}
 
 	bool updated_all = false ;
+
 	if (mMappedData && mVertexLocked && type != TYPE_INDEX)
 	{
 		updated_all = (mIndexLocked && type < 0) ; //both vertex and index buffers done updating
 
 		if(sDisableVBOMapping)
 		{
-			stop_glerror();
-			glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, getSize(), mMappedData);
-			stop_glerror();
+			if (!mMappedVertexRegions.empty())
+			{
+				stop_glerror();
+				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;
+					glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, offset, length, mMappedData+offset);
+					stop_glerror();
+				}
+
+				mMappedVertexRegions.clear();
+			}
+			else
+			{
+				stop_glerror();
+				glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, getSize(), mMappedData);
+				stop_glerror();
+			}
 		}
 		else
 		{
+#ifdef GL_ARB_map_buffer_range
+			if (gGLManager.mHasMapBufferRange)
+			{
+				if (!mMappedVertexRegions.empty())
+				{
+					stop_glerror();
+					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;
+						glFlushMappedBufferRange(GL_ARRAY_BUFFER_ARB, offset, length);
+						stop_glerror();
+					}
+
+					mMappedVertexRegions.clear();
+				}
+			}
+#else
+			llassert_always(!gGLManager.mHasMapBufferRange);
+#endif
 			stop_glerror();
 			glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
 			stop_glerror();
@@ -1103,17 +1299,53 @@ void LLVertexBuffer::unmapBuffer(S32 type)
 		mVertexLocked = FALSE ;
 		sMappedCount--;
 	}
-
-	if(mMappedIndexData && mIndexLocked && (type < 0 || type == TYPE_INDEX))
+	
+	if (mMappedIndexData && mIndexLocked && (type < 0 || type == TYPE_INDEX))
 	{
 		if(sDisableVBOMapping)
 		{
-			stop_glerror();
-			glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0, getIndicesSize(), mMappedIndexData);
-			stop_glerror();
+			if (!mMappedIndexRegions.empty())
+			{
+				for (U32 i = 0; i < mMappedIndexRegions.size(); ++i)
+				{
+					const MappedRegion& region = mMappedIndexRegions[i];
+					S32 offset = region.mIndex >= 0 ? sizeof(U16)*region.mIndex : 0;
+					S32 length = sizeof(U16)*region.mCount;
+					glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, offset, length, mMappedIndexData+offset);
+					stop_glerror();
+				}
+
+				mMappedIndexRegions.clear();
+			}
+			else
+			{
+				stop_glerror();
+				glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0, getIndicesSize(), mMappedIndexData);
+				stop_glerror();
+			}
 		}
 		else
 		{
+#ifdef GL_ARB_map_buffer_range
+			if (gGLManager.mHasMapBufferRange)
+			{
+				if (!mMappedIndexRegions.empty())
+				{
+					for (U32 i = 0; i < mMappedIndexRegions.size(); ++i)
+					{
+						const MappedRegion& region = mMappedIndexRegions[i];
+						S32 offset = region.mIndex >= 0 ? sizeof(U16)*region.mIndex : 0;
+						S32 length = sizeof(U16)*region.mCount;
+						glFlushMappedBufferRange(GL_ELEMENT_ARRAY_BUFFER_ARB, offset, length);
+						stop_glerror();
+					}
+
+					mMappedIndexRegions.clear();
+				}
+			}
+#else
+			llassert_always(!gGLManager.mHasMapBufferRange);
+#endif
 			stop_glerror();
 			glUnmapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB);
 			stop_glerror();
@@ -1152,19 +1384,19 @@ template <class T,S32 type> struct VertexBufferStrider
 	typedef LLStrider<T> strider_t;
 	static bool get(LLVertexBuffer& vbo, 
 					strider_t& strider, 
-					S32 index)
+					S32 index, S32 count, bool map_range)
 	{
 		if (type == LLVertexBuffer::TYPE_INDEX)
 		{
-			S32 stride = sizeof(T);
+			U8* ptr = vbo.mapIndexBuffer(index, count, map_range);
 
-			if (vbo.mapIndexBuffer() == NULL)
+			if (ptr == NULL)
 			{
 				llwarns << "mapIndexBuffer failed!" << llendl;
 				return FALSE;
 			}
 
-			strider = (T*)(vbo.getMappedIndices() + index*stride);
+			strider = (T*)ptr;
 			strider.setStride(0);
 			return TRUE;
 		}
@@ -1172,13 +1404,15 @@ template <class T,S32 type> struct VertexBufferStrider
 		{
 			S32 stride = LLVertexBuffer::sTypeSize[type];
 
-			if (vbo.mapVertexBuffer(type) == NULL)
+			U8* ptr = vbo.mapVertexBuffer(type, index, count, map_range);
+
+			if (ptr == NULL)
 			{
 				llwarns << "mapVertexBuffer failed!" << llendl;
 				return FALSE;
 			}
 
-			strider = (T*)(vbo.getMappedData() + vbo.getOffset(type)+index*stride);
+			strider = (T*)ptr;
 			strider.setStride(stride);
 			return TRUE;
 		}
@@ -1190,55 +1424,48 @@ template <class T,S32 type> struct VertexBufferStrider
 	}
 };
 
-bool LLVertexBuffer::getVertexStrider(LLStrider<LLVector3>& strider, S32 index)
-{
-	return VertexBufferStrider<LLVector3,TYPE_VERTEX>::get(*this, strider, index);
-}
-bool LLVertexBuffer::getIndexStrider(LLStrider<U16>& strider, S32 index)
+bool LLVertexBuffer::getVertexStrider(LLStrider<LLVector3>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<U16,TYPE_INDEX>::get(*this, strider, index);
+	return VertexBufferStrider<LLVector3,TYPE_VERTEX>::get(*this, strider, index, count, map_range);
 }
-bool LLVertexBuffer::getTexCoord0Strider(LLStrider<LLVector2>& strider, S32 index)
+bool LLVertexBuffer::getIndexStrider(LLStrider<U16>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<LLVector2,TYPE_TEXCOORD0>::get(*this, strider, index);
+	return VertexBufferStrider<U16,TYPE_INDEX>::get(*this, strider, index, count, map_range);
 }
-bool LLVertexBuffer::getTexCoord1Strider(LLStrider<LLVector2>& strider, S32 index)
+bool LLVertexBuffer::getTexCoord0Strider(LLStrider<LLVector2>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<LLVector2,TYPE_TEXCOORD1>::get(*this, strider, index);
+	return VertexBufferStrider<LLVector2,TYPE_TEXCOORD0>::get(*this, strider, index, count, map_range);
 }
-/*bool LLVertexBuffer::getTexCoord2Strider(LLStrider<LLVector2>& strider, S32 index)
+bool LLVertexBuffer::getTexCoord1Strider(LLStrider<LLVector2>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<LLVector2,TYPE_TEXCOORD2>::get(*this, strider, index);
+	return VertexBufferStrider<LLVector2,TYPE_TEXCOORD1>::get(*this, strider, index, count, map_range);
 }
-bool LLVertexBuffer::getTexCoord3Strider(LLStrider<LLVector2>& strider, S32 index)
-{
-	return VertexBufferStrider<LLVector2,TYPE_TEXCOORD3>::get(*this, strider, index);
-}*/
-bool LLVertexBuffer::getNormalStrider(LLStrider<LLVector3>& strider, S32 index)
+
+bool LLVertexBuffer::getNormalStrider(LLStrider<LLVector3>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<LLVector3,TYPE_NORMAL>::get(*this, strider, index);
+	return VertexBufferStrider<LLVector3,TYPE_NORMAL>::get(*this, strider, index, count, map_range);
 }
-bool LLVertexBuffer::getBinormalStrider(LLStrider<LLVector3>& strider, S32 index)
+bool LLVertexBuffer::getBinormalStrider(LLStrider<LLVector3>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<LLVector3,TYPE_BINORMAL>::get(*this, strider, index);
+	return VertexBufferStrider<LLVector3,TYPE_BINORMAL>::get(*this, strider, index, count, map_range);
 }
-bool LLVertexBuffer::getColorStrider(LLStrider<LLColor4U>& strider, S32 index)
+bool LLVertexBuffer::getColorStrider(LLStrider<LLColor4U>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<LLColor4U,TYPE_COLOR>::get(*this, strider, index);
+	return VertexBufferStrider<LLColor4U,TYPE_COLOR>::get(*this, strider, index, count, map_range);
 }
-bool LLVertexBuffer::getWeightStrider(LLStrider<F32>& strider, S32 index)
+bool LLVertexBuffer::getWeightStrider(LLStrider<F32>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<F32,TYPE_WEIGHT>::get(*this, strider, index);
+	return VertexBufferStrider<F32,TYPE_WEIGHT>::get(*this, strider, index, count, map_range);
 }
 
-bool LLVertexBuffer::getWeight4Strider(LLStrider<LLVector4>& strider, S32 index)
+bool LLVertexBuffer::getWeight4Strider(LLStrider<LLVector4>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<LLVector4,TYPE_WEIGHT4>::get(*this, strider, index);
+	return VertexBufferStrider<LLVector4,TYPE_WEIGHT4>::get(*this, strider, index, count, map_range);
 }
 
-bool LLVertexBuffer::getClothWeightStrider(LLStrider<LLVector4>& strider, S32 index)
+bool LLVertexBuffer::getClothWeightStrider(LLStrider<LLVector4>& strider, S32 index, S32 count, bool map_range)
 {
-	return VertexBufferStrider<LLVector4,TYPE_CLOTHWEIGHT>::get(*this, strider, index);
+	return VertexBufferStrider<LLVector4,TYPE_CLOTHWEIGHT>::get(*this, strider, index, count, map_range);
 }
 
 //----------------------------------------------------------------------------
@@ -1497,17 +1724,16 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const
 	}
 	if (data_mask & MAP_VERTEX)
 	{
-		glVertexPointer(3,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_VERTEX], (void*)(base + 0));
+		if (data_mask & MAP_TEXTURE_INDEX)
+		{
+			glVertexPointer(4,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_VERTEX], (void*)(base + 0));
+		}
+		else
+		{
+			glVertexPointer(3,GL_FLOAT, LLVertexBuffer::sTypeSize[TYPE_VERTEX], (void*)(base + 0));
+		}
 	}
 
 	llglassertok();
 }
 
-void LLVertexBuffer::markDirty(U32 vert_index, U32 vert_count, U32 indices_index, U32 indices_count)
-{
-	// TODO: use GL_APPLE_flush_buffer_range here
-	/*if (useVBOs() && !mFilthy)
-	{
-	
-	}*/
-}
diff --git a/indra/llrender/llvertexbuffer.h b/indra/llrender/llvertexbuffer.h
index a9f22193f8..aa5df305a6 100644
--- a/indra/llrender/llvertexbuffer.h
+++ b/indra/llrender/llvertexbuffer.h
@@ -77,6 +77,18 @@ protected:
 class LLVertexBuffer : public LLRefCount
 {
 public:
+	class MappedRegion
+	{
+	public:
+		S32 mType;
+		S32 mIndex;
+		S32 mCount;
+		
+		MappedRegion(S32 type, S32 index, S32 count)
+			: mType(type), mIndex(index), mCount(count)
+		{ }	
+	};
+
 	LLVertexBuffer(const LLVertexBuffer& rhs)
 	{
 		*this = rhs;
@@ -130,6 +142,9 @@ public:
 		TYPE_CLOTHWEIGHT,
 		TYPE_MAX,
 		TYPE_INDEX,
+		
+		//no actual additional data, but indicates position.w is texture index
+		TYPE_TEXTURE_INDEX,
 	};
 	enum {
 		MAP_VERTEX = (1<<TYPE_VERTEX),
@@ -144,6 +159,7 @@ public:
 		MAP_WEIGHT = (1<<TYPE_WEIGHT),
 		MAP_WEIGHT4 = (1<<TYPE_WEIGHT4),
 		MAP_CLOTHWEIGHT = (1<<TYPE_CLOTHWEIGHT),
+		MAP_TEXTURE_INDEX = (1<<TYPE_TEXTURE_INDEX),
 	};
 	
 protected:
@@ -173,8 +189,8 @@ public:
 	LLVertexBuffer(U32 typemask, S32 usage);
 	
 	// map for data access
-	U8*		mapVertexBuffer(S32 type = -1, S32 access = -1);
-	U8*		mapIndexBuffer(S32 access = -1);
+	U8*		mapVertexBuffer(S32 type, S32 index, S32 count, bool map_range);
+	U8*		mapIndexBuffer(S32 index, S32 count, bool map_range);
 
 	// set for rendering
 	virtual void	setBuffer(U32 data_mask, S32 type = -1); 	// calls  setupVertexBuffer() if data_mask is not 0
@@ -189,16 +205,16 @@ public:
 	//   vb->getNormalStrider(norms);
 	//   setVertsNorms(verts, norms);
 	//   vb->unmapBuffer();
-	bool getVertexStrider(LLStrider<LLVector3>& strider, S32 index=0);
-	bool getIndexStrider(LLStrider<U16>& strider, S32 index=0);
-	bool getTexCoord0Strider(LLStrider<LLVector2>& strider, S32 index=0);
-	bool getTexCoord1Strider(LLStrider<LLVector2>& strider, S32 index=0);
-	bool getNormalStrider(LLStrider<LLVector3>& strider, S32 index=0);
-	bool getBinormalStrider(LLStrider<LLVector3>& strider, S32 index=0);
-	bool getColorStrider(LLStrider<LLColor4U>& strider, S32 index=0);
-	bool getWeightStrider(LLStrider<F32>& strider, S32 index=0);
-	bool getWeight4Strider(LLStrider<LLVector4>& strider, S32 index=0);
-	bool getClothWeightStrider(LLStrider<LLVector4>& strider, S32 index=0);
+	bool getVertexStrider(LLStrider<LLVector3>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getIndexStrider(LLStrider<U16>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getTexCoord0Strider(LLStrider<LLVector2>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getTexCoord1Strider(LLStrider<LLVector2>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getNormalStrider(LLStrider<LLVector3>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getBinormalStrider(LLStrider<LLVector3>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getColorStrider(LLStrider<LLColor4U>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getWeightStrider(LLStrider<F32>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getWeight4Strider(LLStrider<LLVector4>& strider, S32 index=0, S32 count = -1, bool map_range = false);
+	bool getClothWeightStrider(LLStrider<LLVector4>& strider, S32 index=0, S32 count = -1, bool map_range = false);
 	
 	BOOL isEmpty() const					{ return mEmpty; }
 	BOOL isLocked() const					{ return mVertexLocked || mIndexLocked; }
@@ -218,8 +234,6 @@ public:
 	S32 getOffset(S32 type) const			{ return mOffsets[type]; }
 	S32 getUsage() const					{ return mUsage; }
 
-	void markDirty(U32 vert_index, U32 vert_count, U32 indices_index, U32 indices_count);
-
 	void draw(U32 mode, U32 count, U32 indices_offset) const;
 	void drawArrays(U32 mode, U32 offset, U32 count) const;
 	void drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indices_offset) const;
@@ -253,20 +267,8 @@ protected:
 	BOOL	mDynamicSize;	// if TRUE, buffer has been resized at least once (and should be padded)
 	S32		mOffsets[TYPE_MAX];
 
-	class DirtyRegion
-	{
-	public:
-		U32 mIndex;
-		U32 mCount;
-		U32 mIndicesIndex;
-		U32 mIndicesCount;
-
-		DirtyRegion(U32 vi, U32 vc, U32 ii, U32 ic)
-			: mIndex(vi), mCount(vc), mIndicesIndex(ii), mIndicesCount(ic)
-		{ }	
-	};
-
-	std::vector<DirtyRegion> mDirtyRegions; //vector of dirty regions to rebuild
+	std::vector<MappedRegion> mMappedVertexRegions;
+	std::vector<MappedRegion> mMappedIndexRegions;
 
 public:
 	static S32 sCount;