1 /* 2 * Copyright 2013 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "GrGLBufferImpl.h" 9 #include "GrGpuGL.h" 10 11 #define GL_CALL(GPU, X) GR_GL_CALL(GPU->glInterface(), X) 12 13 #if GR_DEBUG 14 #define VALIDATE() this->validate() 15 #else 16 #define VALIDATE() do {} while(false) 17 #endif 18 19 // GL_STREAM_DRAW triggers an optimization in Chromium's GPU process where a client's vertex buffer 20 // objects are implemented as client-side-arrays on tile-deferred architectures. 21 #define DYNAMIC_USAGE_PARAM GR_GL_STREAM_DRAW 22 23 GrGLBufferImpl::GrGLBufferImpl(GrGpuGL* gpu, const Desc& desc, GrGLenum bufferType) 24 : fDesc(desc) 25 , fBufferType(bufferType) 26 , fLockPtr(NULL) { 27 if (0 == desc.fID) { 28 fCPUData = sk_malloc_flags(desc.fSizeInBytes, SK_MALLOC_THROW); 29 } else { 30 fCPUData = NULL; 31 } 32 VALIDATE(); 33 } 34 35 void GrGLBufferImpl::release(GrGpuGL* gpu) { 36 // make sure we've not been abandoned or already released 37 if (NULL != fCPUData) { 38 VALIDATE(); 39 sk_free(fCPUData); 40 fCPUData = NULL; 41 } else if (fDesc.fID && !fDesc.fIsWrapped) { 42 VALIDATE(); 43 GL_CALL(gpu, DeleteBuffers(1, &fDesc.fID)); 44 if (GR_GL_ARRAY_BUFFER == fBufferType) { 45 gpu->notifyVertexBufferDelete(fDesc.fID); 46 } else { 47 GrAssert(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType); 48 gpu->notifyIndexBufferDelete(fDesc.fID); 49 } 50 fDesc.fID = 0; 51 } 52 fLockPtr = NULL; 53 } 54 55 void GrGLBufferImpl::abandon() { 56 fDesc.fID = 0; 57 fLockPtr = NULL; 58 sk_free(fCPUData); 59 fCPUData = NULL; 60 } 61 62 void GrGLBufferImpl::bind(GrGpuGL* gpu) const { 63 VALIDATE(); 64 if (GR_GL_ARRAY_BUFFER == fBufferType) { 65 gpu->bindVertexBuffer(fDesc.fID); 66 } else { 67 GrAssert(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType); 68 gpu->bindIndexBufferAndDefaultVertexArray(fDesc.fID); 69 } 70 } 71 72 void* GrGLBufferImpl::lock(GrGpuGL* gpu) { 73 VALIDATE(); 74 GrAssert(!this->isLocked()); 75 if (0 == fDesc.fID) { 76 fLockPtr = fCPUData; 77 } else if (gpu->caps()->bufferLockSupport()) { 78 this->bind(gpu); 79 // Let driver know it can discard the old data 80 GL_CALL(gpu, BufferData(fBufferType, 81 fDesc.fSizeInBytes, 82 NULL, 83 fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW)); 84 GR_GL_CALL_RET(gpu->glInterface(), 85 fLockPtr, 86 MapBuffer(fBufferType, GR_GL_WRITE_ONLY)); 87 } 88 return fLockPtr; 89 } 90 91 void GrGLBufferImpl::unlock(GrGpuGL* gpu) { 92 VALIDATE(); 93 GrAssert(this->isLocked()); 94 if (0 != fDesc.fID) { 95 GrAssert(gpu->caps()->bufferLockSupport()); 96 this->bind(gpu); 97 GL_CALL(gpu, UnmapBuffer(fBufferType)); 98 } 99 fLockPtr = NULL; 100 } 101 102 bool GrGLBufferImpl::isLocked() const { 103 VALIDATE(); 104 return NULL != fLockPtr; 105 } 106 107 bool GrGLBufferImpl::updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes) { 108 GrAssert(!this->isLocked()); 109 VALIDATE(); 110 if (srcSizeInBytes > fDesc.fSizeInBytes) { 111 return false; 112 } 113 if (0 == fDesc.fID) { 114 memcpy(fCPUData, src, srcSizeInBytes); 115 return true; 116 } 117 this->bind(gpu); 118 GrGLenum usage = fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW; 119 120 #if GR_GL_USE_BUFFER_DATA_NULL_HINT 121 if (fDesc.fSizeInBytes == srcSizeInBytes) { 122 GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes, src, usage)); 123 } else { 124 // Before we call glBufferSubData we give the driver a hint using 125 // glBufferData with NULL. This makes the old buffer contents 126 // inaccessible to future draws. The GPU may still be processing 127 // draws that reference the old contents. With this hint it can 128 // assign a different allocation for the new contents to avoid 129 // flushing the gpu past draws consuming the old contents. 130 GL_CALL(gpu, BufferData(fBufferType, fDesc.fSizeInBytes, NULL, usage)); 131 GL_CALL(gpu, BufferSubData(fBufferType, 0, srcSizeInBytes, src)); 132 } 133 #else 134 // Note that we're cheating on the size here. Currently no methods 135 // allow a partial update that preserves contents of non-updated 136 // portions of the buffer (lock() does a glBufferData(..size, NULL..)) 137 bool doSubData = false; 138 #if GR_GL_MAC_BUFFER_OBJECT_PERFOMANCE_WORKAROUND 139 static int N = 0; 140 // 128 was chosen experimentally. At 256 a slight hitchiness was noticed 141 // when dragging a Chromium window around with a canvas tab backgrounded. 142 doSubData = 0 == (N % 128); 143 ++N; 144 #endif 145 if (doSubData) { 146 // The workaround is to do a glBufferData followed by glBufferSubData. 147 // Chromium's command buffer may turn a glBufferSubData where the size 148 // exactly matches the buffer size into a glBufferData. So we tack 1 149 // extra byte onto the glBufferData. 150 GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes + 1, NULL, usage)); 151 GL_CALL(gpu, BufferSubData(fBufferType, 0, srcSizeInBytes, src)); 152 } else { 153 GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes, src, usage)); 154 } 155 #endif 156 return true; 157 } 158 159 void GrGLBufferImpl::validate() const { 160 GrAssert(GR_GL_ARRAY_BUFFER == fBufferType || GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType); 161 // The following assert isn't valid when the buffer has been abandoned: 162 // GrAssert((0 == fDesc.fID) == (NULL != fCPUData)); 163 GrAssert(0 != fDesc.fID || !fDesc.fIsWrapped); 164 GrAssert(NULL == fCPUData || NULL == fLockPtr || fCPUData == fLockPtr); 165 } 166