Move the index range cache to gl::Buffer.

src/libGLESv2/Buffer.cpp

@@ -31,11 +31,12 @@ Buffer::Buffer(rx::BufferImpl *impl, GLuint id)
 
 Buffer::~Buffer()
 {
-    delete mBuffer;
+    SafeDelete(mBuffer);
 }
 
 void Buffer::bufferData(const void *data, GLsizeiptr size, GLenum usage)
 {
+    mIndexRangeCache.clear();
     mUsage = usage;
     mSize = size;
     mBuffer->setData(data, size, usage);
@@ -43,11 +44,13 @@ void Buffer::bufferData(const void *data, GLsizeiptr size, GLenum usage)
 
 void Buffer::bufferSubData(const void *data, GLsizeiptr size, GLintptr offset)
 {
+    mIndexRangeCache.invalidateRange(offset, size);
     mBuffer->setSubData(data, size, offset);
 }
 
 void Buffer::copyBufferSubData(Buffer* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size)
 {
+    mIndexRangeCache.invalidateRange(destOffset, size);
     mBuffer->copySubData(source->getImplementation(), sourceOffset, destOffset, size);
 }
 
@@ -64,6 +67,11 @@ GLvoid *Buffer::mapRange(GLintptr offset, GLsizeiptr length, GLbitfield access)
     mMapLength = static_cast<GLint64>(length);
     mAccessFlags = static_cast<GLint>(access);
 
+    if ((access & GL_MAP_WRITE_BIT) > 0)
+    {
+        mIndexRangeCache.invalidateRange(offset, length);
+    }
+
     return mMapPointer;
 }
 
@@ -84,6 +92,7 @@ void Buffer::markTransformFeedbackUsage()
 {
     // TODO: Only used by the DX11 backend. Refactor to a more appropriate place.
     mBuffer->markTransformFeedbackUsage();
+    mIndexRangeCache.clear();
 }
 
 }

src/libGLESv2/Buffer.h

@@ -13,6 +13,7 @@
 
 #include "common/angleutils.h"
 #include "common/RefCountObject.h"
+#include "libGLESv2/renderer/IndexRangeCache.h"
 
 namespace rx
 {
@@ -48,6 +49,8 @@ class Buffer : public RefCountObject
 
     void markTransformFeedbackUsage();
 
+    rx::IndexRangeCache *getIndexRangeCache() { return &mIndexRangeCache; }
+
   private:
     DISALLOW_COPY_AND_ASSIGN(Buffer);
 
@@ -60,6 +63,8 @@ class Buffer : public RefCountObject
     GLvoid *mMapPointer;
     GLint64 mMapOffset;
     GLint64 mMapLength;
+
+    rx::IndexRangeCache mIndexRangeCache;
 };
 
 }

src/libGLESv2/renderer/d3d/BufferD3D.h

@@ -11,7 +11,6 @@
 
 #include "libGLESv2/renderer/BufferImpl.h"
 #include "libGLESv2/angletypes.h"
-#include "libGLESv2/renderer/IndexRangeCache.h"
 
 namespace rx
 {
@@ -36,7 +35,6 @@ class BufferD3D : public BufferImpl
 
     rx::StaticVertexBufferInterface *getStaticVertexBuffer() { return mStaticVertexBuffer; }
     rx::StaticIndexBufferInterface *getStaticIndexBuffer() { return mStaticIndexBuffer; }
-    rx::IndexRangeCache *getIndexRangeCache() { return &mIndexRangeCache; }
 
     void initializeStaticData();
     void invalidateStaticData();
@@ -50,7 +48,6 @@ class BufferD3D : public BufferImpl
 
     rx::StaticVertexBufferInterface *mStaticVertexBuffer;
     rx::StaticIndexBufferInterface *mStaticIndexBuffer;
-    rx::IndexRangeCache mIndexRangeCache;
     unsigned int mUnmodifiedDataUse;
 };
 

src/libGLESv2/renderer/d3d/IndexDataManager.cpp

