kc3-lang/angle/src/libANGLE/renderer/metal/VertexArrayMtl.h

• Show log

  Commit

• Hash : 8a50b42b
  Author :
  Date : 2020-10-24T19:29:12
  

  Metal: Convert index & vertex format on GPU when possible.
  
  - When converting vertex buffer:
    - if there is no render pass active, use compute shader to convert.
    - if there is a render pass active and device supports explicit memory
      barrier then convert the buffer in vertex shader with direct buffer
      write and insert a memory barrier.
    - if there is a render pass active and device doesn't support explicit
      memory barrier then convert the buffer on CPU.
  
  Bug: angleproject:2634
  Change-Id: I5346e3a2adb855f40e46a3912d9db404a4482e0f
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2434025
  Commit-Queue: Le Hoang Quyen <le.hoang.q@gmail.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>
  

Download

• src/libANGLE/renderer/metal/VertexArrayMtl.h

• //
  // Copyright 2019 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.
  //
  // VertexArrayMtl.h:
  //    Defines the class interface for VertexArrayMtl, implementing VertexArrayImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_METAL_VERTEXARRAYMTL_H_
  #define LIBANGLE_RENDERER_METAL_VERTEXARRAYMTL_H_
  
  #include "libANGLE/renderer/VertexArrayImpl.h"
  #include "libANGLE/renderer/metal/BufferMtl.h"
  #include "libANGLE/renderer/metal/mtl_buffer_pool.h"
  #include "libANGLE/renderer/metal/mtl_command_buffer.h"
  #include "libANGLE/renderer/metal/mtl_format_utils.h"
  #include "libANGLE/renderer/metal/mtl_resources.h"
  
  namespace rx
  {
  class ContextMtl;
  
  class VertexArrayMtl : public VertexArrayImpl
  {
    public:
      VertexArrayMtl(const gl::VertexArrayState &state, ContextMtl *context);
      ~VertexArrayMtl() 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;
  
      // Feed client side's vertex/index data
      angle::Result updateClientAttribs(const gl::Context *context,
                                        GLint firstVertex,
                                        GLsizei vertexOrIndexCount,
                                        GLsizei instanceCount,
                                        gl::DrawElementsType indexTypeOrInvalid,
                                        const void *indices);
  
      // vertexDescChanged is both input and output, the input value if is true, will force new
      // mtl::VertexDesc to be returned via vertexDescOut. Otherwise, it is only returned when the
      // vertex array is dirty
      angle::Result setupDraw(const gl::Context *glContext,
                              mtl::RenderCommandEncoder *cmdEncoder,
                              bool *vertexDescChanged,
                              mtl::VertexDesc *vertexDescOut);
  
      angle::Result getIndexBuffer(const gl::Context *glContext,
                                   gl::DrawElementsType indexType,
                                   size_t indexCount,
                                   const void *sourcePointer,
                                   mtl::BufferRef *idxBufferOut,
                                   size_t *idxBufferOffsetOut,
                                   gl::DrawElementsType *indexTypeOut);
  
    private:
      void reset(ContextMtl *context);
  
      void getVertexAttribFormatAndArraySize(const sh::ShaderVariable &var,
                                             MTLVertexFormat *formatOut,
                                             uint32_t *arraySizeOut);
  
      angle::Result syncDirtyAttrib(const gl::Context *glContext,
                                    const gl::VertexAttribute &attrib,
                                    const gl::VertexBinding &binding,
                                    size_t attribIndex);
  
      angle::Result convertIndexBuffer(const gl::Context *glContext,
                                       gl::DrawElementsType indexType,
                                       size_t offset,
                                       mtl::BufferRef *idxBufferOut,
                                       size_t *idxBufferOffsetOut);
      angle::Result streamIndexBufferFromClient(const gl::Context *glContext,
                                                gl::DrawElementsType indexType,
                                                size_t indexCount,
                                                const void *sourcePointer,
                                                mtl::BufferRef *idxBufferOut,
                                                size_t *idxBufferOffsetOut);
  
      angle::Result convertIndexBufferGPU(const gl::Context *glContext,
                                          gl::DrawElementsType indexType,
                                          BufferMtl *idxBuffer,
                                          size_t offset,
                                          size_t indexCount,
                                          IndexConversionBufferMtl *conversion);
  
      angle::Result convertVertexBuffer(const gl::Context *glContext,
                                        BufferMtl *srcBuffer,
                                        const gl::VertexBinding &binding,
                                        size_t attribIndex,
                                        const mtl::VertexFormat &vertexFormat);
  
      angle::Result convertVertexBufferCPU(ContextMtl *contextMtl,
                                           BufferMtl *srcBuffer,
                                           const gl::VertexBinding &binding,
                                           size_t attribIndex,
                                           const mtl::VertexFormat &convertedFormat,
                                           GLuint targetStride,
                                           size_t vertexCount,
                                           ConversionBufferMtl *conversion);
      angle::Result convertVertexBufferGPU(const gl::Context *glContext,
                                           BufferMtl *srcBuffer,
                                           const gl::VertexBinding &binding,
                                           size_t attribIndex,
                                           const mtl::VertexFormat &convertedFormat,
                                           GLuint targetStride,
                                           size_t vertexCount,
                                           bool isExpandingComponents,
                                           ConversionBufferMtl *conversion);
  
      // These can point to real BufferMtl or converted buffer in mConvertedArrayBufferHolders
      gl::AttribArray<BufferHolderMtl *> mCurrentArrayBuffers;
      gl::AttribArray<SimpleWeakBufferHolderMtl> mConvertedArrayBufferHolders;
      gl::AttribArray<size_t> mCurrentArrayBufferOffsets;
      gl::AttribArray<GLuint> mCurrentArrayBufferStrides;
      gl::AttribArray<const mtl::VertexFormat *> mCurrentArrayBufferFormats;
  
      const mtl::VertexFormat &mDefaultFloatVertexFormat;
      const mtl::VertexFormat &mDefaultIntVertexFormat;
      const mtl::VertexFormat &mDefaultUIntVertexFormat;
  
      mtl::BufferPool mDynamicVertexData;
      mtl::BufferPool mDynamicIndexData;
  
      bool mVertexArrayDirty = true;
  };
  }  // namespace rx
  
  #endif /* LIBANGLE_RENDERER_METAL_VERTEXARRAYMTL_H_ */
  

Download