kc3-lang/angle/src/libANGLE/renderer/vulkan/VertexArrayVk.h

• Show log

  Commit

• Hash : 46444b3d
  Author :
  Date : 2025-09-09T16:13:58
  

  Vulkan: Use VkVertexInputBindingDescription2EXT to store stride
  
  This is preparation for next CL. Since most driver supports
  VK_EXT_vertex_input_dynamic_state, which uses
  VkVertexInputBindingDescription2EXT and
  VkVertexInputAttributeDescription2EXT to send stride/divisor/offset to
  the vulkan driver, why not store these directly in these structs instead
  of store gl::AttribArray<> and copy then into
  VkVertexInputBindingDescription2EXT/VkVertexInputBindingDescription2EXT
  later. This CL only replaced mCurrentArrayBufferRelativeOffsets,
  mCurrentArrayBufferStrides, mCurrentArrayBufferDivisors with
  mVertexInputBindingDesc and mVertexInputAttribDesc. It still does the
  data copy, which means this CL is mostly a mechanical change. But it
  makes the next CL diff smaller.
  
  Bug: b/439073246
  Change-Id: Ie3c2034df07ea5e973b07a15f715fdb7c73ec04d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6933260
  Commit-Queue: Charlie Lao <cclao@google.com>
  Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/VertexArrayVk.h