@@ -184,10 +184,10 @@ GLenum IndexDataManager::prepareIndexData(GLenum type, GLsizei count, gl::Buffer
     {
         streamOffset = offset;
 
-        if (!storage->getIndexRangeCache()->findRange(type, offset, count, &translated->indexRange, NULL))
+        if (!buffer->getIndexRangeCache()->findRange(type, offset, count, &translated->indexRange, NULL))
         {
             translated->indexRange = computeRange(type, indices, count);
-            storage->getIndexRangeCache()->addRange(type, offset, count, translated->indexRange, offset);
+            buffer->getIndexRangeCache()->addRange(type, offset, count, translated->indexRange, offset);
         }
     }
     else if (staticBuffer && staticBuffer->getBufferSize() != 0 && staticBuffer->getIndexType() == type && alignedOffset)

src/libGLESv2/renderer/d3d/d3d11/Buffer11.cpp

@@ -180,8 +180,6 @@ Buffer11 *Buffer11::makeBuffer11(BufferImpl *buffer)
 
 void Buffer11::setData(const void* data, size_t size, GLenum usage)
 {
-    mIndexRangeCache.clear();
-
     setSubData(data, size, 0);
 
     if (usage == GL_STATIC_DRAW)
@@ -236,7 +234,6 @@ void Buffer11::setSubData(const void* data, size_t size, size_t offset)
     size_t requiredSize = size + offset;
     mSize = std::max(mSize, requiredSize);
 
-    mIndexRangeCache.invalidateRange(offset, size);
     invalidateStaticData();
 
     if (data && size > 0)
@@ -326,7 +323,6 @@ void Buffer11::copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr d
         mSize = std::max<size_t>(mSize, destOffset + size);
     }
 
-    mIndexRangeCache.invalidateRange(destOffset, size);
     invalidateStaticData();
 }
 
@@ -357,8 +353,6 @@ GLvoid *Buffer11::map(size_t offset, size_t length, GLbitfield access)
 
     if ((access & GL_MAP_WRITE_BIT) > 0)
     {
-        mIndexRangeCache.invalidateRange(offset, length);
-
         // Update the data revision immediately, since the data might be changed at any time
         mMappedStorage->setDataRevision(mMappedStorage->getDataRevision() + 1);
     }
@@ -382,7 +376,6 @@ void Buffer11::markTransformFeedbackUsage()
         transformFeedbackStorage->setDataRevision(transformFeedbackStorage->getDataRevision() + 1);
     }
 
-    mIndexRangeCache.clear();
     invalidateStaticData();
 }
 
@@ -480,8 +473,6 @@ void Buffer11::packPixels(ID3D11Texture2D *srcTexture, UINT srcSubresource, cons
         packStorage->packPixels(srcTexture, srcSubresource, params);
         packStorage->setDataRevision(latestStorage ? latestStorage->getDataRevision() + 1 : 1);
     }
-
-    mIndexRangeCache.clear();
 }
 
 Buffer11::BufferStorage11 *Buffer11::getBufferStorage(BufferUsage usage)

src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp

@@ -2748,10 +2748,13 @@ void Renderer11::readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsi
         area.width = width;
         area.height = height;
 
-        if (pack.pixelBuffer.get() != NULL)
+        gl::Buffer *packBuffer = pack.pixelBuffer.get();
+        if (packBuffer != NULL)
         {
-            rx::Buffer11 *packBufferStorage = Buffer11::makeBuffer11(pack.pixelBuffer.get()->getImplementation());
+            rx::Buffer11 *packBufferStorage = Buffer11::makeBuffer11(packBuffer->getImplementation());
             PackPixelsParams packParams(area, format, type, outputPitch, pack, reinterpret_cast<ptrdiff_t>(pixels));
+
+            packBuffer->getIndexRangeCache()->clear();
             packBufferStorage->packPixels(colorBufferTexture, subresourceIndex, packParams);
         }
         else

src/libGLESv2/renderer/d3d/d3d9/Buffer9.cpp

@@ -47,7 +47,6 @@ void Buffer9::setData(const void* data, size_t size, GLenum usage)
         memcpy(mMemory.data(), data, size);
     }
 
-    mIndexRangeCache.clear();
     invalidateStaticData();
 
     if (usage == GL_STATIC_DRAW)
@@ -77,8 +76,6 @@ void Buffer9::setSubData(const void* data, size_t size, size_t offset)
         memcpy(mMemory.data() + offset, data, size);
     }
 
-    mIndexRangeCache.invalidateRange(offset, size);
-
     invalidateStaticData();
 }
 
@@ -91,7 +88,6 @@ void Buffer9::copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr de
         memcpy(mMemory.data() + destOffset, sourceBuffer->mMemory.data() + sourceOffset, size);
     }
 
-    mIndexRangeCache.invalidateRange(destOffset, size);
     invalidateStaticData();
 }