Use vertex array objects on core profiles.

src/gpu/gl/GrGpuGL.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 162 matching lines @@
         GrPrintf("------ VENDOR %s\n", vendor);
         GrPrintf("------ RENDERER %s\n", renderer);
         GrPrintf("------ VERSION %s\n",  version);
         GrPrintf("------ EXTENSIONS\n %s \n", ext);
     }
 
     this->initCaps();
 
     fProgramCache = SkNEW_ARGS(ProgramCache, (this->glContext()));
 
-    fHWGeometryState.setMaxAttribArrays(this->glCaps().maxVertexAttributes());
-
     GrAssert(this->glCaps().maxVertexAttributes() >= GrDrawState::kVertexAttribCnt);
     GrAssert(this->glCaps().maxVertexAttributes() > GrDrawState::kColorOverrideAttribIndexValue);
     GrAssert(this->glCaps().maxVertexAttributes() > GrDrawState::kCoverageOverrideAttribIndexValue);
 
     fLastSuccessfulStencilFmtIdx = 0;
     if (false) { // avoid bit rot, suppress warning
         fbo_test(this->glInterface(), 0, 0);
     }
 }
 
@@ skipping 221 matching lines @@
         // Desktop-only state that we never change
         if (!this->glCaps().isCoreProfile()) {
             GL_CALL(Disable(GR_GL_POINT_SMOOTH));
             GL_CALL(Disable(GR_GL_LINE_SMOOTH));
             GL_CALL(Disable(GR_GL_POLYGON_SMOOTH));
             GL_CALL(Disable(GR_GL_POLYGON_STIPPLE));
             GL_CALL(Disable(GR_GL_COLOR_LOGIC_OP));
             GL_CALL(Disable(GR_GL_INDEX_LOGIC_OP));
         }
         if (this->glCaps().imagingSupport()) {
+            // This produces a GL error on the windows NVIDIA driver when using a core profile but
+            // I think that is a driver bug since GL_ARB_imaging is in the extension string.
             GL_CALL(Disable(GR_GL_COLOR_TABLE));
         }
         GL_CALL(Disable(GR_GL_POLYGON_OFFSET_FILL));
         // Since ES doesn't support glPointSize at all we always use the VS to
         // set the point size
         GL_CALL(Enable(GR_GL_VERTEX_PROGRAM_POINT_SIZE));
 
         // We should set glPolygonMode(FRONT_AND_BACK,FILL) here, too. It isn't
         // currently part of our gl interface. There are probably others as
         // well.
@@ skipping 803 matching lines @@
     desc.fSizeInBytes = size;
     desc.fIsWrapped = false;
 
     if (this->glCaps().useNonVBOVertexAndIndexDynamicData() && desc.fDynamic) {
         desc.fID = 0;
         GrGLVertexBuffer* vertexBuffer = SkNEW_ARGS(GrGLVertexBuffer, (this, desc));
         return vertexBuffer;
     } else {
         GL_CALL(GenBuffers(1, &desc.fID));
         if (desc.fID) {
-            GL_CALL(BindBuffer(GR_GL_ARRAY_BUFFER, desc.fID));
-            fHWGeometryState.setVertexBufferID(desc.fID);
+            fHWGeometryState.setVertexBufferID(this, desc.fID);
             CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
             // make sure driver can allocate memory for this buffer
             GL_ALLOC_CALL(this->glInterface(),
                           BufferData(GR_GL_ARRAY_BUFFER,
                                      desc.fSizeInBytes,
                                      NULL,   // data ptr
                                      desc.fDynamic ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW));
             if (CHECK_ALLOC_ERROR(this->glInterface()) != GR_GL_NO_ERROR) {
                 GL_CALL(DeleteBuffers(1, &desc.fID));
-                // deleting bound buffer does implicit bind to 0
-                fHWGeometryState.setVertexBufferID(0);
+                this->notifyVertexBufferDelete(desc.fID);
                 return NULL;
             }
             GrGLVertexBuffer* vertexBuffer = SkNEW_ARGS(GrGLVertexBuffer, (this, desc));
             return vertexBuffer;
         }
         return NULL;
     }
 }
 
 GrIndexBuffer* GrGpuGL::onCreateIndexBuffer(uint32_t size, bool dynamic) {
     GrGLIndexBuffer::Desc desc;
     desc.fDynamic = dynamic;
     desc.fSizeInBytes = size;
     desc.fIsWrapped = false;
 
     if (this->glCaps().useNonVBOVertexAndIndexDynamicData() && desc.fDynamic) {
         desc.fID = 0;
         GrIndexBuffer* indexBuffer = SkNEW_ARGS(GrGLIndexBuffer, (this, desc));
         return indexBuffer;
     } else {
         GL_CALL(GenBuffers(1, &desc.fID));
         if (desc.fID) {
-            GL_CALL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, desc.fID));
-            fHWGeometryState.setIndexBufferID(desc.fID);
+            fHWGeometryState.setIndexBufferIDOnDefaultVertexArray(this, desc.fID);
             CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
             // make sure driver can allocate memory for this buffer
             GL_ALLOC_CALL(this->glInterface(),
                           BufferData(GR_GL_ELEMENT_ARRAY_BUFFER,
                                      desc.fSizeInBytes,
                                      NULL,  // data ptr
                                      desc.fDynamic ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW));
             if (CHECK_ALLOC_ERROR(this->glInterface()) != GR_GL_NO_ERROR) {
                 GL_CALL(DeleteBuffers(1, &desc.fID));
-                // deleting bound buffer does implicit bind to 0
-                fHWGeometryState.setIndexBufferID(0);
+                this->notifyIndexBufferDelete(desc.fID);
                 return NULL;
             }
             GrIndexBuffer* indexBuffer = SkNEW_ARGS(GrGLIndexBuffer, (this, desc));
             return indexBuffer;
         }
         return NULL;
     }
 }
 
 GrPath* GrGpuGL::onCreatePath(const SkPath& inPath) {
@@ skipping 851 matching lines @@
             case GrDrawState::kBoth_DrawFace:
                 GL_CALL(Disable(GR_GL_CULL_FACE));
                 break;
             default:
                 GrCrash("Unknown draw face.");
         }
         fHWDrawFace = drawState.getDrawFace();
     }
 }
 