• //
  // Copyright 2016 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.
  //
  // VertexArrayVk.h:
  //    Defines the class interface for VertexArrayVk, implementing VertexArrayImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_VERTEXARRAYVK_H_
  #define LIBANGLE_RENDERER_VULKAN_VERTEXARRAYVK_H_
  
  #include "libANGLE/renderer/VertexArrayImpl.h"
  #include "libANGLE/renderer/vulkan/UtilsVk.h"
  #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  
  namespace rx
  {
  enum class BufferBindingDirty
  {
      No,
      Yes,
  };
  
  struct AttributeRange
  {
      // Stream vertex attribute start pointer address.
      uintptr_t startAddr;
      // Stream vertex attribute end pointer address.
      uintptr_t endAddr;
      // Stream vertex attribute first used pointer address.
      // ie. startAddr + startVertex * stride.
      uintptr_t copyStartAddr;
      AttributeRange() : startAddr(0), endAddr(0), copyStartAddr(0) {}
      AttributeRange(uintptr_t start, uintptr_t end, uintptr_t copyStart)
          : startAddr(start), endAddr(end), copyStartAddr(copyStart)
      {}
  };
  
  ANGLE_INLINE bool operator<(const AttributeRange &a, const AttributeRange &b)
  {
      return a.startAddr == b.startAddr ? a.endAddr < b.endAddr : a.startAddr < b.startAddr;
  }
  
  class VertexArrayVk : public VertexArrayImpl
  {
    public:
      VertexArrayVk(ContextVk *contextVk,
                    const gl::VertexArrayState &state,
                    const gl::VertexArrayBuffers &vertexArrayBuffers);
      ~VertexArrayVk() override;
  
      void destroy(const gl::Context *context) override;
  
      gl::VertexArray::DirtyBits checkBufferForDirtyBits(
          const gl::Context *context,
          const gl::VertexArrayBufferBindingMask bufferBindingMask) override;
  
      angle::Result syncState(const gl::Context *context,
                              const gl::VertexArray::DirtyBits &dirtyBits,
                              gl::VertexArray::DirtyAttribBitsArray *attribBits,
                              gl::VertexArray::DirtyBindingBitsArray *bindingBits) override;
  
      angle::Result updateActiveAttribInfo(ContextVk *contextVk);
  
      angle::Result updateDefaultAttrib(ContextVk *contextVk, size_t attribIndex);
  
      angle::Result updateStreamedAttribs(const gl::Context *context,
                                          GLint firstVertex,
                                          GLsizei vertexOrIndexCount,
                                          GLsizei instanceCount,
                                          gl::DrawElementsType indexTypeOrInvalid,
                                          const void *indices);
  
      angle::Result handleLineLoop(ContextVk *contextVk,
                                   GLint firstVertex,
                                   GLsizei vertexOrIndexCount,
                                   gl::DrawElementsType indexTypeOrInvalid,
                                   const void *indices,
                                   vk::BufferHelper **indexBufferOut,
                                   uint32_t *indexCountOut);
  
      angle::Result handleLineLoopIndexIndirect(ContextVk *contextVk,
                                                gl::DrawElementsType glIndexType,
                                                vk::BufferHelper *srcIndexBuffer,
                                                vk::BufferHelper *srcIndirectBuffer,
                                                VkDeviceSize indirectBufferOffset,
                                                vk::BufferHelper **indexBufferOut,
                                                vk::BufferHelper **indirectBufferOut);
  
      angle::Result handleLineLoopIndirectDraw(const gl::Context *context,
                                               vk::BufferHelper *indirectBufferVk,
                                               VkDeviceSize indirectBufferOffset,
                                               vk::BufferHelper **indexBufferOut,
                                               vk::BufferHelper **indirectBufferOut);
  
      const gl::AttribArray<VkBuffer> &getCurrentArrayBufferHandles() const
      {
          return mCurrentArrayBufferHandles;
      }
  
      const gl::AttribArray<VkDeviceSize> &getCurrentArrayBufferOffsets() const
      {
          return mCurrentArrayBufferOffsets;
      }
  
      GLuint getCurrentArrayBufferRelativeOffset(size_t attribIndex) const
      {
          return mVertexInputAttribDesc[attribIndex].offset;
      }
  
      const gl::AttribArray<vk::BufferHelper *> &getCurrentArrayBuffers() const
      {
          return mCurrentArrayBuffers;
      }
  
      const gl::AttribArray<angle::FormatID> &getCurrentArrayBufferFormats() const
      {
          return mCurrentArrayBufferFormats;
      }
  
      GLuint getCurrentArrayBufferStride(size_t attribIndex) const
      {
          return mVertexInputBindingDesc[attribIndex].stride;
      }
  
      GLuint getCurrentArrayBufferDivisor(size_t attribIndex) const
      {
          return mVertexInputBindingDesc[attribIndex].divisor;
      }
  
      // Update mCurrentElementArrayBuffer based on the vertex array state
      void updateCurrentElementArrayBuffer();
  
      vk::BufferHelper *getCurrentElementArrayBuffer() const { return mCurrentElementArrayBuffer; }
  
      angle::Result convertIndexBufferGPU(ContextVk *contextVk,
                                          BufferVk *bufferVk,
                                          const void *indices);
  
      angle::Result convertIndexBufferIndirectGPU(ContextVk *contextVk,
                                                  vk::BufferHelper *srcIndirectBuf,
                                                  VkDeviceSize srcIndirectBufOffset,
                                                  vk::BufferHelper **indirectBufferVkOut);
  
      angle::Result convertIndexBufferCPU(ContextVk *contextVk,
                                          gl::DrawElementsType indexType,
                                          size_t indexCount,
                                          const void *sourcePointer,
                                          BufferBindingDirty *bufferBindingDirty);
  
      const gl::AttributesMask &getStreamingVertexAttribsMask() const
      {
          return mStreamingVertexAttribsMask;
      }
  
    private:
      gl::AttributesMask mergeClientAttribsRange(
          vk::Renderer *renderer,
          const gl::AttributesMask activeStreamedAttribs,
          size_t startVertex,
          size_t endVertex,
          std::array<AttributeRange, gl::MAX_VERTEX_ATTRIBS> &mergeRangesOut,
          std::array<size_t, gl::MAX_VERTEX_ATTRIBS> &mergedIndexesOut) const;
  
      void setDefaultPackedInput(ContextVk *contextVk,
                                 size_t attribIndex,
                                 angle::FormatID *formatOut);
  
      angle::Result convertVertexBufferGPU(ContextVk *contextVk,
                                           BufferVk *srcBuffer,
                                           VertexConversionBuffer *conversion,
                                           const angle::Format &srcFormat,
                                           const angle::Format &dstFormat);
      angle::Result convertVertexBufferCPU(ContextVk *contextVk,
                                           BufferVk *srcBuffer,
                                           VertexConversionBuffer *conversion,
                                           const angle::Format &srcFormat,
                                           const angle::Format &dstFormat,
                                           const VertexCopyFunction vertexLoadFunction);
  
      angle::Result syncDirtyEnabledAttrib(ContextVk *contextVk,
                                           const gl::VertexAttribute &attrib,
                                           const gl::VertexBinding &binding,
                                           size_t attribIndex,
                                           bool bufferOnly);
  
      angle::Result syncDirtyDisabledAttrib(ContextVk *contextVk,
                                            const gl::VertexAttribute &attrib,
                                            size_t attribIndex);
  
      angle::Result syncNeedsConversionAttrib(ContextVk *contextVk,
                                              const gl::VertexAttribute &attrib,
                                              const gl::VertexBinding &binding,
                                              size_t attribIndex);
  
      gl::AttribArray<VkBuffer> mCurrentArrayBufferHandles;
      gl::AttribArray<VkDeviceSize> mCurrentArrayBufferOffsets;
      gl::AttribArray<vk::BufferHelper *> mCurrentArrayBuffers;
      // Tracks BufferSerial of mCurrentArrayBuffers since they are always valid to access.
      gl::AttribArray<vk::BufferSerial> mCurrentArrayBufferSerial;
      // Cache strides of attributes for a fast pipeline cache update when VAOs are changed
      gl::AttribArray<angle::FormatID> mCurrentArrayBufferFormats;
  
      // These struct are defined by VK_EXT_vertex_input_dynamic_state, for convenience, we these to
      // store offset/divisor even when vertexInputDynamicState not supported.
      gl::AttribArray<VkVertexInputBindingDescription2EXT> mVertexInputBindingDesc;
      gl::AttribArray<VkVertexInputAttributeDescription2EXT> mVertexInputAttribDesc;
  
      vk::BufferHelper *mCurrentElementArrayBuffer;
  
      // Cached element array buffers for improving performance.
      vk::BufferHelperQueue mCachedStreamIndexBuffers;
  
      ConversionBuffer mStreamedIndexData;
      ConversionBuffer mTranslatedByteIndexData;
      ConversionBuffer mTranslatedByteIndirectData;
  
      LineLoopHelper mLineLoopHelper;
      Optional<GLint> mLineLoopBufferFirstIndex;
      Optional<size_t> mLineLoopBufferLastIndex;
      bool mDirtyLineLoopTranslation;
  
      gl::BufferBindingMask mDivisorExceedMaxSupportedValueBindingMask;
  
      gl::AttributesMask mCurrentEnabledAttributesMask;
      // Track client and/or emulated attribs that we have to stream their buffer contents
      gl::AttributesMask mStreamingVertexAttribsMask;
      gl::AttributesMask mNeedsConversionAttribMask;
  
      // The attrib/binding dirty bits that requires graphics pipeline update
      gl::VertexArray::DirtyBindingBits mBindingDirtyBitsRequiresPipelineUpdate;
      gl::VertexArray::DirtyAttribBits mAttribDirtyBitsRequiresPipelineUpdate;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_VERTEXARRAYVK_H_
  

Download