kc3-lang/angle/src/libANGLE/renderer/null/BufferNULL.h

Branch - branch -main

• Show log

  Commit

• Hash : 3bbdee0f
  Author :
  Date : 2025-03-28T11:55:24
  

  Vulkan: Remove Subject/Observer from BufferImpl
  
  Right now the gl::Buffer back end send message to the front end and then
  gl::Buffer propagate the message to the observers (vertex array,
  textures, transform feedback). We are seeing many of these kind of
  message passing (mainly to vertexArray), and each message is a virtual
  function call. The message call also lacks of context information that
  we can not do certain optimizations. This CL adopts the new API feedback
  argument approach for buffer APIs from the back end to the front end.
  The only difficulty I ran into is D3D backend where the message could be
  delivered from draw calls. For now the subject/observer code path is
  still kept in the gl::Buffer, but no back end will use it except D3D11.
  That will be removed in the later CL when D3D11 switch to use feedback
  mechanism.
  
  BYPASS_LARGE_CHANGE_WARNING
  
  Bug: angleproject:400711938
  Change-Id: I5fb3b660fd4260b9ba691239ad777b575b31e2ab
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6408892
  Commit-Queue: Charlie Lao <cclao@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/null/BufferNULL.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.
  //
  // BufferNULL.h:
  //    Defines the class interface for BufferNULL, implementing BufferImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_NULL_BUFFERNULL_H_
  #define LIBANGLE_RENDERER_NULL_BUFFERNULL_H_
  
  #include "libANGLE/renderer/BufferImpl.h"
  
  namespace rx
  {
  
  class AllocationTrackerNULL;
  
  class BufferNULL : public BufferImpl
  {
    public:
      BufferNULL(const gl::BufferState &state, AllocationTrackerNULL *allocationTracker);
      ~BufferNULL() override;
  
      angle::Result setDataWithUsageFlags(const gl::Context *context,
                                          gl::BufferBinding target,
                                          GLeglClientBufferEXT clientBuffer,
                                          const void *data,
                                          size_t size,
                                          gl::BufferUsage usage,
                                          GLbitfield flags,
                                          gl::BufferStorage bufferStorage,
                                          BufferFeedback *feedback) override;
      angle::Result setData(const gl::Context *context,
                            gl::BufferBinding target,
                            const void *data,
                            size_t size,
                            gl::BufferUsage usage,
                            BufferFeedback *feedback) override;
      angle::Result setSubData(const gl::Context *context,
                               gl::BufferBinding target,
                               const void *data,
                               size_t size,
                               size_t offset,
                               BufferFeedback *feedback) override;
      angle::Result copySubData(const gl::Context *context,
                                BufferImpl *source,
                                GLintptr sourceOffset,
                                GLintptr destOffset,
                                GLsizeiptr size,
                                BufferFeedback *feedback) override;
      angle::Result map(const gl::Context *context,
                        GLenum access,
                        void **mapPtr,
                        BufferFeedback *feedback) override;
      angle::Result mapRange(const gl::Context *context,
                             size_t offset,
                             size_t length,
                             GLbitfield access,
                             void **mapPtr,
                             BufferFeedback *feedback) override;
      angle::Result unmap(const gl::Context *context,
                          GLboolean *result,
                          BufferFeedback *feedback) override;
  
      angle::Result getIndexRange(const gl::Context *context,
                                  gl::DrawElementsType type,
                                  size_t offset,
                                  size_t count,
                                  bool primitiveRestartEnabled,
                                  gl::IndexRange *outRange) override;
  
      uint8_t *getDataPtr();
      const uint8_t *getDataPtr() const;
  
    private:
      std::vector<uint8_t> mData;
  
      AllocationTrackerNULL *mAllocationTracker;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_NULL_BUFFERNULL_H_
  

Download