Merge of windlight into release (QAR-286). This includes all changes in

windlight14 which have passed QA (up through r79932).

svn merge -r 80831:80833 svn+ssh://svn.lindenlab.com/svn/linden/branches/merge_windlight14_r80620

1 files changed, 273 insertions, 265 deletions

diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index 2a54fca250..9303e00228 100644
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -31,6 +31,8 @@
 
 #include "linden_common.h"
 
+#include <boost/static_assert.hpp>
+
 #include "llvertexbuffer.h"
 // #include "llrender.h"
 #include "llglheaders.h"
@@ -40,8 +42,16 @@
 //============================================================================
 
 //static
+LLVBOPool LLVertexBuffer::sStreamVBOPool;
+LLVBOPool LLVertexBuffer::sDynamicVBOPool;
+LLVBOPool LLVertexBuffer::sStreamIBOPool;
+LLVBOPool LLVertexBuffer::sDynamicIBOPool;
+
+U32 LLVertexBuffer::sBindCount = 0;
+U32 LLVertexBuffer::sSetCount = 0;
 S32 LLVertexBuffer::sCount = 0;
 S32 LLVertexBuffer::sGLCount = 0;
+S32 LLVertexBuffer::sMappedCount = 0;
 BOOL LLVertexBuffer::sEnableVBOs = TRUE;
 U32 LLVertexBuffer::sGLRenderBuffer = 0;
 U32 LLVertexBuffer::sGLRenderIndices = 0;
@@ -50,9 +60,9 @@ BOOL LLVertexBuffer::sVBOActive = FALSE;
 BOOL LLVertexBuffer::sIBOActive = FALSE;
 U32 LLVertexBuffer::sAllocatedBytes = 0;
 BOOL LLVertexBuffer::sRenderActive = FALSE;
+BOOL LLVertexBuffer::sMapped = FALSE;
 
 std::vector<U32> LLVertexBuffer::sDeleteList;
