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

• Show log

  Commit

• Hash : 6c1f671b
  Author :
  Date : 2017-02-14T19:08:04
  

  Add destroy hooks for several GL objects.
  
  These hooks allow the back-end renderer to free object resources
  without having to store pointers to shared device handles for
  each and every object. This will allow us to save memory on
  back-ends that really care about memory overhead.
  
  There is a downside in that there is more boilerplate in passing
  gl::Context handles around everywhere.
  
  BUG=angleproject:1684
  
  Change-Id: I89463bba8d23f92920e8956650cb73c7fc6d66b7
  Reviewed-on: https://chromium-review.googlesource.com/426401
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/RefCountObject.h

• //
  // Copyright (c) 2002-2010 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.
  //
  
  // RefCountObject.h: Defines the gl::RefCountObject base class that provides
  // lifecycle support for GL objects using the traditional BindObject scheme, but
  // that need to be reference counted for correct cross-context deletion.
  // (Concretely, textures, buffers and renderbuffers.)
  
  #ifndef LIBANGLE_REFCOUNTOBJECT_H_
  #define LIBANGLE_REFCOUNTOBJECT_H_
  
  #include "common/debug.h"
  
  #include "angle_gl.h"
  
  #include <cstddef>
  
  namespace gl
  {
  class Context;
  }
  
  class RefCountObjectNoID : angle::NonCopyable
  {
    public:
      RefCountObjectNoID() : mRefCount(0) {}
  
      void addRef() const { ++mRefCount; }
  
      void release() const
      {
          ASSERT(mRefCount > 0);
  
          if (--mRefCount == 0)
          {
              delete this;
          }
      }
  
      // A specialized release method for objects which need a destroy context.
      void release(const gl::Context *context)
      {
          ASSERT(mRefCount > 0);
          if (--mRefCount == 0)
          {
              destroy(context);
              delete this;
          }
      }
  
      size_t getRefCount() const { return mRefCount; }
  
    protected:
      virtual ~RefCountObjectNoID() { ASSERT(mRefCount == 0); }
      virtual void destroy(const gl::Context *context) {}
  
    private:
      mutable std::size_t mRefCount;
  };
  
  class RefCountObject : public RefCountObjectNoID
  {
    public:
      explicit RefCountObject(GLuint id) : mId(id) {}
  
      GLuint id() const { return mId; }
  
    protected:
      ~RefCountObject() override {}
  
    private:
      GLuint mId;
  };
  
  template <class ObjectType>
  class BindingPointer
  {
    public:
      BindingPointer()
          : mObject(nullptr)
      {
      }
  
      BindingPointer(const BindingPointer<ObjectType> &other)
          : mObject(nullptr)
      {
          set(other.mObject);
      }
  
      void operator=(const BindingPointer<ObjectType> &other)
      {
          set(other.mObject);
      }
  
      virtual ~BindingPointer()
      {
          // Objects have to be released before the resource manager is destroyed, so they must be explicitly cleaned up.
          ASSERT(mObject == nullptr);
      }
  
      virtual void set(ObjectType *newObject)
      {
          // addRef first in case newObject == mObject and this is the last reference to it.
          if (newObject != nullptr) reinterpret_cast<const RefCountObject*>(newObject)->addRef();
          if (mObject != nullptr) reinterpret_cast<const RefCountObject*>(mObject)->release();
          mObject = newObject;
      }
  
      ObjectType *get() const { return mObject; }
      ObjectType *operator->() const { return mObject; }
  
      GLuint id() const { return (mObject != nullptr) ? mObject->id() : 0; }
  
      bool operator==(const BindingPointer<ObjectType> &other) const
      {
          return mObject == other.mObject;
      }
  
      bool operator!=(const BindingPointer<ObjectType> &other) const { return !(*this == other); }
  
    private:
      ObjectType *mObject;
  };
  
  template <class ObjectType>
  class OffsetBindingPointer : public BindingPointer<ObjectType>
  {
    public:
      OffsetBindingPointer() : mOffset(0), mSize(0) { }
  
      void set(ObjectType *newObject) override
      {
          BindingPointer<ObjectType>::set(newObject);
          mOffset = 0;
          mSize = 0;
      }
  
      void set(ObjectType *newObject, GLintptr offset, GLsizeiptr size)
      {
          BindingPointer<ObjectType>::set(newObject);
          mOffset = offset;
          mSize = size;
      }
  
      GLintptr getOffset() const { return mOffset; }
      GLsizeiptr getSize() const { return mSize; }
  
      bool operator==(const OffsetBindingPointer<ObjectType> &other) const
      {
          return this->get() == other.get() && mOffset == other.mOffset && mSize == other.mSize;
      }
  
      bool operator!=(const OffsetBindingPointer<ObjectType> &other) const
      {
          return !(*this == other);
      }
  
    private:
      GLintptr mOffset;
      GLsizeiptr mSize;
  };
  
  #endif   // LIBANGLE_REFCOUNTOBJECT_H_
  

Download