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

• Show log

  Commit

• Hash : f0b02054
  Author :
  Date : 2020-08-06T20:55:05
  

  Add a Vulkan feature to compress float32 vertex formats.
  
  Use the vertex conversion pipeline in VertexArrayVk to detect
  static vertex data and convert float32 vertices to float16. This
  feature is useful for determining if an allication is vertex
  bandwidth bound and seeing what gains could be had by using smaller
  attributes.
  
  This feature could be implemented in ANGLE's frontend but new
  infrastructure for converting and storing the converted attributes
  would need to be added to gl::VertexArray. Our backends already
  have the functionality needed to handle unsupported attribute formats
  and this can be repurposed for compressing vertex formats.
  
  Bug: b/167404532
  Bug: b/161716126
  Change-Id: I9a09656a72e8499faa4124adf876d7261c8341c9
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2342285
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  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/vk_cache_utils.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  
  namespace rx
  {
  class BufferVk;
  struct ConversionBuffer;
  
  class VertexArrayVk : public VertexArrayImpl
  {
    public:
      VertexArrayVk(ContextVk *contextVk, const gl::VertexArrayState &state);
      ~VertexArrayVk() override;
  
      void destroy(const gl::Context *context) 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,
                                        VkBuffer bufferHandle,
                                        vk::BufferHelper *buffer,
                                        uint32_t offset);
  
      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,
                                   uint32_t *indexCountOut);
  
      angle::Result handleLineLoopIndexIndirect(ContextVk *contextVk,
                                                gl::DrawElementsType glIndexType,
                                                vk::BufferHelper *srcIndirectBuf,
                                                VkDeviceSize indirectBufferOffset,
                                                vk::BufferHelper **indirectBufferOut,
                                                VkDeviceSize *indirectBufferOffsetOut);
  
      angle::Result handleLineLoopIndirectDraw(const gl::Context *context,
                                               vk::BufferHelper *indirectBufferVk,
                                               VkDeviceSize indirectBufferOffset,
                                               vk::BufferHelper **indirectBufferOut,
                                               VkDeviceSize *indirectBufferOffsetOut);
  
      const gl::AttribArray<VkBuffer> &getCurrentArrayBufferHandles() const
      {
          return mCurrentArrayBufferHandles;
      }
  
      const gl::AttribArray<VkDeviceSize> &getCurrentArrayBufferOffsets() const
      {
          return mCurrentArrayBufferOffsets;
      }
  
      const gl::AttribArray<vk::BufferHelper *> &getCurrentArrayBuffers() const
      {
          return mCurrentArrayBuffers;
      }
  
      VkDeviceSize getCurrentElementArrayBufferOffset() const
      {
          return mCurrentElementArrayBufferOffset;
      }
  
      void updateCurrentElementArrayBufferOffset(const GLvoid *offset)
      {
          mCurrentElementArrayBufferOffset = reinterpret_cast<VkDeviceSize>(offset);
      }
  
      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,
                                                  VkDeviceSize *indirectBufferVkOffsetOut);
  
      angle::Result convertIndexBufferCPU(ContextVk *contextVk,
                                          gl::DrawElementsType indexType,
                                          size_t indexCount,
                                          const void *sourcePointer);
  
      const gl::AttributesMask &getStreamingVertexAttribsMask() const
      {
          return mStreamingVertexAttribsMask;
      }
  
    private:
      angle::Result setDefaultPackedInput(ContextVk *contextVk, size_t attribIndex);
  
      angle::Result convertVertexBufferGPU(ContextVk *contextVk,
                                           BufferVk *srcBuffer,
                                           const gl::VertexBinding &binding,
                                           size_t attribIndex,
                                           const vk::Format &vertexFormat,
                                           ConversionBuffer *conversion,
                                           GLuint relativeOffset,
                                           bool compressed);
      angle::Result convertVertexBufferCPU(ContextVk *contextVk,
                                           BufferVk *srcBuffer,
                                           const gl::VertexBinding &binding,
                                           size_t attribIndex,
                                           const vk::Format &vertexFormat,
                                           ConversionBuffer *conversion,
                                           GLuint relativeOffset,
                                           bool compress);
  
      angle::Result syncDirtyAttrib(ContextVk *contextVk,
                                    const gl::VertexAttribute &attrib,
                                    const gl::VertexBinding &binding,
                                    size_t attribIndex,
                                    bool bufferOnly);
  
      gl::AttribArray<VkBuffer> mCurrentArrayBufferHandles;
      gl::AttribArray<VkDeviceSize> mCurrentArrayBufferOffsets;
      // The offset into the buffer to the first attrib
      gl::AttribArray<GLuint> mCurrentArrayBufferRelativeOffsets;
      gl::AttribArray<vk::BufferHelper *> mCurrentArrayBuffers;
      // Cache strides of attributes for a fast pipeline cache update when VAOs are changed
      gl::AttribArray<GLuint> mCurrentArrayBufferStrides;
      gl::AttributesMask mCurrentArrayBufferCompressed;
      VkDeviceSize mCurrentElementArrayBufferOffset;
      vk::BufferHelper *mCurrentElementArrayBuffer;
  
      vk::DynamicBuffer mDynamicVertexData;
      vk::DynamicBuffer mDynamicIndexData;
      vk::DynamicBuffer mTranslatedByteIndexData;
      vk::DynamicBuffer mTranslatedByteIndirectData;
  
      vk::LineLoopHelper mLineLoopHelper;
      Optional<GLint> mLineLoopBufferFirstIndex;
      Optional<size_t> mLineLoopBufferLastIndex;
      bool mDirtyLineLoopTranslation;
  
      // Track client and/or emulated attribs that we have to stream their buffer contents
      gl::AttributesMask mStreamingVertexAttribsMask;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_VERTEXARRAYVK_H_
  

Download