-LLVertexBuffer::buffer_list_t LLVertexBuffer::sLockedList;
 
 S32 LLVertexBuffer::sTypeOffsets[LLVertexBuffer::TYPE_MAX] =
 {
@@ -70,6 +80,10 @@ S32 LLVertexBuffer::sTypeOffsets[LLVertexBuffer::TYPE_MAX] =
 void LLVertexBuffer::initClass(bool use_vbo)
 {
 	sEnableVBOs = use_vbo;
+	LLGLNamePool::registerPool(&sDynamicVBOPool);
+	LLGLNamePool::registerPool(&sDynamicIBOPool);
+	LLGLNamePool::registerPool(&sStreamVBOPool);
+	LLGLNamePool::registerPool(&sStreamIBOPool);
 }
 
 //static 
@@ -88,13 +102,13 @@ void LLVertexBuffer::unbind()
 
 	sGLRenderBuffer = 0;
 	sGLRenderIndices = 0;
+	sLastMask = 0;
 }
 
 //static
 void LLVertexBuffer::cleanupClass()
 {
 	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
-	sLockedList.clear();
 	startRender(); 
 	stopRender();
 	clientCopy(); // deletes GL buffers
@@ -127,41 +141,8 @@ void LLVertexBuffer::clientCopy(F64 max_time)
 {
 	if (!sDeleteList.empty())
 	{
-		size_t num = sDeleteList.size();
 		glDeleteBuffersARB(sDeleteList.size(), (GLuint*) &(sDeleteList[0]));
 		sDeleteList.clear();
-		sGLCount -= num;
-	}
-
-	if (sEnableVBOs)
-	{
-		LLTimer timer;
-		BOOL reset = TRUE;
-		buffer_list_t::iterator iter = sLockedList.begin();
-		while(iter != sLockedList.end())
-		{
-			LLVertexBuffer* buffer = *iter;
-			if (buffer->isLocked() && buffer->useVBOs())
-			{
-				buffer->setBuffer(0);
-			}
-			++iter;
-			if (reset)
-			{
-				reset = FALSE;
-				timer.reset(); //skip first copy (don't count pipeline stall)
-			}
-			else
-			{
-				if (timer.getElapsedTimeF64() > max_time)
-				{
-					break;
-				}
-			}
-
-		}
-
-		sLockedList.erase(sLockedList.begin(), iter);
 	}
 }
 
@@ -175,27 +156,40 @@ LLVertexBuffer::LLVertexBuffer(U32 typemask, S32 usage) :
 	mFinal(FALSE),
 	mFilthy(FALSE),
 	mEmpty(TRUE),
-	mResized(FALSE)
+	mResized(FALSE),
+	mDynamicSize(FALSE)
 {
 	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
 	if (!sEnableVBOs)
 	{
-		mUsage = GL_STREAM_DRAW_ARB;
+		mUsage = 0 ; 
 	}
 	
+	S32 stride = calcStride(typemask, mOffsets);
+
+	mTypeMask = typemask;
+	mStride = stride;
+	sCount++;
+}
+
+//static
+S32 LLVertexBuffer::calcStride(const U32& typemask, S32* offsets)
+{
 	S32 stride = 0;
 	for (S32 i=0; i<TYPE_MAX; i++)
 	{
 		U32 mask = 1<<i;
 		if (typemask & mask)
 		{
-			mOffsets[i] = stride;
+			if (offsets)
+			{
+				offsets[i] = stride;
+			}
 			stride += sTypeOffsets[i];
 		}
 	}
-	mTypeMask = typemask;
-	mStride = stride;
-	sCount++;
+
+	return stride;
 }
 
 // protected, use unref()
@@ -206,23 +200,80 @@ LLVertexBuffer::~LLVertexBuffer()
 	destroyGLBuffer();
 	destroyGLIndices();
 	sCount--;
-	
-	if (mLocked)
-	{
-		//pull off of locked list
-		for (buffer_list_t::iterator i = sLockedList.begin(); i != sLockedList.end(); ++i)
-		{
-			if (*i == this)
-			{
-				sLockedList.erase(i);
-				break;
-			}
-		}
-	}
 };
 
 //----------------------------------------------------------------------------
 
+void LLVertexBuffer::genBuffer()
+{
+	if (mUsage == GL_STREAM_DRAW_ARB)
+	{
+		mGLBuffer = sStreamVBOPool.allocate();
+	}
+	else if (mUsage == GL_DYNAMIC_DRAW_ARB)
+	{
+		mGLBuffer = sDynamicVBOPool.allocate();
+	}
+	else
+	{
+		BOOST_STATIC_ASSERT(sizeof(mGLBuffer) == sizeof(GLuint));
+		glGenBuffersARB(1, (GLuint*)&mGLBuffer);
+	}
+	sGLCount++;
+}
+
+void LLVertexBuffer::genIndices()
+{
+	if (mUsage == GL_STREAM_DRAW_ARB)
+	{
+		mGLIndices = sStreamIBOPool.allocate();
+	}
+	else if (mUsage == GL_DYNAMIC_DRAW_ARB)
+	{
+		mGLIndices = sDynamicIBOPool.allocate();
+	}
+	else
+	{
+		BOOST_STATIC_ASSERT(sizeof(mGLBuffer) == sizeof(GLuint));
+		glGenBuffersARB(1, (GLuint*)&mGLIndices);
+	}
+	sGLCount++;
+}
+
+void LLVertexBuffer::releaseBuffer()
+{
+	if (mUsage == GL_STREAM_DRAW_ARB)
+	{
+		sStreamVBOPool.release(mGLBuffer);
+	}
+	else if (mUsage == GL_DYNAMIC_DRAW_ARB)
+	{
+		sDynamicVBOPool.release(mGLBuffer);
+	}
+	else
+	{
+		sDeleteList.push_back(mGLBuffer);
+	}
+	sGLCount--;
+}
+
+void LLVertexBuffer::releaseIndices()
+{
+	if (mUsage == GL_STREAM_DRAW_ARB)
+	{
+		sStreamIBOPool.release(mGLIndices);
+	}
+	else if (mUsage == GL_DYNAMIC_DRAW_ARB)
+	{
+		sDynamicIBOPool.release(mGLIndices);
+	}
+	else
+	{
+		sDeleteList.push_back(mGLIndices);
+	}
+	sGLCount--;
+}
+
 void LLVertexBuffer::createGLBuffer()
 {
 	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
@@ -238,20 +289,20 @@ void LLVertexBuffer::createGLBuffer()
 		return;
 	}
 
