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

• Show log

  Commit

• Hash : 611bbaab
  Author :
  Date : 2018-12-06T01:59:53
  

  Vulkan: Convert vertex attributes in compute
  
  In this commit, VertexArrayVk::convertVertexBuffer() is renamed to
  VertexArrayVk::convertVertexBufferCpu() to explicitly show it does a CPU
  readback.  A new VertexArrayVk::convertVertexBuffer() function is added
  that has the same functionality in gpu (with some assumptions, where the
  CPU fallback is used should those assumptions fail).  Currently, the
  only requirement is that buffer offset/stride are divided by the
  component size.
  
  ConvertVertex.comp is the shader responsible for this conversion, and it
  implements the functionality in renderer/copyvertex.inc, minus a few
  functions that are not used in the Vulkan backend.
  
  Bug: angleproject:2958, angleproject:3009
  Change-Id: I8ec9a5f4672509bcf7b9e352cd27663970ad4653
  Reviewed-on: https://chromium-review.googlesource.com/c/1364451
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@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(const gl::VertexArrayState &state, RendererVk *renderer);
      ~VertexArrayVk() override;
  
      void destroy(const gl::Context *context) override;
  
      angle::Result syncState(const gl::Context *context,
                              const gl::VertexArray::DirtyBits &dirtyBits,
                              const gl::VertexArray::DirtyAttribBitsArray &attribBits,
                              const gl::VertexArray::DirtyBindingBitsArray &bindingBits) override;
  
      void getPackedInputDescriptions(vk::GraphicsPipelineDesc *pipelineDesc);
  
      void updateDefaultAttrib(RendererVk *renderer,
                               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:
      // This will update any dirty packed input descriptions, regardless if they're used by the
      // active program. This could lead to slight inefficiencies when the app would repeatedly
      // update vertex info for attributes the program doesn't use, (very silly edge case). The
      // advantage is the cached state then doesn't depend on the Program, so doesn't have to be
      // updated when the active Program changes.
      void updatePackedInputDescriptions();
      void updatePackedInputInfo(uint32_t attribIndex,
                                 const gl::VertexBinding &binding,
                                 const gl::VertexAttribute &attrib);
  
      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;
  
      // Keep a cache of binding and attribute descriptions for easy pipeline updates.
      // This is copied out of here into the pipeline description on a Context state change.
      gl::AttributesMask mDirtyPackedInputs;
      vk::VertexInputBindings mPackedInputBindings;
      vk::VertexInputAttributes mPackedInputAttributes;
  
      vk::DynamicBuffer mDynamicVertexData;
      vk::DynamicBuffer mDynamicIndexData;
      vk::DynamicBuffer mTranslatedByteIndexData;
  
      vk::LineLoopHelper mLineLoopHelper;
      Optional<GLint> mLineLoopBufferFirstIndex;
      Optional<size_t> mLineLoopBufferLastIndex;
      bool mDirtyLineLoopTranslation;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_VERTEXARRAYVK_H_
  

Download