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

• Show log

  Commit

• Hash : c759b8b4
  Author :
  Date : 2019-01-03T15:16:50
  

  Vulkan: More Vertex Array optimizations.
  
  Inlines a number of Vulkan vertex array methods.
  
  Also changes the way vertex buffers are bound. Note that Vulkan doesn't
  support NULL buffer bindings. Thus we create an emulated NULL buffer
  to work around the problem of having gaps in the bound vertex buffers.
  This allows us to use a single bind call for ranges of vertex buffers
  even when there are gaps.
  
  Also changes how vertex array dirty bits are reset. Instead of calling
  memset to clear the affected buffers we pass a mutable pointer to the
  Vertex Array sync state. This allows us to only reset the dirty bits
  that we sync. This saves on the memory clearing time.
  
  Improves perf by about 10% in the Vulkan VBO state change test.
  
  Bug: angleproject:3014
  Change-Id: Ib7b742dff7897fc891606a652ea0b64255a24c86
  Reviewed-on: https://chromium-review.googlesource.com/c/1390360
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@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;
  
  namespace vk
  {
  class RecordableGraphResource;
  }  // namespace vk
  
  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;
  
      void updateDefaultAttrib(ContextVk *contextVk,
                               size_t attribIndex,
                               VkBuffer bufferHandle,
                               uint32_t offset);
  
      angle::Result updateClientAttribs(const gl::Context *context,
                                        GLint firstVertex,
                                        GLsizei vertexOrIndexCount,
                                        gl::DrawElementsType indexTypeOrInvalid,
                                        const void *indices);
  
      angle::Result handleLineLoop(ContextVk *contextVk,
                                   GLint firstVertex,
                                   GLsizei vertexOrIndexCount,
                                   gl::DrawElementsType indexTypeOrInvalid,
                                   const void *indices);
  
      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 updateIndexTranslation(ContextVk *contextVk,
                                           GLsizei indexCount,
                                           gl::DrawElementsType type,
                                           const void *indices);
  
    private:
      void setPackedInputInfo(ContextVk *contextVk,
                              size_t attribIndex,
                              const gl::VertexAttribute &attrib,
                              const gl::VertexBinding &binding);
      void setDefaultPackedInput(ContextVk *contextVk, size_t attribIndex);
  
      angle::Result streamIndexData(ContextVk *contextVk,
                                    gl::DrawElementsType indexType,
                                    size_t indexCount,
                                    const void *sourcePointer,
                                    vk::DynamicBuffer *dynamicBuffer);
      angle::Result convertVertexBufferGpu(ContextVk *contextVk,
                                           BufferVk *srcBuffer,
                                           const gl::VertexBinding &binding,
                                           size_t attribIndex);
      angle::Result convertVertexBufferCpu(ContextVk *contextVk,
                                           BufferVk *srcBuffer,
                                           const gl::VertexBinding &binding,
                                           size_t attribIndex);
      void ensureConversionReleased(RendererVk *renderer, size_t attribIndex);
  
      angle::Result syncDirtyAttrib(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;
      gl::AttribArray<const vk::Format *> mCurrentArrayBufferFormats;
      gl::AttribArray<GLuint> mCurrentArrayBufferStrides;
      gl::AttribArray<vk::DynamicBuffer> mCurrentArrayBufferConversion;
      gl::AttribArray<bool> mCurrentArrayBufferConversionCanRelease;
      VkDeviceSize mCurrentElementArrayBufferOffset;
      vk::BufferHelper *mCurrentElementArrayBuffer;
  
      vk::DynamicBuffer mDynamicVertexData;
      vk::DynamicBuffer mDynamicIndexData;
      vk::DynamicBuffer mTranslatedByteIndexData;
  
      vk::LineLoopHelper mLineLoopHelper;
      Optional<GLint> mLineLoopBufferFirstIndex;
      Optional<size_t> mLineLoopBufferLastIndex;
      bool mDirtyLineLoopTranslation;
  
      // Vulkan does not allow binding a null vertex buffer. We use a dummy as a placeholder.
      vk::BufferHelper mTheNullBuffer;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_VERTEXARRAYVK_H_
  

Download