The Tor Browser: gfx/skia/trunk/src/gpu/gl/GrGLVertexArray.cpp@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     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  */

     8 #include "GrGLVertexArray.h"

     9 #include "GrGpuGL.h"

    11 #define GPUGL static_cast<GrGpuGL*>(this->getGpu())

    12 #define GL_CALL(X) GR_GL_CALL(GPUGL->glInterface(), X);

    14 void GrGLAttribArrayState::set(const GrGpuGL* gpu,

    15                                int index,

    16                                GrGLVertexBuffer* buffer,

    17                                GrGLint size,

    18                                GrGLenum type,

    19                                GrGLboolean normalized,

    20                                GrGLsizei stride,

    21                                GrGLvoid* offset) {

    22     SkASSERT(index >= 0 && index < fAttribArrayStates.count());

    23     AttribArrayState* array = &fAttribArrayStates[index];

    24     if (!array->fEnableIsValid || !array->fEnabled) {

    25         GR_GL_CALL(gpu->glInterface(), EnableVertexAttribArray(index));

    26         array->fEnableIsValid = true;

    27         array->fEnabled = true;

    28     }

    29     if (!array->fAttribPointerIsValid ||

    30         array->fVertexBufferID != buffer->bufferID() ||

    31         array->fSize != size ||

    32         array->fNormalized != normalized ||

    33         array->fStride != stride ||

    34         array->fOffset != offset) {

    36         buffer->bind();

    37         GR_GL_CALL(gpu->glInterface(), VertexAttribPointer(index,

    38                                                            size,

    39                                                            type,

    40                                                            normalized,

    41                                                            stride,

    42                                                            offset));

    43         array->fAttribPointerIsValid = true;

    44         array->fVertexBufferID = buffer->bufferID();

    45         array->fSize = size;

    46         array->fNormalized = normalized;

    47         array->fStride = stride;

    48         array->fOffset = offset;

    49     }

    50 }

    52 void GrGLAttribArrayState::disableUnusedArrays(const GrGpuGL* gpu, uint64_t usedMask) {

    53     int count = fAttribArrayStates.count();

    54     for (int i = 0; i < count; ++i) {

    55         if (!(usedMask & 0x1)) {

    56             if (!fAttribArrayStates[i].fEnableIsValid || fAttribArrayStates[i].fEnabled) {

    57                 GR_GL_CALL(gpu->glInterface(), DisableVertexAttribArray(i));

    58                 fAttribArrayStates[i].fEnableIsValid = true;

    59                 fAttribArrayStates[i].fEnabled = false;

    60             }

    61         } else {

    62             SkASSERT(fAttribArrayStates[i].fEnableIsValid && fAttribArrayStates[i].fEnabled);

    63         }

    64         // if the count is greater than 64 then this will become 0 and we will disable arrays 64+.

    65         usedMask >>= 1;

    66     }

    67 }

    69 ///////////////////////////////////////////////////////////////////////////////////////////////////

    71 GrGLVertexArray::GrGLVertexArray(GrGpuGL* gpu, GrGLint id, int attribCount)

    72     : GrResource(gpu, false)

    73     , fID(id)

    74     , fAttribArrays(attribCount)

    75     , fIndexBufferIDIsValid(false) {

    76 }

    78 void GrGLVertexArray::onAbandon() {

    79     fID = 0;

    80     INHERITED::onAbandon();

    81 }

    83 void GrGLVertexArray::onRelease() {

    84     if (0 != fID) {

    85         GL_CALL(DeleteVertexArrays(1, &fID));

    86         GPUGL->notifyVertexArrayDelete(fID);

    87         fID = 0;

    88     }

    89     INHERITED::onRelease();

    90 }

    92 GrGLAttribArrayState* GrGLVertexArray::bind() {

    93     if (0 == fID) {

    94         return NULL;

    95     }

    96     GPUGL->bindVertexArray(fID);

    97     return &fAttribArrays;

    98 }

   100 GrGLAttribArrayState* GrGLVertexArray::bindWithIndexBuffer(const GrGLIndexBuffer* buffer) {

   101     GrGLAttribArrayState* state = this->bind();

   102     if (NULL != state && NULL != buffer) {

   103         GrGLuint bufferID = buffer->bufferID();

   104         if (!fIndexBufferIDIsValid || bufferID != fIndexBufferID) {

   105             GL_CALL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, bufferID));

   106             fIndexBufferIDIsValid = true;

   107             fIndexBufferID = bufferID;

   108         }

   109     }

   110     return state;

   111 }

   113 void GrGLVertexArray::notifyIndexBufferDelete(GrGLuint bufferID) {

   114     if (fIndexBufferIDIsValid && bufferID == fIndexBufferID) {

   115         fIndexBufferID = 0;

   116     }

   117  }

   119 void GrGLVertexArray::invalidateCachedState() {

   120     fAttribArrays.invalidate();

   121     fIndexBufferIDIsValid = false;

   122 }

The Tor Browser / file revision