-void GrGpuGL::notifyVertexBufferBind(GrGLuint id) {
-    fHWGeometryState.setVertexBufferID(id);
-}
-
-void GrGpuGL::notifyVertexBufferDelete(GrGLuint id) {
-    fHWGeometryState.notifyVertexBufferDelete(id);
-}
-
-void GrGpuGL::notifyIndexBufferBind(GrGLuint id) {
-    fHWGeometryState.setIndexBufferID(id);
-}
-
-void GrGpuGL::notifyIndexBufferDelete(GrGLuint id) {
-    fHWGeometryState.notifyIndexBufferDelete(id);
-}
-
 void GrGpuGL::notifyRenderTargetDelete(GrRenderTarget* renderTarget) {
     GrAssert(NULL != renderTarget);
     if (fHWBoundRenderTarget == renderTarget) {
         fHWBoundRenderTarget = NULL;
     }
 }
 
 void GrGpuGL::notifyTextureDelete(GrGLTexture* texture) {
     for (int s = 0; s < GrDrawState::kNumStages; ++s) {
         if (fHWBoundTextures[s] == texture) {
@@ skipping 122 matching lines @@
     }
 }
 
 void GrGpuGL::setSpareTextureUnit() {
     if (fHWActiveTextureUnitIdx != (GR_GL_TEXTURE0 + SPARE_TEX_UNIT)) {
         GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + SPARE_TEX_UNIT));
         fHWActiveTextureUnitIdx = SPARE_TEX_UNIT;
     }
 }
 
