Separated reference counting from Resources

Former-commit-id: 7380818cfee9e249c11fd15da9ff7883a6e76565

include/Nazara/Audio/Music.hpp

@@ -10,6 +10,7 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Audio/Enums.hpp>
 #include <Nazara/Audio/SoundEmitter.hpp>
+#include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
 
 struct NzMusicParams
@@ -27,7 +28,7 @@ using NzMusicLoader = NzResourceLoader<NzMusic, NzMusicParams>;
 
 struct NzMusicImpl;
 
-class NAZARA_API NzMusic : public NzSoundEmitter
+class NAZARA_API NzMusic : public NzResource, public NzSoundEmitter
 {
 	friend NzMusicLoader;
 

include/Nazara/Audio/SoundBuffer.hpp

@@ -11,9 +11,10 @@
 #include <Nazara/Audio/Enums.hpp>
 #include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/NonCopyable.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
 
 struct NzSoundBufferParams
 {
@@ -25,13 +26,13 @@ struct NzSoundBufferParams
 class NzSound;
 class NzSoundBuffer;
 
-using NzSoundBufferConstRef = NzResourceRef<const NzSoundBuffer>;
+using NzSoundBufferConstRef = NzObjectRef<const NzSoundBuffer>;
 using NzSoundBufferLoader = NzResourceLoader<NzSoundBuffer, NzSoundBufferParams>;
-using NzSoundBufferRef = NzResourceRef<NzSoundBuffer>;
+using NzSoundBufferRef = NzObjectRef<NzSoundBuffer>;
 
 struct NzSoundBufferImpl;
 
-class NAZARA_API NzSoundBuffer : public NzResource, public NzNonCopyable
+class NAZARA_API NzSoundBuffer : public NzRefCounted, public NzResource, NzNonCopyable
 {
 	friend NzSound;
 	friend NzSoundBufferLoader;

include/Nazara/Core.hpp

@@ -59,15 +59,15 @@
 #include <Nazara/Core/MemoryStream.hpp>
 #include <Nazara/Core/Mutex.hpp>
 #include <Nazara/Core/NonCopyable.hpp>
+#include <Nazara/Core/ObjectListener.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Core/OffsetOf.hpp>
 #include <Nazara/Core/ParameterList.hpp>
 #include <Nazara/Core/PluginManager.hpp>
 #include <Nazara/Core/Primitive.hpp>
 #include <Nazara/Core/PrimitiveList.hpp>
 #include <Nazara/Core/Resource.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Core/Semaphore.hpp>
 #include <Nazara/Core/SparsePtr.hpp>
 #include <Nazara/Core/Stream.hpp>

include/Nazara/Core/Config.hpp

@@ -62,7 +62,7 @@
 #define NAZARA_THREADSAFETY_DYNLIB 1       // NzDynLib
 #define NAZARA_THREADSAFETY_FILE 1         // NzFile
 #define NAZARA_THREADSAFETY_LOG 1          // NzLog
-#define NAZARA_THREADSAFETY_RESOURCE 1     // NzResource
+#define NAZARA_THREADSAFETY_REFCOUNTED 1   // NzRefCounted
 
 // Le nombre de spinlocks à utiliser avec les sections critiques de Windows (0 pour désactiver)
 #define NAZARA_CORE_WINDOWS_CS_SPINLOCKS 4096

include/Nazara/Core/ObjectListener.hpp

@@ -0,0 +1,26 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_OBJECTLISTENER_HPP
+#define NAZARA_OBJECTLISTENER_HPP
+
+#include <Nazara/Prerequesites.hpp>
+
+class NzRefCounted;
+
+class NAZARA_API NzObjectListener
+{
+	public:
+		NzObjectListener() = default;
+		virtual ~NzObjectListener();
+
+		virtual bool OnObjectCreated(const NzRefCounted* object, int index);
+		virtual bool OnObjectDestroy(const NzRefCounted* object, int index);
+		virtual bool OnObjectModified(const NzRefCounted* object, int index, unsigned int code);
+		virtual void OnObjectReleased(const NzRefCounted* object, int index);
+};
+
+#endif // NAZARA_OBJECTLISTENER_HPP

include/Nazara/Core/ObjectRef.hpp

@@ -8,38 +8,38 @@
 #define NAZARA_RESOURCEREF_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <type_traits>
 
 template<typename T>
-class NzResourceRef
+class NzObjectRef
 {
-	static_assert(std::is_base_of<NzResource, T>::value, "ResourceRef should only be used with resource type");
+	static_assert(std::is_base_of<NzRefCounted, T>::value, "ObjectRef shall only be used with RefCounted-derived type");
 
 	public:
-		NzResourceRef();
+		NzObjectRef();
-		NzResourceRef(T* resource);
+		NzObjectRef(T* resource);
-		NzResourceRef(const NzResourceRef& ref);
+		NzObjectRef(const NzObjectRef& ref);
-		NzResourceRef(NzResourceRef&& ref) noexcept;
+		NzObjectRef(NzObjectRef&& ref) noexcept;
-		~NzResourceRef();
+		~NzObjectRef();
 
 		bool IsValid() const;
 		T* Release();
 		bool Reset(T* resource = nullptr);
-		NzResourceRef& Swap(NzResourceRef& ref);
+		NzObjectRef& Swap(NzObjectRef& ref);
 
 		operator bool() const;
 		operator T*() const;
 		T* operator->() const;
 
-		NzResourceRef& operator=(T* resource);
+		NzObjectRef& operator=(T* resource);
-		NzResourceRef& operator=(const NzResourceRef& ref);
+		NzObjectRef& operator=(const NzObjectRef& ref);
-		NzResourceRef& operator=(NzResourceRef&& ref) noexcept;
+		NzObjectRef& operator=(NzObjectRef&& ref) noexcept;
 
 	private:
 		T* m_resource;
 };
 
-#include <Nazara/Core/ResourceRef.inl>
+#include <Nazara/Core/ObjectRef.inl>
 
 #endif // NAZARA_RESOURCEREF_HPP

include/Nazara/Core/ObjectRef.inl

@@ -6,49 +6,49 @@
 #include <Nazara/Core/Debug.hpp>
 
 template<typename T>
-NzResourceRef<T>::NzResourceRef() :
+NzObjectRef<T>::NzObjectRef() :
 m_resource(nullptr)
 {
 }
 
 template<typename T>
-NzResourceRef<T>::NzResourceRef(T* resource) :
+NzObjectRef<T>::NzObjectRef(T* resource) :
 m_resource(resource)
 {
 	if (m_resource)
-		m_resource->AddResourceReference();
+		m_resource->AddReference();
 }
 
 template<typename T>
-NzResourceRef<T>::NzResourceRef(const NzResourceRef& ref) :
+NzObjectRef<T>::NzObjectRef(const NzObjectRef& ref) :
 m_resource(ref.m_resource)
 {
 	if (m_resource)
-		m_resource->AddResourceReference();
+		m_resource->AddReference();
 }
 
 template<typename T>
-NzResourceRef<T>::NzResourceRef(NzResourceRef&& ref) noexcept :
+NzObjectRef<T>::NzObjectRef(NzObjectRef&& ref) noexcept :
 m_resource(ref.m_resource)
 {
 	ref.m_resource = nullptr; // On vole la référence
 }
 
 template<typename T>
-NzResourceRef<T>::~NzResourceRef()
+NzObjectRef<T>::~NzObjectRef()
 {
 	if (m_resource)
-		m_resource->RemoveResourceReference();
+		m_resource->RemoveReference();
 }
 
 template<typename T>
-bool NzResourceRef<T>::IsValid() const
+bool NzObjectRef<T>::IsValid() const
 {
 	return m_resource != nullptr;
 }
 
 template<typename T>
-T* NzResourceRef<T>::Release()
+T* NzObjectRef<T>::Release()
 {
 	T* resource = m_resource;
 	m_resource = nullptr;
@@ -57,27 +57,27 @@ T* NzResourceRef<T>::Release()
 }
 
 template<typename T>
-bool NzResourceRef<T>::Reset(T* resource)
+bool NzObjectRef<T>::Reset(T* resource)
 {
 	bool destroyed = false;
 	if (m_resource != resource)
 	{
 		if (m_resource)
 		{
-			destroyed = m_resource->RemoveResourceReference();
+			destroyed = m_resource->RemoveReference();
 			m_resource = nullptr;
 		}
 
 		m_resource = resource;
 		if (m_resource)
-			m_resource->AddResourceReference();
+			m_resource->AddReference();
 	}
 
 	return destroyed;
 }
 
 template<typename T>
-NzResourceRef<T>& NzResourceRef<T>::Swap(NzResourceRef& ref)
+NzObjectRef<T>& NzObjectRef<T>::Swap(NzObjectRef& ref)
 {
 	std::swap(m_resource, ref.m_resource);
 
@@ -85,25 +85,25 @@ NzResourceRef<T>& NzResourceRef<T>::Swap(NzResourceRef& ref)
 }
 
 template<typename T>
-NzResourceRef<T>::operator bool() const
+NzObjectRef<T>::operator bool() const
 {
 	return IsValid();
 }
 
 template<typename T>
-NzResourceRef<T>::operator T*() const
+NzObjectRef<T>::operator T*() const
 {
 	return m_resource;
 }
 
 template<typename T>
-T* NzResourceRef<T>::operator->() const
+T* NzObjectRef<T>::operator->() const
 {
 	return m_resource;
 }
 
 template<typename T>
-NzResourceRef<T>& NzResourceRef<T>::operator=(T* resource)
+NzObjectRef<T>& NzObjectRef<T>::operator=(T* resource)
 {
 	Reset(resource);
 
@@ -111,7 +111,7 @@ NzResourceRef<T>& NzResourceRef<T>::operator=(T* resource)
 }
 
 template<typename T>
-NzResourceRef<T>& NzResourceRef<T>::operator=(const NzResourceRef& ref)
+NzObjectRef<T>& NzObjectRef<T>::operator=(const NzObjectRef& ref)
 {
 	Reset(ref.m_resource);
 
@@ -119,7 +119,7 @@ NzResourceRef<T>& NzResourceRef<T>::operator=(const NzResourceRef& ref)
 }
 
 template<typename T>
-NzResourceRef<T>& NzResourceRef<T>::operator=(NzResourceRef&& ref) noexcept
+NzObjectRef<T>& NzObjectRef<T>::operator=(NzObjectRef&& ref) noexcept
 {
 	Reset();
 

include/Nazara/Core/RefCounted.hpp

@@ -0,0 +1,58 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_REFCOUNTED_HPP
+#define NAZARA_REFCOUNTED_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <atomic>
+#include <unordered_map>
+
+#if NAZARA_CORE_THREADSAFE && NAZARA_THREADSAFETY_REFCOUNTED
+	#include <Nazara/Core/ThreadSafety.hpp>
+#else
+	#include <Nazara/Core/ThreadSafetyOff.hpp>
+#endif
+
+class NzObjectListener;
+
+class NAZARA_API NzRefCounted
+{
+	public:
+		NzRefCounted(bool persistent = true);
+		virtual ~NzRefCounted();
+
+		void AddObjectListener(NzObjectListener* listener, int index = 0) const;
+		void AddReference() const;
+
+		unsigned int GetReferenceCount() const;
+
+		bool IsPersistent() const;
+
+		void RemoveObjectListener(NzObjectListener* listener) const;
+		bool RemoveReference() const;
+
+		bool SetPersistent(bool persistent = true, bool checkReferenceCount = false);
+
+	protected:
+		void NotifyCreated();
+		void NotifyDestroy();
+		void NotifyModified(unsigned int code);
+
+	private:
+		using ObjectListenerMap = std::unordered_map<NzObjectListener*, std::pair<int, unsigned int>>;
+
+		void RemoveObjectListenerIterator(ObjectListenerMap::iterator iterator) const;
+
+		NazaraMutexAttrib(m_mutex, mutable)
+
+		mutable ObjectListenerMap m_objectListeners;
+		        std::atomic_bool m_persistent;
+		mutable std::atomic_uint m_referenceCount;
+		        bool m_objectListenersLocked;
+};
+
+#endif // NAZARA_RESOURCE_HPP

include/Nazara/Core/Resource.hpp

@@ -8,52 +8,20 @@
 #define NAZARA_RESOURCE_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <atomic>
+#include <Nazara/Core/String.hpp>
-#include <unordered_map>
-
-#if NAZARA_CORE_THREADSAFE && NAZARA_THREADSAFETY_RESOURCE
-	#include <Nazara/Core/ThreadSafety.hpp>
-#else
-	#include <Nazara/Core/ThreadSafetyOff.hpp>
-#endif
-
-class NzResourceListener;
 
 class NAZARA_API NzResource
 {
 	public:
-		NzResource(bool persistent = true);
+		NzResource() = default;
 		virtual ~NzResource();
 
-		void AddResourceListener(NzResourceListener* listener, int index = 0) const;
+		NzString GetFilePath() const;
-		void AddResourceReference() const;
 
-		unsigned int GetResourceReferenceCount() const;
+		void SetFilePath(const NzString& filePath);
-
-		bool IsPersistent() const;
-
-		void RemoveResourceListener(NzResourceListener* listener) const;
-		bool RemoveResourceReference() const;
-
-		bool SetPersistent(bool persistent = true, bool checkReferenceCount = false);
-
-	protected:
-		void NotifyCreated();
-		void NotifyDestroy();
-		void NotifyModified(unsigned int code);
 
 	private:
-		using ResourceListenerMap = std::unordered_map<NzResourceListener*, std::pair<int, unsigned int>>;
+		NzString m_filePath;
-
-		void RemoveResourceListenerIterator(ResourceListenerMap::iterator iterator) const;
-
-		NazaraMutexAttrib(m_mutex, mutable)
-
-		// Je fais précéder le nom par 'resource' pour éviter les éventuels conflits de noms
-		mutable ResourceListenerMap m_resourceListeners;
-		        std::atomic_bool m_resourcePersistent;
-		mutable std::atomic_uint m_resourceReferenceCount;
-		        bool m_resourceListenersLocked;
 };
 
 #endif // NAZARA_RESOURCE_HPP

include/Nazara/Core/ResourceListener.hpp

@@ -1,26 +0,0 @@
-// Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Core module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_RESOURCELISTENER_HPP
-#define NAZARA_RESOURCELISTENER_HPP
-
-#include <Nazara/Prerequesites.hpp>
-
-class NzResource;
-
-class NAZARA_API NzResourceListener
-{
-	public:
-		NzResourceListener() = default;
-		virtual ~NzResourceListener();
-
-		virtual bool OnResourceCreated(const NzResource* resource, int index);
-		virtual bool OnResourceDestroy(const NzResource* resource, int index);
-		virtual bool OnResourceModified(const NzResource* resource, int index, unsigned int code);
-		virtual void OnResourceReleased(const NzResource* resource, int index);
-};
-
-#endif // NAZARA_RESOURCELISTENER_HPP

include/Nazara/Core/ResourceLoader.hpp

@@ -8,9 +8,11 @@
 #define NAZARA_RESOURCELOADER_HPP
 
 #include <Nazara/Core/Enums.hpp>
+#include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/String.hpp>
 #include <list>
 #include <tuple>
+#include <type_traits>
 
 class NzInputStream;
 

include/Nazara/Core/ResourceLoader.inl

@@ -84,7 +84,10 @@ bool NzResourceLoader<Type, Parameters>::LoadFromFile(Type* resource, const NzSt
 			}
 
 			if (fileLoader(resource, filePath, parameters))
+			{
+				resource->SetFilePath(filePath);
 				return true;
+			}
 		}
 		else
 		{
@@ -99,7 +102,10 @@ bool NzResourceLoader<Type, Parameters>::LoadFromFile(Type* resource, const NzSt
 			file.SetCursorPos(0);
 
 			if (streamLoader(resource, file, parameters))
+			{
+				resource->SetFilePath(filePath);
 				return true;
+			}
 		}
 
 		if (recognized == nzTernary_True)

include/Nazara/Graphics/DeferredRenderQueue.hpp

@@ -9,7 +9,7 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Color.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
+#include <Nazara/Core/ObjectListener.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Math/Matrix4.hpp>
@@ -22,7 +22,7 @@ class NzMaterial;
 class NzSkeletalMesh;
 class NzStaticMesh;
 
-class NAZARA_API NzDeferredRenderQueue : public NzAbstractRenderQueue, NzResourceListener
+class NAZARA_API NzDeferredRenderQueue : public NzAbstractRenderQueue, NzObjectListener
 {
 	public:
 		NzDeferredRenderQueue(NzForwardRenderQueue* forwardQueue);
@@ -63,8 +63,8 @@ class NAZARA_API NzDeferredRenderQueue : public NzAbstractRenderQueue, NzResourc
 		NzForwardRenderQueue* m_forwardQueue;
 
 	private:
-		bool OnResourceDestroy(const NzResource* resource, int index) override;
+		bool OnObjectDestroy(const NzRefCounted* object, int index) override;
-		void OnResourceReleased(const NzResource* resource, int index) override;
+		void OnObjectReleased(const NzRefCounted* object, int index) override;
 };
 
 #endif // NAZARA_DEFERREDRENDERQUEUE_HPP

include/Nazara/Graphics/ForwardRenderQueue.hpp

@@ -9,7 +9,7 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Color.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
+#include <Nazara/Core/ObjectListener.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Math/Matrix4.hpp>
@@ -22,7 +22,7 @@ class NzMaterial;
 class NzSkeletalMesh;
 class NzStaticMesh;
 
-class NAZARA_API NzForwardRenderQueue : public NzAbstractRenderQueue, NzResourceListener
+class NAZARA_API NzForwardRenderQueue : public NzAbstractRenderQueue, NzObjectListener
 {
 	friend class NzForwardRenderTechnique;
 
@@ -40,8 +40,8 @@ class NAZARA_API NzForwardRenderQueue : public NzAbstractRenderQueue, NzResource
 		void Sort(const NzAbstractViewer* viewer);
 
 	private:
-		bool OnResourceDestroy(const NzResource* resource, int index) override;
+		bool OnObjectDestroy(const NzRefCounted* object, int index) override;
-		void OnResourceReleased(const NzResource* resource, int index) override;
+		void OnObjectReleased(const NzRefCounted* object, int index) override;
 
 		struct TransparentModelData
 		{

include/Nazara/Graphics/ForwardRenderTechnique.hpp

@@ -8,7 +8,6 @@
 #define NAZARA_FORWARDRENDERTECHNIQUE_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
 #include <Nazara/Graphics/AbstractRenderTechnique.hpp>
 #include <Nazara/Graphics/ForwardRenderQueue.hpp>
 #include <Nazara/Graphics/Light.hpp>
@@ -16,7 +15,7 @@
 #include <Nazara/Utility/IndexBuffer.hpp>
 #include <Nazara/Utility/VertexBuffer.hpp>
 
-class NAZARA_API NzForwardRenderTechnique : public NzAbstractRenderTechnique, NzResourceListener
+class NAZARA_API NzForwardRenderTechnique : public NzAbstractRenderTechnique
 {
 	public:
 		NzForwardRenderTechnique();

include/Nazara/Graphics/Material.hpp

@@ -9,9 +9,10 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Color.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Graphics/Enums.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
@@ -34,11 +35,11 @@ struct NAZARA_API NzMaterialParams
 
 class NzMaterial;
 
-using NzMaterialConstRef = NzResourceRef<const NzMaterial>;
+using NzMaterialConstRef = NzObjectRef<const NzMaterial>;
 using NzMaterialLoader = NzResourceLoader<NzMaterial, NzMaterialParams>;
-using NzMaterialRef = NzResourceRef<NzMaterial>;
+using NzMaterialRef = NzObjectRef<NzMaterial>;
 
-class NAZARA_API NzMaterial : public NzResource
+class NAZARA_API NzMaterial : public NzRefCounted, public NzResource
 {
 	friend NzMaterialLoader;
 	friend class NzGraphics;

include/Nazara/Graphics/Model.hpp

@@ -8,6 +8,7 @@
 #define NAZARA_MODEL_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
 #include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/SceneNode.hpp>
@@ -28,7 +29,7 @@ class NzModel;
 
 using NzModelLoader = NzResourceLoader<NzModel, NzModelParameters>;
 
-class NAZARA_API NzModel : public NzSceneNode
+class NAZARA_API NzModel : public NzResource, public NzSceneNode
 {
 	friend NzModelLoader;
 	friend class NzScene;

include/Nazara/Renderer/Context.hpp

@@ -8,20 +8,20 @@
 #define NAZARA_CONTEXT_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Renderer/ContextParameters.hpp>
 #include <memory>
 #include <vector>
 
 class NzContext;
 
-using NzContextConstRef = NzResourceRef<const NzContext>;
+using NzContextConstRef = NzObjectRef<const NzContext>;
-using NzContextRef = NzResourceRef<NzContext>;
+using NzContextRef = NzObjectRef<NzContext>;
 
 class NzContextImpl;
 
-class NAZARA_API NzContext : public NzResource
+class NAZARA_API NzContext : public NzRefCounted
 {
 	friend NzContextImpl;
 	friend class NzOpenGL;

include/Nazara/Renderer/RenderBuffer.hpp

@@ -9,16 +9,16 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/NonCopyable.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Utility/Enums.hpp>
 
 class NzRenderBuffer;
 
-using NzRenderBufferConstRef = NzResourceRef<const NzRenderBuffer>;
+using NzRenderBufferConstRef = NzObjectRef<const NzRenderBuffer>;
-using NzRenderBufferRef = NzResourceRef<NzRenderBuffer>;
+using NzRenderBufferRef = NzObjectRef<NzRenderBuffer>;
 
-class NAZARA_API NzRenderBuffer : public NzResource, NzNonCopyable
+class NAZARA_API NzRenderBuffer : public NzRefCounted, NzNonCopyable
 {
 	public:
 		NzRenderBuffer();

include/Nazara/Renderer/RenderTexture.hpp

@@ -9,7 +9,7 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/NonCopyable.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
+#include <Nazara/Core/ObjectListener.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/RenderTarget.hpp>
 #include <Nazara/Renderer/Texture.hpp>
@@ -20,7 +20,7 @@ class NzRenderBuffer;
 
 struct NzRenderTextureImpl;
 
-class NAZARA_API NzRenderTexture : public NzRenderTarget, NzResourceListener, NzNonCopyable
+class NAZARA_API NzRenderTexture : public NzRenderTarget, NzObjectListener, NzNonCopyable
 {
 	public:
 		NzRenderTexture() = default;
@@ -66,7 +66,7 @@ class NAZARA_API NzRenderTexture : public NzRenderTarget, NzResourceListener, Nz
 		void EnsureTargetUpdated() const override;
 
 	private:
-		bool OnResourceDestroy(const NzResource* resource, int index) override;
+		bool OnObjectDestroy(const NzRefCounted* object, int index) override;
 		void UpdateDrawBuffers() const;
 		void UpdateTargets() const;
 

include/Nazara/Renderer/Shader.hpp

@@ -11,8 +11,8 @@
 #include <Nazara/Core/ByteArray.hpp>
 #include <Nazara/Core/Color.hpp>
 #include <Nazara/Core/NonCopyable.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Math/Matrix4.hpp>
 #include <Nazara/Math/Vector2.hpp>
@@ -23,10 +23,10 @@
 class NzShader;
 class NzShaderStage;
 
-using NzShaderConstRef = NzResourceRef<const NzShader>;
+using NzShaderConstRef = NzObjectRef<const NzShader>;
-using NzShaderRef = NzResourceRef<NzShader>;
+using NzShaderRef = NzObjectRef<NzShader>;
 
-class NAZARA_API NzShader : public NzResource, NzNonCopyable
+class NAZARA_API NzShader : public NzRefCounted, NzNonCopyable
 {
 	friend class NzRenderer;
 

include/Nazara/Renderer/Texture.hpp

@@ -9,8 +9,9 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/NonCopyable.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Resource.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Renderer/Enums.hpp>
 #include <Nazara/Utility/CubemapParams.hpp>
 #include <Nazara/Utility/Image.hpp>
@@ -18,12 +19,12 @@
 
 class NzTexture;
 
-using NzTextureConstRef = NzResourceRef<const NzTexture>;
+using NzTextureConstRef = NzObjectRef<const NzTexture>;
-using NzTextureRef = NzResourceRef<NzTexture>;
+using NzTextureRef = NzObjectRef<NzTexture>;
 
 struct NzTextureImpl;
 
-class NAZARA_API NzTexture : public NzResource, NzNonCopyable
+class NAZARA_API NzTexture : public NzRefCounted, public NzResource, NzNonCopyable
 {
 	friend class NzRenderer;
 	friend class NzRenderTexture;

include/Nazara/Renderer/UberShader.hpp

@@ -9,17 +9,17 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/ParameterList.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Renderer/UberShaderInstance.hpp>
 #include <unordered_map>
 
 class NzUberShader;
 
-using NzUberShaderConstRef = NzResourceRef<const NzUberShader>;
+using NzUberShaderConstRef = NzObjectRef<const NzUberShader>;
-using NzUberShaderRef = NzResourceRef<NzUberShader>;
+using NzUberShaderRef = NzObjectRef<NzUberShader>;
 
-class NAZARA_API NzUberShader : public NzResource
+class NAZARA_API NzUberShader : public NzRefCounted
 {
 	public:
 		NzUberShader() = default;

include/Nazara/Utility/Animation.hpp

@@ -8,9 +8,10 @@
 #define NAZARA_ANIMATION_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Utility/Enums.hpp>
 #include <Nazara/Utility/Sequence.hpp>
@@ -28,13 +29,13 @@ struct NAZARA_API NzAnimationParams
 class NzAnimation;
 class NzSkeleton;
 
-using NzAnimationConstRef = NzResourceRef<const NzAnimation>;
+using NzAnimationConstRef = NzObjectRef<const NzAnimation>;
 using NzAnimationLoader = NzResourceLoader<NzAnimation, NzAnimationParams>;
-using NzAnimationRef = NzResourceRef<NzAnimation>;
+using NzAnimationRef = NzObjectRef<NzAnimation>;
 
 struct NzAnimationImpl;
 
-class NAZARA_API NzAnimation : public NzResource
+class NAZARA_API NzAnimation : public NzRefCounted, public NzResource
 {
 	friend NzAnimationLoader;
 

include/Nazara/Utility/Buffer.hpp

@@ -9,18 +9,18 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/NonCopyable.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Utility/Enums.hpp>
 
 class NzBuffer;
 
-using NzBufferConstRef = NzResourceRef<const NzBuffer>;
+using NzBufferConstRef = NzObjectRef<const NzBuffer>;
-using NzBufferRef = NzResourceRef<NzBuffer>;
+using NzBufferRef = NzObjectRef<NzBuffer>;
 
 class NzAbstractBuffer;
 
-class NAZARA_API NzBuffer : public NzResource, NzNonCopyable
+class NAZARA_API NzBuffer : public NzRefCounted, NzNonCopyable
 {
 	friend class NzUtility;
 

include/Nazara/Utility/Image.hpp

@@ -10,9 +10,10 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Color.hpp>
 #include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Math/Rect.hpp>
 #include <Nazara/Math/Vector3.hpp>
@@ -36,11 +37,11 @@ struct NAZARA_API NzImageParams
 
 class NzImage;
 
-using NzImageConstRef = NzResourceRef<const NzImage>;
+using NzImageConstRef = NzObjectRef<const NzImage>;
 using NzImageLoader = NzResourceLoader<NzImage, NzImageParams>;
-using NzImageRef = NzResourceRef<NzImage>;
+using NzImageRef = NzObjectRef<NzImage>;
 
-class NAZARA_API NzImage : public NzResource
+class NAZARA_API NzImage : public NzRefCounted, public NzResource
 {
 	friend NzImageLoader;
 

include/Nazara/Utility/IndexBuffer.hpp

@@ -8,16 +8,16 @@
 #define NAZARA_INDEXBUFFER_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Core/Resource.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Utility/Buffer.hpp>
 
 class NzIndexBuffer;
 
-using NzIndexBufferConstRef = NzResourceRef<const NzIndexBuffer>;
+using NzIndexBufferConstRef = NzObjectRef<const NzIndexBuffer>;
-using NzIndexBufferRef = NzResourceRef<NzIndexBuffer>;
+using NzIndexBufferRef = NzObjectRef<NzIndexBuffer>;
 
-class NAZARA_API NzIndexBuffer : public NzResource
+class NAZARA_API NzIndexBuffer : public NzRefCounted
 {
 	public:
 		NzIndexBuffer() = default;

include/Nazara/Utility/Mesh.hpp

@@ -9,11 +9,12 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/ObjectListener.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Core/Primitive.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Resource.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Utility/Skeleton.hpp>
@@ -49,13 +50,13 @@ class NzPrimitiveList;
 typedef NzVertexStruct_XYZ_Normal_UV_Tangent NzMeshVertex;
 typedef NzVertexStruct_XYZ_Normal_UV_Tangent_Skinning NzSkeletalMeshVertex;
 
-using NzMeshConstRef = NzResourceRef<const NzMesh>;
+using NzMeshConstRef = NzObjectRef<const NzMesh>;
 using NzMeshLoader = NzResourceLoader<NzMesh, NzMeshParams>;
-using NzMeshRef = NzResourceRef<NzMesh>;
+using NzMeshRef = NzObjectRef<NzMesh>;
 
 struct NzMeshImpl;
 
-class NAZARA_API NzMesh : public NzResource, NzResourceListener
+class NAZARA_API NzMesh : public NzRefCounted, public NzResource, NzObjectListener
 {
 	friend NzMeshLoader;
 
@@ -118,7 +119,7 @@ class NAZARA_API NzMesh : public NzResource, NzResourceListener
 		void Transform(const NzMatrix4f& matrix);
 
 	private:
-		void OnResourceReleased(const NzResource* resource, int index) override;
+		void OnObjectReleased(const NzRefCounted* object, int index) override;
 
 		NzMeshImpl* m_impl = nullptr;
 

include/Nazara/Utility/SkeletalMesh.hpp

@@ -13,8 +13,8 @@
 
 class NzSkeletalMesh;
 
-using NzSkeletalMeshConstRef = NzResourceRef<const NzSkeletalMesh>;
+using NzSkeletalMeshConstRef = NzObjectRef<const NzSkeletalMesh>;
-using NzSkeletalMeshRef = NzResourceRef<NzSkeletalMesh>;
+using NzSkeletalMeshRef = NzObjectRef<NzSkeletalMesh>;
 
 class NAZARA_API NzSkeletalMesh final : public NzSubMesh
 {

include/Nazara/Utility/Skeleton.hpp

@@ -8,14 +8,14 @@
 #define NAZARA_SKELETON_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Utility/Joint.hpp>
 #include <vector>
 
 struct NzSkeletonImpl;
 
-class NAZARA_API NzSkeleton : public NzResource
+class NAZARA_API NzSkeleton : public NzRefCounted
 {
 	friend NzJoint;
 

include/Nazara/Utility/StaticMesh.hpp

@@ -8,15 +8,14 @@
 #define NAZARA_STATICMESH_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
 #include <Nazara/Utility/SubMesh.hpp>
 
 class NzStaticMesh;
 
-using NzStaticMeshConstRef = NzResourceRef<const NzStaticMesh>;
+using NzStaticMeshConstRef = NzObjectRef<const NzStaticMesh>;
-using NzStaticMeshRef = NzResourceRef<NzStaticMesh>;
+using NzStaticMeshRef = NzObjectRef<NzStaticMesh>;
 
-class NAZARA_API NzStaticMesh final : public NzSubMesh, NzResourceListener
+class NAZARA_API NzStaticMesh final : public NzSubMesh
 {
 	public:
 		NzStaticMesh(const NzMesh* parent);

include/Nazara/Utility/SubMesh.hpp

@@ -8,8 +8,8 @@
 #define NAZARA_SUBMESH_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Utility/Enums.hpp>
 #include <Nazara/Utility/IndexBuffer.hpp>
@@ -19,10 +19,10 @@
 class NzMesh;
 class NzSubMesh;
 
-using NzSubMeshConstRef = NzResourceRef<const NzSubMesh>;
+using NzSubMeshConstRef = NzObjectRef<const NzSubMesh>;
-using NzSubMeshRef = NzResourceRef<NzSubMesh>;
+using NzSubMeshRef = NzObjectRef<NzSubMesh>;
 
-class NAZARA_API NzSubMesh : public NzResource
+class NAZARA_API NzSubMesh : public NzRefCounted
 {
 	friend NzMesh;
 

include/Nazara/Utility/VertexBuffer.hpp

@@ -8,17 +8,17 @@
 #define NAZARA_VERTEXBUFFER_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Utility/Buffer.hpp>
 #include <Nazara/Utility/VertexDeclaration.hpp>
 
 class NzVertexBuffer;
 
-using NzVertexBufferConstRef = NzResourceRef<NzVertexBuffer>;
+using NzVertexBufferConstRef = NzObjectRef<NzVertexBuffer>;
-using NzVertexBufferRef = NzResourceRef<NzVertexBuffer>;
+using NzVertexBufferRef = NzObjectRef<NzVertexBuffer>;
 
-class NAZARA_API NzVertexBuffer : public NzResource
+class NAZARA_API NzVertexBuffer : public NzRefCounted
 {
 	public:
 		NzVertexBuffer() = default;

include/Nazara/Utility/VertexDeclaration.hpp

@@ -8,16 +8,16 @@
 #define NAZARA_VERTEXDECLARATION_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Utility/Enums.hpp>
 
 class NzVertexDeclaration;
 
-using NzVertexDeclarationConstRef = NzResourceRef<const NzVertexDeclaration>;
+using NzVertexDeclarationConstRef = NzObjectRef<const NzVertexDeclaration>;
-using NzVertexDeclarationRef = NzResourceRef<NzVertexDeclaration>;
+using NzVertexDeclarationRef = NzObjectRef<NzVertexDeclaration>;
 
-class NAZARA_API NzVertexDeclaration : public NzResource
+class NAZARA_API NzVertexDeclaration : public NzRefCounted
 {
 	friend class NzUtility;
 

src/Nazara/Core/ObjectListener.cpp

@@ -0,0 +1,39 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Core/ObjectListener.hpp>
+#include <Nazara/Core/Debug.hpp>
+
+NzObjectListener::~NzObjectListener() = default;
+
+bool NzObjectListener::OnObjectCreated(const NzRefCounted* object, int index)
+{
+	NazaraUnused(object);
+	NazaraUnused(index);
+
+	return true;
+}
+
+bool NzObjectListener::OnObjectDestroy(const NzRefCounted* object, int index)
+{
+	NazaraUnused(object);
+	NazaraUnused(index);
+
+	return true;
+}
+
+bool NzObjectListener::OnObjectModified(const NzRefCounted* object, int index, unsigned int code)
+{
+	NazaraUnused(object);
+	NazaraUnused(index);
+	NazaraUnused(code);
+
+	return true;
+}
+
+void NzObjectListener::OnObjectReleased(const NzRefCounted* object, int index)
+{
+	NazaraUnused(object);
+	NazaraUnused(index);
+}

src/Nazara/Core/RefCounted.cpp

@@ -0,0 +1,173 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Core/RefCounted.hpp>
+#include <Nazara/Core/Config.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/ObjectListener.hpp>
+
+#if NAZARA_CORE_THREADSAFE && NAZARA_THREADSAFETY_REFCOUNTED
+	#include <Nazara/Core/ThreadSafety.hpp>
+#else
+	#include <Nazara/Core/ThreadSafetyOff.hpp>
+#endif
+
+#include <Nazara/Core/Debug.hpp>
+
+NzRefCounted::NzRefCounted(bool persistent) :
+m_persistent(persistent),
+m_referenceCount(0),
+m_objectListenersLocked(false)
+{
+}
+
+NzRefCounted::~NzRefCounted()
+{
+	m_objectListenersLocked = true;
+	for (auto& pair : m_objectListeners)
+		pair.first->OnObjectReleased(this, pair.second.first);
+
+	#if NAZARA_CORE_SAFE
+	if (m_referenceCount > 0)
+		NazaraWarning("Resource destroyed while still referenced " + NzString::Number(m_referenceCount) + " time(s)");
+	#endif
+}
+
+void NzRefCounted::AddObjectListener(NzObjectListener* listener, int index) const
+{
+	///DOC: Est ignoré si appelé depuis un évènement
+	NazaraLock(m_mutex)
+
+	if (!m_objectListenersLocked)
+	{
+		auto pair = m_objectListeners.insert(std::make_pair(listener, std::make_pair(index, 1U)));
+		if (!pair.second)
+			pair.first->second.second++;
+	}
+}
+
+void NzRefCounted::AddReference() const
+{
+	m_referenceCount++;
+}
+
+unsigned int NzRefCounted::GetReferenceCount() const
+{
+	return m_referenceCount;
+}
+
+bool NzRefCounted::IsPersistent() const
+{
+	return m_persistent;
+}
+
+void NzRefCounted::RemoveObjectListener(NzObjectListener* listener) const
+{
+	///DOC: Est ignoré si appelé depuis un évènement
+	NazaraLock(m_mutex);
+
+	if (!m_objectListenersLocked)
+	{
+		ObjectListenerMap::iterator it = m_objectListeners.find(listener);
+		if (it != m_objectListeners.end())
+			RemoveObjectListenerIterator(it);
+	}
+}
+
+bool NzRefCounted::RemoveReference() const
+{
+	#if NAZARA_CORE_SAFE
+	if (m_referenceCount == 0)
+	{
+		NazaraError("Impossible to remove reference (Ref. counter is already 0)");
+		return false;
+	}
+	#endif
+
+	if (--m_referenceCount == 0 && !m_persistent)
+	{
+		delete this; // Suicide
+
+		return true;
+	}
+	else
+		return false;
+}
+
+bool NzRefCounted::SetPersistent(bool persistent, bool checkReferenceCount)
+{
+	m_persistent = persistent;
+
+	if (checkReferenceCount && !persistent && m_referenceCount == 0)
+	{
+		delete this;
+
+		return true;
+	}
+	else
+		return false;
+}
+
+void NzRefCounted::NotifyCreated()
+{
+	NazaraLock(m_mutex)
+
+	m_objectListenersLocked = true;
+
+	auto it = m_objectListeners.begin();
+	while (it != m_objectListeners.end())
+	{
+		if (!it->first->OnObjectCreated(this, it->second.first))
+			RemoveObjectListenerIterator(it++);
+		else
+			++it;
+	}
+
+	m_objectListenersLocked = false;
+}
+
+void NzRefCounted::NotifyDestroy()
+{
+	NazaraLock(m_mutex)
+
+	m_objectListenersLocked = true;
+
+	auto it = m_objectListeners.begin();
+	while (it != m_objectListeners.end())
+	{
+		if (!it->first->OnObjectDestroy(this, it->second.first))
+			RemoveObjectListenerIterator(it++);
+		else
+			++it;
+	}
+
+	m_objectListenersLocked = false;
+}
+
+void NzRefCounted::NotifyModified(unsigned int code)
+{
+	NazaraLock(m_mutex)
+
+	m_objectListenersLocked = true;
+
+	auto it = m_objectListeners.begin();
+	while (it != m_objectListeners.end())
+	{
+		if (!it->first->OnObjectModified(this, it->second.first, code))
+			RemoveObjectListenerIterator(it++);
+		else
+			++it;
+	}
+
+	m_objectListenersLocked = false;
+}
+
+void NzRefCounted::RemoveObjectListenerIterator(ObjectListenerMap::iterator iterator) const
+{
+	unsigned int& referenceCount = iterator->second.second;
+	if (referenceCount == 1)
+		m_objectListeners.erase(iterator);
+	else
+		referenceCount--;
+}

src/Nazara/Core/Resource.cpp

@@ -3,174 +3,16 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/Resource.hpp>
-#include <Nazara/Core/Config.hpp>
-#include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
-#include <Nazara/Utility/StaticMesh.hpp>
-#include <Nazara/Utility/VertexDeclaration.hpp>
-#include <typeinfo>
-
-#if NAZARA_CORE_THREADSAFE && NAZARA_THREADSAFETY_RESOURCE
-	#include <Nazara/Core/ThreadSafety.hpp>
-#else
-	#include <Nazara/Core/ThreadSafetyOff.hpp>
-#endif
-
 #include <Nazara/Core/Debug.hpp>
 
-NzResource::NzResource(bool persistent) :
+NzResource::~NzResource() = default;
-m_resourcePersistent(persistent),
+
-m_resourceReferenceCount(0),
+NzString NzResource::GetFilePath() const
-m_resourceListenersLocked(false)
 {
+	return m_filePath;
 }
 
-NzResource::~NzResource()
+void NzResource::SetFilePath(const NzString& filePath)
 {
-	m_resourceListenersLocked = true;
+	m_filePath = filePath;
-	for (auto& pair : m_resourceListeners)
-		pair.first->OnResourceReleased(this, pair.second.first);
-
-	#if NAZARA_CORE_SAFE
-	if (m_resourceReferenceCount > 0)
-		NazaraWarning("Resource destroyed while still referenced " + NzString::Number(m_resourceReferenceCount) + " time(s)");
-	#endif
-}
-
-void NzResource::AddResourceListener(NzResourceListener* listener, int index) const
-{
-	///DOC: Est ignoré si appelé depuis un évènement
-	NazaraLock(m_mutex)
-
-	if (!m_resourceListenersLocked)
-	{
-		auto pair = m_resourceListeners.insert(std::make_pair(listener, std::make_pair(index, 1U)));
-		if (!pair.second)
-			pair.first->second.second++;
-	}
-}
-
-void NzResource::AddResourceReference() const
-{
-	m_resourceReferenceCount++;
-}
-
-unsigned int NzResource::GetResourceReferenceCount() const
-{
-	return m_resourceReferenceCount;
-}
-
-bool NzResource::IsPersistent() const
-{
-	return m_resourcePersistent;
-}
-
-void NzResource::RemoveResourceListener(NzResourceListener* listener) const
-{
-	///DOC: Est ignoré si appelé depuis un évènement
-	NazaraLock(m_mutex);
-
-	if (!m_resourceListenersLocked)
-	{
-		ResourceListenerMap::iterator it = m_resourceListeners.find(listener);
-		if (it != m_resourceListeners.end())
-			RemoveResourceListenerIterator(it);
-	}
-}
-
-bool NzResource::RemoveResourceReference() const
-{
-	#if NAZARA_CORE_SAFE
-	if (m_resourceReferenceCount == 0)
-	{
-		NazaraError("Impossible to remove reference (Ref. counter is already 0)");
-		return false;
-	}
-	#endif
-
-	if (--m_resourceReferenceCount == 0 && !m_resourcePersistent)
-	{
-		delete this; // Suicide
-
-		return true;
-	}
-	else
-		return false;
-}
-
-bool NzResource::SetPersistent(bool persistent, bool checkReferenceCount)
-{
-	m_resourcePersistent = persistent;
-
-	if (checkReferenceCount && !persistent && m_resourceReferenceCount == 0)
-	{
-		delete this;
-
-		return true;
-	}
-	else
-		return false;
-}
-
-void NzResource::NotifyCreated()
-{
-	NazaraLock(m_mutex)
-
-	m_resourceListenersLocked = true;
-
-	auto it = m_resourceListeners.begin();
-	while (it != m_resourceListeners.end())
-	{
-		if (!it->first->OnResourceCreated(this, it->second.first))
-			RemoveResourceListenerIterator(it++);
-		else
-			++it;
-	}
-
-	m_resourceListenersLocked = false;
-}
-
-void NzResource::NotifyDestroy()
-{
-	NazaraLock(m_mutex)
-
-	m_resourceListenersLocked = true;
-
-	auto it = m_resourceListeners.begin();
-	while (it != m_resourceListeners.end())
-	{
-		if (!it->first->OnResourceDestroy(this, it->second.first))
-			RemoveResourceListenerIterator(it++);
-		else
-			++it;
-	}
-
-	m_resourceListenersLocked = false;
-}
-
-void NzResource::NotifyModified(unsigned int code)
-{
-	NazaraLock(m_mutex)
-
-	m_resourceListenersLocked = true;
-
-	auto it = m_resourceListeners.begin();
-	while (it != m_resourceListeners.end())
-	{
-		if (!it->first->OnResourceModified(this, it->second.first, code))
-			RemoveResourceListenerIterator(it++);
-		else
-			++it;
-	}
-
-	m_resourceListenersLocked = false;
-}
-
-void NzResource::RemoveResourceListenerIterator(ResourceListenerMap::iterator iterator) const
-{
-	unsigned int& referenceCount = iterator->second.second;
-	if (referenceCount == 1)
-		m_resourceListeners.erase(iterator);
-	else
-		referenceCount--;
 }

src/Nazara/Core/ResourceListener.cpp

@@ -1,39 +0,0 @@
-// Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Core module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Core/ResourceListener.hpp>
-#include <Nazara/Core/Debug.hpp>
-
-NzResourceListener::~NzResourceListener() = default;
-
-bool NzResourceListener::OnResourceCreated(const NzResource* resource, int index)
-{
-	NazaraUnused(resource);
-	NazaraUnused(index);
-
-	return true;
-}
-
-bool NzResourceListener::OnResourceDestroy(const NzResource* resource, int index)
-{
-	NazaraUnused(resource);
-	NazaraUnused(index);
-
-	return true;
-}
-
-bool NzResourceListener::OnResourceModified(const NzResource* resource, int index, unsigned int code)
-{
-	NazaraUnused(resource);
-	NazaraUnused(index);
-	NazaraUnused(code);
-
-	return true;
-}
-
-void NzResourceListener::OnResourceReleased(const NzResource* resource, int index)
-{
-	NazaraUnused(resource);
-	NazaraUnused(index);
-}

src/Nazara/Graphics/DeferredRenderQueue.cpp

@@ -13,11 +13,11 @@
 
 namespace
 {
-	enum ResourceType
+	enum ObjectType
 	{
-		ResourceType_IndexBuffer,
+		ObjectType_IndexBuffer,
-		ResourceType_Material,
+		ObjectType_Material,
-		ResourceType_VertexBuffer
+		ObjectType_VertexBuffer
 	};
 }
 
@@ -74,7 +74,7 @@ void NzDeferredRenderQueue::AddMesh(const NzMaterial* material, const NzMeshData
 		if (it == opaqueModels.end())
 		{
 			it = opaqueModels.insert(std::make_pair(material, ModelBatches::mapped_type())).first;
-			material->AddResourceListener(this, ResourceType_Material);
+			material->AddObjectListener(this, ObjectType_Material);
 		}
 
 		bool& used = std::get<0>(it->second);
@@ -89,9 +89,9 @@ void NzDeferredRenderQueue::AddMesh(const NzMaterial* material, const NzMeshData
 			it2 = meshMap.insert(std::make_pair(meshData, MeshInstanceContainer::mapped_type())).first;
 
 			if (meshData.indexBuffer)
-				meshData.indexBuffer->AddResourceListener(this, ResourceType_IndexBuffer);
+				meshData.indexBuffer->AddObjectListener(this, ObjectType_IndexBuffer);
 
-			meshData.vertexBuffer->AddResourceListener(this, ResourceType_VertexBuffer);
+			meshData.vertexBuffer->AddObjectListener(this, ObjectType_VertexBuffer);
 		}
 
 		std::vector<NzMatrix4f>& instances = it2->second;
@@ -139,7 +139,7 @@ void NzDeferredRenderQueue::Clear(bool fully)
 		for (auto& matIt : opaqueModels)
 		{
 			const NzMaterial* material = matIt.first;
-			material->RemoveResourceListener(this);
+			material->RemoveObjectListener(this);
 
 			MeshInstanceContainer& instances = std::get<2>(matIt.second);
 			for (auto& instanceIt : instances)
@@ -147,9 +147,9 @@ void NzDeferredRenderQueue::Clear(bool fully)
 				const NzMeshData& renderData = instanceIt.first;
 
 				if (renderData.indexBuffer)
-					renderData.indexBuffer->RemoveResourceListener(this);
+					renderData.indexBuffer->RemoveObjectListener(this);
 
-				renderData.vertexBuffer->RemoveResourceListener(this);
+				renderData.vertexBuffer->RemoveObjectListener(this);
 			}
 		}
 
@@ -160,11 +160,11 @@ void NzDeferredRenderQueue::Clear(bool fully)
 	m_forwardQueue->Clear(fully);
 }
 
-bool NzDeferredRenderQueue::OnResourceDestroy(const NzResource* resource, int index)
+bool NzDeferredRenderQueue::OnObjectDestroy(const NzRefCounted* object, int index)
 {
 	switch (index)
 	{
-		case ResourceType_IndexBuffer:
+		case ObjectType_IndexBuffer:
 		{
 			for (auto& modelPair : opaqueModels)
 			{
@@ -172,7 +172,7 @@ bool NzDeferredRenderQueue::OnResourceDestroy(const NzResource* resource, int in
 				for (auto it = meshes.begin(); it != meshes.end();)
 				{
 					const NzMeshData& renderData = it->first;
-					if (renderData.indexBuffer == resource)
+					if (renderData.indexBuffer == object)
 						it = meshes.erase(it);
 					else
 						++it;
@@ -181,11 +181,11 @@ bool NzDeferredRenderQueue::OnResourceDestroy(const NzResource* resource, int in
 			break;
 		}
 
-		case ResourceType_Material:
+		case ObjectType_Material:
-			opaqueModels.erase(static_cast<const NzMaterial*>(resource));
+			opaqueModels.erase(static_cast<const NzMaterial*>(object));
 			break;
 
-		case ResourceType_VertexBuffer:
+		case ObjectType_VertexBuffer:
 		{
 			for (auto& modelPair : opaqueModels)
 			{
@@ -193,7 +193,7 @@ bool NzDeferredRenderQueue::OnResourceDestroy(const NzResource* resource, int in
 				for (auto it = meshes.begin(); it != meshes.end();)
 				{
 					const NzMeshData& renderData = it->first;
-					if (renderData.vertexBuffer == resource)
+					if (renderData.vertexBuffer == object)
 						it = meshes.erase(it);
 					else
 						++it;
@@ -206,14 +206,14 @@ bool NzDeferredRenderQueue::OnResourceDestroy(const NzResource* resource, int in
 	return false; // Nous ne voulons plus recevoir d'évènement de cette ressource
 }
 
-void NzDeferredRenderQueue::OnResourceReleased(const NzResource* resource, int index)
+void NzDeferredRenderQueue::OnObjectReleased(const NzRefCounted* object, int index)
 {
 	// La ressource vient d'être libérée, nous ne pouvons donc plus utiliser la méthode traditionnelle de recherche
 	// des pointeurs stockés (À cause de la fonction de triage utilisant des spécificités des ressources)
 
 	switch (index)
 	{
-		case ResourceType_IndexBuffer:
+		case ObjectType_IndexBuffer:
 		{
 			for (auto& modelPair : opaqueModels)
 			{
@@ -221,7 +221,7 @@ void NzDeferredRenderQueue::OnResourceReleased(const NzResource* resource, int i
 				for (auto it = meshes.begin(); it != meshes.end();)
 				{
 					const NzMeshData& renderData = it->first;
-					if (renderData.indexBuffer == resource)
+					if (renderData.indexBuffer == object)
 						it = meshes.erase(it);
 					else
 						++it;
@@ -230,11 +230,11 @@ void NzDeferredRenderQueue::OnResourceReleased(const NzResource* resource, int i
 			break;
 		}
 
-		case ResourceType_Material:
+		case ObjectType_Material:
 		{
 			for (auto it = opaqueModels.begin(); it != opaqueModels.end(); ++it)
 			{
-				if (it->first == resource)
+				if (it->first == object)
 				{
 					opaqueModels.erase(it);
 					break;
@@ -243,7 +243,7 @@ void NzDeferredRenderQueue::OnResourceReleased(const NzResource* resource, int i
 			break;
 		}
 
-		case ResourceType_VertexBuffer:
+		case ObjectType_VertexBuffer:
 		{
 			for (auto& modelPair : opaqueModels)
 			{
@@ -251,7 +251,7 @@ void NzDeferredRenderQueue::OnResourceReleased(const NzResource* resource, int i
 				for (auto it = meshes.begin(); it != meshes.end();)
 				{
 					const NzMeshData& renderData = it->first;
-					if (renderData.vertexBuffer == resource)
+					if (renderData.vertexBuffer == object)
 						it = meshes.erase(it);
 					else
 						++it;

src/Nazara/Graphics/ForwardRenderQueue.cpp

@@ -89,7 +89,7 @@ void NzForwardRenderQueue::AddMesh(const NzMaterial* material, const NzMeshData&
 		if (it == opaqueModels.end())
 		{
 			it = opaqueModels.insert(std::make_pair(material, ModelBatches::mapped_type())).first;
-			material->AddResourceListener(this, ResourceType_Material);
+			material->AddObjectListener(this, ResourceType_Material);
 		}
 
 		bool& used = std::get<0>(it->second);
@@ -107,9 +107,9 @@ void NzForwardRenderQueue::AddMesh(const NzMaterial* material, const NzMeshData&
 			squaredBoundingSphere.Set(meshAABB.GetSquaredBoundingSphere());
 
 			if (meshData.indexBuffer)
-				meshData.indexBuffer->AddResourceListener(this, ResourceType_IndexBuffer);
+				meshData.indexBuffer->AddObjectListener(this, ResourceType_IndexBuffer);
 
-			meshData.vertexBuffer->AddResourceListener(this, ResourceType_VertexBuffer);
+			meshData.vertexBuffer->AddObjectListener(this, ResourceType_VertexBuffer);
 		}
 
 		std::vector<NzMatrix4f>& instances = it2->second.second;
@@ -153,7 +153,7 @@ void NzForwardRenderQueue::Clear(bool fully)
 		for (auto& matIt : opaqueModels)
 		{
 			const NzMaterial* material = matIt.first;
-			material->RemoveResourceListener(this);
+			material->RemoveObjectListener(this);
 
 			MeshInstanceContainer& instances = std::get<2>(matIt.second);
 			for (auto& instanceIt : instances)
@@ -161,9 +161,9 @@ void NzForwardRenderQueue::Clear(bool fully)
 				const NzMeshData& renderData = instanceIt.first;
 
 				if (renderData.indexBuffer)
-					renderData.indexBuffer->RemoveResourceListener(this);
+					renderData.indexBuffer->RemoveObjectListener(this);
 
-				renderData.vertexBuffer->RemoveResourceListener(this);
+				renderData.vertexBuffer->RemoveObjectListener(this);
 			}
 		}
 		opaqueModels.clear();
@@ -188,7 +188,7 @@ void NzForwardRenderQueue::Sort(const NzAbstractViewer* viewer)
 	});
 }
 
-bool NzForwardRenderQueue::OnResourceDestroy(const NzResource* resource, int index)
+bool NzForwardRenderQueue::OnObjectDestroy(const NzRefCounted* object, int index)
 {
 	switch (index)
 	{
@@ -200,7 +200,7 @@ bool NzForwardRenderQueue::OnResourceDestroy(const NzResource* resource, int ind
 				for (auto it = meshes.begin(); it != meshes.end();)
 				{
 					const NzMeshData& renderData = it->first;
-					if (renderData.indexBuffer == resource)
+					if (renderData.indexBuffer == object)
 						it = meshes.erase(it);
 					else
 						++it;
@@ -210,7 +210,7 @@ bool NzForwardRenderQueue::OnResourceDestroy(const NzResource* resource, int ind
 		}
 
 		case ResourceType_Material:
-			opaqueModels.erase(static_cast<const NzMaterial*>(resource));
+			opaqueModels.erase(static_cast<const NzMaterial*>(object));
 			break;
 
 		case ResourceType_VertexBuffer:
@@ -221,7 +221,7 @@ bool NzForwardRenderQueue::OnResourceDestroy(const NzResource* resource, int ind
 				for (auto it = meshes.begin(); it != meshes.end();)
 				{
 					const NzMeshData& renderData = it->first;
-					if (renderData.vertexBuffer == resource)
+					if (renderData.vertexBuffer == object)
 						it = meshes.erase(it);
 					else
 						++it;
@@ -234,7 +234,7 @@ bool NzForwardRenderQueue::OnResourceDestroy(const NzResource* resource, int ind
 	return false; // Nous ne voulons plus recevoir d'évènement de cette ressource
 }
 
-void NzForwardRenderQueue::OnResourceReleased(const NzResource* resource, int index)
+void NzForwardRenderQueue::OnObjectReleased(const NzRefCounted* object, int index)
 {
 	// La ressource vient d'être libérée, nous ne pouvons donc plus utiliser la méthode traditionnelle de recherche
 	// des pointeurs stockés (À cause de la fonction de triage utilisant des spécificités des ressources)
@@ -249,7 +249,7 @@ void NzForwardRenderQueue::OnResourceReleased(const NzResource* resource, int in
 				for (auto it = meshes.begin(); it != meshes.end();)
 				{
 					const NzMeshData& renderData = it->first;
-					if (renderData.indexBuffer == resource)
+					if (renderData.indexBuffer == object)
 						it = meshes.erase(it);
 					else
 						++it;
@@ -262,7 +262,7 @@ void NzForwardRenderQueue::OnResourceReleased(const NzResource* resource, int in
 		{
 			for (auto it = opaqueModels.begin(); it != opaqueModels.end(); ++it)
 			{
-				if (it->first == resource)
+				if (it->first == object)
 				{
 					opaqueModels.erase(it);
 					break;
@@ -279,7 +279,7 @@ void NzForwardRenderQueue::OnResourceReleased(const NzResource* resource, int in
 				for (auto it = meshes.begin(); it != meshes.end();)
 				{
 					const NzMeshData& renderData = it->first;
-					if (renderData.vertexBuffer == resource)
+					if (renderData.vertexBuffer == object)
 						it = meshes.erase(it);
 					else
 						++it;

src/Nazara/Graphics/Material.cpp

@@ -29,6 +29,7 @@ NzMaterial::NzMaterial()
 }
 
 NzMaterial::NzMaterial(const NzMaterial& material) :
+NzRefCounted(),
 NzResource()
 {
 	Copy(material);

src/Nazara/Graphics/SkinningManager.cpp

@@ -4,7 +4,7 @@
 
 #include <Nazara/Graphics/SkinningManager.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
-#include <Nazara/Core/ResourceListener.hpp>
+#include <Nazara/Core/ObjectListener.hpp>
 #include <Nazara/Core/TaskScheduler.hpp>
 #include <Nazara/Utility/Algorithm.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
@@ -16,10 +16,10 @@
 
 namespace
 {
-	enum ResourceType
+	enum ObjectType
 	{
-		ResourceType_SkeletalMesh,
+		ObjectType_SkeletalMesh,
-		ResourceType_Skeleton,
+		ObjectType_Skeleton,
 	};
 
     struct BufferData
@@ -40,38 +40,38 @@ namespace
 	SkeletonMap s_cache;
 	std::vector<SkinningData> s_skinningQueue;
 
-	class ResourceListener : public NzResourceListener
+	class ObjectListener : public NzObjectListener
 	{
 		public:
-			bool OnResourceDestroy(const NzResource* resource, int index)
+			bool OnObjectDestroy(const NzRefCounted* object, int index) override
 			{
 				switch (index)
 				{
-					case ResourceType_SkeletalMesh:
+					case ObjectType_SkeletalMesh:
 					{
 						for (auto& pair : s_cache)
 						{
 							MeshMap& meshMap = pair.second;
-							meshMap.erase(static_cast<const NzSkeletalMesh*>(resource));
+							meshMap.erase(static_cast<const NzSkeletalMesh*>(object));
 						}
 						break;
 					}
 
-					case ResourceType_Skeleton:
+					case ObjectType_Skeleton:
-						s_cache.erase(static_cast<const NzSkeleton*>(resource));
+						s_cache.erase(static_cast<const NzSkeleton*>(object));
 						break;
 				}
 
 				return false;
 			}
 
-			bool OnResourceModified(const NzResource* resource, int index, unsigned int code)
+			bool OnObjectModified(const NzRefCounted* object, int index, unsigned int code) override
 			{
 				NazaraUnused(code);
 
 				switch (index)
 				{
-					case ResourceType_SkeletalMesh:
+					case ObjectType_SkeletalMesh:
 					{
 						for (auto& pair : s_cache)
 						{
@@ -82,9 +82,9 @@ namespace
 						break;
 					}
 
-					case ResourceType_Skeleton:
+					case ObjectType_Skeleton:
 					{
-						for (auto& pair : s_cache.at(static_cast<const NzSkeleton*>(resource)))
+						for (auto& pair : s_cache.at(static_cast<const NzSkeleton*>(object)))
 							pair.second.updated = false;
 						break;
 					}
@@ -93,13 +93,13 @@ namespace
 				return true;
 			}
 
-			void OnResourceReleased(const NzResource* resource, int index)
+			void OnObjectReleased(const NzRefCounted* resource, int index) override
 			{
-				OnResourceDestroy(resource, index);
+				OnObjectDestroy(resource, index);
 			}
 	};
 
-	ResourceListener listener;
+	ObjectListener listener;
 
 	void Skin_MonoCPU(const NzSkeletalMesh* mesh, const NzSkeleton* skeleton, NzVertexBuffer* buffer)
 	{
@@ -163,7 +163,7 @@ NzVertexBuffer* NzSkinningManager::GetBuffer(const NzSkeletalMesh* mesh, const N
 	if (it == s_cache.end())
 	{
 		it = s_cache.insert(std::make_pair(skeleton, SkeletonMap::mapped_type())).first;
-		skeleton->AddResourceListener(&listener, ResourceType_Skeleton);
+		skeleton->AddObjectListener(&listener, ObjectType_Skeleton);
 	}
 
 	NzVertexBuffer* buffer;
@@ -179,7 +179,7 @@ NzVertexBuffer* NzSkinningManager::GetBuffer(const NzSkeletalMesh* mesh, const N
 		BufferData data({vertexBuffer.get(), true});
 		meshMap.insert(std::make_pair(mesh, data));
 
-		mesh->AddResourceListener(&listener, ResourceType_SkeletalMesh);
+		mesh->AddObjectListener(&listener, ObjectType_SkeletalMesh);
 
 		s_skinningQueue.push_back(SkinningData{mesh, skeleton, vertexBuffer.get()});
 
@@ -223,10 +223,10 @@ void NzSkinningManager::Uninitialize()
 {
 	for (auto& pair : s_cache)
 	{
-		pair.first->RemoveResourceListener(&listener);
+		pair.first->RemoveObjectListener(&listener);
 		MeshMap& meshMap = pair.second;
 		for (auto& pair2 : meshMap)
-			pair2.first->RemoveResourceListener(&listener);
+			pair2.first->RemoveObjectListener(&listener);
 	}
 	s_cache.clear();
 	s_skinningQueue.clear();

src/Nazara/Renderer/RenderTexture.cpp

@@ -150,7 +150,7 @@ bool NzRenderTexture::AttachBuffer(nzAttachmentPoint attachmentPoint, nzUInt8 in
 	attachment.height = buffer->GetHeight();
 	attachment.width = buffer->GetWidth();
 
-	buffer->AddResourceListener(this, attachIndex);
+	buffer->AddObjectListener(this, attachIndex);
 
 	m_impl->checked = false;
 
@@ -294,7 +294,7 @@ bool NzRenderTexture::AttachTexture(nzAttachmentPoint attachmentPoint, nzUInt8 i
 	attachment.texture = texture;
 	attachment.width = texture->GetWidth();
 
-	texture->AddResourceListener(this, attachIndex);
+	texture->AddObjectListener(this, attachIndex);
 
 	m_impl->checked = false;
 
@@ -339,7 +339,7 @@ bool NzRenderTexture::Create(bool lock)
 
 	m_impl = impl.release();
 	m_impl->context = NzContext::GetCurrent();
-	m_impl->context->AddResourceListener(this);
+	m_impl->context->AddObjectListener(this);
 
 	if (lock)
 	{
@@ -371,16 +371,16 @@ void NzRenderTexture::Destroy()
 		if (IsActive())
 			NzRenderer::SetTarget(nullptr);
 
-		m_impl->context->RemoveResourceListener(this);
+		m_impl->context->RemoveObjectListener(this);
 
 		for (const Attachment& attachment : m_impl->attachments)
 		{
 			if (attachment.isUsed)
 			{
 				if (attachment.isBuffer)
-					attachment.buffer->RemoveResourceListener(this);
+					attachment.buffer->RemoveObjectListener(this);
 				else
-					attachment.texture->RemoveResourceListener(this);
+					attachment.texture->RemoveObjectListener(this);
 			}
 		}
 
@@ -429,7 +429,7 @@ void NzRenderTexture::Detach(nzAttachmentPoint attachmentPoint, nzUInt8 index)
 	{
 		glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, NzOpenGL::Attachment[attachmentPoint]+index, GL_RENDERBUFFER, 0);
 
-		attachement.buffer->RemoveResourceListener(this);
+		attachement.buffer->RemoveObjectListener(this);
 		attachement.buffer = nullptr;
 	}
 	else
@@ -439,7 +439,7 @@ void NzRenderTexture::Detach(nzAttachmentPoint attachmentPoint, nzUInt8 index)
 		else
 			glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, NzOpenGL::Attachment[attachmentPoint]+index, 0, 0, 0);
 
-		attachement.texture->RemoveResourceListener(this);
+		attachement.texture->RemoveObjectListener(this);
 		attachement.texture = nullptr;
 	}
 
@@ -877,10 +877,10 @@ void NzRenderTexture::EnsureTargetUpdated() const
 	}
 }
 
-bool NzRenderTexture::OnResourceDestroy(const NzResource* resource, int index)
+bool NzRenderTexture::OnObjectDestroy(const NzRefCounted* object, int index)
 {
-	if (resource == m_impl->context)
+	if (object == m_impl->context)
-		// Notre contexte va être détruit, libérons la RenderTexture pour éviter un leak
+		// Notre contexte va être détruit, libérons la RenderTexture pour éviter un éventuel leak
 		Destroy();
 	else // Sinon, c'est une texture
 	{

src/Nazara/Renderer/Renderer.cpp

@@ -8,6 +8,7 @@
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/Log.hpp>
+#include <Nazara/Core/ObjectListener.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/Context.hpp>
 #include <Nazara/Renderer/DebugDrawer.hpp>
@@ -34,12 +35,12 @@
 
 namespace
 {
-	enum ResourceType
+	enum ObjectType
 	{
-		ResourceType_Context,
+		ObjectType_Context,
-		ResourceType_IndexBuffer,
+		ObjectType_IndexBuffer,
-		ResourceType_VertexBuffer,
+		ObjectType_VertexBuffer,
-		ResourceType_VertexDeclaration
+		ObjectType_VertexDeclaration
 	};
 
 	enum UpdateFlags
@@ -95,23 +96,23 @@ namespace
 	unsigned int s_maxTextureUnit;
 	unsigned int s_maxVertexAttribs;
 
-	class ResourceListener : public NzResourceListener
+	class ObjectListener : public NzObjectListener
 	{
 		public:
-			void OnResourceReleased(const NzResource* resource, int index) override
+			void OnObjectReleased(const NzRefCounted* object, int index) override
 			{
 				switch (index)
 				{
-					case ResourceType_Context:
+					case ObjectType_Context:
 					{
-						const NzContext* context = static_cast<const NzContext*>(resource);
+						const NzContext* context = static_cast<const NzContext*>(object);
 						s_vaos.erase(context);
 						break;
 					}
 
-					case ResourceType_IndexBuffer:
+					case ObjectType_IndexBuffer:
 					{
-						const NzIndexBuffer* indexBuffer = static_cast<const NzIndexBuffer*>(resource);
+						const NzIndexBuffer* indexBuffer = static_cast<const NzIndexBuffer*>(object);
 						for (auto& pair : s_vaos)
 						{
 							const NzContext* context = pair.first;
@@ -140,9 +141,9 @@ namespace
 						break;
 					}
 
-					case ResourceType_VertexBuffer:
+					case ObjectType_VertexBuffer:
 					{
-						const NzVertexBuffer* vertexBuffer = static_cast<const NzVertexBuffer*>(resource);
+						const NzVertexBuffer* vertexBuffer = static_cast<const NzVertexBuffer*>(object);
 						for (auto& pair : s_vaos)
 						{
 							const NzContext* context = pair.first;
@@ -171,9 +172,9 @@ namespace
 						break;
 					}
 
-					case ResourceType_VertexDeclaration:
+					case ObjectType_VertexDeclaration:
 					{
-						const NzVertexDeclaration* vertexDeclaration = static_cast<const NzVertexDeclaration*>(resource);
+						const NzVertexDeclaration* vertexDeclaration = static_cast<const NzVertexDeclaration*>(object);
 						for (auto& pair : s_vaos)
 						{
 							const NzContext* context = pair.first;
@@ -210,7 +211,7 @@ namespace
 			}
 	};
 
-	ResourceListener s_listener;
+	ObjectListener s_listener;
 }
 
 void NzRenderer::BeginCondition(const NzGpuQuery& query, nzGpuQueryCondition condition)
@@ -1530,13 +1531,13 @@ void NzRenderer::Uninitialize()
 			const NzVertexDeclaration* instancingDeclaration = std::get<3>(key);
 
 			if (indexBuffer)
-				indexBuffer->RemoveResourceListener(&s_listener);
+				indexBuffer->RemoveObjectListener(&s_listener);
 
-			vertexBuffer->RemoveResourceListener(&s_listener);
+			vertexBuffer->RemoveObjectListener(&s_listener);
-			vertexDeclaration->RemoveResourceListener(&s_listener);
+			vertexDeclaration->RemoveObjectListener(&s_listener);
 
 			if (instancingDeclaration)
-				instancingDeclaration->RemoveResourceListener(&s_listener);
+				instancingDeclaration->RemoveObjectListener(&s_listener);
 
 			NzOpenGL::DeleteVertexArray(context, pair2.second);
 		}
@@ -1710,7 +1711,7 @@ bool NzRenderer::EnsureStateUpdate()
 				auto it = s_vaos.find(context);
 				if (it == s_vaos.end())
 				{
-					context->AddResourceListener(&s_listener, ResourceType_Context);
+					context->AddObjectListener(&s_listener, ObjectType_Context);
 					auto pair = s_vaos.insert(std::make_pair(context, Context_Map::mapped_type()));
 					vaos = &pair.first->second;
 				}
@@ -1733,13 +1734,13 @@ bool NzRenderer::EnsureStateUpdate()
 					// On l'ajoute à notre liste
 					vaoIt = vaos->insert(std::make_pair(key, s_currentVAO)).first;
 					if (s_indexBuffer)
-						s_indexBuffer->AddResourceListener(&s_listener, ResourceType_IndexBuffer);
+						s_indexBuffer->AddObjectListener(&s_listener, ObjectType_IndexBuffer);
 
-					s_vertexBuffer->AddResourceListener(&s_listener, ResourceType_VertexBuffer);
+					s_vertexBuffer->AddObjectListener(&s_listener, ObjectType_VertexBuffer);
-					vertexDeclaration->AddResourceListener(&s_listener, ResourceType_VertexDeclaration);
+					vertexDeclaration->AddObjectListener(&s_listener, ObjectType_VertexDeclaration);
 
 					if (instancingDeclaration)
-						instancingDeclaration->AddResourceListener(&s_listener, ResourceType_VertexDeclaration);
+						instancingDeclaration->AddObjectListener(&s_listener, ObjectType_VertexDeclaration);
 
 					// Et on indique qu'on veut le programmer
 					update = true;

src/Nazara/Utility/Image.cpp

@@ -51,6 +51,7 @@ m_sharedImage(&emptyImage)
 }
 
 NzImage::NzImage(const NzImage& image) :
+NzRefCounted(),
 NzResource(),
 m_sharedImage(image.m_sharedImage)
 {

src/Nazara/Utility/IndexBuffer.cpp

@@ -22,7 +22,7 @@ NzIndexBuffer::NzIndexBuffer(bool largeIndices, unsigned int length, nzBufferSto
 }
 
 NzIndexBuffer::NzIndexBuffer(const NzIndexBuffer& indexBuffer) :
-NzResource(),
+NzRefCounted(),
 m_buffer(indexBuffer.m_buffer),
 m_largeIndices(indexBuffer.m_largeIndices),
 m_endOffset(indexBuffer.m_endOffset),
@@ -32,7 +32,7 @@ m_startOffset(indexBuffer.m_startOffset)
 }
 
 NzIndexBuffer::NzIndexBuffer(NzIndexBuffer&& indexBuffer) noexcept :
-NzResource(),
+NzRefCounted(),
 m_buffer(std::move(indexBuffer.m_buffer)),
 m_largeIndices(indexBuffer.m_largeIndices),
 m_endOffset(indexBuffer.m_endOffset),

src/Nazara/Utility/Mesh.cpp

@@ -91,8 +91,8 @@ void NzMesh::AddSubMesh(NzSubMesh* subMesh)
 	}
 	#endif
 
-	subMesh->AddResourceListener(this, m_impl->subMeshes.size());
+	subMesh->AddObjectListener(this, m_impl->subMeshes.size());
-	subMesh->AddResourceReference();
+	subMesh->AddReference();
 
 	m_impl->aabbUpdated = false; // On invalide l'AABB
 	m_impl->subMeshes.push_back(subMesh);
@@ -135,8 +135,8 @@ void NzMesh::AddSubMesh(const NzString& identifier, NzSubMesh* subMesh)
 
 	int index = m_impl->subMeshes.size();
 
-	subMesh->AddResourceListener(this, index);
+	subMesh->AddObjectListener(this, index);
-	subMesh->AddResourceReference();
+	subMesh->AddReference();
 
 	m_impl->aabbUpdated = false; // On invalide l'AABB
 	m_impl->subMeshes.push_back(subMesh);
@@ -373,8 +373,8 @@ void NzMesh::Destroy()
 
 		for (NzSubMesh* subMesh : m_impl->subMeshes)
 		{
-			subMesh->RemoveResourceListener(this);
+			subMesh->RemoveObjectListener(this);
-			subMesh->RemoveResourceReference();
+			subMesh->RemoveReference();
 		}
 
 		delete m_impl;
@@ -866,8 +866,8 @@ void NzMesh::RemoveSubMesh(const NzString& identifier)
 
 	// On libère la ressource
 	NzSubMesh* subMesh = *it2;
-	subMesh->RemoveResourceListener(this);
+	subMesh->RemoveObjectListener(this);
-	subMesh->RemoveResourceReference();
+	subMesh->RemoveReference();
 
 	m_impl->subMeshes.erase(it2);
 
@@ -896,8 +896,8 @@ void NzMesh::RemoveSubMesh(unsigned int index)
 
 	// On libère la ressource
 	NzSubMesh* subMesh = *it;
-	subMesh->RemoveResourceListener(this);
+	subMesh->RemoveObjectListener(this);
-	subMesh->RemoveResourceReference();
+	subMesh->RemoveReference();
 
 	m_impl->subMeshes.erase(it);
 
@@ -1011,9 +1011,9 @@ void NzMesh::Transform(const NzMatrix4f& matrix)
 	m_impl->aabbUpdated = false;
 }
 
-void NzMesh::OnResourceReleased(const NzResource* resource, int index)
+void NzMesh::OnObjectReleased(const NzRefCounted* object, int index)
 {
-	NazaraUnused(resource);
+	NazaraUnused(object);
 
 	RemoveSubMesh(index);
 }

src/Nazara/Utility/Skeleton.cpp

@@ -16,7 +16,7 @@ struct NzSkeletonImpl
 };
 
 NzSkeleton::NzSkeleton(const NzSkeleton& skeleton) :
-NzResource(),
+NzRefCounted(),
 m_impl(nullptr)
 {
 	operator=(skeleton);

src/Nazara/Utility/SubMesh.cpp

@@ -13,7 +13,7 @@
 #include <Nazara/Utility/Debug.hpp>
 
 NzSubMesh::NzSubMesh(const NzMesh* parent) :
-NzResource(false), // Un SubMesh n'est pas persistant par défaut
+NzRefCounted(false), // Un SubMesh n'est pas persistant par défaut
 m_primitiveMode(nzPrimitiveMode_TriangleList),
 m_parent(parent),
 m_matIndex(0)

src/Nazara/Utility/VertexBuffer.cpp

@@ -18,7 +18,7 @@ NzVertexBuffer::NzVertexBuffer(const NzVertexDeclaration* vertexDeclaration, uns
 }
 
 NzVertexBuffer::NzVertexBuffer(const NzVertexBuffer& vertexBuffer) :
-NzResource(),
+NzRefCounted(),
 m_buffer(vertexBuffer.m_buffer),
 m_vertexDeclaration(vertexBuffer.m_vertexDeclaration),
 m_endOffset(vertexBuffer.m_endOffset),

src/Nazara/Utility/VertexDeclaration.cpp

@@ -19,7 +19,7 @@ m_stride(0)
 }
 
 NzVertexDeclaration::NzVertexDeclaration(const NzVertexDeclaration& declaration) :
-NzResource(),
+NzRefCounted(),
 m_stride(declaration.m_stride)
 {
 	std::memcpy(m_components, declaration.m_components, sizeof(Component)*(nzVertexComponent_Max+1));