sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Separated reference counting from Resources

Browse Source 
Former-commit-id: 7380818cfee9e249c11fd15da9ff7883a6e76565
This commit is contained in:
Lynix
2014-07-15 00:59:02 +02:00
parent 0af8bc4829
commit 9e04e8a0e4
51 changed files with 566 additions and 508 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/Nazara/Audio/Music.hpp
View File

@@ -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;

9
include/Nazara/Audio/SoundBuffer.hpp
View File

@@ -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;

4
include/Nazara/Core.hpp
View File

@@ -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>

2
include/Nazara/Core/Config.hpp
View File

@@ -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

26
include/Nazara/Core/ObjectListener.hpp Normal file
View File

@@ -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

26
include/Nazara/Core/ResourceRef.hpp → include/Nazara/Core/ObjectRef.hpp
View File

@@ -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();
NzResourceRef(T* resource);
NzResourceRef(const NzResourceRef& ref);
NzResourceRef(NzResourceRef&& ref) noexcept;
~NzResourceRef();
NzObjectRef();
NzObjectRef(T* resource);
NzObjectRef(const NzObjectRef& ref);
NzObjectRef(NzObjectRef&& ref) noexcept;
~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);
NzResourceRef& operator=(const NzResourceRef& ref);
NzResourceRef& operator=(NzResourceRef&& ref) noexcept;
NzObjectRef& operator=(T* resource);
NzObjectRef& operator=(const NzObjectRef& ref);
NzObjectRef& operator=(NzObjectRef&& ref) noexcept;
private:
T* m_resource;
};
#include <Nazara/Core/ResourceRef.inl>
#include <Nazara/Core/ObjectRef.inl>
#endif // NAZARA_RESOURCEREF_HPP

40
include/Nazara/Core/ResourceRef.inl → include/Nazara/Core/ObjectRef.inl
View File

@@ -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();

58
include/Nazara/Core/RefCounted.hpp Normal file
View File

@@ -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

42
include/Nazara/Core/Resource.hpp
View File

@@ -8,52 +8,20 @@
#define NAZARA_RESOURCE_HPP
#include <Nazara/Prerequesites.hpp>
#include <atomic>
#include <unordered_map>
#if NAZARA_CORE_THREADSAFE && NAZARA_THREADSAFETY_RESOURCE
#include <Nazara/Core/ThreadSafety.hpp>
#else
#include <Nazara/Core/ThreadSafetyOff.hpp>
#endif
class NzResourceListener;
#include <Nazara/Core/String.hpp>
class NAZARA_API NzResource
{
public:
NzResource(bool persistent = true);
NzResource() = default;
virtual ~NzResource();
void AddResourceListener(NzResourceListener* listener, int index = 0) const;
void AddResourceReference() const;
NzString GetFilePath() const;
unsigned int GetResourceReferenceCount() const;
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);
void SetFilePath(const NzString& filePath);
private:
using ResourceListenerMap = std::unordered_map<NzResourceListener*, std::pair<int, unsigned int>>;
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;
NzString m_filePath;
};
#endif // NAZARA_RESOURCE_HPP

26
include/Nazara/Core/ResourceListener.hpp
View File

@@ -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

2
include/Nazara/Core/ResourceLoader.hpp
View File

@@ -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;

6
include/Nazara/Core/ResourceLoader.inl
View File

@@ -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)

8
include/Nazara/Graphics/DeferredRenderQueue.hpp
View File

@@ -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;
void OnResourceReleased(const NzResource* resource, int index) override;
bool OnObjectDestroy(const NzRefCounted* object, int index) override;
void OnObjectReleased(const NzRefCounted* object, int index) override;
};
#endif // NAZARA_DEFERREDRENDERQUEUE_HPP

8
include/Nazara/Graphics/ForwardRenderQueue.hpp
View File

@@ -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;
void OnResourceReleased(const NzResource* resource, int index) override;
bool OnObjectDestroy(const NzRefCounted* object, int index) override;
void OnObjectReleased(const NzRefCounted* object, int index) override;
struct TransparentModelData
{

3
include/Nazara/Graphics/ForwardRenderTechnique.hpp
View File

@@ -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();

9
include/Nazara/Graphics/Material.hpp
View File

@@ -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;

3
include/Nazara/Graphics/Model.hpp
View File

@@ -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;

10
include/Nazara/Renderer/Context.hpp
View File

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

10
include/Nazara/Renderer/RenderBuffer.hpp
View File

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

6
include/Nazara/Renderer/RenderTexture.hpp
View File

@@ -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;

10
include/Nazara/Renderer/Shader.hpp
View File

@@ -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/ResourceRef.hpp>
#include <Nazara/Core/ObjectRef.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 NzShaderRef = NzResourceRef<NzShader>;
using NzShaderConstRef = NzObjectRef<const NzShader>;
using NzShaderRef = NzObjectRef<NzShader>;
class NAZARA_API NzShader : public NzResource, NzNonCopyable
class NAZARA_API NzShader : public NzRefCounted, NzNonCopyable
{
friend class NzRenderer;

9
include/Nazara/Renderer/Texture.hpp
View File

@@ -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 NzTextureRef = NzResourceRef<NzTexture>;
using NzTextureConstRef = NzObjectRef<const 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;

10
include/Nazara/Renderer/UberShader.hpp
View File

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

9
include/Nazara/Utility/Animation.hpp
View File

@@ -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;

10
include/Nazara/Utility/Buffer.hpp
View File

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

9
include/Nazara/Utility/Image.hpp
View File

@@ -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;

8
include/Nazara/Utility/IndexBuffer.hpp
View File

@@ -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 NzIndexBufferRef = NzResourceRef<NzIndexBuffer>;
using NzIndexBufferConstRef = NzObjectRef<const NzIndexBuffer>;
using NzIndexBufferRef = NzObjectRef<NzIndexBuffer>;
class NAZARA_API NzIndexBuffer : public NzResource
class NAZARA_API NzIndexBuffer : public NzRefCounted
{
public:
NzIndexBuffer() = default;

13
include/Nazara/Utility/Mesh.hpp
View File

@@ -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;

4
include/Nazara/Utility/SkeletalMesh.hpp
View File

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

4
include/Nazara/Utility/Skeleton.hpp
View File

@@ -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;

7
include/Nazara/Utility/StaticMesh.hpp
View File

@@ -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 NzStaticMeshRef = NzResourceRef<NzStaticMesh>;
using NzStaticMeshConstRef = NzObjectRef<const 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);

10
include/Nazara/Utility/SubMesh.hpp
View File

@@ -8,8 +8,8 @@
#define NAZARA_SUBMESH_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/Resource.hpp>
#include <Nazara/Core/ResourceRef.hpp>
#include <Nazara/Core/ObjectRef.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 NzSubMeshRef = NzResourceRef<NzSubMesh>;
using NzSubMeshConstRef = NzObjectRef<const NzSubMesh>;
using NzSubMeshRef = NzObjectRef<NzSubMesh>;
class NAZARA_API NzSubMesh : public NzResource
class NAZARA_API NzSubMesh : public NzRefCounted
{
friend NzMesh;

10
include/Nazara/Utility/VertexBuffer.hpp
View File

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

10
include/Nazara/Utility/VertexDeclaration.hpp
View File

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