-GrGLVertexBuffer* GrGpuGL::setBuffers(bool indexed,
-                                      size_t* vertexOffsetInBytes,
-                                      size_t* indexOffsetInBytes) {
-
-    GrAssert(NULL != vertexOffsetInBytes);
-
-    const GeometryPoolState& geoPoolState = this->getGeomPoolState();
-
-    GrGLVertexBuffer* vbuf;
-    switch (this->getGeomSrc().fVertexSrc) {
-        case kBuffer_GeometrySrcType:
-            *vertexOffsetInBytes = 0;
-            vbuf = (GrGLVertexBuffer*) this->getGeomSrc().fVertexBuffer;
-            break;
-        case kArray_GeometrySrcType:
-        case kReserved_GeometrySrcType:
-            this->finalizeReservedVertices();
-            *vertexOffsetInBytes = geoPoolState.fPoolStartVertex * this->getGeomSrc().fVertexSize;
-            vbuf = (GrGLVertexBuffer*) geoPoolState.fPoolVertexBuffer;
-            break;
-        default:
-            vbuf = NULL; // suppress warning
-            GrCrash("Unknown geometry src type!");
-    }
-
-    GrAssert(NULL != vbuf);
-    GrAssert(!vbuf->isLocked());
-    *vertexOffsetInBytes += vbuf->baseOffset();
-
-    if (indexed) {
-        GrAssert(NULL != indexOffsetInBytes);
-
-        GrGLIndexBuffer* ibuf;
-        switch (this->getGeomSrc().fIndexSrc) {
-        case kBuffer_GeometrySrcType:
-            *indexOffsetInBytes = 0;
-            ibuf = (GrGLIndexBuffer*)this->getGeomSrc().fIndexBuffer;
-            break;
-        case kArray_GeometrySrcType:
-        case kReserved_GeometrySrcType:
-            this->finalizeReservedIndices();
-            *indexOffsetInBytes = geoPoolState.fPoolStartIndex * sizeof(GrGLushort);
-            ibuf = (GrGLIndexBuffer*) geoPoolState.fPoolIndexBuffer;
-            break;
-        default:
-            ibuf = NULL; // suppress warning
-            GrCrash("Unknown geometry src type!");
-        }
-
-        GrAssert(NULL != ibuf);
-        GrAssert(!ibuf->isLocked());
-        *indexOffsetInBytes += ibuf->baseOffset();
-        if (!fHWGeometryState.isIndexBufferIDBound(ibuf->bufferID())) {
-            ibuf->bind();
-            fHWGeometryState.setIndexBufferID(ibuf->bufferID());
-        }
-    }
-    return vbuf;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGpuGL::HWGeometryState::AttribArray::set(const GrGpuGL* gpu,
-                                                HWGeometryState* geoState,
-                                                int index,
-                                                GrGLVertexBuffer* buffer,
-                                                GrGLint size,
-                                                GrGLenum type,
-                                                GrGLboolean normalized,
-                                                GrGLsizei stride,
-                                                GrGLvoid* offset) {
-    if (!fEnableIsValid || !fEnabled) {
-        GR_GL_CALL(gpu->glInterface(), EnableVertexAttribArray(index));
-        fEnableIsValid = true;
-        fEnabled = true;
+GrGLAttribArrayState* GrGpuGL::HWGeometryState::bindArrayAndBuffersToDraw(
+                                                GrGpuGL* gpu,
+                                                const GrGLVertexBuffer* vbuffer,
+                                                const GrGLIndexBuffer* ibuffer) {
+    GrAssert(NULL != vbuffer);
+    GrGLAttribArrayState* attribState = &fDefaultVertexArrayAttribState;
+    // We use a vertex array if we're on a core profile and the verts are in a VBO.
+    if (gpu->glCaps().isCoreProfile() && !vbuffer->isCPUBacked()) {
+        if (NULL == fVBOVertexArray || !fVBOVertexArray->isValid()) {
+            SkSafeUnref(fVBOVertexArray);
+            GrGLuint arrayID;
+            GR_GL_CALL(gpu->glInterface(), GenVertexArrays(1, &arrayID));
+            int attrCount = gpu->glCaps().maxVertexAttributes();
+            fVBOVertexArray = SkNEW_ARGS(GrGLVertexArray, (gpu, arrayID, attrCount));
+        }
+        attribState = fVBOVertexArray->bindWithIndexBuffer(ibuffer);
+    } else {
+        if (NULL != ibuffer) {
+            this->setIndexBufferIDOnDefaultVertexArray(gpu, ibuffer->bufferID());
+        } else {
+            this->setVertexArrayID(gpu, 0);
+        }
+        int attrCount = gpu->glCaps().maxVertexAttributes();
+        if (fDefaultVertexArrayAttribState.count() != attrCount) {
+            fDefaultVertexArrayAttribState.resize(attrCount);
+        }
+        attribState = &fDefaultVertexArrayAttribState;
     }
-    if (!fAttribPointerIsValid ||
-        fVertexBufferID != buffer->bufferID() ||
-        fSize != size ||
-        fNormalized != normalized ||
-        fStride != stride ||
-        offset != fOffset) {
-
-        GrGLuint bufferID = buffer->bufferID();
-        if (!geoState->isVertexBufferIDBound(bufferID)) {
-            buffer->bind();
-            geoState->setVertexBufferID(bufferID);
-        }
-        GR_GL_CALL(gpu->glInterface(), VertexAttribPointer(index,
-                                                           size,
-                                                           type,
-                                                           normalized,
-                                                           stride,
-                                                           offset));
-        fAttribPointerIsValid = true;
-        fVertexBufferID = bufferID;
-        fSize = size;
-        fNormalized = normalized;
-        fStride = stride;
-        fOffset = offset;
-    }
+    return attribState;
 }