kc3-lang/angle/src/libANGLE/renderer/gl/BufferGL.h

• Show log

  Commit

• Hash : f1150231
  Author :
  Date : 2024-01-16T16:28:36
  

  Track WebGL buffer type in gl::Buffer state.
  
  WebGL has special validation that disallows buffers from changing
  "WebGL buffer type". Once a buffer is marked as having index data it
  cannot be bound as any other type of buffer except the copy binding
  points to copy to other index buffers. This disallows any GPU writes
  to buffers used for index data.
  
  Use this rule to shadow index buffer data when the driver is unable
  to give us robust access. Index range computation can be done much
  faster when the buffer does not need to be read back.
  
  Bug: angleproject:8434
  Change-Id: I059eff732bb2f43234f61d9ef5528289f7698b38
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5200242
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/gl/BufferGL.h

• //
  // Copyright 2015 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.
  //
  
  // BufferGL.h: Defines the class interface for BufferGL.
  
  #ifndef LIBANGLE_RENDERER_GL_BUFFERGL_H_
  #define LIBANGLE_RENDERER_GL_BUFFERGL_H_
  
  #include "common/MemoryBuffer.h"
  #include "libANGLE/renderer/BufferImpl.h"
  
  #include <optional>
  
  namespace rx
  {
  
  class FunctionsGL;
  class StateManagerGL;
  
  class BufferGL : public BufferImpl
  {
    public:
      BufferGL(const gl::BufferState &state, GLuint buffer);
      ~BufferGL() 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;
  
      size_t getBufferSize() const;
      GLuint getBufferID() const;
  
    private:
      bool mIsMapped;
      size_t mMapOffset;
      size_t mMapSize;
  
      std::optional<angle::MemoryBuffer> mShadowCopy;
  
      size_t mBufferSize;
  
      GLuint mBufferID;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_GL_BUFFERGL_H_
  

Download