kc3-lang/angle/src/libANGLE/VertexArray.cpp

• Show log

  Commit

• Hash : dd5f27ee
  Author :
  Date : 2017-06-07T10:17:09
  

  Make VertexBinding's member variables private
  
  The patch decorates all members in VertexBinding as private and limits
  access to them only through getters and setters. This makes it easier to
  debug and keep track of any assignments to the class members.
  
  BUG=angleproject:2062
  TEST=angle_end2end_tests
  
  Change-Id: Iddd49063d060f136bc9cf11c313a5af0931d433c
  Reviewed-on: https://chromium-review.googlesource.com/530786
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/VertexArray.cpp

• //
  // Copyright (c) 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.
  //
  
  #include "libANGLE/VertexArray.h"
  #include "libANGLE/Buffer.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/renderer/GLImplFactory.h"
  #include "libANGLE/renderer/VertexArrayImpl.h"
  
  namespace gl
  {
  
  VertexArrayState::VertexArrayState(size_t maxAttribs, size_t maxAttribBindings)
      : mLabel(), mVertexBindings(maxAttribBindings), mMaxEnabledAttribute(0)
  {
      ASSERT(maxAttribs <= maxAttribBindings);
  
      for (size_t i = 0; i < maxAttribs; i++)
      {
          mVertexAttributes.emplace_back(static_cast<GLuint>(i));
      }
  }
  
  VertexArrayState::~VertexArrayState()
  {
      for (auto &binding : mVertexBindings)
      {
          binding.setBuffer(nullptr);
      }
      mElementArrayBuffer.set(nullptr);
  }
  
  VertexArray::VertexArray(rx::GLImplFactory *factory,
                           GLuint id,
                           size_t maxAttribs,
                           size_t maxAttribBindings)
      : mId(id),
        mState(maxAttribs, maxAttribBindings),
        mVertexArray(factory->createVertexArray(mState))
  {
  }
  
  VertexArray::~VertexArray()
  {
      SafeDelete(mVertexArray);
  }
  
  GLuint VertexArray::id() const
  {
      return mId;
  }
  
  void VertexArray::setLabel(const std::string &label)
  {
      mState.mLabel = label;
  }
  
  const std::string &VertexArray::getLabel() const
  {
      return mState.mLabel;
  }
  
  void VertexArray::detachBuffer(GLuint bufferName)
  {
      for (auto &binding : mState.mVertexBindings)
      {
          if (binding.getBuffer().id() == bufferName)
          {
              binding.setBuffer(nullptr);
          }
      }
  
      if (mState.mElementArrayBuffer.id() == bufferName)
      {
          mState.mElementArrayBuffer.set(nullptr);
      }
  }
  
  const VertexAttribute &VertexArray::getVertexAttribute(size_t attribIndex) const
  {
      ASSERT(attribIndex < getMaxAttribs());
      return mState.mVertexAttributes[attribIndex];
  }
  
  const VertexBinding &VertexArray::getVertexBinding(size_t bindingIndex) const
  {
      ASSERT(bindingIndex < getMaxBindings());
      return mState.mVertexBindings[bindingIndex];
  }
  
  size_t VertexArray::GetAttribIndex(size_t dirtyBit)
  {
      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_ENABLED) % gl::MAX_VERTEX_ATTRIBS;
  }
  
  void VertexArray::bindVertexBuffer(size_t bindingIndex,
                                     Buffer *boundBuffer,
                                     GLintptr offset,
                                     GLsizei stride)
  {
      ASSERT(bindingIndex < getMaxBindings());
  
      VertexBinding *binding = &mState.mVertexBindings[bindingIndex];
  
      binding->setBuffer(boundBuffer);
      binding->setOffset(offset);
      binding->setStride(stride);
      mDirtyBits.set(DIRTY_BIT_BINDING_0_BUFFER + bindingIndex);
  }
  
  void VertexArray::setVertexAttribBinding(size_t attribIndex, size_t bindingIndex)
  {
      ASSERT(attribIndex < getMaxAttribs() && bindingIndex < getMaxBindings());
  
      mState.mVertexAttributes[attribIndex].bindingIndex = static_cast<GLuint>(bindingIndex);
      mDirtyBits.set(DIRTY_BIT_ATTRIB_0_BINDING + attribIndex);
  }
  
  void VertexArray::setVertexBindingDivisor(size_t bindingIndex, GLuint divisor)
  {
      ASSERT(bindingIndex < getMaxBindings());
  
      mState.mVertexBindings[bindingIndex].setDivisor(divisor);
      mDirtyBits.set(DIRTY_BIT_BINDING_0_DIVISOR + bindingIndex);
  }
  
  void VertexArray::setVertexAttribFormat(size_t attribIndex,
                                          GLint size,
                                          GLenum type,
                                          bool normalized,
                                          bool pureInteger,
                                          GLintptr relativeOffset)
  {
      ASSERT(attribIndex < getMaxAttribs());
  
      VertexAttribute *attrib = &mState.mVertexAttributes[attribIndex];
  
      attrib->size           = size;
      attrib->type           = type;
      attrib->normalized     = normalized;
      attrib->pureInteger    = pureInteger;
      attrib->relativeOffset = relativeOffset;
      mDirtyBits.set(DIRTY_BIT_ATTRIB_0_FORMAT + attribIndex);
  }
  
  void VertexArray::setVertexAttribDivisor(size_t index, GLuint divisor)
  {
      ASSERT(index < getMaxAttribs());
  
      setVertexAttribBinding(index, index);
      setVertexBindingDivisor(index, divisor);
  }
  
  void VertexArray::enableAttribute(size_t attribIndex, bool enabledState)
  {
      ASSERT(attribIndex < getMaxAttribs());
  
      mState.mVertexAttributes[attribIndex].enabled = enabledState;
      mDirtyBits.set(DIRTY_BIT_ATTRIB_0_ENABLED + attribIndex);
  
      // Update state cache
      if (enabledState)
      {
          mState.mMaxEnabledAttribute = std::max(attribIndex + 1, mState.mMaxEnabledAttribute);
      }
      else if (mState.mMaxEnabledAttribute == attribIndex + 1)
      {
          while (mState.mMaxEnabledAttribute > 0 &&
                 !mState.mVertexAttributes[mState.mMaxEnabledAttribute - 1].enabled)
          {
              --mState.mMaxEnabledAttribute;
          }
      }
  }
  
  void VertexArray::setAttributeState(size_t attribIndex,
                                      gl::Buffer *boundBuffer,
                                      GLint size,
                                      GLenum type,
                                      bool normalized,
                                      bool pureInteger,
                                      GLsizei stride,
                                      const void *pointer)
  {
      ASSERT(attribIndex < getMaxAttribs());
  
      GLintptr offset = boundBuffer ? reinterpret_cast<GLintptr>(pointer) : 0;
  
      setVertexAttribFormat(attribIndex, size, type, normalized, pureInteger, 0);
      setVertexAttribBinding(attribIndex, attribIndex);
  
      VertexAttribute &attrib = mState.mVertexAttributes[attribIndex];
      GLsizei effectiveStride =
          stride != 0 ? stride : static_cast<GLsizei>(ComputeVertexAttributeTypeSize(attrib));
      attrib.pointer                 = pointer;
      attrib.vertexAttribArrayStride = stride;
  
      bindVertexBuffer(attribIndex, boundBuffer, offset, effectiveStride);
  
      mDirtyBits.set(DIRTY_BIT_ATTRIB_0_POINTER + attribIndex);
  }
  
  void VertexArray::setElementArrayBuffer(Buffer *buffer)
  {
      mState.mElementArrayBuffer.set(buffer);
      mDirtyBits.set(DIRTY_BIT_ELEMENT_ARRAY_BUFFER);
  }
  
  void VertexArray::syncImplState(const Context *context)
  {
      if (mDirtyBits.any())
      {
          mVertexArray->syncState(context, mDirtyBits);
          mDirtyBits.reset();
      }
  }
  
  }  // namespace gl
  

Download