1 /* 2 Copyright 2011 Google Inc. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 18 #include "GrGLIndexBuffer.h" 19 #include "GrGpuGL.h" 20 21 #define GPUGL static_cast<GrGpuGL*>(getGpu()) 22 23 GrGLIndexBuffer::GrGLIndexBuffer(GrGpuGL* gpu, 24 GrGLuint id, 25 size_t sizeInBytes, 26 bool dynamic) 27 : INHERITED(gpu, sizeInBytes, dynamic) 28 , fBufferID(id) 29 , fLockPtr(NULL) { 30 31 } 32 33 void GrGLIndexBuffer::onRelease() { 34 // make sure we've not been abandoned 35 if (fBufferID) { 36 GPUGL->notifyIndexBufferDelete(this); 37 GR_GL(DeleteBuffers(1, &fBufferID)); 38 fBufferID = 0; 39 } 40 } 41 42 void GrGLIndexBuffer::onAbandon() { 43 fBufferID = 0; 44 fLockPtr = NULL; 45 } 46 47 void GrGLIndexBuffer::bind() const { 48 GR_GL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, fBufferID)); 49 GPUGL->notifyIndexBufferBind(this); 50 } 51 52 GrGLuint GrGLIndexBuffer::bufferID() const { 53 return fBufferID; 54 } 55 56 void* GrGLIndexBuffer::lock() { 57 GrAssert(fBufferID); 58 GrAssert(!isLocked()); 59 if (GPUGL->supportsBufferLocking()) { 60 this->bind(); 61 // Let driver know it can discard the old data 62 GR_GL(BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, size(), NULL, 63 dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW)); 64 fLockPtr = GR_GL(MapBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, GR_GL_WRITE_ONLY)); 65 66 return fLockPtr; 67 } 68 return NULL; 69 } 70 71 void* GrGLIndexBuffer::lockPtr() const { 72 return fLockPtr; 73 } 74 75 void GrGLIndexBuffer::unlock() { 76 GrAssert(fBufferID); 77 GrAssert(isLocked()); 78 GrAssert(GPUGL->supportsBufferLocking()); 79 80 this->bind(); 81 GR_GL(UnmapBuffer(GR_GL_ELEMENT_ARRAY_BUFFER)); 82 fLockPtr = NULL; 83 } 84 85 bool GrGLIndexBuffer::isLocked() const { 86 #if GR_DEBUG 87 if (this->isValid() && GPUGL->supportsBufferLocking()) { 88 this->bind(); 89 GrGLint mapped; 90 GR_GL(GetBufferParameteriv(GR_GL_ELEMENT_ARRAY_BUFFER, 91 GR_GL_BUFFER_MAPPED, &mapped)); 92 GrAssert(!!mapped == !!fLockPtr); 93 } 94 #endif 95 return NULL != fLockPtr; 96 } 97 98 bool GrGLIndexBuffer::updateData(const void* src, size_t srcSizeInBytes) { 99 GrAssert(fBufferID); 100 GrAssert(!isLocked()); 101 if (srcSizeInBytes > size()) { 102 return false; 103 } 104 this->bind(); 105 GrGLenum usage = dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW; 106 if (size() == srcSizeInBytes) { 107 GR_GL(BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, srcSizeInBytes, src, usage)); 108 } else { 109 GR_GL(BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, size(), NULL, usage)); 110 GR_GL(BufferSubData(GR_GL_ELEMENT_ARRAY_BUFFER, 0, srcSizeInBytes, src)); 111 } 112 return true; 113 } 114 115 bool GrGLIndexBuffer::updateSubData(const void* src, 116 size_t srcSizeInBytes, 117 size_t offset) { 118 GrAssert(fBufferID); 119 GrAssert(!isLocked()); 120 if (srcSizeInBytes + offset > size()) { 121 return false; 122 } 123 this->bind(); 124 GR_GL(BufferSubData(GR_GL_ELEMENT_ARRAY_BUFFER, offset, srcSizeInBytes, src)); 125 return true; 126 } 127 128