-	mMappedData = new U8[size];
-	memset(mMappedData, 0, size);
 	mEmpty = TRUE;
 
 	if (useVBOs())
 	{
-		glGenBuffersARB(1, (GLuint*) &mGLBuffer);
+		mMappedData = NULL;
+		genBuffer();
 		mResized = TRUE;
-		sGLCount++;
 	}
 	else
 	{
 		static int gl_buffer_idx = 0;
 		mGLBuffer = ++gl_buffer_idx;
+		mMappedData = new U8[size];
+		memset(mMappedData, 0, size);
 	}
 }
 
@@ -270,18 +321,18 @@ void LLVertexBuffer::createGLIndices()
 		return;
 	}
 
-	mMappedIndexData = new U8[size];
-	memset(mMappedIndexData, 0, size);
 	mEmpty = TRUE;
 
 	if (useVBOs())
 	{
-		glGenBuffersARB(1, (GLuint*) &mGLIndices);
+		mMappedIndexData = NULL;
+		genIndices();
 		mResized = TRUE;
-		sGLCount++;
 	}
 	else
 	{
+		mMappedIndexData = new U8[size];
+		memset(mMappedIndexData, 0, size);
 		static int gl_buffer_idx = 0;
 		mGLIndices = ++gl_buffer_idx;
 	}
@@ -294,12 +345,19 @@ void LLVertexBuffer::destroyGLBuffer()
 	{
 		if (useVBOs())
 		{
-			sDeleteList.push_back(mGLBuffer);
+			if (mMappedData || mMappedIndexData)
+			{
+				llerrs << "Vertex buffer destroyed while mapped!" << llendl;
+			}
+			releaseBuffer();
+		}
+		else
+		{
+			delete [] mMappedData;
+			mMappedData = NULL;
+			mEmpty = TRUE;
 		}
-		
-		delete [] mMappedData;
-		mMappedData = NULL;
-		mEmpty = TRUE;
+
 		sAllocatedBytes -= getSize();
 	}
 	
@@ -313,12 +371,19 @@ void LLVertexBuffer::destroyGLIndices()
 	{
 		if (useVBOs())
 		{
-			sDeleteList.push_back(mGLIndices);
+			if (mMappedData || mMappedIndexData)
+			{
+				llerrs << "Vertex buffer destroyed while mapped." << llendl;
+			}
+			releaseIndices();
+		}
+		else
+		{
+			delete [] mMappedIndexData;
+			mMappedIndexData = NULL;
+			mEmpty = TRUE;
 		}
-		
-		delete [] mMappedIndexData;
-		mMappedIndexData = NULL;
-		mEmpty = TRUE;
+
 		sAllocatedBytes -= getIndicesSize();
 	}
 
