kc3-lang/angle/src/libANGLE/Buffer.h

• Show log

  Commit

• Hash : 0946393d
  Author :
  Date : 2018-04-04T05:26:59
  

  Move Buffer Subject/Observer to front end.
  
  This makes BufferImpl into an Observer Subject. It also refactors
  the Vertex Array updates for the D3D11 backend use more of a dirty
  bit coding style.
  
  This change makes it so Buffer contents changes trigger front-end
  dirty bits from the back-end, which may be undesirable.
  
  Bug: angleproject:2389
  Change-Id: Iac8ce1171284a86851c18cd1373ddf24fcefe40b
  Reviewed-on: https://chromium-review.googlesource.com/979812
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/Buffer.h

• //
  // Copyright (c) 2002-2014 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.
  //
  
  // Buffer.h: Defines the gl::Buffer class, representing storage of vertex and/or
  // index data. Implements GL buffer objects and related functionality.
  // [OpenGL ES 2.0.24] section 2.9 page 21.
  
  #ifndef LIBANGLE_BUFFER_H_
  #define LIBANGLE_BUFFER_H_
  
  #include "common/angleutils.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/IndexRangeCache.h"
  #include "libANGLE/PackedGLEnums.h"
  #include "libANGLE/RefCountObject.h"
  
  namespace rx
  {
  class BufferImpl;
  class GLImplFactory;
  };
  
  namespace gl
  {
  class Buffer;
  class Context;
  
  class BufferState final : angle::NonCopyable
  {
    public:
      BufferState();
      ~BufferState();
  
      const std::string &getLabel();
  
      BufferUsage getUsage() const { return mUsage; }
      GLbitfield getAccessFlags() const { return mAccessFlags; }
      GLenum getAccess() const { return mAccess; }
      GLboolean isMapped() const { return mMapped; }
      void *getMapPointer() const { return mMapPointer; }
      GLint64 getMapOffset() const { return mMapOffset; }
      GLint64 getMapLength() const { return mMapLength; }
      GLint64 getSize() const { return mSize; }
  
    private:
      friend class Buffer;
  
      std::string mLabel;
  
      BufferUsage mUsage;
      GLint64 mSize;
      GLbitfield mAccessFlags;
      GLenum mAccess;
      GLboolean mMapped;
      void *mMapPointer;
      GLint64 mMapOffset;
      GLint64 mMapLength;
      int mBindingCount;
      int mTransformFeedbackBindingCount;
  };
  
  class Buffer final : public RefCountObject, public LabeledObject
  {
    public:
      Buffer(rx::GLImplFactory *factory, GLuint id);
      ~Buffer() override;
      Error onDestroy(const Context *context) override;
  
      void setLabel(const std::string &label) override;
      const std::string &getLabel() const override;
  
      Error bufferData(const Context *context,
                       BufferBinding target,
                       const void *data,
                       GLsizeiptr size,
                       BufferUsage usage);
      Error bufferSubData(const Context *context,
                          BufferBinding target,
                          const void *data,
                          GLsizeiptr size,
                          GLintptr offset);
      Error copyBufferSubData(const Context *context,
                              Buffer *source,
                              GLintptr sourceOffset,
                              GLintptr destOffset,
                              GLsizeiptr size);
      Error map(const Context *context, GLenum access);
      Error mapRange(const Context *context, GLintptr offset, GLsizeiptr length, GLbitfield access);
      Error unmap(const Context *context, GLboolean *result);
  
      // These are called when another operation changes Buffer data.
      void onTransformFeedback(const Context *context);
      void onPixelPack(const Context *context);
  
      Error getIndexRange(const gl::Context *context,
                          GLenum type,
                          size_t offset,
                          size_t count,
                          bool primitiveRestartEnabled,
                          IndexRange *outRange) const;
  
      BufferUsage getUsage() const { return mState.mUsage; }
      GLbitfield getAccessFlags() const { return mState.mAccessFlags; }
      GLenum getAccess() const { return mState.mAccess; }
      GLboolean isMapped() const { return mState.mMapped; }
      void *getMapPointer() const { return mState.mMapPointer; }
      GLint64 getMapOffset() const { return mState.mMapOffset; }
      GLint64 getMapLength() const { return mState.mMapLength; }
      GLint64 getSize() const { return mState.mSize; }
  
      rx::BufferImpl *getImplementation() const { return mImpl; }
  
      bool isBound() const;
      bool isBoundForTransformFeedbackAndOtherUse() const;
      void onBindingChanged(bool bound, BufferBinding target);
  
    private:
      BufferState mState;
      rx::BufferImpl *mImpl;
  
      mutable IndexRangeCache mIndexRangeCache;
  };
  
  }  // namespace gl
  
  #endif  // LIBANGLE_BUFFER_H_
  

Download