Renaming graphics again

include/anki/AnKi.h

@@ -6,12 +6,6 @@
 #ifndef ANKI_ANKI_H
 #define ANKI_ANKI_H
 
-/// @defgroup anki_public Public AnKi interfaces
-/// This includes the interfaces that should be exposed from the library
-
-/// @defgroup anki_private Private AnKi interfaces
-/// This includes the interfaces that shouldn't be exposed from the library
-
 #include "anki/Util.h"
 #include "anki/Math.h"
 #include "anki/Scene.h"

include/anki/Collision.h

@@ -7,7 +7,6 @@
 #define ANKI_COLLISION_H
 
 /// @defgroup collision Collision detection module
-/// @ingroup anki_public
 
 #include "anki/collision/Plane.h"
 #include "anki/collision/Sphere.h"

include/anki/Gr.h

@@ -11,22 +11,21 @@
 #define ANKI_GR_H
 
 /// @defgroup graphics Graphics backend abstraction
-/// @ingroup anki_private
 
-/// @defgroup openg OpenGL backend
+/// @defgroup opengl OpenGL backend
 /// @ingroup graphics
 
-#include "anki/gr/BufferHandle.h"
-#include "anki/gr/TextureHandle.h"
-#include "anki/gr/SamplerHandle.h"
-#include "anki/gr/ShaderHandle.h"
+#include "anki/gr/BufferPtr.h"
+#include "anki/gr/TexturePtr.h"
+#include "anki/gr/SamplerPtr.h"
+#include "anki/gr/ShaderPtr.h"
 
-#include "anki/gr/FramebufferHandle.h"
+#include "anki/gr/FramebufferPtr.h"
 #include "anki/gr/PipelineCommon.h"
-#include "anki/gr/PipelineHandle.h"
+#include "anki/gr/PipelinePtr.h"
 
-#include "anki/gr/CommandBufferHandle.h"
-#include "anki/gr/OcclusionQueryHandle.h"
+#include "anki/gr/CommandBufferPtr.h"
+#include "anki/gr/OcclusionQueryPtr.h"
 #include "anki/gr/GrManager.h"
 
 #endif

include/anki/Math.h

@@ -11,6 +11,5 @@
 #include "anki/math/Functions.h"
 
 /// @defgroup math Math library
-/// @ingroup anki_public
 
 #endif

include/anki/Renderer.h

@@ -9,7 +9,6 @@
 #include "anki/renderer/MainRenderer.h"
 
 /// @defgroup renderer Renderering system
-/// @ingroup anki_public
 
 #endif
 

include/anki/Resource.h

@@ -4,14 +4,13 @@
 // http://www.anki3d.org/LICENSE
 
 /// @file
-/// This file contains the public resource headers and all the resource classes 
+/// This file contains the public resource headers and all the resource classes
 /// that the rest of AnKi should use
 
 #ifndef ANKI_RESOURCE_H
 #define ANKI_RESOURCE_H
 
 /// @defgroup resource Collection of resources and management
-/// @ingroup anki_public
 
 /// @defgroup resource_private Private resource interfaces
 /// Other modules should not use them.

include/anki/Util.h

@@ -4,7 +4,6 @@
 // http://www.anki3d.org/LICENSE
 
 /// @defgroup util Utilities (like STL)
-/// @ingroup anki_public
 
 /// @defgroup util_containers STL compatible containers
 /// @ingroup util

include/anki/core/App.h

@@ -41,7 +41,7 @@ public:
 	App();
 	~App();
 