@@ -328,6 +393,15 @@ void LLVertexBuffer::destroyGLIndices()
 void LLVertexBuffer::updateNumVerts(S32 nverts)
 {
 	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+
+	if (nverts >= 65535)
+	{
+		llwarns << "Vertex buffer overflow!" << llendl;
+		nverts = 65535;
+	}
+
+	mRequestedNumVerts = nverts;
+	
 	if (!mDynamicSize)
 	{
 		mNumVerts = nverts;
@@ -336,18 +410,19 @@ void LLVertexBuffer::updateNumVerts(S32 nverts)
 		nverts > mNumVerts ||
 		nverts < mNumVerts/2)
 	{
-		if (mUsage != GL_STATIC_DRAW_ARB)
+		if (mUsage != GL_STATIC_DRAW_ARB && nverts + nverts/4 <= 65535)
 		{
 			nverts += nverts/4;
 		}
-
 		mNumVerts = nverts;
 	}
+
 }
 
 void LLVertexBuffer::updateNumIndices(S32 nindices)
 {
 	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
+	mRequestedNumIndices = nindices;
 	if (!mDynamicSize)
 	{
 		mNumIndices = nindices;
@@ -365,54 +440,6 @@ void LLVertexBuffer::updateNumIndices(S32 nindices)
 	}
 }
 
-void LLVertexBuffer::makeStatic()
-{
-	if (!sEnableVBOs)
-	{
-		return;
-	}
-	
-	if (sRenderActive)
-	{
-		llerrs << "Make static called during render." << llendl;
-	}
-	
-	if (mUsage != GL_STATIC_DRAW_ARB)
-	{
-		if (useVBOs())
-		{
-			if (mGLBuffer)
-			{
-				sDeleteList.push_back(mGLBuffer);
-			}
-			if (mGLIndices)
-			{
-				sDeleteList.push_back(mGLIndices);
-			}
-		}
-	
-		if (mGLBuffer)
-		{
-			sGLCount++;
-			glGenBuffersARB(1, (GLuint*) &mGLBuffer);
-		}
-		if (mGLIndices)
-		{
-			sGLCount++;
-			glGenBuffersARB(1, (GLuint*) &mGLIndices);
-		}
-			
-		mUsage = GL_STATIC_DRAW_ARB;
-		mResized = TRUE;
-
-		if (!mLocked)
-		{
-			mLocked = TRUE;
-			sLockedList.push_back(this);
-		}
-	}
-}
-
 void LLVertexBuffer::allocateBuffer(S32 nverts, S32 nindices, bool create)
 {
 	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
@@ -435,6 +462,9 @@ void LLVertexBuffer::allocateBuffer(S32 nverts, S32 nindices, bool create)
 
 void LLVertexBuffer::resizeBuffer(S32 newnverts, S32 newnindices)
 {
+	mRequestedNumVerts = newnverts;
+	mRequestedNumIndices = newnindices;
+
 	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
 	mDynamicSize = TRUE;
 	if (mUsage == GL_STATIC_DRAW_ARB)
@@ -469,22 +499,25 @@ void LLVertexBuffer::resizeBuffer(S32 newnverts, S32 newnindices)
 			else
 			{
 				//delete old buffer, keep GL buffer for now
-				U8* old = mMappedData;
-				mMappedData = new U8[newsize];
-				if (old)
-				{	
-					memcpy(mMappedData, old, llmin(newsize, oldsize));
-					if (newsize > oldsize)
+				if (!useVBOs())
+				{
+					U8* old = mMappedData;
+					mMappedData = new U8[newsize];
+					if (old)
+					{	
+						memcpy(mMappedData, old, llmin(newsize, oldsize));
+						if (newsize > oldsize)
+						{
+							memset(mMappedData+oldsize, 0, newsize-oldsize);
+						}
+
+						delete [] old;
+					}
+					else
 					{
-						memset(mMappedData+oldsize, 0, newsize-oldsize);
+						memset(mMappedData, 0, newsize);
+						mEmpty = TRUE;
 					}
-
-					delete [] old;
-				}
-				else
-				{
-					memset(mMappedData, 0, newsize);
-					mEmpty = TRUE;
 				}
 				mResized = TRUE;
 			}
@@ -502,22 +535,26 @@ void LLVertexBuffer::resizeBuffer(S32 newnverts, S32 newnindices)
 			}
 			else
 			{
-				//delete old buffer, keep GL buffer for now
-				U8* old = mMappedIndexData;
-				mMappedIndexData = new U8[new_index_size];
-				if (old)
-				{	
-					memcpy(mMappedIndexData, old, llmin(new_index_size, old_index_size));
-					if (new_index_size > old_index_size)
+				if (!useVBOs())
+				{
+					//delete old buffer, keep GL buffer for now
+					U8* old = mMappedIndexData;
+					mMappedIndexData = new U8[new_index_size];
+					
+					if (old)
+					{	
+						memcpy(mMappedIndexData, old, llmin(new_index_size, old_index_size));
+						if (new_index_size > old_index_size)
+						{
+							memset(mMappedIndexData+old_index_size, 0, new_index_size - old_index_size);
+						}
+						delete [] old;
+					}
+					else
 					{
-						memset(mMappedIndexData+old_index_size, 0, new_index_size - old_index_size);
+						memset(mMappedIndexData, 0, new_index_size);
+						mEmpty = TRUE;
 					}
-					delete [] old;
-				}
-				else
-				{
-					memset(mMappedIndexData, 0, new_index_size);
-					mEmpty = TRUE;
 				}
 				mResized = TRUE;
 			}
@@ -527,18 +564,29 @@ void LLVertexBuffer::resizeBuffer(S32 newnverts, S32 newnindices)
 			destroyGLIndices();
 		}
 	}
+
+	if (mResized && useVBOs())
+	{
+		setBuffer(0);
+	}
 }
 
 BOOL LLVertexBuffer::useVBOs() const
 {
-	//it's generally ineffective to use VBO for things that are streaming
-	//when we already have a client buffer around
-	if (mUsage == GL_STREAM_DRAW_ARB)
+	//it's generally ineffective to use VBO for things that are streaming on apple
+		
+#if LL_DARWIN
+	if (!mUsage || mUsage == GL_STREAM_DRAW_ARB)
 	{
 		return FALSE;
 	}
-
-	return sEnableVBOs && (!sRenderActive || !mLocked);
+#else
+	if (!mUsage)
+	{
+		return FALSE;
+	}
+#endif
+	return sEnableVBOs; // && (!sRenderActive || !mLocked);
 }
 
 //----------------------------------------------------------------------------
