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

• Show log

  Commit

• Hash : ab42afa6
  Author :
  Date : 2019-11-21T10:13:44
  

  Metal: fix vertex attribute's conversion lost after changing buffer binding.
  
  After vertex buffer's attribute is converted and stored in conversion
  buffer. Binding the same attribute to another buffer, then binding it
  back to previous buffer will result in previous conversion
  information lost. The conversion method would skip the conversion due to
  buffer's content hadn't been changed, however it didn't reuse the old
  conversion result.
  
  This CL also changed the way binding offset is used in Metal backend.
  - Previous, the offset would be assigned to the offset field of
    MTLVertexAttributeDescriptor, then the buffer would simply be bound to
    the command encoder with offset=0
    i.e. setVertexBuffer(buffer, index, 0)
  - However this approach has several disadvantages. Since Metal doesn't
    allow MTLVertexAttributeDescriptor's offset to be larger than the
    vertex attribute's stride, the old approach would force the back-end
    to convert the attribute and store in conversion buffer.
  
  New approach:
  - MTLVertexAttributeDescriptor's offset will be zero. The offset will be
    used to bind the buffer itself to the render command encoder.
    i.e. setVertexBuffer(buffer, index, offset)
    This way the "offset <= stride" restriction no longer exists. The only
    restriction is the offset must be multiple of attribute's size.
  
  Added 3 new tests:
  - SimpleStateChangeTest.RebindTranslatedAttribute
  - VertexAttributeTest.DrawWithLargeBufferOffset
  - VertexAttributeTest.DrawWithLargeBufferOffsetAndLessComponents
  
  Bug: angleproject:2634
  Change-Id: I6c2fa8091436e4a24405d791f86d17d97df02d64
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1940009
  Commit-Queue: Jonah Ryan-Davis <jonahr@google.com>
  Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>
  

Download

