Add GrGLBufferImpl to unify implementation of GrGLVertexBuffer and GrGLIndexBuffer.
Review URL: https://codereview.appspot.com/7346055
git-svn-id: http://skia.googlecode.com/svn/trunk@7798 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/gpu/gl/GrGLBufferImpl.cpp b/src/gpu/gl/GrGLBufferImpl.cpp
new file mode 100644
index 0000000..0ab83fb
--- /dev/null
+++ b/src/gpu/gl/GrGLBufferImpl.cpp
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrGLBufferImpl.h"
+#include "GrGpuGL.h"
+
+#define GL_CALL(GPU, X) GR_GL_CALL(GPU->glInterface(), X)
+
+GrGLBufferImpl::GrGLBufferImpl(GrGpuGL* gpu, const Desc& desc, GrGLenum bufferType)
+ : fDesc(desc)
+ , fBufferType(bufferType)
+ , fLockPtr(NULL) {
+ GrAssert(GR_GL_ARRAY_BUFFER == bufferType || GR_GL_ELEMENT_ARRAY_BUFFER == bufferType);
+}
+
+void GrGLBufferImpl::release(GrGpuGL* gpu) {
+ // make sure we've not been abandoned
+ if (fDesc.fID && !fDesc.fIsWrapped) {
+ GL_CALL(gpu, DeleteBuffers(1, &fDesc.fID));
+ if (GR_GL_ARRAY_BUFFER == fBufferType) {
+ gpu->notifyVertexBufferDelete(fDesc.fID);
+ } else {
+ GrAssert(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
+ gpu->notifyIndexBufferDelete(fDesc.fID);
+ }
+ fDesc.fID = 0;
+ }
+}
+
+void GrGLBufferImpl::abandon() {
+ fDesc.fID = 0;
+ fLockPtr = NULL;
+}
+
+void GrGLBufferImpl::bind(GrGpuGL* gpu) const {
+ GL_CALL(gpu, BindBuffer(fBufferType, fDesc.fID));
+ if (GR_GL_ARRAY_BUFFER == fBufferType) {
+ gpu->notifyVertexBufferBind(fDesc.fID);
+ } else {
+ GrAssert(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
+ gpu->notifyIndexBufferBind(fDesc.fID);
+ }
+}
+
+void* GrGLBufferImpl::lock(GrGpuGL* gpu) {
+ GrAssert(0 != fDesc.fID);
+ GrAssert(!this->isLocked());
+ if (gpu->getCaps().bufferLockSupport()) {
+ this->bind(gpu);
+ // Let driver know it can discard the old data
+ GL_CALL(gpu, BufferData(fBufferType,
+ fDesc.fSizeInBytes,
+ NULL,
+ fDesc.fDynamic ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW));
+ GR_GL_CALL_RET(gpu->glInterface(),
+ fLockPtr,
+ MapBuffer(fBufferType, GR_GL_WRITE_ONLY));
+ return fLockPtr;
+ }
+ return NULL;
+}
+
+void GrGLBufferImpl::unlock(GrGpuGL* gpu) {
+
+ GrAssert(0 != fDesc.fID);
+ GrAssert(this->isLocked());
+ GrAssert(gpu->getCaps().bufferLockSupport());
+
+ this->bind(gpu);
+ GL_CALL(gpu, UnmapBuffer(fBufferType));
+ fLockPtr = NULL;
+}
+
+bool GrGLBufferImpl::isLocked() const {
+ GrAssert(0 != fDesc.fID);
+ return NULL != fLockPtr;
+}
+
+bool GrGLBufferImpl::updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes) {
+ GrAssert(!this->isLocked());
+ if (srcSizeInBytes > fDesc.fSizeInBytes) {
+ return false;
+ }
+ if (0 == fDesc.fID) {
+ return false;
+ }
+ this->bind(gpu);
+ GrGLenum usage = fDesc.fDynamic ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW;
+
+#if GR_GL_USE_BUFFER_DATA_NULL_HINT
+ if (fDesc.fSizeInBytes == srcSizeInBytes) {
+ GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes, src, usage));
+ } else {
+ // Before we call glBufferSubData we give the driver a hint using
+ // glBufferData with NULL. This makes the old buffer contents
+ // inaccessible to future draws. The GPU may still be processing
+ // draws that reference the old contents. With this hint it can
+ // assign a different allocation for the new contents to avoid
+ // flushing the gpu past draws consuming the old contents.
+ GL_CALL(gpu, BufferData(fBufferType, fDesc.fSizeInBytes, NULL, usage));
+ GL_CALL(gpu, BufferSubData(fBufferType, 0, srcSizeInBytes, src));
+ }
+#else
+ // Note that we're cheating on the size here. Currently no methods
+ // allow a partial update that preserves contents of non-updated
+ // portions of the buffer (lock() does a glBufferData(..size, NULL..))
+ bool doSubData = false;
+#if GR_GL_MAC_BUFFER_OBJECT_PERFOMANCE_WORKAROUND
+ static int N = 0;
+ // 128 was chosen experimentally. At 256 a slight hitchiness was noticed
+ // when dragging a Chromium window around with a canvas tab backgrounded.
+ doSubData = 0 == (N % 128);
+ ++N;
+#endif
+ if (doSubData) {
+ // The workaround is to do a glBufferData followed by glBufferSubData.
+ // Chromium's command buffer may turn a glBufferSubData where the size
+ // exactly matches the buffer size into a glBufferData. So we tack 1
+ // extra byte onto the glBufferData.
+ GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes + 1, NULL, usage));
+ GL_CALL(gpu, BufferSubData(fBufferType, 0, srcSizeInBytes, src));
+ } else {
+ GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes, src, usage));
+ }
+#endif
+ return true;
+}