@@ -547,27 +595,27 @@ BOOL LLVertexBuffer::useVBOs() const
 U8* LLVertexBuffer::mapBuffer(S32 access)
 {
 	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
-	if (sRenderActive)
-	{
-		llwarns << "Buffer mapped during render frame!" << llendl;
-	}
-	if (!mGLBuffer && !mGLIndices)
-	{
-		llerrs << "LLVertexBuffer::mapBuffer() called  before createGLBuffer" << llendl;
-	}
 	if (mFinal)
 	{
 		llerrs << "LLVertexBuffer::mapBuffer() called on a finalized buffer." << llendl;
 	}
-	if (!mMappedData && !mMappedIndexData)
+	if (!useVBOs() && !mMappedData && !mMappedIndexData)
 	{
 		llerrs << "LLVertexBuffer::mapBuffer() called on unallocated buffer." << llendl;
 	}
-	
+		
 	if (!mLocked && useVBOs())
 	{
+		setBuffer(0);
 		mLocked = TRUE;
-		sLockedList.push_back(this);
+		mMappedData = (U8*) glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
+		mMappedIndexData = (U8*) glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
+		/*if (sMapped)
+		{
+			llerrs << "Mapped two VBOs at the same time!" << llendl;
+		}
+		sMapped = TRUE;*/
+		sMappedCount++;
 	}
 	
 	return mMappedData;
@@ -580,64 +628,19 @@ void LLVertexBuffer::unmapBuffer()
 	{
 		if (useVBOs() && mLocked)
 		{
-			if (mGLBuffer)
-			{
-				if (mResized)
-				{
-					glBufferDataARB(GL_ARRAY_BUFFER_ARB, getSize(), mMappedData, mUsage);
-				}
-				else
-				{
-					if (mEmpty || mDirtyRegions.empty())
-					{
-						glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, getSize(), mMappedData);
-					}
-					else
-					{
-						for (std::vector<DirtyRegion>::iterator i = mDirtyRegions.begin(); i != mDirtyRegions.end(); ++i)
-						{
-							DirtyRegion& region = *i;
-							glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, region.mIndex*mStride, region.mCount*mStride, mMappedData + region.mIndex*mStride);
-						}
-					}
-				}
-			}
-			
-			if (mGLIndices)
+			glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
+			glUnmapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB);
+
+			/*if (!sMapped)
 			{
-				if (mResized)
-				{
-					glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, getIndicesSize(), mMappedIndexData, mUsage);
-				}
-				else
-				{
-					if (mEmpty || mDirtyRegions.empty())
-					{
-						glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0, getIndicesSize(), mMappedIndexData);
-					}
-					else
-					{
-						for (std::vector<DirtyRegion>::iterator i = mDirtyRegions.begin(); i != mDirtyRegions.end(); ++i)
-						{
-							DirtyRegion& region = *i;
-							glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, region.mIndicesIndex*sizeof(U32), 
-								region.mIndicesCount*sizeof(U32), mMappedIndexData + region.mIndicesIndex*sizeof(U32));
-						}
-					}
-				}
+				llerrs << "Redundantly unmapped VBO!" << llendl;
 			}
-
-			mDirtyRegions.clear();
-			mFilthy = FALSE;
-			mResized = FALSE;
+			sMapped = FALSE;*/
+			sMappedCount--;
 
 			if (mUsage == GL_STATIC_DRAW_ARB)
 			{ //static draw buffers can only be mapped a single time
 				//throw out client data (we won't be using it again)
-				delete [] mMappedData;
-				delete [] mMappedIndexData;
-				mMappedIndexData = NULL;
-				mMappedData = NULL;
 				mEmpty = TRUE;
 				mFinal = TRUE;
 			}