-	ANKI_USE_RESULT Error create(const ConfigSet& config, 
+	ANKI_USE_RESULT Error create(const ConfigSet& config,
 		AllocAlignedCallback allocCb, void* allocCbUserData);
 
 	F32 getTimerTick() const
@@ -155,7 +155,7 @@ private:
 	String m_cacheDir; ///< This is used as a cache
 	F32 m_timerTick;
 
-	ANKI_USE_RESULT Error createInternal(const ConfigSet& config, 
+	ANKI_USE_RESULT Error createInternal(const ConfigSet& config,
 		AllocAlignedCallback allocCb, void* allocCbUserData);
 
 	ANKI_USE_RESULT Error initDirs();

include/anki/gr/BufferHandle.h → include/anki/gr/BufferPtr.h

@@ -6,50 +6,50 @@
 #ifndef ANKI_GR_BUFFER_HANDLE_H
 #define ANKI_GR_BUFFER_HANDLE_H
 
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 
 namespace anki {
 
 /// @addtogroup opengl_containers
 /// @{
 
-/// GPU buffer handle
-class BufferHandle: public GrHandle<BufferImpl>
+/// GPU buffer.
+class BufferPtr: public GrPtr<BufferImpl>
 {
 public:
-	using Base = GrHandle<BufferImpl>;
+	using Base = GrPtr<BufferImpl>;
 
-	BufferHandle();
+	BufferPtr();
 
-	~BufferHandle();
+	~BufferPtr();
 
 	/// Create the buffer with data
-	ANKI_USE_RESULT Error create(GrManager* manager, GLenum target, 
+	ANKI_USE_RESULT Error create(GrManager* manager, GLenum target,
 		const void* data, PtrSize size, GLbitfield flags);
 
-	/// Get buffer size. It may serialize 
+	/// Get buffer size. It may serialize
 	PtrSize getSize() const;
 
-	/// Get buffer's current target. It may serialize 
+	/// Get buffer's current target. It may serialize
 	GLenum getTarget() const;
 
-	/// Get persistent mapping address. It may serialize 
+	/// Get persistent mapping address. It may serialize
 	void* getPersistentMappingAddress();
 
 	/// Write data to the buffer
 	void write(
-		CommandBufferHandle& commands, 
+		CommandBufferPtr& commands,
 		const void* data, PtrSize dataSize, PtrSize readOffset,
 		PtrSize writeOffset, PtrSize size);
 
 	/// Bind to the state as uniform/shader storage buffer
-	void bindShaderBuffer(CommandBufferHandle& commands, U32 bindingPoint)
+	void bindShaderBuffer(CommandBufferPtr& commands, U32 bindingPoint)
 	{
 		bindShaderBufferInternal(commands, -1, -1, bindingPoint);
 	}
 
 	/// Bind to the state as uniform/shader storage buffer
-	void bindShaderBuffer(CommandBufferHandle& commands,
+	void bindShaderBuffer(CommandBufferPtr& commands,
 		U32 offset, U32 size, U32 bindingPoint)
 	{
 		bindShaderBufferInternal(commands, offset, size, bindingPoint);
@@ -57,7 +57,7 @@ public:
 
 	/// Bind to the state as vertex buffer
 	void bindVertexBuffer(
-		CommandBufferHandle& commands, 
+		CommandBufferPtr& commands,
 		U32 elementSize,
 		GLenum type,
 		Bool normalized,
@@ -66,10 +66,10 @@ public:
 		U32 attribLocation);
 
 	/// Bind to the state as index buffer
-	void bindIndexBuffer(CommandBufferHandle& commands);
+	void bindIndexBuffer(CommandBufferPtr& commands);
 
 private:
-	void bindShaderBufferInternal(CommandBufferHandle& commands,
+	void bindShaderBufferInternal(CommandBufferPtr& commands,
 		I32 offset, I32 size, U32 bindingPoint);
 };
 /// @}

include/anki/gr/CommandBufferHandle.h → include/anki/gr/CommandBufferPtr.h

@@ -6,23 +6,23 @@
 #ifndef ANKI_GR_COMMAND_BUFFER_HANDLE_H
 #define ANKI_GR_COMMAND_BUFFER_HANDLE_H
 
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 
 namespace anki {
 
 /// @addtogroup graphics
 /// @{
 
-/// Command buffer handle
-class CommandBufferHandle: public GrHandle<CommandBufferImpl>
+/// Command buffer.
+class CommandBufferPtr: public GrPtr<CommandBufferImpl>
 {
 public:
-	using Base = GrHandle<CommandBufferImpl>;
+	using Base = GrPtr<CommandBufferImpl>;
 	using UserCallback = Error(*)(void*);
 
-	CommandBufferHandle();
+	CommandBufferPtr();
 
-	~CommandBufferHandle();
+	~CommandBufferPtr();
 
 	/// Create command buffer
 	ANKI_USE_RESULT Error create(GrManager* manager,
@@ -32,7 +32,7 @@ public:
 	void pushBackUserCommand(UserCallback callback, void* data);
 
 	/// Add another command buffer for execution
-	void pushBackOtherCommandBuffer(CommandBufferHandle& commands);
+	void pushBackOtherCommandBuffer(CommandBufferPtr& commands);
 
 	/// Flush command buffer for deferred execution.
 	void flush();
@@ -120,7 +120,7 @@ public:
 	/// @param first The unit where the first texture will be bound.
 	/// @param textures The array of textures.
 	/// @param count The count of textures
-	void bindTextures(U32 first, TextureHandle textures[], U32 count);
+	void bindTextures(U32 first, TexturePtr textures[], U32 count);
 	/// @}
 
 	/// @name Drawcalls
@@ -132,12 +132,12 @@ public:
 	void drawArrays(GLenum mode, U32 count, U32 instanceCount = 1,
 		U32 first = 0, U32 baseInstance = 0);
 
-	void drawElementsConditional(OcclusionQueryHandle& query,
+	void drawElementsConditional(OcclusionQueryPtr& query,
 		GLenum mode, U8 indexSize,
 		U32 count, U32 instanceCount = 1, U32 firstIndex = 0,
 		U32 baseVertex = 0, U32 baseInstance = 0);
 
-	void drawArraysConditional(OcclusionQueryHandle& query,
+	void drawArraysConditional(OcclusionQueryPtr& query,
 		GLenum mode, U32 count, U32 instanceCount = 1,
 		U32 first = 0, U32 baseInstance = 0);
 
@@ -146,7 +146,7 @@ public:
 
 	/// @name Other operations
 	/// @{
-	void copyTextureToBuffer(TextureHandle& from, BufferHandle& To);
+	void copyTextureToBuffer(TexturePtr& from, BufferPtr& To);
 	/// @}
 };
 /// @}

include/anki/gr/Common.h

@@ -30,32 +30,32 @@ namespace anki {
 
 // Forward
 class BufferImpl;
-class BufferHandle;
+class BufferPtr;
 class ShaderImpl;
-class ShaderHandle;
+class ShaderPtr;
 class PipelineImpl;
-class PipelineHandle;
+class PipelinePtr;
 class PipelineInitializer;
 class FramebufferImpl;
-class FramebufferHandle;
+class FramebufferPtr;
 class FramebufferInitializer;
 class TextureImpl;
-class TextureHandle;
+class TexturePtr;
 class SamplerImpl;
-class SamplerHandle;
+class SamplerPtr;
 class OcclusionQueryImpl;
-class OcclusionQueryHandle;
+class OcclusionQueryPtr;
 class CommandBufferImpl;
-class CommandBufferHandle;
+class CommandBufferPtr;
 class ResourceGroupImpl;
-class ResourceGroupHandle;
+class ResourceGroupPtr;
 class GrManager;
 class GrManagerImpl;
 class TextureInitializer;
 class SamplerInitializer;
 class GrManagerInitializer;
 
-/// @addtogroup graphics_private
+/// @addtogroup graphics
 /// @{
 
 /// The type of the allocator of CommandBuffer
@@ -65,10 +65,6 @@ using CommandBufferAllocator = ChainAllocator<T>;
 /// The type of the allocator for heap allocations
 template<typename T>
 using GrAllocator = HeapAllocator<T>;
-/// @}
-
-/// @addtogroup graphics
-/// @{
 
 // Some constants
 const U MAX_VERTEX_ATTRIBUTES = 8;
@@ -83,7 +79,7 @@ const U MAX_STORAGE_BUFFER_BINDINGS = 4;
 using SwapBuffersCallback = void(*)(void*);
 using MakeCurrentCallback = void(*)(void*, void*);
 
-/// Command buffer initialization hints. They are used to optimize the 
+/// Command buffer initialization hints. They are used to optimize the
 /// allocators of a command buffer
 class CommandBufferInitHints
 {
@@ -102,7 +98,7 @@ private:
 /// @addtogroup opengl_other
 /// @{
 
-/// The draw indirect structure for index drawing, also the parameters of a 
+/// The draw indirect structure for index drawing, also the parameters of a
 /// regular drawcall
 class GlDrawElementsIndirectInfo
 {
@@ -111,14 +107,14 @@ public:
 	{}
 
 	GlDrawElementsIndirectInfo(
-		U32 count, 
-		U32 instanceCount, 
-		U32 firstIndex, 
-		U32 baseVertex, 
+		U32 count,
+		U32 instanceCount,
+		U32 firstIndex,
+		U32 baseVertex,
 		U32 baseInstance)
-	:	m_count(count), 
-		m_instanceCount(instanceCount), 
-		m_firstIndex(firstIndex), 
+	:	m_count(count),
+		m_instanceCount(instanceCount),
+		m_firstIndex(firstIndex),
 		m_baseVertex(baseVertex),
 		m_baseInstance(baseInstance)
 	{}
@@ -130,7 +126,7 @@ public:
 	U32 m_baseInstance = 0;
 };
 
-/// The draw indirect structure for arrays drawing, also the parameters of a 
+/// The draw indirect structure for arrays drawing, also the parameters of a
 /// regular drawcall
 class GlDrawArraysIndirectInfo
 {
@@ -139,20 +135,20 @@ public:
 	{}
 
 	GlDrawArraysIndirectInfo(
-		U32 count, 
-		U32 instanceCount, 
-		U32 first, 
+		U32 count,
+		U32 instanceCount,
+		U32 first,
 		U32 baseInstance)
-	:	m_count(count), 
-		m_instanceCount(instanceCount), 
-		m_first(first), 
+	:	m_count(count),
+		m_instanceCount(instanceCount),
+		m_first(first),
 		m_baseInstance(baseInstance)
 	{}
 
 	U32 m_count = MAX_U32;
 	U32 m_instanceCount = 1;
 	U32 m_first = 0;
-	U32 m_baseInstance = 0;	
+	U32 m_baseInstance = 0;
 };
 /// @}
 

include/anki/gr/FramebufferCommon.h

@@ -7,7 +7,7 @@
 #define ANKI_GR_FRAMEBUFFER_COMMON_H
 
 #include "anki/gr/Common.h"
-#include "anki/gr/TextureHandle.h"
+#include "anki/gr/TexturePtr.h"
 
 namespace anki {
 
@@ -16,7 +16,7 @@ namespace anki {
 class Attachment
 {
 public:
-	TextureHandle m_texture;
+	TexturePtr m_texture;
 	U32 m_layer = 0;
 	U32 m_mipmap = 0;
 	PixelFormat m_format;

include/anki/gr/FramebufferHandle.h → include/anki/gr/FramebufferPtr.h

@@ -6,7 +6,7 @@
 #ifndef ANKI_GR_FRAMEBUFFER_HANDLE_H
 #define ANKI_GR_FRAMEBUFFER_HANDLE_H
 
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 #include "anki/gr/FramebufferCommon.h"
 
 namespace anki {
@@ -14,16 +14,16 @@ namespace anki {
 /// @addtogroup graphics
 /// @{
 
-/// Framebuffer handle
-class FramebufferHandle: public GrHandle<FramebufferImpl>
+/// Framebuffer.
+class FramebufferPtr: public GrPtr<FramebufferImpl>
 {
 public:
-	using Base = GrHandle<FramebufferImpl>;
+	using Base = GrPtr<FramebufferImpl>;
 	using Initializer = FramebufferInitializer;
 
-	FramebufferHandle();
+	FramebufferPtr();
 
-	~FramebufferHandle();
+	~FramebufferPtr();
 
 	/// Create a framebuffer
 	ANKI_USE_RESULT Error create(GrManager* manager,
@@ -31,7 +31,7 @@ public:
 
 	/// Bind it to the command buffer
 	/// @param commands The command buffer
-	void bind(CommandBufferHandle& commands);
+	void bind(CommandBufferPtr& commands);
 
 	/// Blit another framebuffer to this
 	/// @param[in, out] commands The command buffer
@@ -40,10 +40,10 @@ public:
 	/// @param[in] destRect The destination rectangle
 	/// @param attachmentMask The attachments to blit
 	/// @param linear Perform linean filtering
-	void blit(CommandBufferHandle& commands,
-		const FramebufferHandle& b, 
+	void blit(CommandBufferPtr& commands,
+		const FramebufferPtr& b,
 		const Array<U32, 4>& sourceRect,
-		const Array<U32, 4>& destRect, 
+		const Array<U32, 4>& destRect,
 		GLbitfield attachmentMask,
 		Bool linear);
 };

include/anki/gr/GrHandle.h

@@ -1,214 +0,0 @@
-// Copyright (C) 2009-2015, Panagiotis Christopoulos Charitos.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#ifndef ANKI_GR_GR_HANDLE_H
-#define ANKI_GR_GR_HANDLE_H
-
-#include "anki/gr/GrObject.h"
-#include "anki/gr/GrManager.h"
-
-namespace anki {
-
-/// @addtogroup graphics_private
-/// @{
-
-/// Default deleter for the GrHandle
-template<typename T>
-class GrHandleDefaultDeleter
-{
-public:
-	void operator()(T* ptr)
-	{
-		ptr->getAllocator().deleteInstance(ptr);
-	}
-};
-
-/// It's essentialy a custom shared pointer. Created to have full control over 
-/// allocations, it takes less space than a regular shared pointer (1 pointer 
-/// instead of 2) and it can have custom control blocks
-///
-/// @tparam T The type of the pointer
-template<typename T>
-class GrHandle
-{
-public:
-	using Type = T;
-
-	GrHandle()
-	:	m_cb(nullptr)
-	{}
-
-	GrHandle(const GrHandle& b)
-	:	GrHandle()
-	{
-		*this = b;
-	}
-
-	~GrHandle()
-	{
-		reset();
-	}
-
-	/// Copy
-	GrHandle& operator=(const GrHandle& b)
-	{
-		reset();
-	
-		if(b.m_cb)
-		{
-			auto count = b.m_cb->getRefcount().fetchAdd(1);
-			ANKI_ASSERT(count > 0);
-			(void)count;
-
-			m_cb = b.m_cb;
-		}
-
-		return *this;
-	}
-
-	/// Compare
-	Bool operator==(const GrHandle& b) const
-	{
-		return m_cb == b.m_cb;
-	}
-
-	/// Compare
-	Bool operator!=(const GrHandle& b) const
-	{
-		return m_cb != b.m_cb;
-	}
-
-	/// Compare
-	Bool operator<(const GrHandle& b) const
-	{
-		return m_cb < b.m_cb;
-	}
-
-	/// Compare
-	Bool operator<=(const GrHandle& b) const
-	{
-		return m_cb <= b.m_cb;
-	}
-
-	/// Compare
-	Bool operator>(const GrHandle& b) const
-	{
-		return m_cb > b.m_cb;
-	}
-
-	/// Compare
-	Bool operator>=(const GrHandle& b) const
-	{
-		return m_cb >= b.m_cb;
-	}
-
-	/// Create an object and initialize the handle with that.
-	/// @param[in,out] manager The manager.
-	/// @param[in] del The deleter that will be used to cleanup the allocated
-	///                object. Some objects example may require deferred 
-	///                deleters.
-	template<typename TDeleter>
-	void create(GrManager& manager, TDeleter del)
-	{
-		using Cb = CtrlBlock<TDeleter>;
-
-		// Create the object
-		auto alloc = manager.getAllocator();
-		T* ptr = alloc.template newInstance<T>(&manager);
-		Cb* cb = alloc.template newInstance<Cb>();
-
-		cb->m_del = del;
-		ptr->GrObject::getRefcount().store(1);
-		cb->m_ptr = ptr;
-
-		m_cb = cb;
-	}
-
-	/// Return true if it's pointing to actual data
-	Bool isCreated() const
-	{
-		return m_cb != nullptr;
-	}
-
-	/// Get the mutable pointer 
-	T& get()
-	{
-		ANKI_ASSERT(m_cb != nullptr && m_cb->m_ptr != nullptr);
-		return *static_cast<T*>(m_cb->m_ptr);
-	}
-
-	/// Get the immutable pointer
-	const T& get() const
-	{
-		ANKI_ASSERT(m_cb != nullptr && m_cb->m_ptr != nullptr);
-		return *static_cast<T*>(m_cb->m_ptr);
-	}
-
-private:
-	/// Control block base
-	class CtrlBlockBase
-	{
-	public:
-		GrObject* m_ptr;
-
-		virtual ~CtrlBlockBase()
-		{}
-
-		Atomic<I32>& getRefcount()
-		{
-			ANKI_ASSERT(m_ptr);
-			return m_ptr->getRefcount();
-		}
-		
-		/// Delete the m_ptr
-		virtual void deletePtr() = 0;
-	};
-
-	/// Control block with deleter.
-	template<typename YDeleter>
-	class CtrlBlock: public CtrlBlockBase
-	{
-	public:	
-		using Base = CtrlBlockBase;
-
-		/// The deleter functor
-		YDeleter m_del;
-		
-		void deletePtr()
-		{
-			// Delete object
-			m_del(static_cast<T*>(Base::m_ptr));
-		}
-	};
-
-	CtrlBlockBase* m_cb;
-
-	/// Reset the pointer to it's original state and remove the references to
-	/// any object
-	void reset()
-	{
-		if(m_cb && m_cb->m_ptr)
-		{
-			auto count = m_cb->getRefcount().fetchSub(1);
-			if(count == 1)
-			{
-				auto alloc = m_cb->m_ptr->getAllocator();
-				// Delete pointer
-				m_cb->deletePtr();
-				m_cb->m_ptr = nullptr;
-				// Delete control block
-				alloc.deleteInstance(m_cb);
-			}
-
-			m_cb = nullptr;
-		}
-	}
-};
-/// @}
-
-} // end namespace anki
-
-#endif
-

include/anki/gr/GrManager.h

@@ -18,7 +18,7 @@ namespace anki {
 class GrManagerInitializer
 {
 public:
-	AllocAlignedCallback m_allocCallback = nullptr; 
+	AllocAlignedCallback m_allocCallback = nullptr;
 	void* m_allocCallbackUserData = nullptr;
 
 	MakeCurrentCallback m_makeCurrentCallback = nullptr;
@@ -67,7 +67,7 @@ public:
 		return m_alloc;
 	}
 
-	GrManagerImpl& getImplementation() 
+	GrManagerImpl& getImplementation()
 	{
 		return *m_impl;
 	}

include/anki/gr/GrObject.h

@@ -8,14 +8,15 @@
 
 #include "anki/gr/Common.h"
 #include "anki/util/Atomic.h"
+#include "anki/util/NonCopyable.h"
 
 namespace anki {
 
-/// @addtogroup graphics_private
+/// @addtogroup graphics
 /// @{
 
 /// Base of all graphics objects.
-class GrObject
+class GrObject: public NonCopyable
 {
 public:
 	GrObject(GrManager* manager)

include/anki/gr/GrPtr.h

@@ -0,0 +1,52 @@
+// Copyright (C) 2009-2015, Panagiotis Christopoulos Charitos.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#ifndef ANKI_GR_GR_HANDLE_H
+#define ANKI_GR_GR_HANDLE_H
+
+#include "anki/gr/GrObject.h"
+#include "anki/gr/GrManager.h"
+#include "anki/util/Ptr.h"
+
+namespace anki {
+
+/// @addtogroup graphics
+/// @{
+
+/// Shared pointer for graphics objects.
+///
+/// @tparam T The type of the pointer
+template<typename T>
+class GrPtr: public IntrusivePtr<GrObject>
+{
+public:
+	using Base = IntrusivePtr<GrObject>;
+
+	/// Create an object and initialize the handle with that.
+	/// @param manager The manager.
+	void create(GrManager& manager)
+	{
+		// Create the object
+		auto alloc = manager.getAllocator();
+		T* ptr = alloc.template newInstance<T>(&manager);
+		Base::reset(ptr);
+	}
+
+	const T& get() const
+	{
+		return static_cast<const T&>(Base::get());
+	}
+
+	T& get()
+	{
+		return static_cast<T&>(Base::get());
+	}
+};
+/// @}
+
+} // end namespace anki
+
+#endif
+

include/anki/gr/OcclusionQueryHandle.h → include/anki/gr/OcclusionQueryPtr.h

@@ -6,33 +6,33 @@
 #ifndef ANKI_GR_OCCLUSION_QUERY_HANDLE_H
 #define ANKI_GR_OCCLUSION_QUERY_HANDLE_H
 
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 
 namespace anki {
 
 /// @addtogroup graphics
 /// @{
 
-/// Occlusion query handle.
-class OcclusionQueryHandle: public GrHandle<OcclusionQueryImpl>
+/// Occlusion query.
+class OcclusionQueryPtr: public GrPtr<OcclusionQueryImpl>
 {
 public:
-	using Base = GrHandle<OcclusionQueryImpl>;
+	using Base = GrPtr<OcclusionQueryImpl>;
 	using ResultBit = OcclusionQueryResultBit;
 
-	OcclusionQueryHandle();
+	OcclusionQueryPtr();
 
-	~OcclusionQueryHandle();
+	~OcclusionQueryPtr();
 
 	/// Create a query.
 	ANKI_USE_RESULT Error create(
 		GrManager* manager, ResultBit condRenderingBit);
 
 	/// Begin query.
-	void begin(CommandBufferHandle& commands);
+	void begin(CommandBufferPtr& commands);
 
 	/// End query.
-	void end(CommandBufferHandle& commands);
+	void end(CommandBufferPtr& commands);
 };
 /// @}
 

include/anki/gr/PipelineCommon.h

@@ -7,8 +7,8 @@
 #define ANKI_GR_PIPELINE_COMMON_H
 
 #include "anki/gr/Common.h"
-#include "anki/gr/ShaderHandle.h"
-#include "anki/gr/PipelineHandle.h"
+#include "anki/gr/ShaderPtr.h"
+#include "anki/gr/PipelinePtr.h"
 
 namespace anki {
 
@@ -109,8 +109,8 @@ public:
 	DepthStencilStateInfo m_depthStencil;
 	ColorStateInfo m_color;
 
-	Array<ShaderHandle, 6> m_shaders;
-	PipelineHandle m_templatePipeline;
+	Array<ShaderPtr, 6> m_shaders;
+	PipelinePtr m_templatePipeline;
 	SubStateBit m_definedState = SubStateBit::NONE;
 };
 /// @}

include/anki/gr/PipelineHandle.h → include/anki/gr/PipelinePtr.h

@@ -6,29 +6,29 @@
 #ifndef ANKI_GR_PIPELINE_HANDLE_H
 #define ANKI_GR_PIPELINE_HANDLE_H
 
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 
 namespace anki {
 
 /// @addtogroup graphics
 /// @{
 
-/// Program pipeline handle.
-class PipelineHandle: public GrHandle<PipelineImpl>
+/// Program pipeline.
+class PipelinePtr: public GrPtr<PipelineImpl>
 {
 public:
-	using Base = GrHandle<PipelineImpl>;
+	using Base = GrPtr<PipelineImpl>;
 	using Initializer = PipelineInitializer;
 
-	PipelineHandle();
+	PipelinePtr();
 
-	~PipelineHandle();
+	~PipelinePtr();
 
 	/// Create a pipeline
 	ANKI_USE_RESULT Error create(GrManager* manager, const Initializer& init);
 
 	/// Bind it to the state
-	void bind(CommandBufferHandle& commands);
+	void bind(CommandBufferPtr& commands);
 };
 /// @}
 

include/anki/gr/ResourceGroupCommon.h

@@ -7,9 +7,9 @@
 #define ANKI_GR_RESOURCE_GROUP_COMMON_H
 
 #include "anki/gr/Common.h"
-#include "anki/gr/TextureHandle.h"
-#include "anki/gr/SamplerHandle.h"
-#include "anki/gr/BufferHandle.h"
+#include "anki/gr/TexturePtr.h"
+#include "anki/gr/SamplerPtr.h"
+#include "anki/gr/BufferPtr.h"
 
 namespace anki {
 
@@ -20,15 +20,15 @@ namespace anki {
 class TextureBinding
 {
 public:
-	TextureHandle m_texture;
-	SamplerHandle m_sampler; ///< Use it to override texture's sampler.
+	TexturePtr m_texture;
+	SamplerPtr m_sampler; ///< Use it to override texture's sampler.
 };
 
 /// Buffer binding point.
 class BufferBinding
 {
 public:
-	BufferHandle m_buffer;
+	BufferPtr m_buffer;
 	PtrSize m_offset = 0;
 	PtrSize m_range = 0;
 };

include/anki/gr/ResourceGroupHandle.h → include/anki/gr/ResourceGroupPtr.h

@@ -6,7 +6,7 @@
 #ifndef ANKI_GR_RESOURCE_GROUP_HANDLE_H
 #define ANKI_GR_RESOURCE_GROUP_HANDLE_H
 
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 #include "anki/gr/ResourceGroupCommon.h"
 
 namespace anki {
@@ -15,15 +15,15 @@ namespace anki {
 /// @{
 
 /// A collection of resource bindings.
-class ResourceGroupHandle: public GrHandle<ResourceGroupImpl>
+class ResourceGroupPtr: public GrPtr<ResourceGroupImpl>
 {
 public:
-	using Base = GrHandle<ResourceGroupImpl>;
+	using Base = GrPtr<ResourceGroupImpl>;
 	using Initializer = ResourceGroupInitializer;
 
-	ResourceGroupHandle();
+	ResourceGroupPtr();
 
-	~ResourceGroupHandle();
+	~ResourceGroupPtr();
 
 	/// Create resource group.
 	ANKI_USE_RESULT Error create(GrManager* manager, const Initializer& init);

include/anki/gr/SamplerHandle.h → include/anki/gr/SamplerPtr.h

@@ -7,34 +7,34 @@
 #define ANKI_GR_SAMPLER_HANDLE_H
 
 #include "anki/gr/TextureSamplerCommon.h"
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 
 namespace anki {
 
 /// @addtogroup graphics
 /// @{
 
-/// Sampler handle.
-class SamplerHandle: public GrHandle<SamplerImpl>
+/// Sampler.
+class SamplerPtr: public GrPtr<SamplerImpl>
 {
 public:
-	using Base = GrHandle<SamplerImpl>;
+	using Base = GrPtr<SamplerImpl>;
 	using Initializer = SamplerInitializer;
 
 	/// Create husk.
-	SamplerHandle();
+	SamplerPtr();
 
-	~SamplerHandle();
+	~SamplerPtr();
 
 	/// Create the sampler
-	ANKI_USE_RESULT Error create(CommandBufferHandle& commands, 
+	ANKI_USE_RESULT Error create(CommandBufferPtr& commands,
 		const Initializer& init);
 
 	/// Bind to a unit
-	void bind(CommandBufferHandle& commands, U32 unit);
+	void bind(CommandBufferPtr& commands, U32 unit);
 
 	/// Bind default sampler
-	static void bindDefault(CommandBufferHandle& commands, U32 unit);
+	static void bindDefault(CommandBufferPtr& commands, U32 unit);
 };
 /// @}
 

include/anki/gr/ShaderHandle.h → include/anki/gr/ShaderPtr.h

@@ -7,25 +7,25 @@
 #define ANKI_GR_SHADER_HANDLE_H
 
 #include "anki/gr/ShaderCommon.h"
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 
 namespace anki {
 
 /// @addtogroup graphics
 /// @{
 
-/// Shader handle.
-class ShaderHandle: public GrHandle<ShaderImpl>
+/// Shader.
+class ShaderPtr: public GrPtr<ShaderImpl>
 {
 public:
-	using Base = GrHandle<ShaderImpl>;
+	using Base = GrPtr<ShaderImpl>;
 
-	ShaderHandle();
+	ShaderPtr();
 
-	~ShaderHandle();
+	~ShaderPtr();
 
 	/// Create shader program.
-	ANKI_USE_RESULT Error create(GrManager* manager, 
+	ANKI_USE_RESULT Error create(GrManager* manager,
 		ShaderType shaderType, const void* source, PtrSize sourceSize);
 };
 /// @}

include/anki/gr/TextureHandle.h → include/anki/gr/TexturePtr.h

@@ -6,7 +6,7 @@
 #ifndef ANKI_GR_TEXTURE_HANDLE_H
 #define ANKI_GR_TEXTURE_HANDLE_H
 
-#include "anki/gr/GrHandle.h"
+#include "anki/gr/GrPtr.h"
 #include "anki/gr/TextureSamplerCommon.h"
 
 namespace anki {
@@ -14,26 +14,26 @@ namespace anki {
 /// @addtogroup graphics
 /// @{
 
-/// Texture handle
-class TextureHandle: public GrHandle<TextureImpl>
+/// Texture.
+class TexturePtr: public GrPtr<TextureImpl>
 {
 public:
-	using Base = GrHandle<TextureImpl>;
+	using Base = GrPtr<TextureImpl>;
 	using Initializer = TextureInitializer;
 
 	/// Create husk
-	TextureHandle();
+	TexturePtr();
 
-	~TextureHandle();
+	~TexturePtr();
 
 	/// Create the texture
-	Error create(CommandBufferHandle& commands, const Initializer& init);
+	Error create(CommandBufferPtr& commands, const Initializer& init);
 
 	/// Bind to a unit
-	void bind(CommandBufferHandle& commands, U32 unit);
+	void bind(CommandBufferPtr& commands, U32 unit);
 
 	/// Generate mips
-	void generateMipmaps(CommandBufferHandle& commands);
+	void generateMipmaps(CommandBufferPtr& commands);
 };
 /// @}
 

include/anki/gr/gl/CommandBufferImpl.h

@@ -30,7 +30,7 @@ public:
 };
 
 /// A number of GL commands organized in a chain
-class CommandBufferImpl: public GrObject, public NonCopyable
+class CommandBufferImpl: public GrObject
 {
 public:
 	using InitHints = CommandBufferInitHints;

include/anki/gr/gl/DeferredDeleter.h

@@ -1,64 +0,0 @@
-// Copyright (C) 2009-2015, Panagiotis Christopoulos Charitos.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#ifndef ANKI_GR_GL_DEFERRED_DELETER_H
-#define ANKI_GR_GL_DEFERRED_DELETER_H
-
-#include "anki/gr/GrManager.h"
-#include "anki/gr/CommandBufferHandle.h"
-#include "anki/gr/gl/CommandBufferImpl.h"
-#include "anki/gr/gl/RenderingThread.h"
-#include "anki/gr/gl/GrManagerImpl.h"
-
-namespace anki {
-
-/// @addtogroup opengl
-/// @{
-
-/// Common deleter for objects that require deferred deletion. Some handles
-/// might get releaced in various threads but their underlying GL object should 
-/// get deleted in the server thread (where the context is). This deleter will
-/// fire a server command with the deletion if the handle gets realeased thread 
-/// other than the server thread.
-template<typename T, typename TDeleteCommand>
-class DeferredDeleter
-{
-public:
-	void operator()(T* obj)
-	{
-		ANKI_ASSERT(obj);
-		GrManager& manager = obj->getManager();
-		const RenderingThread& thread = 
-			manager.getImplementation().getRenderingThread();
-		
-		/// If not the server thread then create a command for the server thread
-		if(!thread.isServerThread())
-		{
-			CommandBufferHandle commands;
-			
-			Error err = commands.create(&manager);
-			if(!err)
-			{
-				commands.get().template pushBackNewCommand<TDeleteCommand>(obj);
-				commands.flush();
-			}
-			else
-			{
-				ANKI_LOGE("Failed to create command");
-			}
-		}
-		else
-		{
-			auto alloc = obj->getAllocator();
-			alloc.deleteInstance(obj);
-		}
-	}
-};
-/// @}
-
-} // end namespace anki
-
-#endif
-

include/anki/gr/gl/GlObject.h

@@ -11,7 +11,7 @@
 
 namespace anki {
 
-/// @addtogroup opengl_private
+/// @addtogroup opengl
 /// @{
 
 /// State of the handle
@@ -26,10 +26,11 @@ enum class GlObjectState: U32
 };
 
 /// A GL object
-class GlObject: public GrObject, public NonCopyable
+class GlObject: public GrObject
 {
 public:
 	using State = GlObjectState;
+	using GlDeleteFunction = void (*)(GLsizei, const GLuint*);
 
 	/// Default
 	GlObject(GrManager* manager)
@@ -65,6 +66,9 @@ public:
 	/// Check if the object has been created and if not serialize the thread.
 	ANKI_USE_RESULT Error serializeOnGetter() const;
 
+	/// Should be called from GL objects for deferred deletion.
+	void destroyDeferred(GlDeleteFunction deleteCallback);
+
 protected:
 	GLuint m_glName; ///< OpenGL name
 	mutable Atomic<I32> m_state;

include/anki/gr/gl/GlState.h

@@ -7,7 +7,7 @@
 #define ANKI_GR_GL_STATE_H
 
 #include "anki/gr/Common.h"
-#include "anki/gr/PipelineHandle.h"
+#include "anki/gr/PipelinePtr.h"
 
 namespace anki {
 
@@ -55,7 +55,7 @@ public:
 	GLenum m_cullMode = GL_BACK;
 	GLenum m_depthCompareFunction = GL_LESS;
 
-	PipelineHandle m_lastPipeline;
+	PipelinePtr m_lastPipeline;
 	/// @}
 
 	/// Global UBO ring buffer

include/anki/gr/gl/RenderingThread.h

@@ -6,7 +6,7 @@
 #ifndef ANKI_GR_GL_RENDERING_THREAD_H
 #define ANKI_GR_GL_RENDERING_THREAD_H
 
-#include "anki/gr/CommandBufferHandle.h"
+#include "anki/gr/CommandBufferPtr.h"
 #include "anki/gr/gl/GlState.h"
 #include "anki/util/Thread.h"
 
@@ -17,7 +17,7 @@ namespace anki {
 
 #define ANKI_DISABLE_GL_RENDERING_THREAD 0
 
-/// Command queue. It's essentialy a queue of command buffers waiting for 
+/// Command queue. It's essentialy a queue of command buffers waiting for
 /// execution and a server
 class RenderingThread
 {
@@ -54,10 +54,10 @@ public:
 	void stop();
 
 	/// Push a command buffer to the queue for deferred execution
-	void flushCommandBuffer(CommandBufferHandle& commands);
+	void flushCommandBuffer(CommandBufferPtr& commands);
 
 	/// Push a command buffer to the queue and wait for it
-	void finishCommandBuffer(CommandBufferHandle& commands);
+	void finishCommandBuffer(CommandBufferPtr& commands);
 
 	/// Sync the client and server
 	void syncClientServer();
@@ -74,7 +74,7 @@ public:
 private:
 	GrManager* m_manager = nullptr;
 
-	Array<CommandBufferHandle, 128> m_queue; ///< Command queue
+	Array<CommandBufferPtr, 128> m_queue; ///< Command queue
 	U64 m_tail; ///< Tail of queue
 	U64 m_head; ///< Head of queue. Points to the end
 	U8 m_renderingThreadSignal; ///< Signal to the thread
@@ -86,7 +86,7 @@ private:
 	void* m_ctx = nullptr; ///< Pointer to the system GL context
 	MakeCurrentCallback m_makeCurrentCb; ///< Making a context current
 
-	CommandBufferHandle m_swapBuffersCommands;
+	CommandBufferPtr m_swapBuffersCommands;
 	SwapBuffersCallback m_swapBuffersCallback;
 	void* m_swapBuffersCbData;
 	ConditionVariable m_frameCondVar;
@@ -94,13 +94,13 @@ private:
 	Bool8 m_frameWait = false;
 
 	Thread::Id m_serverThreadId;
-	
+
 	GlState m_state;
 	GLuint m_defaultVao;
 
-	/// A special command buffer that is called every time we want to wait for 
+	/// A special command buffer that is called every time we want to wait for
 	/// the server
-	CommandBufferHandle m_syncCommands;
+	CommandBufferPtr m_syncCommands;
 	Barrier m_syncBarrier{2};
 
 	GLuint m_copyFbo = MAX_U32; ///< FBO for copying from tex to buffer.

include/anki/gr/gl/SamplerImpl.h

@@ -48,8 +48,7 @@ private:
 	{
 		if(m_glName)
 		{
-			glDeleteSamplers(1, &m_glName);
-			m_glName = 0;
+			destroyDeferred(glDeleteSamplers);
 		}
 	}
 };

include/anki/renderer/Bloom.h

@@ -32,7 +32,7 @@ public:
 	~Bloom();
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	void run(CommandBufferHandle& jobs);
+	void run(CommandBufferPtr& jobs);
 
 	U32 getBlurringIterationsCount() const
 	{
@@ -45,7 +45,7 @@ public:
 
 	/// @privatesection
 	/// @{
-	TextureHandle& getRt()
+	TexturePtr& getRt()
 	{
 		return m_vblurRt;
 	}
@@ -68,29 +68,29 @@ private:
 	U32 m_blurringIterationsCount = 2; ///< The blurring iterations
 	F32 m_blurringDist = 1.0; ///< Distance in blurring
 	
-	FramebufferHandle m_hblurFb;
-	FramebufferHandle m_vblurFb;
+	FramebufferPtr m_hblurFb;
+	FramebufferPtr m_vblurFb;
 
 	ShaderResourcePointer m_toneFrag;
 	ShaderResourcePointer m_hblurFrag;
 	ShaderResourcePointer m_vblurFrag;
 
-	PipelineHandle m_tonePpline;
-	PipelineHandle m_hblurPpline;
-	PipelineHandle m_vblurPpline;
+	PipelinePtr m_tonePpline;
+	PipelinePtr m_hblurPpline;
+	PipelinePtr m_vblurPpline;
 
-	TextureHandle m_hblurRt; ///< pass0Fai with the horizontal blur FAI
-	TextureHandle m_vblurRt; ///< The final FAI
+	TexturePtr m_hblurRt; ///< pass0Fai with the horizontal blur FAI
+	TexturePtr m_vblurRt; ///< The final FAI
 	/// When a parameter changed by the setters
 	Timestamp m_parameterUpdateTimestamp = 0;
 	/// When the commonUbo got updated
 	Timestamp m_commonUboUpdateTimestamp = 0;
-	BufferHandle m_commonBuff;
+	BufferPtr m_commonBuff;
 
-	ANKI_USE_RESULT Error initFb(FramebufferHandle& fb, TextureHandle& rt);
+	ANKI_USE_RESULT Error initFb(FramebufferPtr& fb, TexturePtr& rt);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 
-	void updateDefaultBlock(CommandBufferHandle& jobs);
+	void updateDefaultBlock(CommandBufferPtr& jobs);
 };
 
 /// @}

include/anki/renderer/Dbg.h

@@ -58,7 +58,7 @@ public:
 	}
 
 private:
-	FramebufferHandle m_fb;
+	FramebufferPtr m_fb;
 	DebugDrawer* m_drawer = nullptr;
 	// Have it as ptr because the constructor calls opengl
 	SceneDebugDrawer* m_sceneDrawer = nullptr;
@@ -72,7 +72,7 @@ private:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 
-	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error run(CommandBufferPtr& jobs);
 };
 
 /// @}

include/anki/renderer/DebugDrawer.h

@@ -38,14 +38,14 @@ public:
 	void drawCube(F32 size = 1.0);
 	void drawLine(const Vec3& from, const Vec3& to, const Vec4& color);
 
-	void prepareDraw(CommandBufferHandle& jobs)
+	void prepareDraw(CommandBufferPtr& jobs)
 	{
 		m_jobs = jobs;
 	}
 
 	void finishDraw()
 	{
-		m_jobs = CommandBufferHandle(); // Release job chain
+		m_jobs = CommandBufferPtr(); // Release job chain
 	}
 
 	/// @name Render functions. Imitate the GL 1.1 immediate mode
@@ -86,8 +86,8 @@ private:
 
 	ShaderResourcePointer m_frag;
 	ShaderResourcePointer m_vert;
-	PipelineHandle m_ppline;
-	CommandBufferHandle m_jobs;
+	PipelinePtr m_ppline;
+	CommandBufferPtr m_jobs;
 
 	static const U MAX_POINTS_PER_DRAW = 256;
 	Mat4 m_mMat;
@@ -98,7 +98,7 @@ private:
 	Vec3 m_crntCol;
 	GLenum m_primitive;
 
-	BufferHandle m_vertBuff;
+	BufferPtr m_vertBuff;
 
 	Array<Vertex, MAX_POINTS_PER_DRAW> m_clientLineVerts;
 	Array<Vertex, MAX_POINTS_PER_DRAW> m_clientTriVerts;

include/anki/renderer/Drawer.h

@@ -42,7 +42,7 @@ public:
 	ANKI_USE_RESULT Error create(Renderer* r);
 
 	void prepareDraw(
-		RenderingStage stage, Pass pass, CommandBufferHandle& cmdBuff);
+		RenderingStage stage, Pass pass, CommandBufferPtr& cmdBuff);
 
 	ANKI_USE_RESULT Error render(
 		SceneNode& frsn,
@@ -56,7 +56,7 @@ private:
 
 	/// @name State
 	/// @{
-	CommandBufferHandle m_cmdBuff;
+	CommandBufferPtr m_cmdBuff;
 
 	RenderingStage m_stage;
 	Pass m_pass;

include/anki/renderer/Ez.h

@@ -27,7 +27,7 @@ private:
 	{}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferPtr& cmdBuff);
 };
 /// @}
 

include/anki/renderer/Fs.h

@@ -24,10 +24,10 @@ public:
 	~Fs();
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdb);
+	ANKI_USE_RESULT Error run(CommandBufferPtr& cmdb);
 
 private:
-	FramebufferHandle m_fb;
+	FramebufferPtr m_fb;
 };
 /// @}
 

include/anki/renderer/Is.h

@@ -45,12 +45,12 @@ public:
 
 	/// @privatesection
 	/// @{
-	TextureHandle& _getRt()
+	TexturePtr& _getRt()
 	{
 		return m_rt;
 	}
 
-	void generateMipmaps(CommandBufferHandle& cmdb)
+	void generateMipmaps(CommandBufferPtr& cmdb)
 	{
 		m_rt.generateMipmaps(cmdb);
 	}
@@ -71,37 +71,37 @@ private:
 	U32 m_currentFrame = 0; ///< Cache value.
 
 	/// The IS render target
-	TextureHandle m_rt;
+	TexturePtr m_rt;
 
 	/// The IS FBO
-	FramebufferHandle m_fb;
+	FramebufferPtr m_fb;
 
 	/// @name GPU buffers
 	/// @{
 
 	/// Contains common data for all shader programs
-	BufferHandle m_commonBuffer;
+	BufferPtr m_commonBuffer;
 
 	/// Track the updates of commonUbo
 	Timestamp m_commonBuffUpdateTimestamp = 0;
 
 	/// Contains all the lights
-	Array<BufferHandle, MAX_FRAMES> m_lightsBuffers;
+	Array<BufferPtr, MAX_FRAMES> m_lightsBuffers;
 	Array<void*, MAX_FRAMES> m_lightsBufferAddresses;
 
 	/// Contains the number of lights per tile
-	Array<BufferHandle, MAX_FRAMES> m_tilesBuffers;
+	Array<BufferPtr, MAX_FRAMES> m_tilesBuffers;
 	Array<void*, MAX_FRAMES> m_tilesBufferAddresses;
 
 	/// Contains light indices.
-	Array<BufferHandle, MAX_FRAMES> m_lightIdsBuffers;
+	Array<BufferPtr, MAX_FRAMES> m_lightIdsBuffers;
 	Array<void*, MAX_FRAMES> m_lightIdsBufferAddresses;
 	/// @}
 
 	// Light shaders
 	ShaderResourcePointer m_lightVert;
 	ShaderResourcePointer m_lightFrag;
-	PipelineHandle m_lightPpline;
+	PipelinePtr m_lightPpline;
 
 	/// Shadow mapping
 	Sm m_sm;
@@ -116,7 +116,7 @@ private:
 
 	/// @name For drawing a quad into the active framebuffer
 	/// @{
-	BufferHandle m_quadPositionsVertBuff;
+	BufferPtr m_quadPositionsVertBuff;
 	/// @}
 
 	/// @name Limits
@@ -132,16 +132,16 @@ private:
 	~Is();
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferPtr& cmdBuff);
 
 	/// Called by init
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 
 	/// Do the actual pass
-	ANKI_USE_RESULT Error lightPass(CommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error lightPass(CommandBufferPtr& cmdBuff);
 
 	/// Prepare GL for rendering
-	void setState(CommandBufferHandle& cmdBuff);
+	void setState(CommandBufferPtr& cmdBuff);
 
 	/// Calculate the size of the lights UBO
 	PtrSize calcLightsBufferSize() const;
@@ -149,7 +149,7 @@ private:
 	/// Calculate the size of the tile
 	PtrSize calcTileSize() const;
 
-	ANKI_USE_RESULT Error updateCommonBlock(CommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error updateCommonBlock(CommandBufferPtr& cmdBuff);
 
 	// Binning
 	void binLights(U32 threadId, PtrSize threadsCount, TaskCommonData& data);

include/anki/renderer/Lf.h

@@ -30,24 +30,24 @@ public:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& config);
 
-	void runOcclusionTests(CommandBufferHandle& cmdb);
+	void runOcclusionTests(CommandBufferPtr& cmdb);
 
-	void run(CommandBufferHandle& cmdb);
+	void run(CommandBufferPtr& cmdb);
 	/// @}
 
 private:
 	// Occlusion query
-	Array<BufferHandle, 3> m_positionsVertBuff;
-	BufferHandle m_mvpBuff;
+	Array<BufferPtr, 3> m_positionsVertBuff;
+	BufferPtr m_mvpBuff;
 	ShaderResourcePointer m_occlusionVert;
 	ShaderResourcePointer m_occlusionFrag;
-	PipelineHandle m_occlusionPpline;
+	PipelinePtr m_occlusionPpline;
 
 	// Sprite billboards
 	ShaderResourcePointer m_realVert;
 	ShaderResourcePointer m_realFrag;
-	PipelineHandle m_realPpline;
-	Array<BufferHandle, 3> m_flareDataBuff;
+	PipelinePtr m_realPpline;
+	Array<BufferPtr, 3> m_flareDataBuff;
 	U32 m_flareSize;
 	U8 m_maxSpritesPerFlare;
 	U8 m_maxFlares;

include/anki/renderer/MainRenderer.h

@@ -39,7 +39,7 @@ public:
 
 private:
 	ShaderResourcePointer m_blitFrag;
-	PipelineHandle m_blitPpline;
+	PipelinePtr m_blitPpline;
 
 	/// Optimize job chain
 	Array<CommandBufferInitHints, JOB_CHAINS_COUNT> m_jobsInitHints;

include/anki/renderer/Ms.h

@@ -23,32 +23,32 @@ class Ms: public RenderingPass
 public:
 	/// @privatesection
 	/// @{
-	TextureHandle& getRt0()
+	TexturePtr& getRt0()
 	{
 		return m_planes[1].m_rt0;
 	}
 
-	TextureHandle& getRt1()
+	TexturePtr& getRt1()
 	{
 		return m_planes[1].m_rt1;
 	}
 
-	TextureHandle& getRt2()
+	TexturePtr& getRt2()
 	{
 		return m_planes[1].m_rt2;
 	}
 
-	TextureHandle& getDepthRt()
+	TexturePtr& getDepthRt()
 	{
 		return m_planes[1].m_depthRt;
 	}
 
-	FramebufferHandle& getFramebuffer()
+	FramebufferPtr& getFramebuffer()
 	{
 		return m_planes[1].m_fb;
 	}
 
-	void generateMipmaps(CommandBufferHandle& cmdb);
+	void generateMipmaps(CommandBufferPtr& cmdb);
 	/// @}
 
 private:
@@ -56,19 +56,19 @@ private:
 	class Plane
 	{
 	public:
-		FramebufferHandle m_fb;
+		FramebufferPtr m_fb;
 
 		/// Contains diffuse color and emission
-		TextureHandle m_rt0;
+		TexturePtr m_rt0;
 
 		/// Contains specular color, roughness
-		TextureHandle m_rt1;
+		TexturePtr m_rt1;
 
 		/// Contains normals
-		TextureHandle m_rt2;
+		TexturePtr m_rt2;
 
 		/// Depth stencil
-		TextureHandle m_depthRt;
+		TexturePtr m_depthRt;
 	};
 
 	Ez m_ez; /// EarlyZ pass
@@ -85,7 +85,7 @@ private:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error run(CommandBufferPtr& jobs);
 
 	/// Create a G buffer FBO
 	ANKI_USE_RESULT Error createRt(U32 index, U32 samples);

include/anki/renderer/Pps.h

@@ -24,14 +24,14 @@ public:
 	/// @privatesection
 	/// @{
 	ANKI_USE_RESULT Error init(const ConfigSet& config);
-	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error run(CommandBufferPtr& jobs);
 
-	const TextureHandle& getRt() const
+	const TexturePtr& getRt() const
 	{
 		return m_rt;
 	}
 
-	TextureHandle& getRt()
+	TexturePtr& getRt()
 	{
 		return m_rt;
 	}
@@ -87,10 +87,10 @@ private:
 	UniquePtr<Bloom> m_bloom;
 	UniquePtr<Sslf> m_sslf;
 
-	FramebufferHandle m_fb;
+	FramebufferPtr m_fb;
 	ShaderResourcePointer m_frag;
-	PipelineHandle m_ppline;
-	TextureHandle m_rt;
+	PipelinePtr m_ppline;
+	TexturePtr m_rt;
 
 	TextureResourcePointer m_lut; ///< Color grading lookup texture.
 

include/anki/renderer/Renderer.h

@@ -184,19 +184,19 @@ public:
 		return UVec2(TILE_SIZE, TILE_SIZE);
 	}
 
-	const ShaderHandle& getDrawQuadVertexShader() const
+	const ShaderPtr& getDrawQuadVertexShader() const
 	{
 		return m_drawQuadVert->getGrShader();
 	}
 
-	FramebufferHandle& getDefaultFramebuffer()
+	FramebufferPtr& getDefaultFramebuffer()
 	{
 		return m_defaultFb;
 	}
 
 	/// This function does all the rendering stages and produces a final FAI
 	ANKI_USE_RESULT Error render(SceneGraph& scene,
-		Array<CommandBufferHandle, JOB_CHAINS_COUNT>& cmdBuff);
+		Array<CommandBufferPtr, JOB_CHAINS_COUNT>& cmdBuff);
 
 	/// My version of gluUnproject
 	/// @param windowCoords Window screen coords
@@ -210,12 +210,12 @@ public:
 
 	/// Draws a quad. Actually it draws 2 triangles because OpenGL will no
 	/// longer support quads
-	void drawQuad(CommandBufferHandle& cmdBuff);
+	void drawQuad(CommandBufferPtr& cmdBuff);
 
 	void drawQuadConditional(
-		OcclusionQueryHandle& q, CommandBufferHandle& cmdBuff);
+		OcclusionQueryPtr& q, CommandBufferPtr& cmdBuff);
 
-	void drawQuadInstanced(CommandBufferHandle& cmdBuff, U32 primitiveCount);
+	void drawQuadInstanced(CommandBufferPtr& cmdBuff, U32 primitiveCount);
 
 	/// Get the LOD given the distance of an object from the camera
 	F32 calculateLod(F32 distance) const
@@ -226,12 +226,12 @@ public:
 	/// Create a framebuffer attachment texture
 	ANKI_USE_RESULT Error createRenderTarget(U32 w, U32 h,
 		const PixelFormat& format, U32 samples, SamplingFilter filter,
-		U mipsCount, TextureHandle& rt);
+		U mipsCount, TexturePtr& rt);
 
 	/// Create a pipeline object that has as a vertex shader the m_drawQuadVert
 	/// and the given fragment progam
 	ANKI_USE_RESULT Error createDrawQuadPipeline(
-		ShaderHandle frag, PipelineHandle& ppline);
+		ShaderPtr frag, PipelinePtr& ppline);
 
 	/// Init the renderer given an initialization class
 	/// @param initializer The initializer class
@@ -316,7 +316,7 @@ private:
 
 	/// @name For drawing a quad into the active framebuffer
 	/// @{
-	BufferHandle m_quadPositionsBuff; ///< The VBO for quad positions
+	BufferPtr m_quadPositionsBuff; ///< The VBO for quad positions
 	ShaderResourcePointer m_drawQuadVert;
 	/// @}
 
@@ -336,7 +336,7 @@ private:
 
 	U m_framesNum; ///< Frame number
 
-	FramebufferHandle m_defaultFb;
+	FramebufferPtr m_defaultFb;
 
 	String m_shadersPrependedSource; ///< String to append in user shaders
 

include/anki/renderer/RenderingPass.h

@@ -72,10 +72,10 @@ protected:
 	class Direction
 	{
 	public:
-		FramebufferHandle m_fb;
-		TextureHandle m_rt;
+		FramebufferPtr m_fb;
+		TexturePtr m_rt;
 		ShaderResourcePointer m_frag;
-		PipelineHandle m_ppline;
+		PipelinePtr m_ppline;
 	};
 
 	enum class DirectionEnum: U
@@ -89,7 +89,7 @@ protected:
 	ANKI_USE_RESULT Error initBlurring(Renderer& r, U width, U height, U samples,
 		F32 blurringDistance);
 
-	ANKI_USE_RESULT Error runBlurring(Renderer& r, CommandBufferHandle& jobs);
+	ANKI_USE_RESULT Error runBlurring(Renderer& r, CommandBufferPtr& jobs);
 };
 
 /// @}

include/anki/renderer/Sm.h

@@ -41,13 +41,13 @@ public:
 	/// @}
 
 private:
-	TextureHandle m_sm2DArrayTex;
+	TexturePtr m_sm2DArrayTex;
 
 	/// Shadowmap
 	struct Shadowmap
 	{
 		U32 m_layerId;
-		FramebufferHandle m_fb;
+		FramebufferPtr m_fb;
 		SceneNode* m_light = nullptr;
 		U32 m_timestamp = 0; ///< Timestamp of last render or light change
 	};
@@ -79,7 +79,7 @@ private:
 	ANKI_USE_RESULT Error run(
 		SceneNode* shadowCasters[], 
 		U32 shadowCastersCount, 
-		CommandBufferHandle& cmdBuff);
+		CommandBufferPtr& cmdBuff);
 
 	/// Get max shadow casters
 	U32 getMaxLightsCount()
@@ -87,14 +87,14 @@ private:
 		return m_sms.getSize();
 	}
 
-	void prepareDraw(CommandBufferHandle& cmdBuff);
-	void finishDraw(CommandBufferHandle& cmdBuff);
+	void prepareDraw(CommandBufferPtr& cmdBuff);
+	void finishDraw(CommandBufferPtr& cmdBuff);
 
 	/// Find the best shadowmap for that light
 	Shadowmap& bestCandidate(SceneNode& light);
 
 	ANKI_USE_RESULT Error doLight(
-		SceneNode& light, CommandBufferHandle& cmdBuff, Shadowmap*& sm);
+		SceneNode& light, CommandBufferPtr& cmdBuff, Shadowmap*& sm);
 };
 
 /// @}

include/anki/renderer/Ssao.h

@@ -28,14 +28,14 @@ public:
 	{}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferPtr& cmdBuff);
 
-	TextureHandle& _getRt()
+	TexturePtr& _getRt()
 	{
 		return m_vblurRt;
 	}
 
-	BufferHandle& getUniformBuffer()
+	BufferPtr& getUniformBuffer()
 	{
 		return m_uniformsBuff;
 	}
@@ -45,24 +45,24 @@ private:
 	U32 m_width, m_height; ///< Blur passes size
 	U8 m_blurringIterationsCount;
 
-	TextureHandle m_vblurRt;
-	TextureHandle m_hblurRt;
-	FramebufferHandle m_vblurFb;
-	FramebufferHandle m_hblurFb;
+	TexturePtr m_vblurRt;
+	TexturePtr m_hblurRt;
+	FramebufferPtr m_vblurFb;
+	FramebufferPtr m_hblurFb;
 
 	ShaderResourcePointer m_ssaoFrag;
 	ShaderResourcePointer m_hblurFrag;
 	ShaderResourcePointer m_vblurFrag;
-	PipelineHandle m_ssaoPpline;
-	PipelineHandle m_hblurPpline;
-	PipelineHandle m_vblurPpline;
+	PipelinePtr m_ssaoPpline;
+	PipelinePtr m_hblurPpline;
+	PipelinePtr m_vblurPpline;
 	
 	Timestamp m_commonUboUpdateTimestamp = 0;
-	BufferHandle m_uniformsBuff;
-	TextureHandle m_noiseTex;
+	BufferPtr m_uniformsBuff;
+	TexturePtr m_noiseTex;
 
 	ANKI_USE_RESULT Error createFb(
-		FramebufferHandle& fb, TextureHandle& rt);
+		FramebufferPtr& fb, TexturePtr& rt);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 };
 

include/anki/renderer/Sslf.h

@@ -24,19 +24,19 @@ public:
 	{}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& config);
-	void run(CommandBufferHandle& cmdb);
+	void run(CommandBufferPtr& cmdb);
 
-	TextureHandle& getRt()
+	TexturePtr& getRt()
 	{
 		return m_rt;
 	}
 	/// @}
 
 private:
-	TextureHandle m_rt;
-	FramebufferHandle m_fb;
+	TexturePtr m_rt;
+	FramebufferPtr m_fb;
 	ShaderResourcePointer m_frag;
-	PipelineHandle m_ppline;
+	PipelinePtr m_ppline;
 	TextureResourcePointer m_lensDirtTex;
 
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& config);

include/anki/renderer/Sslr.h

@@ -25,7 +25,7 @@ public:
 	{}
 
 	ANKI_USE_RESULT Error init(const ConfigSet& config);
-	ANKI_USE_RESULT Error run(CommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error run(CommandBufferPtr& cmdBuff);
 	/// @}
 
 private:
@@ -34,12 +34,12 @@ private:
 
 	// 1st pass
 	ShaderResourcePointer m_reflectionFrag;
-	PipelineHandle m_reflectionPpline;
-	SamplerHandle m_depthMapSampler;
+	PipelinePtr m_reflectionPpline;
+	SamplerPtr m_depthMapSampler;
 
 	// 2nd pass: blit
 	ShaderResourcePointer m_blitFrag;
-	PipelineHandle m_blitPpline;
+	PipelinePtr m_blitPpline;
 };
 
 /// @}

include/anki/renderer/Tiler.h

@@ -74,7 +74,7 @@ public:
 	ANKI_USE_RESULT Error init();
 
 	/// Issue the GPU job
-	void runMinMax(CommandBufferHandle& cmd);
+	void runMinMax(CommandBufferPtr& cmd);
 
 	/// Update the tiles before doing visibility tests
 	void updateTiles(Camera& cam);
@@ -85,7 +85,7 @@ public:
 
 	/// @privatesection
 	/// @{
-	BufferHandle& getTilesBuffer()
+	BufferPtr& getTilesBuffer()
 	{
 		U i = (getGlobalTimestamp() - m_pbos.getSize() + 1) % m_pbos.getSize();
 		return m_pbos[i];
@@ -103,13 +103,13 @@ private:
 	SArray<Plane> m_farPlanesW;
 
 	/// PBO buffer that is used to read the data
-	Array<BufferHandle, 2> m_pbos;
+	Array<BufferPtr, 2> m_pbos;
 	Array<Vec2*, 2> m_pbosAddress;
 	DArray<Vec2> m_prevMinMaxDepth;
 
 	/// Main shader program
 	ShaderResourcePointer m_shader;
-	PipelineHandle m_ppline;
+	PipelinePtr m_ppline;
 
 	/// Used to check if the camera is changed and we need to update the planes
 	const Camera* m_prevCam = nullptr;

include/anki/renderer/Tm.h

@@ -21,19 +21,19 @@ public:
 	:	RenderingPass(r)
 	{}
 
-	BufferHandle& getAverageLuminanceBuffer()
+	BufferPtr& getAverageLuminanceBuffer()
 	{
 		return m_luminanceBuff;
 	}
 
 	ANKI_USE_RESULT Error create(const ConfigSet& initializer);
 
-	void run(CommandBufferHandle& cmdb);
+	void run(CommandBufferPtr& cmdb);
 
 private:
 	ShaderResourcePointer m_luminanceShader;
-	PipelineHandle m_luminancePpline;
-	BufferHandle m_luminanceBuff;
+	PipelinePtr m_luminancePpline;
+	BufferPtr m_luminanceBuff;
 };
 /// @}
 

include/anki/resource/Material.h

@@ -351,7 +351,7 @@ public:
 	}
 
 	ANKI_USE_RESULT Error getProgramPipeline(
-		const RenderingKey& key, PipelineHandle& out);
+		const RenderingKey& key, PipelinePtr& out);
 
 	/// Load a material file
 	ANKI_USE_RESULT Error load(const CString& filename);
@@ -367,7 +367,7 @@ private:
 	Dictionary<MaterialVariable*> m_varDict;
 
 	DArray<ShaderResourcePointer> m_progs;
-	DArray<PipelineHandle> m_pplines;
+	DArray<PipelinePtr> m_pplines;
 
 	U32 m_shaderBlockSize;
 

include/anki/resource/MaterialCommon.h

@@ -20,7 +20,7 @@ namespace anki {
 class MaterialResourceData: public NonCopyable
 {
 public:
-	PipelineHandle m_pipelines[U(Pass::COUNT)];
+	PipelinePtr m_pipelines[U(Pass::COUNT)];
 
 	MaterialResourceData() = default;
 	~MaterialResourceData() = default;

include/anki/resource/Mesh.h

@@ -88,7 +88,7 @@ public:
 
 	/// Get info on how to attach a GL buffer to the state
 	void getBufferInfo(
-		const VertexAttribute attrib, BufferHandle& buffer,
+		const VertexAttribute attrib, BufferPtr& buffer,
 		U32& size, GLenum& type, U32& stride, U32& offset,
 		Bool& normalized) const;
 
@@ -114,8 +114,8 @@ protected:
 	U8 m_texChannelsCount;
 	Bool8 m_weights;
 
-	BufferHandle m_vertBuff;
-	BufferHandle m_indicesBuff;
+	BufferPtr m_vertBuff;
+	BufferPtr m_indicesBuff;
 
 	/// Create the VBOs using the mesh data
 	ANKI_USE_RESULT Error createBuffers(const MeshLoader& loader);

include/anki/resource/Model.h

@@ -70,8 +70,8 @@ public:
 	/// offsets and counts
 	ANKI_USE_RESULT Error getRenderingDataSub(
 		const RenderingKey& key,
-		CommandBufferHandle& vertJobs,
-		PipelineHandle& ppline,
+		CommandBufferPtr& vertJobs,
+		PipelinePtr& ppline,
 		const U8* subMeshIndicesArray,
 		U32 subMeshIndicesCount,
 		Array<U32, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesCountArray,
@@ -81,7 +81,7 @@ public:
 protected:
 	ResourceAllocator<U8> m_alloc;
 	/// Array [lod][pass]
-	DArray<CommandBufferHandle> m_vertJobs;
+	DArray<CommandBufferPtr> m_vertJobs;
 	Material* m_mtl = nullptr;
 	DArray<Mesh*> m_meshes; ///< One for each LOD
 
@@ -93,7 +93,7 @@ private:
 	/// vertex descriptor
 	static ANKI_USE_RESULT Error createVertexDesc(
 		const Mesh& mesh,
-		CommandBufferHandle& vertexJobs);
+		CommandBufferPtr& vertexJobs);
 
 	/// Return the maximum number of LODs
 	U getLodsCount() const;

include/anki/resource/ShaderResource.h

@@ -26,7 +26,7 @@ public:
 	~ShaderResource()
 	{}
 
-	const ShaderHandle& getGrShader() const
+	const ShaderPtr& getGrShader() const
 	{
 		return m_shader;
 	}
@@ -60,7 +60,7 @@ public:
 	}
 
 private:
-	ShaderHandle m_shader;
+	ShaderPtr m_shader;
 	ShaderType m_type;
 };
 /// @}

include/anki/resource/TextureResource.h

@@ -35,13 +35,13 @@ public:
 	ANKI_USE_RESULT Error load(const CString& filename);
 
 	/// Get the GL texture
-	const TextureHandle& getGlTexture() const
+	const TexturePtr& getGlTexture() const
 	{
 		return m_tex;
 	}
 
 	/// Get the GL texture
-	TextureHandle& getGlTexture()
+	TexturePtr& getGlTexture()
 	{
 		return m_tex;
 	}
@@ -62,7 +62,7 @@ public:
 	}
 
 private:
-	TextureHandle m_tex;
+	TexturePtr m_tex;
 	UVec3 m_size;
 };
 /// @}

include/anki/scene/LensFlareComponent.h

@@ -71,19 +71,19 @@ public:
 		return m_colorMul;
 	}
 
-	TextureHandle getTexture() const
+	TexturePtr getTexture() const
 	{
 		return m_tex->getGlTexture();
 	}
 
-	OcclusionQueryHandle& getOcclusionQueryToTest();
+	OcclusionQueryPtr& getOcclusionQueryToTest();
 
 	/// Get the occlusion query to test.
 	/// @param[out] q The returned query.
 	/// @param[out] queryInvalid It's true if the query has an old result that
 	///             cannot be used.
 	void getOcclusionQueryToCheck(
-		OcclusionQueryHandle& q, Bool& queryInvalid);
+		OcclusionQueryPtr& q, Bool& queryInvalid);
 
 	/// @name SceneComponent virtuals
 	/// @{
@@ -104,7 +104,7 @@ private:
 	Vec2 m_firstFlareSize = Vec2(1.0);
 	Vec2 m_otherFlareSize = Vec2(1.0);
 
-	Array<OcclusionQueryHandle, 3> m_queries;
+	Array<OcclusionQueryPtr, 3> m_queries;
 	Array<Timestamp, 3> m_queryTestTimestamp = {{MAX_U32, MAX_U32, MAX_U32}};
 	U8 m_crntQueryIndex = 0;
 

include/anki/scene/ParticleEmitter.h

@@ -190,7 +190,7 @@ private:
 
 	U32 m_aliveParticlesCount = 0;
 
-	BufferHandle m_vertBuff; ///< Hold the vertex data
+	BufferPtr m_vertBuff; ///< Hold the vertex data
 	U8* m_vertBuffMapping = nullptr; 
 
 	SimulationType m_simulationType = SimulationType::UNDEFINED;

include/anki/scene/RenderComponent.h

@@ -215,7 +215,7 @@ public:
 	RenderingKey m_key;
 	const U8* m_subMeshIndicesArray; ///< @note indices != drawing indices
 	U32 m_subMeshIndicesCount;
-	CommandBufferHandle m_jobs; ///< A job chain 
+	CommandBufferPtr m_jobs; ///< A job chain 
 };
 
 /// RenderComponent interface. Implemented by renderable scene nodes

include/anki/util/Enum.h

@@ -77,7 +77,7 @@ inline typename EnumUnderlyingType<TEnum>::Type enumToType(TEnum e)
 /// @addtogroup util_other
 /// @{
 
-/// Implement all those functions that will make a stronly typed enum behave 
+/// Implement all those functions that will make a stronly typed enum behave
 /// like the old type of enums.
 #define ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(enum_, qualifier_) \
 	_ANKI_ENUM_OPERATOR(enum_, qualifier_, |, |=) \
@@ -105,7 +105,6 @@ inline TEnum valueToEnum(typename EnumUnderlyingType<TEnum>::Type v)
 {
 	return static_cast<TEnum>(v);
 }
-
 /// @}
 
 #endif

src/gr/gl/BufferImpl.cpp

@@ -16,13 +16,12 @@ void BufferImpl::destroy()
 {
 	if(isCreated())
 	{
-		glDeleteBuffers(1, &m_glName);
-		m_glName = 0;
+		destroyDeferred(glDeleteBuffers);
 	}
 }
 
 //==============================================================================
-void BufferImpl::create(GLenum target, const void* dataPtr, 
+void BufferImpl::create(GLenum target, const void* dataPtr,
 	U32 sizeInBytes, GLbitfield flags)
 {
 	ANKI_ASSERT(!isCreated());
@@ -36,11 +35,11 @@ void BufferImpl::create(GLenum target, const void* dataPtr,
 		{
 			ANKI_LOGW("The size (%u) of the uniform buffer is greater "
 				"than the spec's min", sizeInBytes);
-		} 
+		}
 		else if(sizeInBytes > (PtrSize)maxBufferSize)
 		{
 			ANKI_LOGW("The size (%u) of the uniform buffer is greater "
-				"than the implementation's min (%u)", sizeInBytes, 
+				"than the implementation's min (%u)", sizeInBytes,
 				maxBufferSize);
 		}
 	}
@@ -53,11 +52,11 @@ void BufferImpl::create(GLenum target, const void* dataPtr,
 		{
 			ANKI_LOGW("The size (%u) of the uniform buffer is greater "
 				"than the spec's min", sizeInBytes);
-		} 
+		}
 		else if(sizeInBytes > (PtrSize)maxBufferSize)
 		{
 			ANKI_LOGW("The size (%u) of the shader storage buffer is greater "
-				"than the implementation's min (%u)", sizeInBytes, 
+				"than the implementation's min (%u)", sizeInBytes,
 				maxBufferSize);
 		}
 	}
@@ -76,10 +75,10 @@ void BufferImpl::create(GLenum target, const void* dataPtr,
 	// Map if needed
 	if((flags & GL_MAP_PERSISTENT_BIT) && (flags & GL_MAP_COHERENT_BIT))
 	{
-		const GLbitfield mapbits = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT 
+		const GLbitfield mapbits = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT
 			| GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;
 
-		m_persistentMapping = 
+		m_persistentMapping =
 			glMapBufferRange(m_target, 0, sizeInBytes, flags & mapbits);
 		ANKI_ASSERT(m_persistentMapping != nullptr);
 	}
@@ -99,7 +98,7 @@ void BufferImpl::write(const void* buff, U32 offset, U32 size)
 void BufferImpl::setBinding(GLuint binding) const
 {
 	ANKI_ASSERT(isCreated());
-	ANKI_ASSERT(m_target == GL_SHADER_STORAGE_BUFFER 
+	ANKI_ASSERT(m_target == GL_SHADER_STORAGE_BUFFER
 		|| m_target == GL_UNIFORM_BUFFER);
 	glBindBufferBase(m_target, binding, m_glName);
 }

src/gr/gl/BufferHandle.cpp → src/gr/gl/BufferPtr.cpp

@@ -3,10 +3,11 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/BufferHandle.h"
-#include "anki/gr/gl/DeferredDeleter.h"
+#include "anki/gr/BufferPtr.h"
 #include "anki/gr/gl/BufferImpl.h"
 #include "anki/gr/GrManager.h"
+#include "anki/gr/gl/CommandBufferImpl.h"
+#include "anki/gr/CommandBufferPtr.h"
 
 namespace anki {
 
@@ -19,7 +20,7 @@ namespace anki {
 class BufferCreateCommand final: public GlCommand
 {
 public:
-	BufferHandle m_buff;
+	BufferPtr m_buff;
 	GLenum m_target;
 	const void* m_data;
 	PtrSize m_size;
@@ -27,11 +28,11 @@ public:
 	Bool8 m_cleanup;
 
 	BufferCreateCommand(
-		BufferHandle buff, GLenum target, const void* data, PtrSize size,
+		BufferPtr buff, GLenum target, const void* data, PtrSize size,
 		GLenum flags, Bool cleanup)
-	:	m_buff(buff), 
-		m_target(target), 
-		m_data(data), 
+	:	m_buff(buff),
+		m_target(target),
+		m_data(data),
 		m_size(size),
 		m_flags(flags),
 		m_cleanup(cleanup)
@@ -41,7 +42,7 @@ public:
 	{
 		m_buff.get().create(m_target, m_data, m_size, m_flags);
 
-		GlObject::State oldState = 
+		GlObject::State oldState =
 			m_buff.get().setStateAtomically(GlObject::State::CREATED);
 
 		(void)oldState;
@@ -61,20 +62,20 @@ public:
 class BufferWriteCommand: public GlCommand
 {
 public:
-	BufferHandle m_buff;
+	BufferPtr m_buff;
 	const void* m_data;
 	PtrSize m_dataSize;
 	PtrSize m_readOffset;
 	PtrSize m_writeOffset;
 	PtrSize m_size;
 
-	BufferWriteCommand(BufferHandle& buff, const void* data, PtrSize dataSize,
+	BufferWriteCommand(BufferPtr& buff, const void* data, PtrSize dataSize,
 		PtrSize readOffset, PtrSize writeOffset, PtrSize size)
-	:	m_buff(buff), 
-		m_data(data), 
+	:	m_buff(buff),
+		m_data(data),
 		m_dataSize(dataSize),
-		m_readOffset(readOffset), 
-		m_writeOffset(writeOffset), 
+		m_readOffset(readOffset),
+		m_writeOffset(writeOffset),
 		m_size(size)
 	{}
 
@@ -83,8 +84,8 @@ public:
 		ANKI_ASSERT(m_readOffset + m_size <= m_dataSize);
 
 		m_buff.get().write(
-			static_cast<const U8*>(m_data) + m_readOffset, 
-			m_writeOffset, 
+			static_cast<const U8*>(m_data) + m_readOffset,
+			m_writeOffset,
 			m_size);
 
 		ANKI_ASSERT(cmdb);
@@ -98,7 +99,7 @@ public:
 class BufferBindVertexCommand: public GlCommand
 {
 public:
-	BufferHandle m_buff;
+	BufferPtr m_buff;
 	U32 m_elementSize;
 	GLenum m_type;
 	Bool8 m_normalized;
@@ -106,12 +107,12 @@ public:
 	U32 m_offset;
 	U32 m_attribLocation;
 
-	BufferBindVertexCommand(BufferHandle& buff, U32 elementSize, GLenum type, 
+	BufferBindVertexCommand(BufferPtr& buff, U32 elementSize, GLenum type,
 		Bool8 normalized, U32 stride, U32 offset, U32 attribLocation)
-	:	m_buff(buff), 
-		m_elementSize(elementSize), 
-		m_type(type), 
-		m_normalized(normalized), 
+	:	m_buff(buff),
+		m_elementSize(elementSize),
+		m_type(type),
+		m_normalized(normalized),
 		m_stride(stride),
 		m_offset(offset),
 		m_attribLocation(attribLocation)
@@ -123,17 +124,17 @@ public:
 	{
 		BufferImpl& buff = m_buff.get();
 		ANKI_ASSERT(m_offset < m_buff.getSize());
-		
+
 		buff.setTarget(GL_ARRAY_BUFFER);
 		buff.bind();
 
 		glEnableVertexAttribArray(m_attribLocation);
 		glVertexAttribPointer(
-			m_attribLocation, 
-			m_elementSize, 
-			m_type, 
+			m_attribLocation,
+			m_elementSize,
+			m_type,
 			m_normalized,
-			m_stride, 
+			m_stride,
 			reinterpret_cast<const GLvoid*>(m_offset));
 
 		return ErrorCode::NONE;
@@ -144,17 +145,17 @@ public:
 class BindShaderBufferCommand: public GlCommand
 {
 public:
-	BufferHandle m_buff;
+	BufferPtr m_buff;
 	I32 m_offset;
 	I32 m_size;
 	U8 m_binding;
 
-	BindShaderBufferCommand(BufferHandle& buff, 
+	BindShaderBufferCommand(BufferPtr& buff,
 		I32 offset, I32 size, U8 binding)
 	:
-		m_buff(buff), 
-		m_offset(offset), 
-		m_size(size), 
+		m_buff(buff),
+		m_offset(offset),
+		m_size(size),
 		m_binding(binding)
 	{}
 
@@ -173,9 +174,9 @@ public:
 class BindIndexBufferCommand: public GlCommand
 {
 public:
-	BufferHandle m_buff;
+	BufferPtr m_buff;
 
-	BindIndexBufferCommand(BufferHandle& buff)
+	BindIndexBufferCommand(BufferPtr& buff)
 	:	m_buff(buff)
 	{}
 
@@ -190,30 +191,27 @@ public:
 };
 
 //==============================================================================
-// BufferHandle                                                                =
+// BufferPtr                                                                =
 //==============================================================================
 
 //==============================================================================
-BufferHandle::BufferHandle()
+BufferPtr::BufferPtr()
 {}
 
 //==============================================================================
-BufferHandle::~BufferHandle()
+BufferPtr::~BufferPtr()
 {}
 
 //==============================================================================
-Error BufferHandle::create(GrManager* manager,
+Error BufferPtr::create(GrManager* manager,
 	GLenum target, const void* data, PtrSize size, GLenum flags)
 {
 	ANKI_ASSERT(!isCreated());
 
-	using DeleteCommand = DeleteObjectCommand<BufferImpl>;
-	using Deleter = DeferredDeleter<BufferImpl, DeleteCommand>;
-
-	CommandBufferHandle cmdb;
+	CommandBufferPtr cmdb;
 	ANKI_CHECK(cmdb.create(manager));
 
-	Base::create(cmdb.get().getManager(), Deleter());
+	Base::create(cmdb.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
 	// Allocate temp memory for the data
@@ -235,8 +233,8 @@ Error BufferHandle::create(GrManager* manager,
 }
 
 //==============================================================================
-void BufferHandle::write(CommandBufferHandle& commands, 
-	const void* data, PtrSize dataSize, PtrSize readOffset, PtrSize writeOffset, 
+void BufferPtr::write(CommandBufferPtr& commands,
+	const void* data, PtrSize dataSize, PtrSize readOffset, PtrSize writeOffset,
 	PtrSize size)
 {
 	ANKI_ASSERT(isCreated());
@@ -250,7 +248,7 @@ void BufferHandle::write(CommandBufferHandle& commands,
 }
 
 //==============================================================================
-void BufferHandle::bindShaderBufferInternal(CommandBufferHandle& commands,
+void BufferPtr::bindShaderBufferInternal(CommandBufferPtr& commands,
 	I32 offset, I32 size, U32 bindingPoint)
 {
 	ANKI_ASSERT(isCreated());
@@ -259,8 +257,8 @@ void BufferHandle::bindShaderBufferInternal(CommandBufferHandle& commands,
 }
 
 //==============================================================================
-void BufferHandle::bindVertexBuffer(
-	CommandBufferHandle& commands, 
+void BufferPtr::bindVertexBuffer(
+	CommandBufferPtr& commands,
 	U32 elementSize,
 	GLenum type,
 	Bool normalized,
@@ -274,28 +272,28 @@ void BufferHandle::bindVertexBuffer(
 }
 
 //==============================================================================
-void BufferHandle::bindIndexBuffer(CommandBufferHandle& commands)
+void BufferPtr::bindIndexBuffer(CommandBufferPtr& commands)
 {
 	ANKI_ASSERT(isCreated());
 	commands.get().pushBackNewCommand<BindIndexBufferCommand>(*this);
 }
 
 //==============================================================================
-PtrSize BufferHandle::getSize() const
+PtrSize BufferPtr::getSize() const
 {
 	return (get().serializeOnGetter()) ? 0 : get().getSize();
 }
 
 //==============================================================================
-GLenum BufferHandle::getTarget() const
+GLenum BufferPtr::getTarget() const
 {
 	return (get().serializeOnGetter()) ? GL_NONE : get().getTarget();
 }
 
 //==============================================================================
-void* BufferHandle::getPersistentMappingAddress()
+void* BufferPtr::getPersistentMappingAddress()
 {
-	return (get().serializeOnGetter()) 
+	return (get().serializeOnGetter())
 		? nullptr : get().getPersistentMappingAddress();
 }
 

src/gr/gl/CommandBufferHandle.cpp → src/gr/gl/CommandBufferPtr.cpp

@@ -3,17 +3,17 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/CommandBufferHandle.h"
+#include "anki/gr/CommandBufferPtr.h"
 #include "anki/gr/gl/CommandBufferImpl.h"
 #include "anki/gr/GrManager.h"
 #include "anki/gr/gl/GrManagerImpl.h"
 #include "anki/gr/gl/RenderingThread.h"
 #include "anki/gr/gl/FramebufferImpl.h"
-#include "anki/gr/TextureHandle.h"
+#include "anki/gr/TexturePtr.h"
 #include "anki/gr/gl/TextureImpl.h"
-#include "anki/gr/BufferHandle.h"
+#include "anki/gr/BufferPtr.h"
 #include "anki/gr/gl/BufferImpl.h"
-#include "anki/gr/OcclusionQueryHandle.h"
+#include "anki/gr/OcclusionQueryPtr.h"
 #include "anki/gr/gl/OcclusionQueryImpl.h"
 #include "anki/core/Counters.h"
 #include <utility>
@@ -126,37 +126,34 @@ namespace anki {
 	get().pushBackNewCommand<Command>(enable_)
 
 //==============================================================================
-CommandBufferHandle::CommandBufferHandle()
+CommandBufferPtr::CommandBufferPtr()
 {}
 
 //==============================================================================
-CommandBufferHandle::~CommandBufferHandle()
+CommandBufferPtr::~CommandBufferPtr()
 {}
 
 //==============================================================================
-Error CommandBufferHandle::create(GrManager* manager,
+Error CommandBufferPtr::create(GrManager* manager,
 	CommandBufferInitHints hints)
 {
 	ANKI_ASSERT(!isCreated());
 	ANKI_ASSERT(manager);
 
-	Base::create(
-		*manager,
-		GrHandleDefaultDeleter<CommandBufferImpl>());
-
+	Base::create(*manager);
 	get().create(hints);
 
 	return ErrorCode::NONE;
 }
 
 //==============================================================================
-CommandBufferInitHints CommandBufferHandle::computeInitHints() const
+CommandBufferInitHints CommandBufferPtr::computeInitHints() const
 {
 	return get().computeInitHints();
 }
 
 //==============================================================================
-void CommandBufferHandle::pushBackUserCommand(
+void CommandBufferPtr::pushBackUserCommand(
 	UserCallback callback, void* data)
 {
 	class Command: public GlCommand
@@ -182,15 +179,15 @@ void CommandBufferHandle::pushBackUserCommand(
 }
 
 //==============================================================================
-void CommandBufferHandle::pushBackOtherCommandBuffer(
-	CommandBufferHandle& commands)
+void CommandBufferPtr::pushBackOtherCommandBuffer(
+	CommandBufferPtr& commands)
 {
 	class Command: public GlCommand
 	{
 	public:
-		CommandBufferHandle m_commands;
+		CommandBufferPtr m_commands;
 
-		Command(CommandBufferHandle& commands)
+		Command(CommandBufferPtr& commands)
 		:	m_commands(commands)
 		{}
 
@@ -205,21 +202,21 @@ void CommandBufferHandle::pushBackOtherCommandBuffer(
 }
 
 //==============================================================================
-void CommandBufferHandle::flush()
+void CommandBufferPtr::flush()
 {
 	get().getManager().getImplementation().
 		getRenderingThread().flushCommandBuffer(*this);
 }
 
 //==============================================================================
-void CommandBufferHandle::finish()
+void CommandBufferPtr::finish()
 {
 	get().getManager().getImplementation().getRenderingThread().
 		finishCommandBuffer(*this);
 }
 
 //==============================================================================
-void CommandBufferHandle::setViewport(U16 minx, U16 miny, U16 maxx, U16 maxy)
+void CommandBufferPtr::setViewport(U16 minx, U16 miny, U16 maxx, U16 maxy)
 {
 	class Command: public GlCommand
 	{
@@ -254,70 +251,70 @@ void CommandBufferHandle::setViewport(U16 minx, U16 miny, U16 maxx, U16 maxy)
 }
 
 //==============================================================================
-void CommandBufferHandle::setColorWriteMask(
+void CommandBufferPtr::setColorWriteMask(
 	Bool red, Bool green, Bool blue, Bool alpha)
 {
 	ANKI_STATE_CMD_4(Bool8, glColorMask, red, green, blue, alpha);
 }
 
 //==============================================================================
-void CommandBufferHandle::enableDepthTest(Bool enable)
+void CommandBufferPtr::enableDepthTest(Bool enable)
 {
 	ANKI_STATE_CMD_ENABLE(GL_DEPTH_TEST, enable);
 }
 
 //==============================================================================
-void CommandBufferHandle::setDepthFunction(GLenum func)
+void CommandBufferPtr::setDepthFunction(GLenum func)
 {
 	ANKI_STATE_CMD_1(GLenum, glDepthFunc, func);
 }
 
 //==============================================================================
-void CommandBufferHandle::setDepthWriteMask(Bool write)
+void CommandBufferPtr::setDepthWriteMask(Bool write)
 {
 	ANKI_STATE_CMD_1(Bool8, glDepthMask, write);
 }
 
 //==============================================================================
-void CommandBufferHandle::enableStencilTest(Bool enable)
+void CommandBufferPtr::enableStencilTest(Bool enable)
 {
 	ANKI_STATE_CMD_ENABLE(GL_STENCIL_TEST, enable);
 }
 
 //==============================================================================
-void CommandBufferHandle::setStencilFunction(
+void CommandBufferPtr::setStencilFunction(
 	GLenum function, U32 reference, U32 mask)
 {
 	ANKI_STATE_CMD_3(U32, glStencilFunc, function, reference, mask);
 }
 
 //==============================================================================
-void CommandBufferHandle::setStencilPlaneMask(U32 mask)
+void CommandBufferPtr::setStencilPlaneMask(U32 mask)
 {
 	ANKI_STATE_CMD_1(U32, glStencilMask, mask);
 }
 
 //==============================================================================
-void CommandBufferHandle::setStencilOperations(GLenum stencFail, GLenum depthFail,
+void CommandBufferPtr::setStencilOperations(GLenum stencFail, GLenum depthFail,
 	GLenum depthPass)
 {
 	ANKI_STATE_CMD_3(GLenum, glStencilOp, stencFail, depthFail, depthPass);
 }
 
 //==============================================================================
-void CommandBufferHandle::enableBlend(Bool enable)
+void CommandBufferPtr::enableBlend(Bool enable)
 {
 	ANKI_STATE_CMD_ENABLE(GL_BLEND, enable);
 }
 
 //==============================================================================
-void CommandBufferHandle::setBlendEquation(GLenum equation)
+void CommandBufferPtr::setBlendEquation(GLenum equation)
 {
 	ANKI_STATE_CMD_1(GLenum, glBlendEquation, equation);
 }
 
 //==============================================================================
-void CommandBufferHandle::setBlendFunctions(GLenum sfactor, GLenum dfactor)
+void CommandBufferPtr::setBlendFunctions(GLenum sfactor, GLenum dfactor)
 {
 	class Command: public GlCommand
 	{
@@ -351,55 +348,55 @@ void CommandBufferHandle::setBlendFunctions(GLenum sfactor, GLenum dfactor)
 }
 
 //==============================================================================
-void CommandBufferHandle::setBlendColor(F32 r, F32 g, F32 b, F32 a)
+void CommandBufferPtr::setBlendColor(F32 r, F32 g, F32 b, F32 a)
 {
 	ANKI_STATE_CMD_4(F32, glBlendColor, r, g, b, a);
 }
 
 //==============================================================================
-void CommandBufferHandle::enablePrimitiveRestart(Bool enable)
+void CommandBufferPtr::enablePrimitiveRestart(Bool enable)
 {
 	ANKI_STATE_CMD_ENABLE(GL_PRIMITIVE_RESTART, enable);
 }
 
 //==============================================================================
-void CommandBufferHandle::setPatchVertexCount(U32 count)
+void CommandBufferPtr::setPatchVertexCount(U32 count)
 {
 	ANKI_STATE_CMD_2(GLint, glPatchParameteri, GL_PATCH_VERTICES, count);
 }
 
 //==============================================================================
-void CommandBufferHandle::enableCulling(Bool enable)
+void CommandBufferPtr::enableCulling(Bool enable)
 {
 	ANKI_STATE_CMD_ENABLE(GL_CULL_FACE, enable);
 }
 
 //==============================================================================
-void CommandBufferHandle::setCullFace(GLenum mode)
+void CommandBufferPtr::setCullFace(GLenum mode)
 {
 	ANKI_STATE_CMD_1(GLenum, glCullFace, mode);
 }
 
 //==============================================================================
-void CommandBufferHandle::setPolygonOffset(F32 factor, F32 units)
+void CommandBufferPtr::setPolygonOffset(F32 factor, F32 units)
 {
 	ANKI_STATE_CMD_2(F32, glPolygonOffset, factor, units);
 }
 
 //==============================================================================
-void CommandBufferHandle::enablePolygonOffset(Bool enable)
+void CommandBufferPtr::enablePolygonOffset(Bool enable)
 {
 	ANKI_STATE_CMD_ENABLE(GL_POLYGON_OFFSET_FILL, enable);
 }
 
 //==============================================================================
-void CommandBufferHandle::setPolygonMode(GLenum face, GLenum mode)
+void CommandBufferPtr::setPolygonMode(GLenum face, GLenum mode)
 {
 	ANKI_STATE_CMD_2(GLenum, glPolygonMode, face, mode);
 }
 
 //==============================================================================
-void CommandBufferHandle::enablePointSize(Bool enable)
+void CommandBufferPtr::enablePointSize(Bool enable)
 {
 	ANKI_STATE_CMD_ENABLE(GL_PROGRAM_POINT_SIZE, enable);
 }
@@ -410,16 +407,16 @@ class BindTexturesCommand: public GlCommand
 public:
 	static const U MAX_BIND_TEXTURES = 8;
 
-	Array<TextureHandle, MAX_BIND_TEXTURES> m_texes;
+	Array<TexturePtr, MAX_BIND_TEXTURES> m_texes;
 	U32 m_texCount;
 	U32 m_first;
 
 	BindTexturesCommand(
-		TextureHandle textures[], U count, U32 first)
+		TexturePtr textures[], U count, U32 first)
 	:	m_first(first)
 	{
 		m_texCount = count;
-		TextureHandle* t = textures;
+		TexturePtr* t = textures;
 		while(count-- != 0)
 		{
 			m_texes[count] = *t;
@@ -444,8 +441,8 @@ public:
 	}
 };
 
-void CommandBufferHandle::bindTextures(U32 first,
-	TextureHandle textures[], U32 count)
+void CommandBufferPtr::bindTextures(U32 first,
+	TexturePtr textures[], U32 count)
 {
 	ANKI_ASSERT(count > 0);
 
@@ -459,13 +456,13 @@ public:
 	GLenum m_mode;
 	U8 m_indexSize;
 	GlDrawElementsIndirectInfo m_info;
-	OcclusionQueryHandle m_query;
+	OcclusionQueryPtr m_query;
 
 	DrawElementsCondCommand(
 		GLenum mode,
 		U8 indexSize,
 		GlDrawElementsIndirectInfo& info,
-		OcclusionQueryHandle query = OcclusionQueryHandle())
+		OcclusionQueryPtr query = OcclusionQueryPtr())
 	:	m_mode(mode),
 		m_indexSize(indexSize),
 		m_info(info),
@@ -511,7 +508,7 @@ public:
 	}
 };
 
-void CommandBufferHandle::drawElements(
+void CommandBufferPtr::drawElements(
 	GLenum mode, U8 indexSize, U32 count, U32 instanceCount, U32 firstIndex,
 	U32 baseVertex, U32 baseInstance)
 {
@@ -527,12 +524,12 @@ class DrawArraysCondCommand: public GlCommand
 public:
 	GLenum m_mode;
 	GlDrawArraysIndirectInfo m_info;
-	OcclusionQueryHandle m_query;
+	OcclusionQueryPtr m_query;
 
 	DrawArraysCondCommand(
 		GLenum mode,
 		GlDrawArraysIndirectInfo& info,
-		OcclusionQueryHandle query = OcclusionQueryHandle())
+		OcclusionQueryPtr query = OcclusionQueryPtr())
 	:	m_mode(mode),
 		m_info(info),
 		m_query(query)
@@ -556,7 +553,7 @@ public:
 	}
 };
 
-void CommandBufferHandle::drawArrays(
+void CommandBufferPtr::drawArrays(
 	GLenum mode, U32 count, U32 instanceCount, U32 first, U32 baseInstance)
 {
 	GlDrawArraysIndirectInfo info(count, instanceCount, first, baseInstance);
@@ -565,8 +562,8 @@ void CommandBufferHandle::drawArrays(
 }
 
 //==============================================================================
-void CommandBufferHandle::drawElementsConditional(
-	OcclusionQueryHandle& query,
+void CommandBufferPtr::drawElementsConditional(
+	OcclusionQueryPtr& query,
 	GLenum mode, U8 indexSize, U32 count, U32 instanceCount, U32 firstIndex,
 	U32 baseVertex, U32 baseInstance)
 {
@@ -577,8 +574,8 @@ void CommandBufferHandle::drawElementsConditional(
 }
 
 //==============================================================================
-void CommandBufferHandle::drawArraysConditional(
-	OcclusionQueryHandle& query,
+void CommandBufferPtr::drawArraysConditional(
+	OcclusionQueryPtr& query,
 	GLenum mode, U32 count, U32 instanceCount, U32 first, U32 baseInstance)
 {
 	GlDrawArraysIndirectInfo info(count, instanceCount, first, baseInstance);
@@ -590,10 +587,10 @@ void CommandBufferHandle::drawArraysConditional(
 class CopyBuffTex: public GlCommand
 {
 public:
-	TextureHandle m_tex;
-	BufferHandle m_buff;
+	TexturePtr m_tex;
+	BufferPtr m_buff;
 
-	CopyBuffTex(TextureHandle& from, BufferHandle& to)
+	CopyBuffTex(TexturePtr& from, BufferPtr& to)
 	:	m_tex(from),
 		m_buff(to)
 	{}
@@ -648,8 +645,8 @@ public:
 	}
 };
 
-void CommandBufferHandle::copyTextureToBuffer(
-	TextureHandle& from, BufferHandle& to)
+void CommandBufferPtr::copyTextureToBuffer(
+	TexturePtr& from, BufferPtr& to)
 {
 	get().pushBackNewCommand<CopyBuffTex>(from, to);
 }
@@ -671,7 +668,7 @@ public:
 	}
 };
 
-void CommandBufferHandle::dispatchCompute(
+void CommandBufferPtr::dispatchCompute(
 	U32 groupCountX, U32 groupCountY, U32 groupCountZ)
 {
 	get().pushBackNewCommand<DispatchCommand>(
@@ -702,7 +699,7 @@ public:
 	}
 };
 
-void CommandBufferHandle::updateDynamicUniforms(void* data, U32 originalSize)
+void CommandBufferPtr::updateDynamicUniforms(void* data, U32 originalSize)
 {
 	ANKI_ASSERT(data);
 	ANKI_ASSERT(originalSize > 0);

src/gr/gl/FramebufferImpl.cpp

@@ -15,7 +15,7 @@ Error FramebufferImpl::create(Initializer& init)
 {
 	*static_cast<FramebufferInitializer*>(this) = init;
 
-	if(m_colorAttachmentsCount == 0 
+	if(m_colorAttachmentsCount == 0
 		&& !m_depthStencilAttachment.m_texture.isCreated())
 	{
 		m_bindDefault = true;
@@ -50,7 +50,7 @@ Error FramebufferImpl::create(Initializer& init)
 	{
 		const Attachment& att = m_depthStencilAttachment;
 		const GLenum binding = GL_DEPTH_ATTACHMENT;
-			
+
 		attachTextureInternal(binding, att.m_texture.get(), att.m_layer);
 
 		if(att.m_loadOperation == AttachmentLoadOperation::DONT_CARE)
@@ -77,8 +77,7 @@ void FramebufferImpl::destroy()
 {
 	if(m_glName != 0)
 	{
-		glDeleteFramebuffers(1, &m_glName);
-		m_glName = 0;
+		destroyDeferred(glDeleteFramebuffers);
 	}
 }
 
@@ -135,7 +134,7 @@ void FramebufferImpl::bind()
 		// Invalidate
 		if(m_invalidateBuffersCount)
 		{
-			glInvalidateFramebuffer(GL_FRAMEBUFFER, m_invalidateBuffersCount, 
+			glInvalidateFramebuffer(GL_FRAMEBUFFER, m_invalidateBuffersCount,
 				&m_invalidateBuffers[0]);
 		}
 
@@ -150,27 +149,27 @@ void FramebufferImpl::bind()
 			}
 		}
 
-		if(m_depthStencilAttachment.m_texture.isCreated() 
-			&& m_depthStencilAttachment.m_loadOperation 
+		if(m_depthStencilAttachment.m_texture.isCreated()
+			&& m_depthStencilAttachment.m_loadOperation
 				== AttachmentLoadOperation::CLEAR)
 		{
-			glClearBufferfv(GL_DEPTH, 0, 
+			glClearBufferfv(GL_DEPTH, 0,
 				&m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth);
 		}
 	}
 }
 
 //==============================================================================
-void FramebufferImpl::blit(const FramebufferImpl& b, 
+void FramebufferImpl::blit(const FramebufferImpl& b,
 	const Array<U32, 4>& sourceRect,
-	const Array<U32, 4>& destRect, 
+	const Array<U32, 4>& destRect,
 	GLbitfield attachmentMask, Bool linear)
 {
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_glName);
 	glBindFramebuffer(GL_READ_FRAMEBUFFER, b.m_glName);
 	glBlitFramebuffer(
 		sourceRect[0], sourceRect[1], sourceRect[2], sourceRect[3],
-		destRect[0], destRect[1], destRect[2], destRect[3], 
+		destRect[0], destRect[1], destRect[2], destRect[3],
 		attachmentMask,
 		linear ? GL_LINEAR : GL_NEAREST);
 }

src/gr/gl/FramebufferHandle.cpp → src/gr/gl/FramebufferPtr.cpp

@@ -3,9 +3,11 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/FramebufferHandle.h"
-#include "anki/gr/gl/DeferredDeleter.h"
+#include "anki/gr/FramebufferPtr.h"
 #include "anki/gr/gl/FramebufferImpl.h"
+#include "anki/gr/gl/TextureImpl.h"
+#include "anki/gr/gl/CommandBufferImpl.h"
+#include "anki/gr/CommandBufferPtr.h"
 
 namespace anki {
 
@@ -17,11 +19,11 @@ namespace anki {
 class CreateFramebufferCommand: public GlCommand
 {
 public:
-	FramebufferHandle m_fb;
-	FramebufferHandle::Initializer m_init;
+	FramebufferPtr m_fb;
+	FramebufferPtr::Initializer m_init;
 
-	CreateFramebufferCommand(const FramebufferHandle& handle,
-		const FramebufferHandle::Initializer& init)
+	CreateFramebufferCommand(const FramebufferPtr& handle,
+		const FramebufferPtr::Initializer& init)
 	:	m_fb(handle),
 		m_init(init)
 	{}
@@ -43,9 +45,9 @@ public:
 class BindFramebufferCommand: public GlCommand
 {
 public:
-	FramebufferHandle m_fb;
+	FramebufferPtr m_fb;
 
-	BindFramebufferCommand(FramebufferHandle& fb)
+	BindFramebufferCommand(FramebufferPtr& fb)
 	:	m_fb(fb)
 	{}
 
@@ -60,15 +62,15 @@ public:
 class BlitFramebufferCommand: public GlCommand
 {
 public:
-	FramebufferHandle m_fbDest;
-	FramebufferHandle m_fbSrc;
+	FramebufferPtr m_fbDest;
+	FramebufferPtr m_fbSrc;
 	Array<U32, 4> m_sourceRect;
 	Array<U32, 4> m_destRect;
 	GLbitfield m_attachmentMask;
 	Bool8 m_linear;
 
-	BlitFramebufferCommand(FramebufferHandle& fbDest,
-		const FramebufferHandle& fbSrc,
+	BlitFramebufferCommand(FramebufferPtr& fbDest,
+		const FramebufferPtr& fbSrc,
 		const Array<U32, 4>& sourceRect,
 		const Array<U32, 4>& destRect,
 		GLbitfield attachmentMask,
@@ -91,27 +93,24 @@ public:
 };
 
 //==============================================================================
-// FramebufferHandle                                                           =
+// FramebufferPtr                                                           =
 //==============================================================================
 
 //==============================================================================
-FramebufferHandle::FramebufferHandle()
+FramebufferPtr::FramebufferPtr()
 {}
 
 //==============================================================================
-FramebufferHandle::~FramebufferHandle()
+FramebufferPtr::~FramebufferPtr()
 {}
 
 //==============================================================================
-Error FramebufferHandle::create(GrManager* manager, Initializer& init)
+Error FramebufferPtr::create(GrManager* manager, Initializer& init)
 {
-	using DeleteCommand = DeleteObjectCommand<FramebufferImpl>;
-	using Deleter = DeferredDeleter<FramebufferImpl, DeleteCommand>;
-
-	CommandBufferHandle cmdb;
+	CommandBufferPtr cmdb;
 	ANKI_CHECK(cmdb.create(manager));
 
-	Base::create(cmdb.get().getManager(), Deleter());
+	Base::create(cmdb.get().getManager());
 
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
@@ -122,14 +121,14 @@ Error FramebufferHandle::create(GrManager* manager, Initializer& init)
 }
 
 //==============================================================================
-void FramebufferHandle::bind(CommandBufferHandle& cmdb)
+void FramebufferPtr::bind(CommandBufferPtr& cmdb)
 {
 	cmdb.get().pushBackNewCommand<BindFramebufferCommand>(*this);
 }
 
 //==============================================================================
-void FramebufferHandle::blit(CommandBufferHandle& cmdb,
-	const FramebufferHandle& b,
+void FramebufferPtr::blit(CommandBufferPtr& cmdb,
+	const FramebufferPtr& b,
 	const Array<U32, 4>& sourceRect,
 	const Array<U32, 4>& destRect,
 	GLbitfield attachmentMask,

src/gr/gl/GlObject.cpp

@@ -7,6 +7,8 @@
 #include "anki/gr/GrManager.h"
 #include "anki/gr/gl/GrManagerImpl.h"
 #include "anki/gr/gl/RenderingThread.h"
+#include "anki/gr/CommandBufferPtr.h"
+#include "anki/gr/gl/CommandBufferImpl.h"
 
 namespace anki {
 
@@ -16,7 +18,7 @@ Error GlObject::serializeOnGetter() const
 	Error err = ErrorCode::NONE;
 	State state = State(m_state.load());
 	ANKI_ASSERT(state != State::NEW);
-	
+
 	if(state == State::TO_BE_CREATED)
 	{
 		RenderingThread& thread = const_cast<RenderingThread&>(
@@ -36,6 +38,54 @@ Error GlObject::serializeOnGetter() const
 	return err;
 }
 
+//==============================================================================
+class DeleteGlObjectCommand final: public GlCommand
+{
+public:
+	GlObject::GlDeleteFunction m_callback;
+	GLuint m_glName;
+
+	DeleteGlObjectCommand(GlObject::GlDeleteFunction callback, GLuint name)
+	:	m_callback(callback),
+		m_glName(name)
+	{}
+
+	Error operator()(CommandBufferImpl*)
+	{
+		m_callback(1, &m_glName);
+		return ErrorCode::NONE;
+	}
+};
+
+void GlObject::destroyDeferred(GlDeleteFunction deleteCallback)
+{
+	GrManager& manager = getManager();
+	RenderingThread& thread = manager.getImplementation().getRenderingThread();
+
+	if(!thread.isServerThread())
+	{
+		CommandBufferPtr commands;
+
+		Error err = commands.create(&manager);
+		if(!err)
+		{
+			commands.get().template pushBackNewCommand<DeleteGlObjectCommand>(
+				deleteCallback, m_glName);
+			commands.flush();
+		}
+		else
+		{
+			ANKI_LOGE("Failed to create command");
+		}
+	}
+	else
+	{
+		deleteCallback(1, &m_glName);
+	}
+
+	m_glName = 0;
+}
+
 } // end namespace anki
 
 

src/gr/gl/OcclusionQueryImpl.cpp

@@ -52,8 +52,7 @@ void OcclusionQueryImpl::destroy()
 {
 	if(m_glName != 0)
 	{
-		glDeleteQueries(1, &m_glName);
-		m_glName = 0;
+		destroyDeferred(glDeleteQueries);
 	}
 }
 

src/gr/gl/OcclusionQueryHandle.cpp → src/gr/gl/OcclusionQueryPtr.cpp

@@ -3,9 +3,10 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/OcclusionQueryHandle.h"
+#include "anki/gr/OcclusionQueryPtr.h"
 #include "anki/gr/gl/OcclusionQueryImpl.h"
-#include "anki/gr/gl/DeferredDeleter.h"
+#include "anki/gr/gl/CommandBufferImpl.h"
+#include "anki/gr/CommandBufferPtr.h"
 
 namespace anki {
 
@@ -16,11 +17,11 @@ namespace anki {
 /// Create command.
 class OqCreateCommand final: public GlCommand
 {
-public:	
-	OcclusionQueryHandle m_handle;
+public:
+	OcclusionQueryPtr m_handle;
 	OcclusionQueryResultBit m_condRenderingBit;
 
-	OqCreateCommand(OcclusionQueryHandle& handle, 
+	OqCreateCommand(OcclusionQueryPtr& handle,
 		OcclusionQueryResultBit condRenderingBit)
 	:	m_handle(handle),
 		m_condRenderingBit(condRenderingBit)
@@ -43,9 +44,9 @@ public:
 class OqBeginCommand final: public GlCommand
 {
 public:
-	OcclusionQueryHandle m_handle;
+	OcclusionQueryPtr m_handle;
 
-	OqBeginCommand(OcclusionQueryHandle& handle)
+	OqBeginCommand(OcclusionQueryPtr& handle)
 	:	m_handle(handle)
 	{}
 
@@ -60,9 +61,9 @@ public:
 class OqEndCommand final: public GlCommand
 {
 public:
-	OcclusionQueryHandle m_handle;
+	OcclusionQueryPtr m_handle;
 
-	OqEndCommand(OcclusionQueryHandle& handle)
+	OqEndCommand(OcclusionQueryPtr& handle)
 	:	m_handle(handle)
 	{}
 
@@ -74,28 +75,25 @@ public:
 };
 
 //==============================================================================
-// OcclusionQueryHandle                                                        =
+// OcclusionQueryPtr                                                        =
 //==============================================================================
 
 //==============================================================================
-OcclusionQueryHandle::OcclusionQueryHandle()
+OcclusionQueryPtr::OcclusionQueryPtr()
 {}
 
 //==============================================================================
-OcclusionQueryHandle::~OcclusionQueryHandle()
+OcclusionQueryPtr::~OcclusionQueryPtr()
 {}
 
 //==============================================================================
-Error OcclusionQueryHandle::create(
+Error OcclusionQueryPtr::create(
 	GrManager* manager, ResultBit condRenderingBit)
 {
-	using DeleteCommand = DeleteObjectCommand<OcclusionQueryImpl>;
-	using Deleter = DeferredDeleter<OcclusionQueryImpl, DeleteCommand>;
-
-	CommandBufferHandle cmd;
+	CommandBufferPtr cmd;
 	ANKI_CHECK(cmd.create(manager));
 
-	Base::create(*manager, Deleter());
+	Base::create(*manager);
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
 	cmd.get().pushBackNewCommand<OqCreateCommand>(*this, condRenderingBit);
@@ -105,14 +103,14 @@ Error OcclusionQueryHandle::create(
 }
 
 //==============================================================================
-void OcclusionQueryHandle::begin(CommandBufferHandle& commands)
+void OcclusionQueryPtr::begin(CommandBufferPtr& commands)
 {
 	ANKI_ASSERT(isCreated());
 	commands.get().pushBackNewCommand<OqBeginCommand>(*this);
 }
 
 //==============================================================================
-void OcclusionQueryHandle::end(CommandBufferHandle& commands)
+void OcclusionQueryPtr::end(CommandBufferPtr& commands)
 {
 	ANKI_ASSERT(isCreated());
 	commands.get().pushBackNewCommand<OqEndCommand>(*this);

src/gr/gl/PipelineImpl.cpp

@@ -140,8 +140,7 @@ void PipelineImpl::destroy()
 {
 	if(m_glName)
 	{
-		glDeleteProgramPipelines(1, &m_glName);
-		m_glName = 0;
+		destroyDeferred(glDeleteProgramPipelines);
 	}
 }
 
@@ -155,7 +154,7 @@ Error PipelineImpl::createGlPipeline()
 	U count = 6;
 	while(count-- != 0)
 	{
-		const ShaderHandle& shader = m_shaders[count];
+		const ShaderPtr& shader = m_shaders[count];
 		if(shader.isCreated())
 		{
 			ANKI_ASSERT(count == enumToType(shader.get().getType()));
@@ -196,7 +195,7 @@ Error PipelineImpl::createGlPipeline()
 
 	for(U i = 0; i < m_shaders.getSize(); i++)
 	{
-		ShaderHandle& shader = m_shaders[i];
+		ShaderPtr& shader = m_shaders[i];
 
 		if(shader.isCreated())
 		{

src/gr/gl/PipelineHandle.cpp → src/gr/gl/PipelinePtr.cpp

@@ -3,10 +3,14 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/PipelineHandle.h"
+#include "anki/gr/PipelinePtr.h"
 #include "anki/gr/PipelineCommon.h"
 #include "anki/gr/gl/PipelineImpl.h"
-#include "anki/gr/gl/DeferredDeleter.h"
+#include "anki/gr/gl/ShaderImpl.h"
+#include "anki/gr/gl/CommandBufferImpl.h"
+#include "anki/gr/CommandBufferPtr.h"
+#include "anki/gr/gl/GrManagerImpl.h"
+#include "anki/gr/gl/RenderingThread.h"
 
 namespace anki {
 
@@ -17,11 +21,11 @@ namespace anki {
 class CreatePipelineCommand final: public GlCommand
 {
 public:
-	PipelineHandle m_ppline;
+	PipelinePtr m_ppline;
 	PipelineInitializer m_init;
 
 	CreatePipelineCommand(
-		const PipelineHandle& ppline, 
+		const PipelinePtr& ppline,
 		const PipelineInitializer& init)
 	:	m_ppline(ppline),
 		m_init(init)
@@ -43,9 +47,9 @@ public:
 class BindPipelineCommand final: public GlCommand
 {
 public:
-	PipelineHandle m_ppline;
+	PipelinePtr m_ppline;
 
-	BindPipelineCommand(PipelineHandle& ppline)
+	BindPipelineCommand(PipelinePtr& ppline)
 	:	m_ppline(ppline)
 	{}
 
@@ -66,27 +70,24 @@ public:
 };
 
 //==============================================================================
-// PipelineHandle                                                              =
+// PipelinePtr                                                              =
 //==============================================================================
 
 //==============================================================================
-PipelineHandle::PipelineHandle()
+PipelinePtr::PipelinePtr()
 {}
 
 //==============================================================================
-PipelineHandle::~PipelineHandle()
+PipelinePtr::~PipelinePtr()
 {}
 
 //==============================================================================
-Error PipelineHandle::create(GrManager* manager, const Initializer& init)
+Error PipelinePtr::create(GrManager* manager, const Initializer& init)
 {
-	using DeleteCommand = DeleteObjectCommand<PipelineImpl>;
-	using Deleter = DeferredDeleter<PipelineImpl, DeleteCommand>;
-
-	CommandBufferHandle cmdb;
+	CommandBufferPtr cmdb;
 	ANKI_CHECK(cmdb.create(manager));
 
-	Base::create(cmdb.get().getManager(), Deleter());
+	Base::create(cmdb.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 	cmdb.get().pushBackNewCommand<CreatePipelineCommand>(*this, init);
 
@@ -96,7 +97,7 @@ Error PipelineHandle::create(GrManager* manager, const Initializer& init)
 }
 
 //==============================================================================
-void PipelineHandle::bind(CommandBufferHandle& commands)
+void PipelinePtr::bind(CommandBufferPtr& commands)
 {
 	ANKI_ASSERT(isCreated());
 	commands.get().pushBackNewCommand<BindPipelineCommand>(*this);

src/gr/gl/RenderingThread.cpp

@@ -48,7 +48,7 @@ RenderingThread::~RenderingThread()
 {}
 
 //==============================================================================
-void RenderingThread::flushCommandBuffer(CommandBufferHandle& commands)
+void RenderingThread::flushCommandBuffer(CommandBufferPtr& commands)
 {
 	commands.get().makeImmutable();
 
@@ -83,7 +83,7 @@ void RenderingThread::flushCommandBuffer(CommandBufferHandle& commands)
 }
 
 //==============================================================================
-void RenderingThread::finishCommandBuffer(CommandBufferHandle& commands)
+void RenderingThread::finishCommandBuffer(CommandBufferPtr& commands)
 {
 #if !ANKI_DISABLE_GL_RENDERING_THREAD
 	flushCommandBuffer(commands);
@@ -210,7 +210,7 @@ void RenderingThread::finish()
 			m_queue[i].get().makeExecuted();
 
 			// Release
-			m_queue[i] = CommandBufferHandle();
+			m_queue[i] = CommandBufferPtr();
 		}
 	}
 
@@ -238,7 +238,7 @@ void RenderingThread::threadLoop()
 
 	while(1)
 	{
-		CommandBufferHandle cmd;
+		CommandBufferPtr cmd;
 
 		// Wait for something
 		{
@@ -258,7 +258,7 @@ void RenderingThread::threadLoop()
 			U64 idx = m_head % m_queue.size();
 			// Pop a command
 			cmd = m_queue[idx];
-			m_queue[idx] = CommandBufferHandle(); // Insert empty cmd buffer
+			m_queue[idx] = CommandBufferPtr(); // Insert empty cmd buffer
 
 			++m_head;
 		}

src/gr/gl/ResourceGroupImpl.cpp

@@ -4,7 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include "anki/gr/gl/ResourceGroupImpl.h"
-#include "anki/gr/TextureHandle.h"
+#include "anki/gr/TexturePtr.h"
 #include "anki/gr/gl/TextureImpl.h"
 #include "anki/gr/gl/SamplerImpl.h"
 #include "anki/gr/gl/BufferImpl.h"

src/gr/gl/ResourceGroupHandle.cpp → src/gr/gl/ResourceGroupPtr.cpp

@@ -3,25 +3,23 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/ResourceGroupHandle.h"
+#include "anki/gr/ResourceGroupPtr.h"
 #include "anki/gr/gl/ResourceGroupImpl.h"
 
 namespace anki {
 
 //==============================================================================
-ResourceGroupHandle::ResourceGroupHandle()
+ResourceGroupPtr::ResourceGroupPtr()
 {}
 
 //==============================================================================
-ResourceGroupHandle::~ResourceGroupHandle()
+ResourceGroupPtr::~ResourceGroupPtr()
 {}
 
 //==============================================================================
-Error ResourceGroupHandle::create(GrManager* manager, const Initializer& init)
+Error ResourceGroupPtr::create(GrManager* manager, const Initializer& init)
 {
-	using Deleter = GrHandleDefaultDeleter<ResourceGroupImpl>;
-
-	Base::create(*manager, Deleter());
+	Base::create(*manager);
 	ANKI_CHECK(get().create(init));
 
 	return ErrorCode::NONE;

src/gr/gl/SamplerHandle.cpp → src/gr/gl/SamplerPtr.cpp

@@ -3,10 +3,11 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/SamplerHandle.h"
+#include "anki/gr/SamplerPtr.h"
 #include "anki/gr/gl/SamplerImpl.h"
 #include "anki/gr/GrManager.h"
-#include "anki/gr/gl/DeferredDeleter.h"	
+#include "anki/gr/gl/CommandBufferImpl.h"
+#include "anki/gr/CommandBufferPtr.h"
 
 namespace anki {
 
@@ -18,10 +19,10 @@ namespace anki {
 class CreateSamplerCommand: public GlCommand
 {
 public:
-	SamplerHandle m_sampler;
+	SamplerPtr m_sampler;
 	SamplerInitializer m_init;
 
-	CreateSamplerCommand(const SamplerHandle& sampler, 
+	CreateSamplerCommand(const SamplerPtr& sampler,
 		const SamplerInitializer& init)
 	:	m_sampler(sampler),
 		m_init(init)
@@ -46,11 +47,11 @@ public:
 class BindSamplerCommand: public GlCommand
 {
 public:
-	SamplerHandle m_sampler;
+	SamplerPtr m_sampler;
 	U8 m_unit;
 
-	BindSamplerCommand(SamplerHandle& sampler, U8 unit)
-	:	m_sampler(sampler), 
+	BindSamplerCommand(SamplerPtr& sampler, U8 unit)
+	:	m_sampler(sampler),
 		m_unit(unit)
 	{}
 
@@ -79,25 +80,22 @@ public:
 };
 
 //==============================================================================
-// SamplerHandle                                                               =
+// SamplerPtr                                                               =
 //==============================================================================
 
 //==============================================================================
-SamplerHandle::SamplerHandle()
+SamplerPtr::SamplerPtr()
 {}
 
 //==============================================================================
-SamplerHandle::~SamplerHandle()
+SamplerPtr::~SamplerPtr()
 {}
 
 //==============================================================================
-Error SamplerHandle::create(CommandBufferHandle& commands, 
+Error SamplerPtr::create(CommandBufferPtr& commands,
 	const SamplerInitializer& init)
 {
-	using DeleteCommand = DeleteObjectCommand<SamplerImpl>;
-	using Deleter = DeferredDeleter<SamplerImpl, DeleteCommand>;
-
-	Base::create(commands.get().getManager(), Deleter());
+	Base::create(commands.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 	commands.get().pushBackNewCommand<CreateSamplerCommand>(*this, init);
 
@@ -105,14 +103,14 @@ Error SamplerHandle::create(CommandBufferHandle& commands,
 }
 
 //==============================================================================
-void SamplerHandle::bind(CommandBufferHandle& commands, U32 unit)
+void SamplerPtr::bind(CommandBufferPtr& commands, U32 unit)
 {
 	ANKI_ASSERT(isCreated());
 	commands.get().pushBackNewCommand<BindSamplerCommand>(*this, unit);
 }
 
 //==============================================================================
-void SamplerHandle::bindDefault(CommandBufferHandle& commands, U32 unit)
+void SamplerPtr::bindDefault(CommandBufferPtr& commands, U32 unit)
 {
 	commands.get().pushBackNewCommand<BindDefaultSamplerCommand>(unit);
 }

src/gr/gl/ShaderImpl.cpp

@@ -16,13 +16,23 @@
 
 namespace anki {
 
+//==============================================================================
+/// Fake glDeletePrograms because some jenius created conflicting interface
+static void deleteProgram(GLsizei n, const GLuint* names)
+{
+	ANKI_ASSERT(n == 1);
+	ANKI_ASSERT(names);
+	ANKI_ASSERT(*names > 0);
+	glDeleteProgram(*names);
+}
+
 //==============================================================================
 Error ShaderImpl::create(ShaderType type, const CString& source)
 {
 	ANKI_ASSERT(source);
 	ANKI_ASSERT(!isCreated());
 
-	static const Array<GLenum, 6> gltype = {{GL_VERTEX_SHADER, 
+	static const Array<GLenum, 6> gltype = {{GL_VERTEX_SHADER,
 		GL_TESS_CONTROL_SHADER, GL_TESS_EVALUATION_SHADER, GL_GEOMETRY_SHADER,
 		GL_FRAGMENT_SHADER, GL_COMPUTE_SHADER}};
 
@@ -42,7 +52,7 @@ Error ShaderImpl::create(ShaderType type, const CString& source)
 	auto alloc = getAllocator();
 	StringAuto fullSrc(alloc);
 #if ANKI_GL == ANKI_GL_DESKTOP
-	fullSrc.sprintf("#version %d core\n%s\n", version, &source[0]); 
+	fullSrc.sprintf("#version %d core\n%s\n", version, &source[0]);
 #else
 	fullSrc.sprintf("#version %d es\n%s\n", version, &source[0]);
 #endif
@@ -88,7 +98,7 @@ Error ShaderImpl::create(ShaderType type, const CString& source)
 
 		StringAuto fname(alloc);
 		CString cacheDir = getManager().getCacheDirectory();
-		fname.sprintf("%s/%05u.%s", &cacheDir[0], 
+		fname.sprintf("%s/%05u.%s", &cacheDir[0],
 			static_cast<U32>(m_glName), ext);
 
 		File file;
@@ -96,7 +106,7 @@ Error ShaderImpl::create(ShaderType type, const CString& source)
 		ANKI_CHECK(file.writeText("%s", &fname[0]));
 	}
 #endif
-	
+
 	GLint status = GL_FALSE;
 	glGetProgramiv(m_glName, GL_LINK_STATUS, &status);
 	if(status == GL_FALSE)
@@ -119,7 +129,7 @@ void ShaderImpl::handleError(String& src)
 	String prettySrc;
 	StringList lines;
 
-	static const char* padding = 
+	static const char* padding =
 		"======================================="
 		"=======================================";
 
@@ -129,7 +139,7 @@ void ShaderImpl::handleError(String& src)
 
 	glGetProgramInfoLog(
 		m_glName, compilerLogLen, &charsWritten, &compilerLog[0]);
-		
+
 	lines.splitString(alloc, src.toCString(), '\n');
 
 	I lineno = 0;
@@ -155,8 +165,7 @@ void ShaderImpl::destroy()
 {
 	if(m_glName != 0)
 	{
-		glDeleteProgram(m_glName);
-		m_glName = 0;
+		destroyDeferred(deleteProgram);
 	}
 }
 

src/gr/gl/ShaderHandle.cpp → src/gr/gl/ShaderPtr.cpp

@@ -3,10 +3,11 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/ShaderHandle.h"
+#include "anki/gr/ShaderPtr.h"
 #include "anki/gr/GrManager.h"
-#include "anki/gr/gl/DeferredDeleter.h"
 #include "anki/gr/gl/ShaderImpl.h"
+#include "anki/gr/gl/CommandBufferImpl.h"
+#include "anki/gr/CommandBufferPtr.h"
 
 namespace anki {
 
@@ -18,20 +19,20 @@ namespace anki {
 class ShaderCreateCommand final: public GlCommand
 {
 public:
-	ShaderHandle m_shader;
+	ShaderPtr m_shader;
 	ShaderType m_type;
 	char* m_source;
 
-	ShaderCreateCommand(ShaderHandle shader, 
+	ShaderCreateCommand(ShaderPtr shader,
 		ShaderType type, char* source)
-	:	m_shader(shader), 
-		m_type(type), 
+	:	m_shader(shader),
+		m_type(type),
 		m_source(source)
 	{}
 
 	Error operator()(CommandBufferImpl* cmdb)
 	{
-		Error err = m_shader.get().create(m_type, 
+		Error err = m_shader.get().create(m_type,
 			static_cast<const char*>(m_source));
 
 		GlObject::State oldState = m_shader.get().setStateAtomically(
@@ -47,29 +48,27 @@ public:
 };
 
 //==============================================================================
-// ShaderHandle                                                                =
+// ShaderPtr                                                                =
 //==============================================================================
 
 //==============================================================================
-ShaderHandle::ShaderHandle()
+ShaderPtr::ShaderPtr()
 {}
 
 //==============================================================================
-ShaderHandle::~ShaderHandle()
+ShaderPtr::~ShaderPtr()
 {}
 
 //==============================================================================
-Error ShaderHandle::create(GrManager* manager, 
+Error ShaderPtr::create(GrManager* manager,
 	ShaderType type, const void* source, PtrSize sourceSize)
 {
 	ANKI_ASSERT(strlen(static_cast<const char*>(source)) == sourceSize - 1);
-	using DeleteCommand = DeleteObjectCommand<ShaderImpl>;
-	using Deleter = DeferredDeleter<ShaderImpl, DeleteCommand>;
 
-	CommandBufferHandle cmdb;
+	CommandBufferPtr cmdb;
 	ANKI_CHECK(cmdb.create(manager));
 
-	Base::create(cmdb.get().getManager(), Deleter());
+	Base::create(cmdb.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
 	// Copy source to the command buffer

src/gr/gl/TextureImpl.cpp

@@ -450,10 +450,9 @@ void TextureImpl::create(const Initializer& init)
 //==============================================================================
 void TextureImpl::destroy()
 {
-	if(isCreated())
+	if(m_glName)
 	{
-		glDeleteTextures(1, &m_glName);
-		m_glName = 0;
+		destroyDeferred(glDeleteTextures);
 	}
 }
 

src/gr/gl/TextureHandle.cpp → src/gr/gl/TexturePtr.cpp

@@ -3,10 +3,11 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gr/TextureHandle.h"
+#include "anki/gr/TexturePtr.h"
 #include "anki/gr/gl/TextureImpl.h"
 #include "anki/gr/GrManager.h"
-#include "anki/gr/gl/DeferredDeleter.h"	
+#include "anki/gr/gl/CommandBufferImpl.h"
+#include "anki/gr/CommandBufferPtr.h"
 
 namespace anki {
 
@@ -18,15 +19,15 @@ namespace anki {
 class CreateTextureCommand: public GlCommand
 {
 public:
-	TextureHandle m_tex;
-	TextureHandle::Initializer m_init;
+	TexturePtr m_tex;
+	TexturePtr::Initializer m_init;
 	Bool8 m_cleanup = false;
 
 	CreateTextureCommand(
-		TextureHandle tex, 
-		const TextureHandle::Initializer& init,
+		TexturePtr tex,
+		const TexturePtr::Initializer& init,
 		Bool cleanup)
-	:	m_tex(tex), 
+	:	m_tex(tex),
 		m_init(init),
 		m_cleanup(cleanup)
 	{}
@@ -66,11 +67,11 @@ public:
 class BindTextureCommand: public GlCommand
 {
 public:
-	TextureHandle m_tex;
+	TexturePtr m_tex;
 	U32 m_unit;
 
-	BindTextureCommand(TextureHandle& tex, U32 unit)
-	:	m_tex(tex), 
+	BindTextureCommand(TexturePtr& tex, U32 unit)
+	:	m_tex(tex),
 		m_unit(unit)
 	{}
 
@@ -85,9 +86,9 @@ public:
 class GenMipmapsCommand: public GlCommand
 {
 public:
-	TextureHandle m_tex;
+	TexturePtr m_tex;
 
-	GenMipmapsCommand(TextureHandle& tex)
+	GenMipmapsCommand(TexturePtr& tex)
 	:	m_tex(tex)
 	{}
 
@@ -99,20 +100,20 @@ public:
 };
 
 //==============================================================================
-// TextureHandle                                                               =
+// TexturePtr                                                               =
 //==============================================================================
 
 //==============================================================================
-TextureHandle::TextureHandle()
+TexturePtr::TexturePtr()
 {}
 
 //==============================================================================
-TextureHandle::~TextureHandle()
+TexturePtr::~TexturePtr()
 {}
 
 //==============================================================================
-Error TextureHandle::create(
-	CommandBufferHandle& commands, const Initializer& initS)
+Error TexturePtr::create(
+	CommandBufferPtr& commands, const Initializer& initS)
 {
 	ANKI_ASSERT(!isCreated());
 	Initializer init(initS);
@@ -137,10 +138,7 @@ Error TextureHandle::create(
 		}
 	}
 
-	using DeleteCommand = DeleteObjectCommand<TextureImpl>;
-	using Deleter = DeferredDeleter<TextureImpl, DeleteCommand>;
-
-	Base::create(commands.get().getManager(), Deleter());
+	Base::create(commands.get().getManager());
 	get().setStateAtomically(GlObject::State::TO_BE_CREATED);
 
 	// Fire the command
@@ -151,14 +149,14 @@ Error TextureHandle::create(
 }
 
 //==============================================================================
-void TextureHandle::bind(CommandBufferHandle& commands, U32 unit)
+void TexturePtr::bind(CommandBufferPtr& commands, U32 unit)
 {
 	ANKI_ASSERT(isCreated());
 	commands.get().pushBackNewCommand<BindTextureCommand>(*this, unit);
 }
 
 //==============================================================================
-void TextureHandle::generateMipmaps(CommandBufferHandle& commands)
+void TexturePtr::generateMipmaps(CommandBufferPtr& commands)
 {
 	ANKI_ASSERT(isCreated());
 	commands.get().pushBackNewCommand<GenMipmapsCommand>(*this);

src/renderer/Bloom.cpp

@@ -15,7 +15,7 @@ Bloom::~Bloom()
 {}
 
 //==============================================================================
-Error Bloom::initFb(FramebufferHandle& fb, TextureHandle& rt)
+Error Bloom::initFb(FramebufferPtr& fb, TexturePtr& rt)
 {
 	// Set to bilinear because the blurring techniques take advantage of that
 	ANKI_CHECK(m_r->createRenderTarget(m_width, m_height, 
@@ -23,7 +23,7 @@ Error Bloom::initFb(FramebufferHandle& fb, TextureHandle& rt)
 		1, SamplingFilter::LINEAR, 1, rt));
 
 	// Create FB
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = rt;
 	fbInit.m_colorAttachments[0].m_loadOperation = 
@@ -65,7 +65,7 @@ Error Bloom::initInternal(const ConfigSet& initializer)
 	ANKI_CHECK(m_commonBuff.create(&gl, GL_UNIFORM_BUFFER, nullptr,
 		sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT));
 
-	CommandBufferHandle cmdb;
+	CommandBufferPtr cmdb;
 	ANKI_CHECK(cmdb.create(&gl));
 	updateDefaultBlock(cmdb);
 
@@ -131,7 +131,7 @@ Error Bloom::init(const ConfigSet& initializer)
 }
 
 //==============================================================================
-void Bloom::run(CommandBufferHandle& cmdb)
+void Bloom::run(CommandBufferPtr& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 
@@ -161,7 +161,7 @@ void Bloom::run(CommandBufferHandle& cmdb)
 	{
 		if(i == 0)
 		{
-			Array<TextureHandle, 2> arr = {{m_hblurRt, m_vblurRt}};
+			Array<TexturePtr, 2> arr = {{m_hblurRt, m_vblurRt}};
 			cmdb.bindTextures(0, arr.begin(), arr.getSize());
 		}
 
@@ -181,7 +181,7 @@ void Bloom::run(CommandBufferHandle& cmdb)
 }
 
 //==============================================================================
-void Bloom::updateDefaultBlock(CommandBufferHandle& cmdb)
+void Bloom::updateDefaultBlock(CommandBufferPtr& cmdb)
 {
 	Vec4 uniform(m_threshold, m_scale, 0.0, 0.0);
 	m_commonBuff.write(cmdb, &uniform, sizeof(uniform), 0, 0, sizeof(uniform));

src/renderer/Dbg.cpp

@@ -41,7 +41,7 @@ Error Dbg::init(const ConfigSet& initializer)
 	enableBits(Flag::ALL);
 
 	// Chose the correct color FAI
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_depthStencilAttachment.m_texture = m_r->getMs().getDepthRt();
 	if(m_r->getPps().getEnabled())
@@ -75,7 +75,7 @@ Error Dbg::init(const ConfigSet& initializer)
 }
 
 //==============================================================================
-Error Dbg::run(CommandBufferHandle& cmdb)
+Error Dbg::run(CommandBufferPtr& cmdb)
 {
 	Error err = ErrorCode::NONE;
 

src/renderer/DebugDrawer.cpp

@@ -35,7 +35,7 @@ Error DebugDrawer::create(Renderer* r)
 	ANKI_CHECK(m_vert.load("shaders/Dbg.vert.glsl", &r->_getResourceManager()));
 	ANKI_CHECK(m_frag.load("shaders/Dbg.frag.glsl", &r->_getResourceManager()));
 
-	PipelineHandle::Initializer init;
+	PipelinePtr::Initializer init;
 	init.m_shaders[U(ShaderType::VERTEX)] = m_vert->getGrShader();
 	init.m_shaders[U(ShaderType::FRAGMENT)] = m_frag->getGrShader();
 

src/renderer/Drawer.cpp

@@ -32,7 +32,7 @@ public:
 	Ptr<const FrustumComponent> m_fr;
 	Ptr<RenderableDrawer> m_drawer;
 	U8 m_instanceCount;
-	CommandBufferHandle m_cmdBuff;
+	CommandBufferPtr m_cmdBuff;
 	Array<U8, MATERIAL_BLOCK_MAX_SIZE> m_tempUniformBuffer;
 
 	F32 m_flod;
@@ -232,7 +232,7 @@ void SetupRenderableVariableVisitor::uniSet<TextureResourcePointer>(
 	const TextureResourcePointer* values, U32 size)
 {
 	ANKI_ASSERT(size == 1);
-	TextureHandle tex = (*values)->getGlTexture();
+	TexturePtr tex = (*values)->getGlTexture();
 	auto unit = mtlvar.getTextureUnit();
 
 	tex.bind(m_cmdBuff, unit);
@@ -374,7 +374,7 @@ Error RenderableDrawer::render(SceneNode& frsn, VisibleNode& visibleNode)
 
 //==============================================================================
 void RenderableDrawer::prepareDraw(RenderingStage stage, Pass pass,
-	CommandBufferHandle& cmdBuff)
+	CommandBufferPtr& cmdBuff)
 {
 	// Set some numbers
 	m_stage = stage;
@@ -391,7 +391,7 @@ void RenderableDrawer::prepareDraw(RenderingStage stage, Pass pass,
 void RenderableDrawer::finishDraw()
 {
 	// Release the job chain
-	m_cmdBuff = CommandBufferHandle();
+	m_cmdBuff = CommandBufferPtr();
 }
 
 }  // end namespace anki

src/renderer/Ez.cpp

@@ -22,7 +22,7 @@ Error Ez::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Ez::run(CommandBufferHandle& cmdBuff)
+Error Ez::run(CommandBufferPtr& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
 

src/renderer/Fs.cpp

@@ -17,7 +17,7 @@ Fs::~Fs()
 //==============================================================================
 Error Fs::init(const ConfigSet&)
 {
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = m_r->getIs()._getRt();
 	fbInit.m_colorAttachments[0].m_loadOperation =
@@ -31,7 +31,7 @@ Error Fs::init(const ConfigSet&)
 }
 
 //==============================================================================
-Error Fs::run(CommandBufferHandle& cmdb)
+Error Fs::run(CommandBufferPtr& cmdb)
 {
 	Error err = ErrorCode::NONE;
 

src/renderer/Is.cpp

@@ -205,7 +205,7 @@ Error Is::initInternal(const ConfigSet& config)
 	ANKI_CHECK(m_lightFrag.loadToCache(&getResourceManager(),
 		"shaders/IsLp.frag.glsl", pps.toCString(), "r_"));
 
-	PipelineHandle::Initializer init;
+	PipelinePtr::Initializer init;
 		init.m_shaders[U(ShaderType::VERTEX)] = m_lightVert->getGrShader();
 		init.m_shaders[U(ShaderType::FRAGMENT)] = m_lightFrag->getGrShader();
 	ANKI_CHECK(m_lightPpline.create(&getGrManager(), init));
@@ -220,7 +220,7 @@ Error Is::initInternal(const ConfigSet& config)
 		//PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM),
 		1, SamplingFilter::LINEAR, MIPMAPS_COUNT, m_rt));
 
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = m_rt;
 	fbInit.m_colorAttachments[0].m_loadOperation =
@@ -280,7 +280,7 @@ Error Is::initInternal(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Is::lightPass(CommandBufferHandle& cmdBuff)
+Error Is::lightPass(CommandBufferPtr& cmdBuff)
 {
 	Error err = ErrorCode::NONE;
 	Threadpool& threadPool = m_r->_getThreadpool();
@@ -444,7 +444,7 @@ Error Is::lightPass(CommandBufferHandle& cmdBuff)
 		cmdBuff, LIGHT_IDS_BLOCK_BINDING);
 
 	// The binding points should much the shader
-	Array<TextureHandle, 5> tarr = {{
+	Array<TexturePtr, 5> tarr = {{
 		m_r->getMs().getRt0(),
 		m_r->getMs().getRt1(),
 		m_r->getMs().getRt2(),
@@ -752,7 +752,7 @@ void Is::binLight(
 }
 
 //==============================================================================
-void Is::setState(CommandBufferHandle& cmdBuff)
+void Is::setState(CommandBufferPtr& cmdBuff)
 {
 #if 1
 	Bool drawToDefaultFbo = !m_r->getPps().getEnabled()
@@ -778,14 +778,14 @@ void Is::setState(CommandBufferHandle& cmdBuff)
 }
 
 //==============================================================================
-Error Is::run(CommandBufferHandle& cmdBuff)
+Error Is::run(CommandBufferPtr& cmdBuff)
 {
 	// Do the light pass including the shadow passes
 	return lightPass(cmdBuff);
 }
 
 //==============================================================================
-Error Is::updateCommonBlock(CommandBufferHandle& cmdBuff)
+Error Is::updateCommonBlock(CommandBufferPtr& cmdBuff)
 {
 	SceneGraph& scene = m_r->getSceneGraph();
 	shader::CommonUniforms blk;

src/renderer/Lf.cpp

@@ -72,7 +72,7 @@ Error Lf::initSprite(const ConfigSet& config)
 	ANKI_CHECK(m_realFrag.loadToCache(&getResourceManager(), 
 		"shaders/LfSpritePass.frag.glsl", pps.toCString(), "r_"));
 
-	PipelineHandle::Initializer init;
+	PipelinePtr::Initializer init;
 	init.m_shaders[U(ShaderType::VERTEX)] = m_realVert->getGrShader();
 	init.m_shaders[U(ShaderType::FRAGMENT)] = m_realFrag->getGrShader();
 	ANKI_CHECK(m_realPpline.create(&getGrManager(), init));
@@ -118,7 +118,7 @@ Error Lf::initOcclusion(const ConfigSet& config)
 	ANKI_CHECK(m_occlusionFrag.load("shaders/LfOcclusion.frag.glsl",
 		&getResourceManager()));
 
-	PipelineHandle::Initializer init;
+	PipelinePtr::Initializer init;
 		init.m_shaders[U(ShaderType::VERTEX)] = m_occlusionVert->getGrShader();
 		init.m_shaders[U(ShaderType::FRAGMENT)] = 
 			m_occlusionFrag->getGrShader();
@@ -137,7 +137,7 @@ Error Lf::initInternal(const ConfigSet& config)
 }
 
 //==============================================================================
-void Lf::runOcclusionTests(CommandBufferHandle& cmdb)
+void Lf::runOcclusionTests(CommandBufferPtr& cmdb)
 {
 	// Retrieve some things
 	SceneGraph& scene = m_r->getSceneGraph();
@@ -164,7 +164,7 @@ void Lf::runOcclusionTests(CommandBufferHandle& cmdb)
 		m_mvpBuff.bindShaderBuffer(cmdb, 0, sizeof(Mat4), 0);
 
 		// Allocate vertices and fire write job
-		BufferHandle& positionsVertBuff = m_positionsVertBuff[
+		BufferPtr& positionsVertBuff = m_positionsVertBuff[
 			getGlobalTimestamp() % m_positionsVertBuff.getSize()];
 		ANKI_ASSERT(sizeof(Vec3) * totalCount <= positionsVertBuff.getSize());
 		
@@ -186,7 +186,7 @@ void Lf::runOcclusionTests(CommandBufferHandle& cmdb)
 			*positions = lf.getWorldPosition().xyz();
 
 			// Draw and query
-			OcclusionQueryHandle& query = lf.getOcclusionQueryToTest();
+			OcclusionQueryPtr& query = lf.getOcclusionQueryToTest();
 			query.begin(cmdb);
 
 			cmdb.drawArrays(GL_POINTS, 1, 1, positions - initialPositions);
@@ -205,7 +205,7 @@ void Lf::runOcclusionTests(CommandBufferHandle& cmdb)
 }
 
 //==============================================================================
-void Lf::run(CommandBufferHandle& cmdb)
+void Lf::run(CommandBufferPtr& cmdb)
 {
 	// Retrieve some things
 	SceneGraph& scene = m_r->getSceneGraph();
@@ -227,7 +227,7 @@ void Lf::run(CommandBufferHandle& cmdb)
 		cmdb.setBlendFunctions(GL_ONE, GL_ONE);
 
 		// Send the command to write the buffer now
-		BufferHandle& flareDataBuff = m_flareDataBuff[
+		BufferPtr& flareDataBuff = m_flareDataBuff[
 			getGlobalTimestamp() % m_flareDataBuff.getSize()];
 
 		Sprite* sprites = static_cast<Sprite*>(
@@ -276,7 +276,7 @@ void Lf::run(CommandBufferHandle& cmdb)
 				sizeof(Sprite) * count,
 				0);
 
-			OcclusionQueryHandle query;
+			OcclusionQueryPtr query;
 			Bool queryInvalid;
 			lf.getOcclusionQueryToCheck(query, queryInvalid);
 			

src/renderer/MainRenderer.cpp

@@ -57,8 +57,8 @@ Error MainRenderer::render(SceneGraph& scene)
 	ANKI_COUNTER_START_TIMER(MAIN_RENDERER_TIME);
 
 	GrManager& gl = _getGrManager();
-	Array<CommandBufferHandle, JOB_CHAINS_COUNT> jobs;
-	CommandBufferHandle& lastJobs = jobs[JOB_CHAINS_COUNT - 1];
+	Array<CommandBufferPtr, JOB_CHAINS_COUNT> jobs;
+	CommandBufferPtr& lastJobs = jobs[JOB_CHAINS_COUNT - 1];
 
 	for(U i = 0; i < JOB_CHAINS_COUNT; i++)
 	{
@@ -84,7 +84,7 @@ Error MainRenderer::render(SceneGraph& scene)
 
 		m_blitPpline.bind(lastJobs);
 
-		TextureHandle* rt;
+		TexturePtr* rt;
 
 		if(getPps().getEnabled())
 		{
@@ -122,7 +122,7 @@ Error MainRenderer::render(SceneGraph& scene)
 Error MainRenderer::initGl()
 {
 	// get max texture units
-	CommandBufferHandle cmdb;
+	CommandBufferPtr cmdb;
 	Error err = cmdb.create(&_getGrManager());
 
 	if(!err)

src/renderer/Ms.cpp

@@ -44,7 +44,7 @@ Error Ms::createRt(U32 index, U32 samples)
 	loadop = AttachmentLoadOperation::CLEAR;
 #endif
 
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 3;
 	fbInit.m_colorAttachments[0].m_texture = plane.m_rt0;
 	fbInit.m_colorAttachments[0].m_loadOperation = loadop;
@@ -89,7 +89,7 @@ Error Ms::initInternal(const ConfigSet& initializer)
 }
 
 //==============================================================================
-Error Ms::run(CommandBufferHandle& cmdb)
+Error Ms::run(CommandBufferPtr& cmdb)
 {
 	// Chose the multisampled or the singlesampled framebuffer
 	U planeId = 0;
@@ -155,7 +155,7 @@ Error Ms::run(CommandBufferHandle& cmdb)
 }
 
 //==============================================================================
-void Ms::generateMipmaps(CommandBufferHandle& cmdb)
+void Ms::generateMipmaps(CommandBufferPtr& cmdb)
 {
 	U planeId = (m_r->getSamples() == 1) ? 1 : 0;
 	m_planes[planeId].m_depthRt.generateMipmaps(cmdb);

src/renderer/Pps.cpp

@@ -58,7 +58,7 @@ Error Pps::initInternal(const ConfigSet& config)
 		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM), 
 		1, SamplingFilter::LINEAR, 1, m_rt));
 
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = m_rt;
 	fbInit.m_colorAttachments[0].m_loadOperation = 
@@ -114,7 +114,7 @@ Error Pps::loadColorGradingTexture(CString filename)
 }
 
 //==============================================================================
-Error Pps::run(CommandBufferHandle& cmdb)
+Error Pps::run(CommandBufferPtr& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 

src/renderer/Renderer.cpp

@@ -148,7 +148,7 @@ Error Renderer::initInternal(const ConfigSet& config)
 	ANKI_CHECK(m_dbg.init(config));
 
 	// Default FB
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	ANKI_CHECK(m_defaultFb.create(m_gr, fbInit));
 
 	return ErrorCode::NONE;
@@ -156,7 +156,7 @@ Error Renderer::initInternal(const ConfigSet& config)
 
 //==============================================================================
 Error Renderer::render(SceneGraph& scene,
-	Array<CommandBufferHandle, JOB_CHAINS_COUNT>& cmdBuff)
+	Array<CommandBufferPtr, JOB_CHAINS_COUNT>& cmdBuff)
 {
 	m_scene = &scene;
 	m_frameAlloc.getMemoryPool().reset();
@@ -213,14 +213,14 @@ Error Renderer::render(SceneGraph& scene,
 }
 
 //==============================================================================
-void Renderer::drawQuad(CommandBufferHandle& cmdBuff)
+void Renderer::drawQuad(CommandBufferPtr& cmdBuff)
 {
 	drawQuadInstanced(cmdBuff, 1);
 }
 
 //==============================================================================
-void Renderer::drawQuadConditional(OcclusionQueryHandle& q,
-	CommandBufferHandle& cmdBuff)
+void Renderer::drawQuadConditional(OcclusionQueryPtr& q,
+	CommandBufferPtr& cmdBuff)
 {
 	m_quadPositionsBuff.bindVertexBuffer(cmdBuff, 2, GL_FLOAT, false, 0, 0, 0);
 	cmdBuff.drawArraysConditional(q, GL_TRIANGLE_STRIP, 4, 1);
@@ -228,7 +228,7 @@ void Renderer::drawQuadConditional(OcclusionQueryHandle& q,
 
 //==============================================================================
 void Renderer::drawQuadInstanced(
-	CommandBufferHandle& cmdBuff, U32 primitiveCount)
+	CommandBufferPtr& cmdBuff, U32 primitiveCount)
 {
 	m_quadPositionsBuff.bindVertexBuffer(cmdBuff, 2, GL_FLOAT, false, 0, 0, 0);
 
@@ -256,7 +256,7 @@ Vec3 Renderer::unproject(const Vec3& windowCoords, const Mat4& modelViewMat,
 
 //==============================================================================
 Error Renderer::createRenderTarget(U32 w, U32 h, const PixelFormat& format,
-	U32 samples, SamplingFilter filter, U mipsCount, TextureHandle& rt)
+	U32 samples, SamplingFilter filter, U mipsCount, TexturePtr& rt)
 {
 	// Not very important but keep the resulution of render targets aligned to
 	// 16
@@ -266,7 +266,7 @@ Error Renderer::createRenderTarget(U32 w, U32 h, const PixelFormat& format,
 		ANKI_ASSERT(isAligned(16, h));
 	}
 
-	TextureHandle::Initializer init;
+	TexturePtr::Initializer init;
 
 	init.m_width = w;
 	init.m_height = h;
@@ -287,7 +287,7 @@ Error Renderer::createRenderTarget(U32 w, U32 h, const PixelFormat& format,
 	init.m_sampling.m_repeat = false;
 	init.m_sampling.m_anisotropyLevel = 0;
 
-	CommandBufferHandle cmdBuff;
+	CommandBufferPtr cmdBuff;
 	ANKI_CHECK(cmdBuff.create(m_gr));
 
 	rt.create(cmdBuff, init);
@@ -298,9 +298,9 @@ Error Renderer::createRenderTarget(U32 w, U32 h, const PixelFormat& format,
 
 //==============================================================================
 Error Renderer::createDrawQuadPipeline(
-	ShaderHandle frag, PipelineHandle& ppline)
+	ShaderPtr frag, PipelinePtr& ppline)
 {
-	PipelineHandle::Initializer init;
+	PipelinePtr::Initializer init;
 	init.m_shaders[U(ShaderType::VERTEX)] = m_drawQuadVert->getGrShader();
 	init.m_shaders[U(ShaderType::FRAGMENT)] = frag;
 

src/renderer/RenderingPass.cpp

@@ -76,7 +76,7 @@ Error BlurringRenderingPass::initBlurring(
 			1, SamplingFilter::LINEAR, 1, dir.m_rt));
 
 		// Create FB
-		FramebufferHandle::Initializer fbInit;
+		FramebufferPtr::Initializer fbInit;
 		fbInit.m_colorAttachmentsCount = 1;
 		fbInit.m_colorAttachments[0].m_texture = dir.m_rt;
 		fbInit.m_colorAttachments[0].m_loadOperation =
@@ -96,7 +96,7 @@ Error BlurringRenderingPass::initBlurring(
 
 //==============================================================================
 Error BlurringRenderingPass::runBlurring(
-	Renderer& r, CommandBufferHandle& cmdb)
+	Renderer& r, CommandBufferPtr& cmdb)
 {
 	// H pass input
 	m_dirs[enumToValue(DirectionEnum::VERTICAL)].m_rt.bind(cmdb, 1);

src/renderer/Sm.cpp

@@ -38,7 +38,7 @@ Error Sm::init(const ConfigSet& initializer)
 	}
 
 	// Create shadowmaps array
-	TextureHandle::Initializer sminit;
+	TexturePtr::Initializer sminit;
 	sminit.m_type = TextureType::_2D_ARRAY;
 	sminit.m_width = m_resolution;
 	sminit.m_height = m_resolution;
@@ -50,7 +50,7 @@ Error Sm::init(const ConfigSet& initializer)
 		: SamplingFilter::NEAREST;
 	sminit.m_sampling.m_compareOperation = CompareOperation::LESS_EQUAL;
 
-	CommandBufferHandle cmdBuff;
+	CommandBufferPtr cmdBuff;
 	ANKI_CHECK(cmdBuff.create(&getGrManager()));
 
 	ANKI_CHECK(m_sm2DArrayTex.create(cmdBuff, sminit));
@@ -59,7 +59,7 @@ Error Sm::init(const ConfigSet& initializer)
 	// Init sms
 	m_sms.create(getAllocator(), initializer.get("is.sm.maxLights"));
 
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_depthStencilAttachment.m_texture = m_sm2DArrayTex;
 	fbInit.m_depthStencilAttachment.m_loadOperation = 
 		AttachmentLoadOperation::CLEAR;
@@ -80,7 +80,7 @@ Error Sm::init(const ConfigSet& initializer)
 }
 
 //==============================================================================
-void Sm::prepareDraw(CommandBufferHandle& cmdBuff)
+void Sm::prepareDraw(CommandBufferPtr& cmdBuff)
 {
 	// disable color & blend & enable depth test
 
@@ -97,7 +97,7 @@ void Sm::prepareDraw(CommandBufferHandle& cmdBuff)
 }
 
 //==============================================================================
-void Sm::finishDraw(CommandBufferHandle& cmdBuff)
+void Sm::finishDraw(CommandBufferPtr& cmdBuff)
 {
 	m_r->getSceneDrawer().finishDraw();
 
@@ -109,7 +109,7 @@ void Sm::finishDraw(CommandBufferHandle& cmdBuff)
 
 //==============================================================================
 Error Sm::run(SceneNode* shadowCasters[], U32 shadowCastersCount, 
-	CommandBufferHandle& cmdBuff)
+	CommandBufferPtr& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
 	Error err = ErrorCode::NONE;
@@ -172,7 +172,7 @@ Sm::Shadowmap& Sm::bestCandidate(SceneNode& light)
 
 //==============================================================================
 Error Sm::doLight(
-	SceneNode& light, CommandBufferHandle& cmdBuff, Sm::Shadowmap*& sm)
+	SceneNode& light, CommandBufferPtr& cmdBuff, Sm::Shadowmap*& sm)
 {
 	sm = &bestCandidate(light);
 

src/renderer/Ssao.cpp

@@ -67,7 +67,7 @@ public:
 //==============================================================================
 
 //==============================================================================
-Error Ssao::createFb(FramebufferHandle& fb, TextureHandle& rt)
+Error Ssao::createFb(FramebufferPtr& fb, TexturePtr& rt)
 {
 	// Set to bilinear because the blurring techniques take advantage of that
 	ANKI_CHECK(m_r->createRenderTarget(m_width, m_height,
@@ -75,7 +75,7 @@ Error Ssao::createFb(FramebufferHandle& fb, TextureHandle& rt)
 		1, SamplingFilter::LINEAR, 1, rt));
 
 	// Create FB
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = rt;
 	fbInit.m_colorAttachments[0].m_loadOperation =
@@ -117,14 +117,14 @@ Error Ssao::initInternal(const ConfigSet& config)
 	//
 	// noise texture
 	//
-	CommandBufferHandle cmdb;
+	CommandBufferPtr cmdb;
 	ANKI_CHECK(cmdb.create(&getGrManager()));
 
 	Array<Vec3, NOISE_TEX_SIZE * NOISE_TEX_SIZE> noise;
 
 	genNoise(&noise[0], &noise[0] + noise.getSize());
 
-	TextureHandle::Initializer tinit;
+	TexturePtr::Initializer tinit;
 
 	tinit.m_width = tinit.m_height = NOISE_TEX_SIZE;
 	tinit.m_type = TextureType::_2D;
@@ -231,7 +231,7 @@ Error Ssao::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Ssao::run(CommandBufferHandle& cmdb)
+Error Ssao::run(CommandBufferPtr& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 
@@ -246,7 +246,7 @@ Error Ssao::run(CommandBufferHandle& cmdb)
 
 	m_uniformsBuff.bindShaderBuffer(cmdb, 0);
 
-	Array<TextureHandle, 3> tarr = {{
+	Array<TexturePtr, 3> tarr = {{
 		m_r->getMs().getDepthRt(),
 		m_r->getMs().getRt2(),
 		m_noiseTex}};
@@ -277,7 +277,7 @@ Error Ssao::run(CommandBufferHandle& cmdb)
 	{
 		if(i == 0)
 		{
-			Array<TextureHandle, 2> tarr = {{m_hblurRt, m_vblurRt}};
+			Array<TexturePtr, 2> tarr = {{m_hblurRt, m_vblurRt}};
 			cmdb.bindTextures(0, tarr.begin(), tarr.getSize());
 		}
 

src/renderer/Sslf.cpp

@@ -55,7 +55,7 @@ Error Sslf::initInternal(const ConfigSet& config)
 		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM), 
 		1, SamplingFilter::LINEAR, 1, m_rt));
 
-	FramebufferHandle::Initializer fbInit;
+	FramebufferPtr::Initializer fbInit;
 	fbInit.m_colorAttachmentsCount = 1;
 	fbInit.m_colorAttachments[0].m_texture = m_rt;
 	fbInit.m_colorAttachments[0].m_loadOperation = 
@@ -66,7 +66,7 @@ Error Sslf::initInternal(const ConfigSet& config)
 }
 
 //==============================================================================
-void Sslf::run(CommandBufferHandle& cmdb)
+void Sslf::run(CommandBufferPtr& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 	
@@ -77,7 +77,7 @@ void Sslf::run(CommandBufferHandle& cmdb)
 
 	m_ppline.bind(cmdb);
 
-	Array<TextureHandle, 2> tarr = {{
+	Array<TexturePtr, 2> tarr = {{
 		m_r->getPps().getBloom().getRt(), 
 		m_lensDirtTex->getGlTexture()}};
 	cmdb.bindTextures(0, tarr.begin(), tarr.getSize());

src/renderer/Sslr.cpp

@@ -65,7 +65,7 @@ Error Sslr::init(const ConfigSet& config)
 			1, SamplingFilter::LINEAR, 1, dir.m_rt));
 
 		// Create FB
-		FramebufferHandle::Initializer fbInit;
+		FramebufferPtr::Initializer fbInit;
 		fbInit.m_colorAttachmentsCount = 1;
 		fbInit.m_colorAttachments[0].m_texture = dir.m_rt;
 		fbInit.m_colorAttachments[0].m_loadOperation =
@@ -77,7 +77,7 @@ Error Sslr::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Sslr::run(CommandBufferHandle& cmdBuff)
+Error Sslr::run(CommandBufferPtr& cmdBuff)
 {
 	ANKI_ASSERT(m_enabled);
 
@@ -88,7 +88,7 @@ Error Sslr::run(CommandBufferHandle& cmdBuff)
 
 	m_reflectionPpline.bind(cmdBuff);
 
-	Array<TextureHandle, 4> tarr = {{
+	Array<TexturePtr, 4> tarr = {{
 		m_r->getIs()._getRt(),
 		m_r->getMs().getDepthRt(),
 		m_r->getMs().getRt1(),
@@ -99,7 +99,7 @@ Error Sslr::run(CommandBufferHandle& cmdBuff)
 
 	m_r->drawQuad(cmdBuff);
 
-	SamplerHandle::bindDefault(cmdBuff, 1); // Unbind the sampler
+	SamplerPtr::bindDefault(cmdBuff, 1); // Unbind the sampler
 
 	// Blurring
 	//

src/renderer/Tiler.cpp

@@ -97,7 +97,7 @@ Error Tiler::initInternal()
 		m_shader.loadToCache(&getResourceManager(),
 		"shaders/TilerMinMax.comp.glsl", pps.toCString(), "r_"));
 
-	PipelineHandle::Initializer pplineInit;
+	PipelinePtr::Initializer pplineInit;
 	pplineInit.m_shaders[U(ShaderType::COMPUTE)] = m_shader->getGrShader();
 	ANKI_CHECK(m_ppline.create(&getGrManager(), pplineInit));
 
@@ -169,7 +169,7 @@ Error Tiler::initPbos()
 }
 
 //==============================================================================
-void Tiler::runMinMax(CommandBufferHandle& cmd)
+void Tiler::runMinMax(CommandBufferPtr& cmd)
 {
 	if(m_enableGpuTests)
 	{

src/renderer/Tm.cpp

@@ -27,7 +27,7 @@ Error Tm::create(const ConfigSet& initializer)
 		"shaders/PpsTmAverageLuminance.comp.glsl", pps.toCString(), "rppstm_"));
 
 	// Create ppline
-	PipelineHandle::Initializer pplineInit;
+	PipelinePtr::Initializer pplineInit;
 	pplineInit.m_shaders[U(ShaderType::COMPUTE)] = 
 		m_luminanceShader->getGrShader();
 	ANKI_CHECK(m_luminancePpline.create(&getGrManager(), pplineInit));
@@ -41,7 +41,7 @@ Error Tm::create(const ConfigSet& initializer)
 }
 
 //==============================================================================
-void Tm::run(CommandBufferHandle& cmdb)
+void Tm::run(CommandBufferPtr& cmdb)
 {
 	m_luminancePpline.bind(cmdb);
 	m_luminanceBuff.bindShaderBuffer(cmdb, 0);

src/resource/Material.cpp

@@ -297,7 +297,7 @@ ShaderResourcePointer& Material::getProgram(
 
 //==============================================================================
 Error Material::getProgramPipeline(
-	const RenderingKey& key, PipelineHandle& out)
+	const RenderingKey& key, PipelinePtr& out)
 {
 	ANKI_ASSERT(enumToType(key.m_pass) < m_passesCount);
 	ANKI_ASSERT(key.m_lod < m_lodsCount);
@@ -315,12 +315,12 @@ Error Material::getProgramPipeline(
 	U idx = enumToType(key.m_pass) * m_lodsCount * tessCount
 		+ key.m_lod * tessCount + key.m_tessellation;
 
-	PipelineHandle& ppline = m_pplines[idx];
+	PipelinePtr& ppline = m_pplines[idx];
 
 	// Lazily create it
 	if(ANKI_UNLIKELY(!ppline.isCreated()))
 	{
-		PipelineHandle::Initializer pplineInit;
+		PipelinePtr::Initializer pplineInit;
 
 		pplineInit.m_shaders[U(ShaderType::VERTEX)] = 
 			getProgram(key, ShaderType::VERTEX)->getGrShader();

src/resource/MaterialCommon.cpp

@@ -13,7 +13,7 @@ namespace anki {
 //==============================================================================
 Error MaterialResourceData::create(ResourceManager& resources)
 {
-	PipelineHandle::Initializer init;
+	PipelinePtr::Initializer init;
 	init.m_depthStencil.m_depthWriteEnabled = true;
 	init.m_color.m_colorAttachmentsCount = MS_COLOR_ATTACHMENTS_COUNT;
 	for(U i = 0; i < MS_COLOR_ATTACHMENTS_COUNT; ++i)