• src/libANGLE/renderer/metal/BufferMtl.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.
  //
  // BufferMtl.h:
  //    Defines the class interface for BufferMtl, implementing BufferImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_METAL_BUFFERMTL_H_
  #define LIBANGLE_RENDERER_METAL_BUFFERMTL_H_
  
  #import <Metal/Metal.h>
  
  #include <utility>
  
  #include "libANGLE/Buffer.h"
  #include "libANGLE/Observer.h"
  #include "libANGLE/angletypes.h"
  #include "libANGLE/renderer/BufferImpl.h"
  #include "libANGLE/renderer/Format.h"
  #include "libANGLE/renderer/metal/mtl_buffer_pool.h"
  #include "libANGLE/renderer/metal/mtl_resources.h"
  
  namespace rx
  {
  
  // Conversion buffers hold translated index and vertex data.
  struct ConversionBufferMtl
  {
      ConversionBufferMtl(const gl::Context *context, size_t initialSize, size_t alignment);
      ~ConversionBufferMtl();
  
      // One state value determines if we need to re-stream vertex data.
      bool dirty;
  
      // The conversion is stored in a dynamic buffer.
      mtl::BufferPool data;
  
      // These properties are to be filled by user of this buffer conversion
      mtl::BufferRef convertedBuffer;
      size_t convertedOffset;
  };
  
  struct IndexConversionBufferMtl : public ConversionBufferMtl
  {
      IndexConversionBufferMtl(const gl::Context *context,
                               gl::DrawElementsType type,
                               size_t offsetIn);
  
      const gl::DrawElementsType type;
      const size_t offset;
  };
  
  class BufferHolderMtl
  {
    public:
      virtual ~BufferHolderMtl() = default;
  
      // Due to the complication of synchronizing accesses between CPU and GPU,
      // a mtl::Buffer might be under used by GPU but CPU wants to modify its content through
      // map() method, this could lead to GPU stalling. The more efficient method is maintain
      // a queue of mtl::Buffer and only let CPU modifies a free mtl::Buffer.
      // So, in order to let GPU use the most recent modified content, one must call this method
      // right before the draw call to retrieved the most up-to-date mtl::Buffer.
      mtl::BufferRef getCurrentBuffer(const gl::Context *context)
      {
          return mIsWeak ? mBufferWeakRef.lock() : mBuffer;
      }
  
    protected:
      mtl::BufferRef mBuffer;
      mtl::BufferWeakRef mBufferWeakRef;
      bool mIsWeak = false;
  };
  
  class BufferMtl : public BufferImpl, public BufferHolderMtl
  {
    public:
      BufferMtl(const gl::BufferState &state);
      ~BufferMtl() override;
      void destroy(const gl::Context *context) override;
  
      angle::Result setData(const gl::Context *context,
                            gl::BufferBinding target,
                            const void *data,
                            size_t size,
                            gl::BufferUsage usage) override;
      angle::Result setSubData(const gl::Context *context,
                               gl::BufferBinding target,
                               const void *data,
                               size_t size,
                               size_t offset) override;
      angle::Result copySubData(const gl::Context *context,
                                BufferImpl *source,
                                GLintptr sourceOffset,
                                GLintptr destOffset,
                                GLsizeiptr size) override;
      angle::Result map(const gl::Context *context, GLenum access, void **mapPtr) override;
      angle::Result mapRange(const gl::Context *context,
                             size_t offset,
                             size_t length,
                             GLbitfield access,
                             void **mapPtr) override;
      angle::Result unmap(const gl::Context *context, GLboolean *result) override;
  
      angle::Result getIndexRange(const gl::Context *context,
                                  gl::DrawElementsType type,
                                  size_t offset,
                                  size_t count,
                                  bool primitiveRestartEnabled,
                                  gl::IndexRange *outRange) override;
  
      angle::Result getFirstLastIndices(const gl::Context *context,
                                        gl::DrawElementsType type,
                                        size_t offset,
                                        size_t count,
                                        std::pair<uint32_t, uint32_t> *outIndices) const;
  
      const uint8_t *getClientShadowCopyData(const gl::Context *context);
  
      ConversionBufferMtl *getVertexConversionBuffer(const gl::Context *context,
                                                     angle::FormatID formatID,
                                                     GLuint stride,
                                                     size_t offset);
  
      IndexConversionBufferMtl *getIndexConversionBuffer(const gl::Context *context,
                                                         gl::DrawElementsType type,
                                                         size_t offset);
  
      size_t size() const { return static_cast<size_t>(mState.getSize()); }
  
    private:
      angle::Result setSubDataImpl(const gl::Context *context,
                                   const void *data,
                                   size_t size,
                                   size_t offset);
  
      angle::Result commitShadowCopy(const gl::Context *context);
      angle::Result commitShadowCopy(const gl::Context *context, size_t size);
  
      void markConversionBuffersDirty();
  
      void clearConversionBuffers();
  
      // Client side shadow buffer
      angle::MemoryBuffer mShadowCopy;
  
      // GPU side buffers pool
      mtl::BufferPool mBufferPool;
  
      struct VertexConversionBuffer : public ConversionBufferMtl
      {
          VertexConversionBuffer(const gl::Context *context,
                                 angle::FormatID formatIDIn,
                                 GLuint strideIn,
                                 size_t offsetIn);
  
          // The conversion is identified by the triple of {format, stride, offset}.
          angle::FormatID formatID;
          GLuint stride;
          size_t offset;
      };
  
      // A cache of converted vertex data.
      std::vector<VertexConversionBuffer> mVertexConversionBuffers;
  
      std::vector<IndexConversionBufferMtl> mIndexConversionBuffers;
  };
  
  class SimpleWeakBufferHolderMtl : public BufferHolderMtl
  {
    public:
      SimpleWeakBufferHolderMtl();
  
      void set(const mtl::BufferRef &buffer) { mBufferWeakRef = buffer; }
  };
  
  }  // namespace rx
  
  #endif /* LIBANGLE_RENDERER_METAL_BUFFERMTL_H_ */
  

Download