@@ -645,10 +648,11 @@ void LLVertexBuffer::unmapBuffer()
 			{
 				mEmpty = FALSE;
 			}
+
+			mMappedIndexData = NULL;
+			mMappedData = NULL;
 			
 			mLocked = FALSE;
-			
-			glFlush();
 		}
 	}
 }
@@ -690,9 +694,9 @@ bool LLVertexBuffer::getVertexStrider(LLStrider<LLVector3>& strider, S32 index)
 {
 	return VertexBufferStrider<LLVector3,TYPE_VERTEX>::get(*this, strider, index);
 }
-bool LLVertexBuffer::getIndexStrider(LLStrider<U32>& strider, S32 index)
+bool LLVertexBuffer::getIndexStrider(LLStrider<U16>& strider, S32 index)
 {
-	return VertexBufferStrider<U32,TYPE_INDEX>::get(*this, strider, index);
+	return VertexBufferStrider<U16,TYPE_INDEX>::get(*this, strider, index);
 }
 bool LLVertexBuffer::getTexCoordStrider(LLStrider<LLVector2>& strider, S32 index)
 {
@@ -755,16 +759,46 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
 	{
 		if (mGLBuffer && (mGLBuffer != sGLRenderBuffer || !sVBOActive))
 		{
+			/*if (sMapped)
+			{
+				llerrs << "VBO bound while another VBO mapped!" << llendl;
+			}*/
 			glBindBufferARB(GL_ARRAY_BUFFER_ARB, mGLBuffer);
+			sBindCount++;
 			sVBOActive = TRUE;
 			setup = TRUE; // ... or the bound buffer changed
 		}
 		if (mGLIndices && (mGLIndices != sGLRenderIndices || !sIBOActive))
 		{
+			/*if (sMapped)
+			{
+				llerrs << "VBO bound while another VBO mapped!" << llendl;
+			}*/
 			glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, mGLIndices);
+			sBindCount++;
 			sIBOActive = TRUE;
 		}
 		
+		if (mResized)
+		{
+			if (mGLBuffer)
+			{
+				glBufferDataARB(GL_ARRAY_BUFFER_ARB, getSize(), NULL, mUsage);
+			}
+			if (mGLIndices)
+			{
+				glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, getIndicesSize(), NULL, mUsage);
+			}
+
+			mEmpty = TRUE;
+			mResized = FALSE;
+
+			if (data_mask != 0)
+			{
+				llerrs << "Buffer set for rendering before being filled after resize." << llendl;
+			}
+		}
+
 		unmapBuffer();
 	}
 	else
