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

• 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.cpp

• //
  // 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.cpp:
  //    Implements the class methods for BufferNULL.
  //
  
  #include "libANGLE/renderer/null/BufferNULL.h"
  
  #include "common/debug.h"
  #include "common/utilities.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/angletypes.h"
  #include "libANGLE/renderer/null/ContextNULL.h"
  
  namespace rx
  {
  
  BufferNULL::BufferNULL(const gl::BufferState &state, AllocationTrackerNULL *allocationTracker)
      : BufferImpl(state), mAllocationTracker(allocationTracker)
  {
      ASSERT(mAllocationTracker != nullptr);
  }
  
  BufferNULL::~BufferNULL()
  {
      bool memoryReleaseResult = mAllocationTracker->updateMemoryAllocation(mData.size(), 0);
      ASSERT(memoryReleaseResult);
  }
  
  angle::Result BufferNULL::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)
  {
      ANGLE_CHECK_GL_ALLOC(GetImplAs<ContextNULL>(context),
                           mAllocationTracker->updateMemoryAllocation(mData.size(), size));
  
      mData.resize(size, 0);
      if (size > 0 && data != nullptr)
      {
          memcpy(mData.data(), data, size);
      }
      return angle::Result::Continue;
  }
  
  angle::Result BufferNULL::setData(const gl::Context *context,
                                    gl::BufferBinding target,
                                    const void *data,
                                    size_t size,
                                    gl::BufferUsage usage,
                                    BufferFeedback *feedback)
  {
      ANGLE_CHECK_GL_ALLOC(GetImplAs<ContextNULL>(context),
                           mAllocationTracker->updateMemoryAllocation(mData.size(), size));
  
      mData.resize(size, 0);
      if (size > 0 && data != nullptr)
      {
          memcpy(mData.data(), data, size);
      }
      return angle::Result::Continue;
  }
  
  angle::Result BufferNULL::setSubData(const gl::Context *context,
                                       gl::BufferBinding target,
                                       const void *data,
                                       size_t size,
                                       size_t offset,
                                       BufferFeedback *feedback)
  {
      if (size > 0)
      {
          memcpy(mData.data() + offset, data, size);
      }
      return angle::Result::Continue;
  }
  
  angle::Result BufferNULL::copySubData(const gl::Context *context,
                                        BufferImpl *source,
                                        GLintptr sourceOffset,
                                        GLintptr destOffset,
                                        GLsizeiptr size,
                                        BufferFeedback *feedback)
  {
      BufferNULL *sourceNULL = GetAs<BufferNULL>(source);
      if (size > 0)
      {
          memcpy(mData.data() + destOffset, sourceNULL->mData.data() + sourceOffset, size);
      }
      return angle::Result::Continue;
  }
  
  angle::Result BufferNULL::map(const gl::Context *context,
                                GLenum access,
                                void **mapPtr,
                                BufferFeedback *feedback)
  {
      *mapPtr = mData.data();
      return angle::Result::Continue;
  }
  
  angle::Result BufferNULL::mapRange(const gl::Context *context,
                                     size_t offset,
                                     size_t length,
                                     GLbitfield access,
                                     void **mapPtr,
                                     BufferFeedback *feedback)
  {
      *mapPtr = mData.data() + offset;
      return angle::Result::Continue;
  }
  
  angle::Result BufferNULL::unmap(const gl::Context *context,
                                  GLboolean *result,
                                  BufferFeedback *feedback)
  {
      *result = GL_TRUE;
      return angle::Result::Continue;
  }
  
  angle::Result BufferNULL::getIndexRange(const gl::Context *context,
                                          gl::DrawElementsType type,
                                          size_t offset,
                                          size_t count,
                                          bool primitiveRestartEnabled,
                                          gl::IndexRange *outRange)
  {
      *outRange = gl::ComputeIndexRange(type, mData.data() + offset, count, primitiveRestartEnabled);
      return angle::Result::Continue;
  }
  
  uint8_t *BufferNULL::getDataPtr()
  {
      return mData.data();
  }
  
  const uint8_t *BufferNULL::getDataPtr() const
  {
      return mData.data();
  }
  
  }  // namespace rx
  

Download