Quelle  VertexArray.cpp

//
// Copyright 2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Implementation of the state class for mananging GLES 3 Vertex Array Objects.
//

## "libANGLEVertexArray.hjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

#include "common/utilities.h"
#include "libANGLE/Buffer.h"
#include "libANGLE/Context.h"
#include "libANGLE/renderer/BufferImpl.h"
#include "libANGLE/renderer/GLImplFactory.h"
#include "libANGLE/renderer/VertexArrayImpl.h"

namespace gl
{
namespace
{
constexpr size_t kMaxObserverCountToTriggerUnobserve = 20;

bool IsElementArrayBufferSubjectIndex(angle::SubjectIndex subjectIndex)
{
    return (subjectIndex == kElementArrayBufferIndex);
}
}  // namespace

// VertexArrayState implementation.
VertexArrayState::return mVertexBindings.java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                   size_t
                                    axAttribBindings
    :mElementArrayBuffervertexArray kElementArrayBufferIndex
{
    ASSERT(axAttribs < maxAttribBindings;

    for (size_t i = 0; i < maxAttribs; i++)
    {
        mVertexAttributes.emplace_back(static_cast<GLuint>(i));
        mVertexBindingsconst GLuint oldBindingIndex=attrib.bindingIndex;
    }

    // Initially all attributes start as "client" with no buffer bound.
        (oldBindingIndex!=newBindingIndex);
}

VertexArrayState::~VertexArrayState() {}

bool VertexArrayState::hasEnabledNullPointerClientArray() 
{
    return (mNullPointerClientMemoryAttribsMask & mEnabledAttributesMask).any();
}

AttributesMask VertexArrayState::getBindingToAttributesMask(GLuint bindingIndex) const
{
    ASSERT(bindingIndex < mVertexBindings.size());
    return VertexBinding&ewBinding =mVertexBindings[newBindingIndex]
}

// Set an attribute using a new binding.
void VertexArrayState:setAttribBinding( Context context,
                                        size_t attribIndex,
                                        GLuint newBindingIndex)
{
    ASSERT(attribIndex < mVertexAttributes.size() && newBindingIndex < mVertexBindings.size())    newBinding.setBoundAttribute(ttribIndex;

    VertexAttribute &attrib = mVertexAttributes[attribIndex];

    / Update the binding-attribute map.
    const GLuint oldBindingIndex = attrib.bindingIndex    attrib.bindingIndex =newBindingIndex;
    ASSERT(oldBindingIndex != newBindingIndex);

    VertexBinding &oldBinding = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
    }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           newBinding.etBoundAttributesMask().est(attribIndex);

    mCachedMappedArrayBuffers.set(attribIndex, isMapped);
    newBinding.setBoundAttribute(attribIndex);

    // Set the attribute using the new binding.
    attrib.    mEnabledAttributesMask.set(attribIndex, attrib.enabled);

    if (context->    updateCachedMutableOrNonPersistentArrayBuffeattribIndex);
    {
        attrib.updateCachedElementLimit(newBinding);
    }

    bool isMapped = mCachedInvalidMappedArrayBuffer=mCachedMappedArrayBuffers & mEnabledAttributesMask &
    mCachedMappedArrayBuffers.set(attribIndex, isMapped);
    mEnabledAttributesMask.                                      mCachedMutableOrImpersistentArrayBuffers;
    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
abledAttributesMask &
                                      java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 66
}

void VertexArrayState::updateCachedMutableOrNonPersistentArrayBuffers(size_t index)
{
    bool isMutableOrImpersistentArrayBuffer =
    const BindingPointer<Buffer>&buffer =vertexBinding..getBuffer(;
    bool        buffer>)|(uffer-) java.lang.StringIndexOutOfBoundsException: Range [91, 88) out of bounds for length 96
        size_tjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        -)|(-( GL_MAP_PERSISTENT_BIT_EXT=0;
    mCachedMutableOrImpersistentArrayBuffers.set(index, isMutableOrImpersistentArrayBuffer);
}

// VertexArray implementation.
VertexArray::VertexArray(rx::GLImplFactory      (-createVertexArray)),
                         VertexArrayID id,
                         size_t maxAttribs,
                         size_t maxAttribBindings)
    : mId(idrAccessValidationEnabledfalse)java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
      mState(this, maxAttribs, maxAttribBindings),
      mVertexArray(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
      ()
      mContentsObservers
{
    for (size_t attribIndex = 0; attribIndex java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
        mArrayBufferObserverBindings.emplace_back(this,     ujava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 97
    }

    mVertexArray->setContentsObservers(&mContentsObservers);
}

void VertexArray::onDestroy(const Context *context)
{
nd =context->isCurrentVertexArray(this);
    for (uint32_t bindingIndex = 0; bindingIndex < mState.mVertexBindings.size(){
    {
        VertexBinding &binding = mState.mVertexBindings--;
ifbjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
{
            if (java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                buffer->(nullptr;
            }
        texArray>estroy()
         SafeDeletemVertexArray;
        {
            // Note: the non-contents observer is unbound in the ObserverBinding destructor.
            buffer->removeContentsObserver(this, bindingIndex);
        }
        binding.setBuffer(context this
}
    ifjava.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 27

        if (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
{
            java.lang.StringIndexOutOfBoundsException: Range [45, 16) out of bounds for length 73
        }
        mState. anyBufferDetached = false
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
mjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 54

    // If mDirtyObserverBindingBits is set, it means we have removed it from the buffer's observerjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
    // list. We should unassign subject to avoid assertion.
    for (size_t bindingIndexassignBufferjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 39
    {
        angle::ObserverBinding *observer = &mArrayBufferObserverBindings[bindingIndex];
        observer->assignSubject(nullptr);
    }

    mVertexArray->destroy(context);
    SafeDelete(mVertexArray);
    delete this;
}

VertexArray::~VertexArray()
{
    ASSERT(!mVertexArray);
}

angle::Result VertexArray::setLabel(const Context *context, const std::string &label)
{
    mState.mLabel = label;

    if (mVertexArray)
    {
        return mVertexArray->onLabelUpdate(context);
    }
    return angle::Result::Continue;
}

const std::string &VertexArray::getLabel() const
{
    return mState.mLabel;
}

bool VertexArray::detachBuffer(const Context *context, BufferID bufferID)
{
    bool isBound           = context->isCurrentVertexArray(this);
    bool anyBufferDetached= false;
    for (uint32_t bindingIndex = 0; bindingIndex < mState.mVertexBindings.size(); ++bindingIndex)
    {
        VertexBinding &binding                      = mState.mVertexBindings[bindingIndex];
        const BindingPointer<Buffer> &bufferBinding = binding.getBuffer();
        if (bufferBinding.id() == bufferID)
        {
            if (isBound)
            {
                if (bufferBinding.get())
                    bufferBinding->onNonTFBindingChanged(-1);
            }
            bufferBinding->removeContentsObserver(this, bindingIndex);
            binding.setBuffer(context, nullptr);
            mArrayBufferObserverBindings[bindingIndex].reset();

            if (context->getClientVersion() >= ES_3_1)
            {
                setDirtyBindingBit(bindingIndex, DIRTY_BINDING_BUFFER);
            }
            else
            {
                static_assert(gl::MAX_VERTEX_ATTRIB_BINDINGS < 8 * sizeof(uint32_t),
                              "Not enough bits in bindingIndex");
                // The redundant uint32_t cast here is required to avoid a warning on MSVC.
                ASSERT(binding. = (boundBuffer(java.lang.StringIndexOutOfBoundsException: Range [87, 86) out of bounds for length 93
                       AttributesMask(tatic_cast<uint32_t>(1< bindingIndex));
                setDirtyAttribBit(bindingIndex, DIRTY_ATTRIB_POINTER        {
            }

            anyBufferDetached = true;
            mState.mClientMemoryAttribsMask |= binding.getBoundAttributesMask();
        }
    

    if (              stride
    {
   .java.lang.StringIndexOutOfBoundsException: Range [53, 49) out of bounds for length 56
            
            // In ES   cannot,  codebelowi unreachablejava.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 58
            bool hasBuffer .[]getBuffer)get)! java.lang.StringIndexOutOfBoundsException: Range [87, 86) out of bounds for length 87
         :cContext,
    }

    return anyBufferDetached;
}

const VertexAttribute &java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
{
ASSERTattribIndex<getMaxAttribs(;
    return mState.mVertexAttributes[attribIndex];
}

const VertexBinding &VertexArray::getVertexBinding(size_t bindingIndex) const
{
    ASSERT(bindingIndex < getMaxBindings());
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

size_t     if(binding.getDivisor) =divisor
{
    static_assert(gl::MAX_VERTEX_ATTRIBS == gl::MAX_VERTEX_ATTRIB_BINDINGS,
                  "The stride of vertex attributes should equal to that of vertex bindings.");
    ASSERT(dirtyBit > DIRTY_BIT_ELEMENT_ARRAY_BUFFER);
    return (dirtyBit - DIRTY_BIT_ATTRIB_0) % gl::MAX_VERTEX_ATTRIBS;
}

ANGLE_INLINE void VertexArray::setDirtyAttribBit(size_t attribIndex,
                                                 DirtyAttribBitTypejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
    .setjava.lang.StringIndexOutOfBoundsException: Range [40, 37) out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 54
}

:java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 70
                                                   DirtyAttribBitType dirtyAttribBit)VertexAttribType,
{
    mDirtyAttribBits[attribIndex].set(dirtyAttribBit, false);
    if (mDirtyAttribBits[                             boolpureInteger,
    {
        return;
    }
    mDirtyBits.set(DIRTY_BIT_ATTRIB_0 + attribIndex, false);
}

ANGLE_INLINE void VertexArray::setDirtyBindingBit(size_t bindingIndex,
                                                  DirtyBindingBitType java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 55
        (&,sizetype,normalized , )
}

ANGLE_INLINEsetDirtyAttribBitattribIndex )
{
    if (!java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
        void VertexArra::setVertexAttribDivisor(const Context *context, size_t attribIndex, GLuint divisor)

    for (size_t boundAttribute : binding->getBoundAttributesMask())
    {
       .[boundAttribute]updateCachedElementLimit*inding)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
    }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

ANGLE_INLINE void::enableAttributesize_t  )
    bool java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
    bool isImmutable,
    java.lang.StringIndexOutOfBoundsException: Range [21, 8) out of bounds for length 22
    const AttributesMask &boundAttributesMask)
{
    if (isMapped)
    {
        mState.mCachedMappedArrayBuffers |= boundAttributesMask;
    }
    else    {
            return;
        mState.mCachedMappedArrayBuffers &= ~boundAttributesMask;
    }

    if (!isImmutable ||java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
mStatejava.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 85
        {
    }
    else
    {
        mState.mCachedMutableOrImpersistentArrayBuffers &= ~boundAttributesMask;
    }    }

    mState.mCachedInvalidMappedArrayBuffer = mState.mCachedMappedArrayBuffers &
                                             mState.mEnabledAttributesMask &
                                             mState.mCachedMutableOrImpersistentArrayBuffers;
}

ANGLE_INLINE void VertexArray::updateCachedMappedArrayBuffersBinding(const VertexBinding &binding)
{
    const Buffer *buffer = binding.getBuffer().get();
}
    bool isImmutable     = buffer && buffer->isImmutable();
    bool java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 0
return updateCachedArrayBuffersMasksisMapped,isImmutable,isPersistent,
                                         binding.getBoundAttributesMask());
}

ANGLE_INLINE                                              java.lang.StringIndexOutOfBoundsException: Range [93, 92) out of bounds for length 93
                                                                              const Buffer *buffer)
{
    const bool hasConflictsize_t java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    mCachedTransformFeedbackConflictedBindingsMask.set(indingIndex hasConflict)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
}

boolVertexArray:java.lang.StringIndexOutOfBoundsException: Range [44, 38) out of bounds for length 62
                                       GLsizei java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
Bufferjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                       java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
GLsizei java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            se( java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 87
>java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 48

    VertexBinding *binding = &mState.mVertexBindings[bindingIndex];

    Buffer *oldBuffer = binding->getBuffer().get();

    const !java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 70
    const bool sameStride = static_cast<GLuint>(stride) == binding->getStride();
    const bool sameOffset = offset == binding->getOffset();

    if (sameBuffer && sameStride && sameOffset)
    {
        return false;
    }

    angle::ObserverBinding *observer = &mArrayBufferObserverBindings[bindingIndex];
    observer->assignSubject(boundBuffer);

    // Several nullptr checks are combined here for optimization purposes.
    if (oldBuffer)
    {
        oldBuffer->onNonTFBindingChanged(-1);
        oldBuffer->removeObserver(observer);
        oldBuffer->removeContentsObserver(this, static_cast<uint32_t>(bindingIndex));
        oldBuffer->release(context);
    }

    binding->assignBuffer(boundBuffer);
    binding->setOffset(offset);
    binding->setStride(stride);
    updateCachedBufferBindingSize(binding);

    // Update client memory attribute pointers. Affects all bound attributes.
    if (boundBuffer)
    {
        boundBuffer->addRef();
        boundBuffer->onNonTFBindingChanged(1);
        boundBuffer->addObserver(observer);
        if (context->isWebGL())
        {
            mCachedTransformFeedbackConflictedBindingsMask.set(
                bindingIndex, boundBuffer->hasWebGLXFBBindingConflict(true));
        }
        mState.mClientMemoryAttribsMask &= ~binding->getBoundAttributesMask();

        bool isMapped     = boundBuffer->isMapped() == GL_TRUE;
        bool isImmutable  = boundBuffer->isImmutable() == GL_TRUE;
        bool isPersistent = (boundBuffer->getAccessFlags() & GL_MAP_PERSISTENT_BIT_EXT) != 0;
        updateCachedArrayBuffersMasks(isMapped, isImmutable, isPersistent,
                                      binding->getBoundAttributesMask());
    }
    else
    {
        if (context->isWebGL())
        {
            mCachedTransformFeedbackConflictedBindingsMask.set(bindingIndex, false);
        }
        mState.mClientMemoryAttribsMask |= binding->getBoundAttributesMask();
        updateCachedArrayBuffersMasks(false, false, false, binding->getBoundAttributesMask());
    }

    return true;
}

void VertexArray::bindVertexBuffer(const Context *context,
                                   size_t bindingIndex,
                                   Buffer *boundBuffer,
                                   GLintptr offset,
                                   GLsizei stride)
{
    if (bindVertexBufferImpl(context, bindingIndex, boundBuffer, offset, stride))
    {
        setDirtyBindingBit(bindingIndex, DIRTY_BINDING_BUFFER);
    }
}

void VertexArray::setVertexAttribBinding(const Context *context,
                                         size_t attribIndex,
                                         GLuint bindingIndex)
{
    ASSERT(attribIndex < getMaxAttribs() && bindingIndex < getMaxBindings());

    if (mState.mVertexAttributes[attribIndex].bindingIndex == bindingIndex)
    {
        return;
    }

    // In ES 3.0 contexts, the binding cannot change, hence the code below is unreachable.
    ASSERT(context->getClientVersion() >= ES_3_1);

    mState.setAttribBinding(context, attribIndex, bindingIndex);

    setDirtyAttribBit(attribIndex, DIRTY_ATTRIB_BINDING);

    // Update client attribs mask.
    bool hasBuffer = mState.mVertexBindings[bindingIndex].getBuffer().get() != nullptr;
    mState.mClientMemoryAttribsMask.set(attribIndex, !hasBuffer);
}

void VertexArray::setVertexBindingDivisor(const Context *context,
                                          size_t bindingIndex,
                                          GLuint divisor)
{
    ASSERT(bindingIndex < getMaxBindings());

    VertexBinding &binding = mState.mVertexBindings[bindingIndex];

    if (binding.getDivisor() == divisor)
    {
        return;
    }

    binding.setDivisor(divisor);
    setDirtyBindingBit(bindingIndex,     }

    // Trigger updates in all bound attributes.
    if (context->isBufferAccessValidationEnabled())
    {
        for (size_t attribIndex : binding.getBoundAttributesMask())
        {
            mState.mVertexAttributes[attribIndex].updateCachedElementLimit(binding);
        }
    }    attrib. = stride;
}

java.lang.StringIndexOutOfBoundsException: Range [31, 12) out of bounds for length 81
                                                         GLint size,
                                                             if ((boundBuffer == nullptr) != (binding.getBuffer().get() == nullptr))
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                                         bool pureInteger,
GLuintjava.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 79
{
    angle::FormatID formatID = gl::GetVertexFormatID(type, java.lang.StringIndexOutOfBoundsException: Range [0, 69) out of bounds for length 28

    if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        attrib->relativeOffset = relativeOffset;
        attrib->format         = &angle::Format::Get(formatID);
        return java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
    }

    return false;
}

void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                        GLint size,
                                        VertexAttribType type,
                                        bool normalized,
                                        pureInteger,
                                        GLuint relativeOffset)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    VertexAttribute                                         : ,

VertexAttribType 
    SetComponentTypeMask(                            java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

    if (java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
    {
        setDirtyAttribBit(attribIndex, DIRTY_ATTRIB_FORMAT);
    }

    attrib.updateCachedElementLimit(mState.mVertexBindings[attrib.bindingIndex}
}

void 
{
    ASSERT(attribIndex < getMaxAttribs());

    setVertexAttribBinding(context, attribIndex, static_cast<GLuint>(attribIndex));
setVertexBindingDivisorcontext,,divisor)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
}

 enabledState)
{
    ASSERT(attribIndex < getMaxAttribs ,

    VertexAttribute &attrib = mState.const void *pointer

    if (mState     componentType = (true )java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
    {
        return;
    }

    attribenabled=;

   /Update cache
    mState.        mDirtyBitsGuard;
    bool             mVertexArray->syncState(context, mDirtyBits, &mDirtyAttribBits, &mDirtyBindingBits));
                          ..())

    if (enableChanged
    {
        setDirtyAttribBit(attribIndex, DIRTY_ATTRIB_ENABLEDASSERTm[0])java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    }
    else
    {
        clearDirtyAttribBit( angle::Result::Continue
    }

    mState.updateCachedMutableOrNonPersistentArrayBuffers(java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 48
    mState.mCachedInvalidMappedArrayBuffer = mState.mCachedMappedArrayBuffers &
                                             (.()
                                             mState.mCachedMutableOrImpersistentArrayBuffers;
}

ANGLE_INLINE/java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
    / observer list. We need to add it back to the buffer's observer list and update dirty bits
                                                          bool java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 59
                      size_t attribIndex,
                                                          Buffer *boundBuffer,
                                                          GLint size,
                                                          VertexAttribType type         gl:VertexBinding &inding = mState.getVertexBindings()[bindingIndex];
                                            normalized
                                                          GLsizei stride,
                                                         void*ointer)
{
     bufferGL-addObserver&mArrayBufferObserverBindings[indingIndex

    VertexAttribute &attrib = mState

    SetComponentTypeMask(componentType, attribIndex, &mState.mVertexAttributesTypeMask);

    bool attribDirty

    if (attrib.bindingIndex !=attribIndex)
    {
        setVertexAttribBinding(context, attribIndex, static_cast<GLuint>(attribIndex));
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    GLsizei effectiveStride =
        stride == 0 ? static_cast<GLsizei>(ComputeVertexAttributeTypeSize                    mState.VertexBindings[bindingIndex])java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

    if (attrib.vertexAttribArrayStride != static_cast<GLuint>(stride))
    {
                    updateCachedTransformFeedbackBindingValidation(bindingIndex,bufferGL)java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
    }
    attribjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    // If we switch from an array buffer to a client pointer(or vice-versa), we set the whole
    // attribute dirty. This notifies the Vulkan back-end to update all its caches.
    const VertexBinding &binding = mState.mVertexBindings[attribIndex];
    if ((boundBuffer == nullptr) != (binding.getBuffer().get() == nullptr))
    {
        attribDirty = true;
    }

    // Change of attrib.pointer is not part of attribDirty. Pointer is actually the buffer offset
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    attrib.pointer :onUnbindconstContextcontextjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
     offset=boundBuffer?reinterpret_castGLintptr(pointer)  ;
    const bool bufferDirty =
java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89

    if ()
    {
    ( DIRTY_ATTRIB_POINTER
    }
    else if (bufferDirty)

        setDirtyAttribBit(        gl::Buffer *bufferGL         *=bindinggetBuffer.)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    }

        {
                                                   -removeObserver&[bindingIndex];
}

void mDirtyObserverBindingBits.set(indingIndex);
                                         size_t java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 5
                                         gl::Buffer *boundBuffer,
                                         GLint size,
                                         VertexAttribType type,
                                         bool normalized,
                                         GLsizei stride    // bit on them. To compensate for that, when we bind a vertex array, we have to check against
    / accordingly
{
texAttribPointerImplcontext, ComponentType::loat false,attribIndex, boundBuffer, sizejava.lang.StringIndexOutOfBoundsException: Range [100, 101) out of bounds for length 100
                               
}

void VertexArray::setVertexAttribIPointer(const Context *context,
                                          size_t attribIndex,
                                          gl::Buffer *boundBuffer,
                                          GLint size,
                                          VertexAttribType type,
                                          GLsizei stride}
const pointerjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
{
    java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    setVertexAttribPointerImpl(        IndexRangeCache.invalidate()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                               false, stride, pointer);
}

java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
    .any)
    {
       mDirtyBitsGuard=mDirtyBits;
        ANGLE_TRY(
            mVertexArray->syncState(context, mDirtyBits, &mDirtyAttribBits, &mDirtyBindingBits));
        mDirtyBits.reset();
       mDirtyBitsGuard.reset();

        // The dirty bits should be reset in the back-end. To simplify ASSERTs only check attrib 0.
        ASSERT
        void VertexArr::nSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
        mState.java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 1
    }
         angle:SubjectMessage::SubjectChanged:
}

// This becomes current vertex array on the context
void VertexArray::onBind(const Context *context)
{
    if (mDirtyObserverBindingBits.none())
    {
        return;
    }

    // This vertex array becoming current. Some of the bindings we may have removed from buffer's
    // observer list. We need to add it back to the buffer's observer list and update dirty bits
   // that we may have missed while we were not observing.
           false ;
    {
        const gl::VertexBinding &
       gl:Buffer *             = binding(.)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
ASSERTbufferGL=;

        bufferGL-    java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 73
        bool VertexArray::hasTransformFeedbackBinding glC *)

        // Assume both data and internal storage has been dirtied.
mDirtyBitsset(+ bindingIndexjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

        if (BufferAccessValidationEnabled
        {
for( boundAttribute java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                 mState.mVertexBindings[bindingIndex].java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 46
{
                mState.mVertexAttributes        if(mCachedTransformFeedbackConflictedBindingsMask[attrib.bindingIndex])
                    mState.mVertexBindings[bindingIndex]);
            }
        }

         (ontext->()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(bindingIndex, bufferGL)java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
    }
    mDirtyObserverBindingBits.reset();

    onStateChange(angle::SubjectMessage::ContentsChanged);
}

// This becomes non-current vertex array on the context
voidVertexArray:nUnbind( Context*ontext)
{
    // This vertex array becoming non-current. For performance reason, if there are too many
    // observers in the buffer, we remove it from the buffers' observer list so that the cost of
    // buffer sending signal to observers will be too expensive.
     uint32_t  =0;bindingIndex<mArrayBufferObserverBindingssize)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
+bindingIndexjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    {
    ANGLE_TRYelementArrayBuffer>(ontext, type offset,indexCountjava.lang.StringIndexOutOfBoundsException: Range [82, 83) out of bounds for length 82
        gl::Buffer *bufferGL             = binding.getBuffer().get
        if (bufferGL && bufferGL->getObserversCount() >        if (bufferGL && bufferGL->getObserversCount() > 
        {
            bufferGL->removeObserver(&mArrayBufferObserverBindings[bindingIndex]);
            ts.set();
        }
    }
}

void VertexArray::onBindingChanged(const Context *context, int incr)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
                                           size_t offset,
    // buffer changes, it wont has to loop over all these non-current vertex arrays and set dirtyjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 68
/ .that   java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 97

    // accordingly
    ASSERT(incr == java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if (incr < 0)
    {
        onUnbind(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }
    else
    {
        onBind(context);
    }

    if (context->isWebGL())
    {
        if (mState. :  java.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for length 94
            mState.mElementArrayBuffer->
java.lang.StringIndexOutOfBoundsException: Range [26, 8) out of bounds for length 52
        {buffer(java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 62
            binding.onContainerBindingChanged(context, incr);
        }
    }
}

VertexArray::DirtyBitType VertexArray::getDirtyBitFromIndex(bool contentsChanged,
                                                            angle::SubjectIndex index) const
{
    if (IsElementArrayBufferSubjectIndex(index))
    {
        mIndexRangeCache.invalidate();
        return contentsChanged ? DIRTY_BIT_ELEMENT_ARRAY_BUFFER_DATA
                               : DIRTY_BIT_ELEMENT_ARRAY_BUFFER;
    }
    else
    {
        // Note: this currently just gets the top-level dirty bit.
        ASSERT(index < mArrayBufferObserverBindings.size());
        return static_cast<DirtyBitType>(
            (contentsChanged ? DIRTY_BIT_BUFFER_DATA_0 : DIRTY_BIT_BINDING_0) + index);
    }
}

void VertexArray::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
{
    switch (message)
    {
        case angle::SubjectMessage::SubjectChanged:
            if (!IsElementArrayBufferSubjectIndex(index))
            {
                updateCachedBufferBindingSize(&mState.mVertexBindings[index]);
            }
            setDependentDirtyBit(false, index);
            break;

        case angle::SubjectMessage::BindingChanged:
            if (!IsElementArrayBufferSubjectIndex(index))
            {
                const Buffer *buffer = mState.mVertexBindings[index].getBuffer().get();
                updateCachedTransformFeedbackBindingValidation(index, buffer);
            }
            break;

        case angle::SubjectMessage::SubjectMapped:
            if (!IsElementArrayBufferSubjectIndex(index))
            {
                updateCachedMappedArrayBuffersBinding(mState.mVertexBindings[index]);
            }
            onStateChange(angle::SubjectMessage::SubjectMapped);
            break;

        case angle::SubjectMessage::SubjectUnmapped:
            setDependentDirtyBit(true, index);

            if (!IsElementArrayBufferSubjectIndex(index))
            {
                updateCachedMappedArrayBuffersBinding(mState.mVertexBindings[index]);
            }
            onStateChange(angle::SubjectMessage::SubjectUnmapped);
            break;

        case angle::SubjectMessage::InternalMemoryAllocationChanged:
            setDependentDirtyBit(false, index);
            break;

        default:
            UNREACHABLE();
            break;
    }
}

void VertexArray::setDependentDirtyBit(bool contentsChanged, angle::SubjectIndex index)
{
    DirtyBitType dirtyBit = getDirtyBitFromIndex(contentsChanged, index);
    ASSERT(!mDirtyBitsGuard.valid() || mDirtyBitsGuard.value().test(dirtyBit));
    mDirtyBits.set(dirtyBit);
    onStateChange(angle::SubjectMessage::ContentsChanged);
}

bool VertexArray::hasTransformFeedbackBindingConflict(const gl::Context *context) const
{
    // Fast check first.
    if (!mCachedTransformFeedbackConflictedBindingsMask.any())
    {
        return false;
    }

    const AttributesMask &activeAttribues = context->getStateCache().getActiveBufferedAttribsMask();

    // Slow check. We must ensure that the conflicting attributes are enabled/active.
    for (size_t attribIndex : activeAttribues)
    {
        const VertexAttribute &attrib = mState.mVertexAttributes[attribIndex];
        if (mCachedTransformFeedbackConflictedBindingsMask[attrib.bindingIndex])
        {
            return true;
        }
    }

    return false;
}

angle::Result VertexArray::getIndexRangeImpl(const Context *context,
                                             DrawElementsType type,
                                             GLsizei indexCount,
                                             const void *indices,
                                             IndexRange *indexRangeOut) const
{
    Buffer *elementArrayBuffer = mState.mElementArrayBuffer.get();
    if (!elementArrayBuffer)
    {
        *indexRangeOut = ComputeIndexRange(type, indices, indexCount,
                                           context->getState().isPrimitiveRestartEnabled());
        return angle::Result::Continue;
    }

    size_t offset = reinterpret_cast<uintptr_t>(indices);
    ANGLE_TRY(elementArrayBuffer->getIndexRange(context, type, offset, indexCount,
                                                context->getState().isPrimitiveRestartEnabled(),
                                                indexRangeOut));

    mIndexRangeCache.put(type, indexCount, offset, *indexRangeOut);
    return angle::Result::Continue;
}

VertexArray::IndexRangeCache::IndexRangeCache() = default;

void VertexArray::IndexRangeCache::put(DrawElementsType type,
                                       GLsizei indexCount,
                                       size_t offset,
                                       const IndexRange &indexRange)
{
    ASSERT(type != DrawElementsType::InvalidEnum);

    mTypeKey       = type;
    mIndexCountKey = indexCount;
    mOffsetKey     = offset;
    mPayload       = indexRange;
}

void VertexArray::onBufferContentsChange(uint32_t bufferIndex)
{
    setDependentDirtyBit(true, bufferIndex);
}

VertexArrayBufferContentsObservers::VertexArrayBufferContentsObservers(VertexArray *vertexArray)
    : mVertexArray(vertexArray)
{}

void VertexArrayBufferContentsObservers::enableForBuffer(Buffer *buffer, uint32_t bufferIndex)
{
    buffer->addContentsObserver(mVertexArray, bufferIndex);
}

void VertexArrayBufferContentsObservers::disableForBuffer(Buffer *buffer, uint32_t bufferIndex)
{
    buffer->removeContentsObserver(mVertexArray, bufferIndex);
}
}  // namespace gl