@@ -774,6 +808,7 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
 			if (sEnableVBOs && sVBOActive)
 			{
 				glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+				sBindCount++;
 				sVBOActive = FALSE;
 				setup = TRUE; // ... or a VBO is deactivated
 			}
@@ -784,7 +819,12 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
 		}
 		if (sEnableVBOs && mGLIndices && sIBOActive)
 		{
+			/*if (sMapped)
+			{
+				llerrs << "VBO unbound while potentially mapped!" << llendl;
+			}*/
 			glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
+			sBindCount++;
 			sIBOActive = FALSE;
 		}
 	}
@@ -803,9 +843,11 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
 				llwarns << "Vertex buffer set for rendering outside of render frame." << llendl;
 			}
 			setupVertexBuffer(data_mask); // subclass specific setup (virtual function)
-			sLastMask = data_mask;
+			sSetCount++;
 		}
 	}
+
+	sLastMask = data_mask;
 }
 
 // virtual (default)
@@ -821,10 +863,6 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const
 		llerrs << "LLVertexBuffer::setupVertexBuffer missing required components for supplied data mask." << llendl;
 	}
 
-	if (data_mask & MAP_VERTEX)
-	{
-		glVertexPointer(3,GL_FLOAT, stride, (void*)(base + 0));
-	}
 	if (data_mask & MAP_NORMAL)
 	{
 		glNormalPointer(GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_NORMAL]));
@@ -855,49 +893,19 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const
 	{
 		glVertexAttribPointerARB(4, 4, GL_FLOAT, TRUE,  stride, (void*)(base + mOffsets[TYPE_CLOTHWEIGHT]));
 	}
+	if (data_mask & MAP_VERTEX)
+	{
+		glVertexPointer(3,GL_FLOAT, stride, (void*)(base + 0));
+	}
 
 	llglassertok();
 }
 
 void LLVertexBuffer::markDirty(U32 vert_index, U32 vert_count, U32 indices_index, U32 indices_count)
 {
-	if (useVBOs() && !mFilthy)
-	{
-		if (!mDirtyRegions.empty())
-		{
-			DirtyRegion& region = *(mDirtyRegions.rbegin());
-			
-			if (region.mIndex+region.mCount > vert_index)
-			{
-				//this buffer has received multiple updates since the last copy, mark it filthy
-				mFilthy = TRUE;
-				mDirtyRegions.clear();
-				return;
-			}
-			
-			if (region.mIndex + region.mCount == vert_index &&
-				region.mIndicesIndex + region.mIndicesCount == indices_index)
-			{
-				region.mCount += vert_count;
-				region.mIndicesCount += indices_count;
-				return;
-			}
-		}
-
-		mDirtyRegions.push_back(DirtyRegion(vert_index,vert_count,indices_index,indices_count));
-	}
-}
-
-void LLVertexBuffer::markClean()
-{
-	if (!mResized && !mEmpty && !mFilthy)
+	// TODO: use GL_APPLE_flush_buffer_range here
+	/*if (useVBOs() && !mFilthy)
 	{
-		buffer_list_t::reverse_iterator iter = sLockedList.rbegin();
-		if (*iter == this)
-		{
-			mLocked = FALSE;
-			sLockedList.pop_back();
-		}
-	}
+	
+	}*/
 }
-