Use vertex buffer objects instead of client side arrays in fixed-function codepaths

src/gpu/gl/GrGLVertexArray.cpp

 /*
  * 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 "GrGLVertexArray.h"
 #include "GrGpuGL.h"
 
@@ skipping 31 matching lines @@
                                                            offset));
         array->fAttribPointerIsValid = true;
         array->fVertexBufferID = buffer->bufferID();
         array->fSize = size;
         array->fNormalized = normalized;
         array->fStride = stride;
         array->fOffset = offset;
     }
 }
 
-void GrGLAttribArrayState::setFixedFunctionVertexArray(const GrGpuGL* gpu,
-                                                       GrGLVertexBuffer* buffer,
-                                                       GrGLint size,
-                                                       GrGLenum type,
-                                                       GrGLsizei stride,
-                                                       GrGLvoid* offset) {
-    SkASSERT(gpu->glCaps().fixedFunctionSupport());
-    AttribArrayState* array = &fFixedFunctionVertexArray;
-    if (!array->fEnableIsValid || !array->fEnabled) {
-        GR_GL_CALL(gpu->glInterface(), EnableClientState(GR_GL_VERTEX_ARRAY));
-        array->fEnableIsValid = true;
-        array->fEnabled = true;
-    }
-    if (!array->fAttribPointerIsValid ||
-        array->fVertexBufferID != buffer->bufferID() ||
-        array->fSize != size ||
-        array->fStride != stride ||
-        array->fOffset != offset) {
-
-        buffer->bind();
-        GR_GL_CALL(gpu->glInterface(), VertexPointer(size,
-                                                     type,
-                                                     stride,
-                                                     offset));
-        array->fAttribPointerIsValid = true;
-        array->fVertexBufferID = buffer->bufferID();
-        array->fSize = size;
-        array->fStride = stride;
-        array->fOffset = offset;
-    }
-}
-
-void GrGLAttribArrayState::disableUnusedArrays(const GrGpuGL* gpu, uint64_t usedMask, bool usingFFVertexArray) {
+void GrGLAttribArrayState::disableUnusedArrays(const GrGpuGL* gpu, uint64_t usedMask) {
     int count = fAttribArrayStates.count();
     for (int i = 0; i < count; ++i) {
         if (!(usedMask & 0x1)) {
             if (!fAttribArrayStates[i].fEnableIsValid || fAttribArrayStates[i].fEnabled) {
                 GR_GL_CALL(gpu->glInterface(), DisableVertexAttribArray(i));
                 fAttribArrayStates[i].fEnableIsValid = true;
                 fAttribArrayStates[i].fEnabled = false;
             }
         } else {
             SkASSERT(fAttribArrayStates[i].fEnableIsValid && fAttribArrayStates[i].fEnabled);
         }
         // if the count is greater than 64 then this will become 0 and we will disable arrays 64+.
         usedMask >>= 1;
     }
-
-    // Deal with fixed-function vertex arrays.
-    if (gpu->glCaps().fixedFunctionSupport()) {
-        if (!usingFFVertexArray) {
-            if (!fFixedFunctionVertexArray.fEnableIsValid || fFixedFunctionVertexArray.fEnabled) {
-                GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_VERTEX_ARRAY));
-                fFixedFunctionVertexArray.fEnableIsValid = true;
-                fFixedFunctionVertexArray.fEnabled = false;
-            }
-        } else {
-            SkASSERT(fFixedFunctionVertexArray.fEnableIsValid && fFixedFunctionVertexArray.fEnabled);
-        }
-        // When we use fixed function vertex processing we always use the vertex array and none of
-        // the other arrays.
-        if (!fUnusedFixedFunctionArraysDisabled) {
-            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_NORMAL_ARRAY));
-            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_COLOR_ARRAY));
-            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_SECONDARY_COLOR_ARRAY));
-            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_INDEX_ARRAY));
-            GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_EDGE_FLAG_ARRAY));
-            for (int i = 0; i < gpu->glCaps().maxFixedFunctionTextureCoords(); ++i) {
-                GR_GL_CALL(gpu->glInterface(), ClientActiveTexture(GR_GL_TEXTURE0 + i));
-                GR_GL_CALL(gpu->glInterface(), DisableClientState(GR_GL_TEXTURE_COORD_ARRAY));
-            }
-            fUnusedFixedFunctionArraysDisabled = true;
-        }
-    } else {
-        SkASSERT(!usingFFVertexArray);
-    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLVertexArray::GrGLVertexArray(GrGpuGL* gpu, GrGLint id, int attribCount)
     : GrResource(gpu, false)
     , fID(id)
     , fAttribArrays(attribCount)
     , fIndexBufferIDIsValid(false) {
 }
@@ skipping 36 matching lines @@
 void GrGLVertexArray::notifyIndexBufferDelete(GrGLuint bufferID) {
     if (fIndexBufferIDIsValid && bufferID == fIndexBufferID) {
         fIndexBufferID = 0;
     }
  }
 
 void GrGLVertexArray::invalidateCachedState() {
     fAttribArrays.invalidate();
     fIndexBufferIDIsValid = false;
 }