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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2019-09-21 14:10:35
  Hash : f703443b
  Message : Use Resource IDs in RefCountObject. This lets us use strongly typed IDs pretty much everywhere. Only one or two additional places still use GLuint IDs. Mostly for external queries and for Framebuffer Attachments. With some clever type reflection helpers lets us define a single template function for handling operator== and != for resource IDs. Refactor in preparation for more Capture/Replay work. Bug: angleproject:3611 Change-Id: I1c0c848e89eb8a4b769714d57686f816daf01634 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1815550 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: Tobin Ehlis <tobine@google.com>

• src/libANGLE/VertexArray.h

• //
  // 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.
  //
  // This class contains prototypes for representing GLES 3 Vertex Array Objects:
  //
  //   The buffer objects that are to be used by the vertex stage of the GL are collected
  //   together to form a vertex array object. All state related to the definition of data used
  //   by the vertex processor is encapsulated in a vertex array object.
  //
  
  #ifndef LIBANGLE_VERTEXARRAY_H_
  #define LIBANGLE_VERTEXARRAY_H_
  
  #include "common/Optional.h"
  #include "libANGLE/Constants.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Observer.h"
  #include "libANGLE/RefCountObject.h"
  #include "libANGLE/VertexAttribute.h"
  
  #include <vector>
  
  namespace rx
  {
  class GLImplFactory;
  class VertexArrayImpl;
  }  // namespace rx
  
  namespace gl
  {
  class Buffer;
  
  class VertexArrayState final : angle::NonCopyable
  {
    public:
      VertexArrayState(VertexArray *vertexArray, size_t maxAttribs, size_t maxBindings);
      ~VertexArrayState();
  
      const std::string &getLabel() const { return mLabel; }
  
      Buffer *getElementArrayBuffer() const { return mElementArrayBuffer.get(); }
      size_t getMaxAttribs() const { return mVertexAttributes.size(); }
      size_t getMaxBindings() const { return mVertexBindings.size(); }
      const AttributesMask &getEnabledAttributesMask() const { return mEnabledAttributesMask; }
      const std::vector<VertexAttribute> &getVertexAttributes() const { return mVertexAttributes; }
      const VertexAttribute &getVertexAttribute(size_t attribIndex) const
      {
          return mVertexAttributes[attribIndex];
      }
      const std::vector<VertexBinding> &getVertexBindings() const { return mVertexBindings; }
      const VertexBinding &getVertexBinding(size_t bindingIndex) const
      {
          return mVertexBindings[bindingIndex];
      }
      const VertexBinding &getBindingFromAttribIndex(size_t attribIndex) const
      {
          return mVertexBindings[mVertexAttributes[attribIndex].bindingIndex];
      }
      size_t getBindingIndexFromAttribIndex(size_t attribIndex) const
      {
          return mVertexAttributes[attribIndex].bindingIndex;
      }
  
      void setAttribBinding(const Context *context, size_t attribIndex, GLuint newBindingIndex);
  
      // Extra validation performed on the Vertex Array.
      bool hasEnabledNullPointerClientArray() const;
  
      // Get all the attributes in an AttributesMask that are using the given binding.
      AttributesMask getBindingToAttributesMask(GLuint bindingIndex) const;
  
    private:
      friend class VertexArray;
      std::string mLabel;
      std::vector<VertexAttribute> mVertexAttributes;
      SubjectBindingPointer<Buffer> mElementArrayBuffer;
      std::vector<VertexBinding> mVertexBindings;
      AttributesMask mEnabledAttributesMask;
      ComponentTypeMask mVertexAttributesTypeMask;
  
      // This is a performance optimization for buffer binding. Allows element array buffer updates.
      friend class State;
  
      // From the GLES 3.1 spec:
      // When a generic attribute array is sourced from client memory, the vertex attribute binding
      // state is ignored. Thus we don't have to worry about binding state when using client memory
      // attribs.
      gl::AttributesMask mClientMemoryAttribsMask;
      gl::AttributesMask mNullPointerClientMemoryAttribsMask;
  
      // Used for validation cache. Indexed by attribute.
      AttributesMask mCachedMappedArrayBuffers;
      AttributesMask mCachedEnabledMappedArrayBuffers;
  };
  
  class VertexArray final : public angle::ObserverInterface,
                            public LabeledObject,
                            public angle::Subject
  {
    public:
      // Dirty bits for VertexArrays use a heirarchical design. At the top level, each attribute
      // has a single dirty bit. Then an array of MAX_ATTRIBS dirty bits each has a dirty bit for
      // enabled/pointer/format/binding. Bindings are handled similarly. Note that because the
      // total number of dirty bits is 33, it will not be as fast on a 32-bit machine, which
      // can't support the advanced 64-bit scanning intrinsics. We could consider packing the
      // binding and attribute bits together if this becomes a problem.
      //
      // Special note on "DIRTY_ATTRIB_POINTER_BUFFER": this is a special case when the app
      // calls glVertexAttribPointer but only changes a VBO and/or offset binding. This allows
      // the Vulkan back-end to skip performing a pipeline change for performance.
      enum DirtyBitType
      {
          DIRTY_BIT_ELEMENT_ARRAY_BUFFER,
          DIRTY_BIT_ELEMENT_ARRAY_BUFFER_DATA,
  
          // Dirty bits for attributes.
          DIRTY_BIT_ATTRIB_0,
          DIRTY_BIT_ATTRIB_MAX = DIRTY_BIT_ATTRIB_0 + gl::MAX_VERTEX_ATTRIBS,
  
          // Dirty bits for bindings.
          DIRTY_BIT_BINDING_0   = DIRTY_BIT_ATTRIB_MAX,
          DIRTY_BIT_BINDING_MAX = DIRTY_BIT_BINDING_0 + gl::MAX_VERTEX_ATTRIB_BINDINGS,
  
          // We keep separate dirty bits for bound buffers whose data changed since last update.
          DIRTY_BIT_BUFFER_DATA_0   = DIRTY_BIT_BINDING_MAX,
          DIRTY_BIT_BUFFER_DATA_MAX = DIRTY_BIT_BUFFER_DATA_0 + gl::MAX_VERTEX_ATTRIB_BINDINGS,
  
          DIRTY_BIT_UNKNOWN = DIRTY_BIT_BUFFER_DATA_MAX,
          DIRTY_BIT_MAX     = DIRTY_BIT_UNKNOWN,
      };
  
      // We want to keep the number of dirty bits within 64 to keep iteration times fast.
      static_assert(DIRTY_BIT_MAX <= 64, "Too many vertex array dirty bits.");
  
      enum DirtyAttribBitType
      {
          DIRTY_ATTRIB_ENABLED,
          DIRTY_ATTRIB_POINTER,
          DIRTY_ATTRIB_FORMAT,
          DIRTY_ATTRIB_BINDING,
          DIRTY_ATTRIB_POINTER_BUFFER,
          DIRTY_ATTRIB_UNKNOWN,
          DIRTY_ATTRIB_MAX = DIRTY_ATTRIB_UNKNOWN,
      };
  
      enum DirtyBindingBitType
      {
          DIRTY_BINDING_BUFFER,
          DIRTY_BINDING_DIVISOR,
          DIRTY_BINDING_UNKNOWN,
          DIRTY_BINDING_MAX = DIRTY_BINDING_UNKNOWN,
      };
  
      using DirtyBits             = angle::BitSet<DIRTY_BIT_MAX>;
      using DirtyAttribBits       = angle::BitSet<DIRTY_ATTRIB_MAX>;
      using DirtyBindingBits      = angle::BitSet<DIRTY_BINDING_MAX>;
      using DirtyAttribBitsArray  = std::array<DirtyAttribBits, gl::MAX_VERTEX_ATTRIBS>;
      using DirtyBindingBitsArray = std::array<DirtyBindingBits, gl::MAX_VERTEX_ATTRIB_BINDINGS>;
  
      VertexArray(rx::GLImplFactory *factory,
                  VertexArrayID id,
                  size_t maxAttribs,
                  size_t maxAttribBindings);
  
      void onDestroy(const Context *context);
  
      VertexArrayID id() const { return mId; }
  
      void setLabel(const Context *context, const std::string &label) override;
      const std::string &getLabel() const override;
  
      const VertexBinding &getVertexBinding(size_t bindingIndex) const;
      const VertexAttribute &getVertexAttribute(size_t attribIndex) const;
      const VertexBinding &getBindingFromAttribIndex(size_t attribIndex) const
      {
          return mState.getBindingFromAttribIndex(attribIndex);
      }
  
      // Returns true if the function finds and detaches a bound buffer.
      bool detachBuffer(const Context *context, BufferID bufferID);
  
      void setVertexAttribDivisor(const Context *context, size_t index, GLuint divisor);
      void enableAttribute(size_t attribIndex, bool enabledState);
  
      void setVertexAttribPointer(const Context *context,
                                  size_t attribIndex,
                                  Buffer *boundBuffer,
                                  GLint size,
                                  VertexAttribType type,
                                  bool normalized,
                                  GLsizei stride,
                                  const void *pointer);
  
      void setVertexAttribIPointer(const Context *context,
                                   size_t attribIndex,
                                   Buffer *boundBuffer,
                                   GLint size,
                                   VertexAttribType type,
                                   GLsizei stride,
                                   const void *pointer);
  
      void setVertexAttribFormat(size_t attribIndex,
                                 GLint size,
                                 VertexAttribType type,
                                 bool normalized,
                                 bool pureInteger,
                                 GLuint relativeOffset);
      void bindVertexBuffer(const Context *context,
                            size_t bindingIndex,
                            Buffer *boundBuffer,
                            GLintptr offset,
                            GLsizei stride);
      void setVertexAttribBinding(const Context *context, size_t attribIndex, GLuint bindingIndex);
      void setVertexBindingDivisor(size_t bindingIndex, GLuint divisor);
  
      Buffer *getElementArrayBuffer() const { return mState.getElementArrayBuffer(); }
      size_t getMaxAttribs() const { return mState.getMaxAttribs(); }
      size_t getMaxBindings() const { return mState.getMaxBindings(); }
  
      const std::vector<VertexAttribute> &getVertexAttributes() const
      {
          return mState.getVertexAttributes();
      }
      const std::vector<VertexBinding> &getVertexBindings() const
      {
          return mState.getVertexBindings();
      }
  
      rx::VertexArrayImpl *getImplementation() const { return mVertexArray; }
  
      const AttributesMask &getEnabledAttributesMask() const
      {
          return mState.getEnabledAttributesMask();
      }
  
      gl::AttributesMask getClientAttribsMask() const { return mState.mClientMemoryAttribsMask; }
  
      bool hasEnabledNullPointerClientArray() const
      {
          return mState.hasEnabledNullPointerClientArray();
      }
  
      bool hasMappedEnabledArrayBuffer() const
      {
          return mState.mCachedEnabledMappedArrayBuffers.any();
      }
  
      // Observer implementation
      void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override;
  
      static size_t GetVertexIndexFromDirtyBit(size_t dirtyBit);
  
      angle::Result syncState(const Context *context);
      bool hasAnyDirtyBit() const { return mDirtyBits.any(); }
  
      ComponentTypeMask getAttributesTypeMask() const { return mState.mVertexAttributesTypeMask; }
      AttributesMask getAttributesMask() const { return mState.mEnabledAttributesMask; }
  
      void onBindingChanged(const Context *context, int incr);
      bool hasTransformFeedbackBindingConflict(const gl::Context *context) const;
  
      ANGLE_INLINE angle::Result getIndexRange(const Context *context,
                                               DrawElementsType type,
                                               GLsizei indexCount,
                                               const void *indices,
                                               IndexRange *indexRangeOut) const
      {
          Buffer *elementArrayBuffer = mState.mElementArrayBuffer.get();
          if (elementArrayBuffer && mIndexRangeCache.get(type, indexCount, indices, indexRangeOut))
          {
              return angle::Result::Continue;
          }
  
          return getIndexRangeImpl(context, type, indexCount, indices, indexRangeOut);
      }
  
      void setBufferAccessValidationEnabled(bool enabled)
      {
          mBufferAccessValidationEnabled = enabled;
      }
  
    private:
      ~VertexArray() override;
  
      // This is a performance optimization for buffer binding. Allows element array buffer updates.
      friend class State;
  
      void setDirtyAttribBit(size_t attribIndex, DirtyAttribBitType dirtyAttribBit);
      void setDirtyBindingBit(size_t bindingIndex, DirtyBindingBitType dirtyBindingBit);
  
      DirtyBitType getDirtyBitFromIndex(bool contentsChanged, angle::SubjectIndex index) const;
      void setDependentDirtyBit(bool contentsChanged, angle::SubjectIndex index);
  
      // These are used to optimize draw call validation.
      void updateCachedBufferBindingSize(VertexBinding *binding);
      void updateCachedTransformFeedbackBindingValidation(size_t bindingIndex, const Buffer *buffer);
      void updateCachedMappedArrayBuffers(bool isMapped, const AttributesMask &boundAttributesMask);
      void updateCachedMappedArrayBuffersBinding(const VertexBinding &binding);
  
      angle::Result getIndexRangeImpl(const Context *context,
                                      DrawElementsType type,
                                      GLsizei indexCount,
                                      const void *indices,
                                      IndexRange *indexRangeOut) const;
  
      void setVertexAttribPointerImpl(const Context *context,
                                      ComponentType componentType,
                                      bool pureInteger,
                                      size_t attribIndex,
                                      Buffer *boundBuffer,
                                      GLint size,
                                      VertexAttribType type,
                                      bool normalized,
                                      GLsizei stride,
                                      const void *pointer);
  
      // These two functions return true if the state was dirty.
      bool setVertexAttribFormatImpl(VertexAttribute *attrib,
                                     GLint size,
                                     VertexAttribType type,
                                     bool normalized,
                                     bool pureInteger,
                                     GLuint relativeOffset);
      bool bindVertexBufferImpl(const Context *context,
                                size_t bindingIndex,
                                Buffer *boundBuffer,
                                GLintptr offset,
                                GLsizei stride);
  
      VertexArrayID mId;
  
      VertexArrayState mState;
      DirtyBits mDirtyBits;
      DirtyAttribBitsArray mDirtyAttribBits;
      DirtyBindingBitsArray mDirtyBindingBits;
      Optional<DirtyBits> mDirtyBitsGuard;
  
      rx::VertexArrayImpl *mVertexArray;
  
      std::vector<angle::ObserverBinding> mArrayBufferObserverBindings;
  
      AttributesMask mCachedTransformFeedbackConflictedBindingsMask;
  
      class IndexRangeCache final : angle::NonCopyable
      {
        public:
          IndexRangeCache();
  
          void invalidate() { mTypeKey = DrawElementsType::InvalidEnum; }
  
          bool get(DrawElementsType type,
                   GLsizei indexCount,
                   const void *indices,
                   IndexRange *indexRangeOut)
          {
              size_t offset = reinterpret_cast<uintptr_t>(indices);
              if (mTypeKey == type && mIndexCountKey == indexCount && mOffsetKey == offset)
              {
                  *indexRangeOut = mPayload;
                  return true;
              }
  
              return false;
          }
  
          void put(DrawElementsType type,
                   GLsizei indexCount,
                   size_t offset,
                   const IndexRange &indexRange);
  
        private:
          DrawElementsType mTypeKey;
          GLsizei mIndexCountKey;
          size_t mOffsetKey;
          IndexRange mPayload;
      };
  
      mutable IndexRangeCache mIndexRangeCache;
      bool mBufferAccessValidationEnabled;
  };
  
  }  // namespace gl
  
  #endif  // LIBANGLE_VERTEXARRAY_H_