Merge branch 'NDK' of https://github.com/DigitalPulseSoftware/NazaraEngine into NDK

Former-commit-id: 425b5941925c15c999e2e0d09e685ce603b29e11

SDK/include/NDK/Components/CameraComponent.hpp

@@ -11,13 +11,14 @@
 #include <Nazara/Math/Matrix4.hpp>
 #include <Nazara/Math/Vector3.hpp>
 #include <Nazara/Renderer/RenderTarget.hpp>
+#include <Nazara/Utility/Node.hpp>
 #include <NDK/Component.hpp>
 
 namespace Ndk
 {
 	class Entity;
 
-	class NDK_API CameraComponent : public Component<CameraComponent>, NzRenderTarget::Listener
+	class NDK_API CameraComponent : public Component<CameraComponent>, NzNode::Listener, NzRenderTarget::Listener
 	{
 		public:
 			CameraComponent();
@@ -62,6 +63,7 @@ namespace Ndk
 			void OnComponentAttached(BaseComponent& component) override;
 			void OnComponentDetached(BaseComponent& component) override;
 			void OnDetached() override;
+			bool OnNodeInvalidated(const NzNode* node, void* userdata) override;
 			void OnRenderTargetReleased(const NzRenderTarget* renderTarget, void* userdata) override;
 			bool OnRenderTargetSizeChange(const NzRenderTarget* renderTarget, void* userdata) override;
 

SDK/src/NDK/Components/CameraComponent.cpp

@@ -8,15 +8,6 @@
 
 namespace Ndk
 {
-	/*void CameraComponent::InvalidateNode()
-	{
-		NzNode::InvalidateNode();
-
-		// Le frustum et la view matrix dépendent des paramètres du node, invalidons-les
-		m_frustumUpdated = false;
-		m_viewMatrixUpdated = false;
-	}*/
-
 	void CameraComponent::OnAttached()
 	{
 		InvalidateViewMatrix();
@@ -25,13 +16,23 @@ namespace Ndk
 	void CameraComponent::OnComponentAttached(BaseComponent& component)
 	{
 		if (IsComponent<NodeComponent>(component))
+		{
+			NodeComponent& nodeComponent = static_cast<NodeComponent&>(component);
+			nodeComponent.AddListener(this);
+
 			InvalidateViewMatrix();
+		}
 	}
 
 	void CameraComponent::OnComponentDetached(BaseComponent& component)
 	{
 		if (IsComponent<NodeComponent>(component))
+		{
+			NodeComponent& nodeComponent = static_cast<NodeComponent&>(component);
+			nodeComponent.RemoveListener(this);
+
 			InvalidateViewMatrix();
+		}
 	}
 
 	void CameraComponent::OnDetached()
@@ -39,6 +40,16 @@ namespace Ndk
 		InvalidateViewMatrix();
 	}
 
+	bool CameraComponent::OnNodeInvalidated(const NzNode* node, void* userdata)
+	{
+		NazaraUnused(node);
+		NazaraUnused(userdata);
+
+		// La matrice de vue dépend directement des données du node, invalidons-là
+		InvalidateViewMatrix();
+		return true;
+	}
+
 	void CameraComponent::OnRenderTargetReleased(const NzRenderTarget* renderTarget, void* userdata)
 	{
 		NazaraUnused(userdata);

include/Nazara/Core/Listenable.hpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2015 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_LISTENABLE_HPP
+#define NAZARA_LISTENABLE_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <unordered_map>
+
+template<typename Base>
+class NzListenable
+{
+	public:
+		NzListenable();
+		~NzListenable() = default;
+
+		template<typename L> void AddListener(L* listener, void* userdata = nullptr) const;
+		template<typename L> void RemoveListener(L* listener) const;
+
+		template<typename F, typename... Args> void Notify(F callback, Args&&... args);
+		template<typename F> void NotifyRelease(F callback);
+
+	private:
+		mutable std::unordered_map<void*, void*> m_listeners;
+		bool m_listenersLocked;
+};
+
+#include <Nazara/Core/Listenable.inl>
+
+#endif // NAZARA_LISTENABLE_HPP

include/Nazara/Core/Listenable.inl

@@ -0,0 +1,68 @@
+// Copyright (C) 2015 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/Debug.hpp>
+
+template<typename Base>
+NzListenable<Base>::NzListenable() :
+m_listenersLocked(false)
+{
+}
+
+template<typename Base>
+template<typename L>
+void NzListenable<Base>::AddListener(L* listener, void* userdata) const
+{
+	static_assert(std::is_base_of<typename Base::Listener, L>::value, "`listener` does not derive from a Listener");
+
+	if (!m_listenersLocked)
+		m_listeners.insert(std::make_pair(listener, userdata));
+}
+
+template<typename Base>
+template<typename L>
+void NzListenable<Base>::RemoveListener(L* listener) const
+{
+	static_assert(std::is_base_of<typename Base::Listener, L>::value, "`listener` does not derive from a Listener");
+
+	if (!m_listenersLocked)
+		m_listeners.erase(listener);
+}
+
+template<typename Base>
+template<typename F, typename... Args>
+void NzListenable<Base>::Notify(F callback, Args&&... args)
+{
+	using Listener = typename Base::Listener;
+
+	m_listenersLocked = true;
+
+	auto it = m_listeners.begin();
+	while (it != m_listeners.end())
+	{
+		Listener* listener = static_cast<Listener*>(it->first);
+		if (!(listener->*callback)(static_cast<Base*>(this), std::forward<Args>(args)..., it->second))
+			m_listeners.erase(it++);
+		else
+			++it;
+	}
+
+	m_listenersLocked = false;
+}
+
+template<typename Base>
+template<typename F>
+void NzListenable<Base>::NotifyRelease(F callback)
+{
+	using Listener = typename Base::Listener;
+
+	m_listenersLocked = true;
+	for (auto& pair : m_listeners)
+	{
+		Listener* listener = static_cast<Listener*>(pair.first);
+		(listener->*callback)(static_cast<Base*>(this), pair.second);
+	}
+}
+
+#include <Nazara/Core/DebugOff.hpp>

include/Nazara/Renderer/RenderTarget.hpp

@@ -8,24 +8,21 @@
 #define NAZARA_RENDERTARGET_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/Listenable.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/RenderTargetParameters.hpp>
 #include <unordered_map>
 
 class NzRenderer;
 
-class NAZARA_API NzRenderTarget
+class NAZARA_API NzRenderTarget : public NzListenable<NzRenderTarget>
 {
 	friend class NzRenderer;
 
 	public:
-		class Listener;
+		NzRenderTarget() = default;
-
-		NzRenderTarget();
 		virtual ~NzRenderTarget();
 
-		void AddListener(Listener* listener, void* userdata = nullptr) const;
-
 		virtual unsigned int GetHeight() const = 0;
 		virtual NzRenderTargetParameters GetParameters() const = 0;
 		virtual unsigned int GetWidth() const = 0;
@@ -33,8 +30,6 @@ class NAZARA_API NzRenderTarget
 		bool IsActive() const;
 		virtual bool IsRenderable() const = 0;
 
-		void RemoveListener(Listener* listener) const;
-
 		bool SetActive(bool active);
 
 		// Fonctions OpenGL
@@ -55,13 +50,6 @@ class NAZARA_API NzRenderTarget
 		virtual bool Activate() const = 0;
 		virtual void Desactivate() const;
 		virtual void EnsureTargetUpdated() const = 0;
-
-		void NotifyParametersChange();
-		void NotifySizeChange();
-
-	private:
-		mutable std::unordered_map<Listener*, void*> m_listeners;
-		bool m_listenersLocked;
 };
 
 #endif // NAZARA_RENDERTARGET_HPP

include/Nazara/Utility/AbstractAtlas.hpp

@@ -8,6 +8,7 @@
 #define NAZARA_ABSTRACTATLAS_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/Listenable.hpp>
 #include <Nazara/Core/SparsePtr.hpp>
 #include <Nazara/Math/Rect.hpp>
 #include <Nazara/Utility/Enums.hpp>
@@ -16,16 +17,12 @@
 class NzAbstractImage;
 class NzImage;
 
-class NAZARA_API NzAbstractAtlas
+class NAZARA_API NzAbstractAtlas : public NzListenable<NzAbstractAtlas>
 {
 	public:
-		class Listener;
+		NzAbstractAtlas() = default;
-
-		NzAbstractAtlas();
 		virtual ~NzAbstractAtlas();
 
-		void AddListener(Listener* font, void* userdata = nullptr) const;
-
 		virtual void Clear() = 0;
 		virtual void Free(NzSparsePtr<const NzRectui> rects, NzSparsePtr<unsigned int> layers, unsigned int count) = 0;
 		virtual NzAbstractImage* GetLayer(unsigned int layerIndex) const = 0;
@@ -33,8 +30,6 @@ class NAZARA_API NzAbstractAtlas
 		virtual nzUInt32 GetStorage() const = 0;
 		virtual bool Insert(const NzImage& image, NzRectui* rect, bool* flipped, unsigned int* layerIndex) = 0;
 
-		void RemoveListener(Listener* font) const;
-
 		class NAZARA_API Listener
 		{
 			public:
@@ -45,14 +40,6 @@ class NAZARA_API NzAbstractAtlas
 				virtual bool OnAtlasLayerChange(const NzAbstractAtlas* atlas, NzAbstractImage* oldLayer, NzAbstractImage* newLayer, void* userdata);
 				virtual void OnAtlasReleased(const NzAbstractAtlas* atlas, void* userdata);
 		};
-
-	protected:
-		void NotifyCleared();
-		void NotifyLayerChange(NzAbstractImage* oldLayer, NzAbstractImage* newLayer);
-
-	private:
-		mutable std::unordered_map<Listener*, void*> m_listeners;
-		bool m_listenersLocked;
 };
 
 #endif // NAZARA_ABSTRACTATLAS_HPP

include/Nazara/Utility/Node.hpp

@@ -8,13 +8,15 @@
 #define NAZARA_NODE_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/Listenable.hpp>
 #include <Nazara/Math/Matrix4.hpp>
 #include <Nazara/Math/Quaternion.hpp>
 #include <Nazara/Math/Vector3.hpp>
 #include <Nazara/Utility/Enums.hpp>
+#include <unordered_map>
 #include <vector>
 
-class NAZARA_API NzNode
+class NAZARA_API NzNode : public NzListenable<NzNode>
 {
 	public:
 		NzNode();
@@ -88,6 +90,17 @@ class NAZARA_API NzNode
 
 		NzNode& operator=(const NzNode& node);
 
+		class NAZARA_API Listener
+		{
+			public:
+				Listener() = default;
+				virtual ~Listener();
+
+				virtual bool OnNodeInvalidated(const NzNode* node, void* userdata);
+				virtual bool OnNodeParented(const NzNode* node, const NzNode* parent, void* userdata);
+				virtual void OnNodeReleased(const NzNode* node, void* userdata);
+		};
+
 	protected:
 		void AddChild(NzNode* node) const;
 		virtual void InvalidateNode();
@@ -113,6 +126,7 @@ class NAZARA_API NzNode
 		bool m_inheritRotation;
 		bool m_inheritScale;
 		mutable bool m_transformMatrixUpdated;
+
 };
 
 #endif // NAZARA_NODE_HPP

src/Nazara/Graphics/SceneNode.cpp

@@ -190,6 +190,8 @@ void NzSceneNode::InvalidateNode()
 
 void NzSceneNode::OnParenting(const NzNode* parent)
 {
+	NzNode::OnParenting(parent);
+
 	if (parent)
 	{
 		///FIXME: Remonter jusqu'au premier parent de type SceneNode plutôt que de s'arrêter au premier venu

src/Nazara/Renderer/RenderTarget.cpp

@@ -6,22 +6,9 @@
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/Debug.hpp>
 
-NzRenderTarget::NzRenderTarget() :
-m_listenersLocked(false)
-{
-}
-
 NzRenderTarget::~NzRenderTarget()
 {
-	m_listenersLocked = true;
+	NotifyRelease(Listener::OnRenderTargetReleased);
-	for (auto& pair : m_listeners)
-		pair.first->OnRenderTargetReleased(this, pair.second);
-}
-
-void NzRenderTarget::AddListener(Listener* listener, void* userdata) const
-{
-	if (!m_listenersLocked)
-		m_listeners.insert(std::make_pair(listener, userdata));
 }
 
 bool NzRenderTarget::IsActive() const
@@ -29,12 +16,6 @@ bool NzRenderTarget::IsActive() const
 	return NzRenderer::GetTarget() == this;
 }
 
-void NzRenderTarget::RemoveListener(Listener* listener) const
-{
-	if (!m_listenersLocked)
-		m_listeners.erase(listener);
-}
-
 bool NzRenderTarget::SetActive(bool active)
 {
 	if (active)
@@ -50,38 +31,6 @@ void NzRenderTarget::Desactivate() const
 	// Seuls les target sans contextes (ex: NzRenderTexture) nécessitent une désactivation
 }
 
-void NzRenderTarget::NotifyParametersChange()
-{
-	m_listenersLocked = true;
-
-	auto it = m_listeners.begin();
-	while (it != m_listeners.end())
-	{
-		if (!it->first->OnRenderTargetParametersChange(this, it->second))
-			m_listeners.erase(it++);
-		else
-			++it;
-	}
-
-	m_listenersLocked = false;
-}
-
-void NzRenderTarget::NotifySizeChange()
-{
-	m_listenersLocked = true;
-
-	auto it = m_listeners.begin();
-	while (it != m_listeners.end())
-	{
-		if (!it->first->OnRenderTargetSizeChange(this, it->second))
-			m_listeners.erase(it++);
-		else
-			++it;
-	}
-
-	m_listenersLocked = false;
-}
-
 NzRenderTarget::Listener::~Listener() = default;
 
 bool NzRenderTarget::Listener::OnRenderTargetParametersChange(const NzRenderTarget* renderTarget, void* userdata)

src/Nazara/Renderer/RenderTexture.cpp

@@ -376,8 +376,8 @@ bool NzRenderTexture::Create(bool lock)
 		onExit.Reset();
 	}
 
-	NotifyParametersChange();
+	Notify(Listener::OnRenderTargetParametersChange);
-	NotifySizeChange();
+	Notify(Listener::OnRenderTargetSizeChange);
 
 	return true;
 }

src/Nazara/Renderer/RenderWindow.cpp

@@ -278,8 +278,8 @@ bool NzRenderWindow::OnWindowCreated()
 	NzOpenGL::SetScissorBox(NzRecti(0, 0, size.x, size.y));
 	NzOpenGL::SetViewport(NzRecti(0, 0, size.x, size.y));
 
-	NotifyParametersChange();
+	Notify(Listener::OnRenderTargetParametersChange);
-	NotifySizeChange();
+	Notify(Listener::OnRenderTargetSizeChange);
 
 	m_clock.Restart();
 
@@ -300,5 +300,5 @@ void NzRenderWindow::OnWindowDestroy()
 
 void NzRenderWindow::OnWindowResized()
 {
-	NotifySizeChange();
+	Notify(Listener::OnRenderTargetSizeChange);
 }

src/Nazara/Utility/AbstractAtlas.cpp

@@ -5,63 +5,11 @@
 #include <Nazara/Utility/AbstractAtlas.hpp>
 #include <Nazara/Utility/Debug.hpp>
 
-NzAbstractAtlas::NzAbstractAtlas() :
-m_listenersLocked(false)
-{
-}
-
 NzAbstractAtlas::~NzAbstractAtlas()
 {
-	m_listenersLocked = true;
+	NotifyRelease(Listener::OnAtlasReleased);
-	for (auto& pair : m_listeners)
-		pair.first->OnAtlasReleased(this, pair.second);
 }
 
-void NzAbstractAtlas::AddListener(Listener* listener, void* userdata) const
-{
-	if (!m_listenersLocked)
-		m_listeners.insert(std::make_pair(listener, userdata));
-}
-
-void NzAbstractAtlas::RemoveListener(Listener* listener) const
-{
-	if (!m_listenersLocked)
-		m_listeners.erase(listener);
-}
-
-void NzAbstractAtlas::NotifyCleared()
-{
-	m_listenersLocked = true;
-
-	auto it = m_listeners.begin();
-	while (it != m_listeners.end())
-	{
-		if (!it->first->OnAtlasCleared(this, it->second))
-			m_listeners.erase(it++);
-		else
-			++it;
-	}
-
-	m_listenersLocked = false;
-}
-
-void NzAbstractAtlas::NotifyLayerChange(NzAbstractImage* oldLayer, NzAbstractImage* newLayer)
-{
-	m_listenersLocked = true;
-
-	auto it = m_listeners.begin();
-	while (it != m_listeners.end())
-	{
-		if (!it->first->OnAtlasLayerChange(this, oldLayer, newLayer, it->second))
-			m_listeners.erase(it++);
-		else
-			++it;
-	}
-
-	m_listenersLocked = false;
-}
-
-
 NzAbstractAtlas::Listener::~Listener() = default;
 
 bool NzAbstractAtlas::Listener::OnAtlasCleared(const NzAbstractAtlas* atlas, void* userdata)

src/Nazara/Utility/GuillotineImageAtlas.cpp

@@ -22,7 +22,7 @@ NzGuillotineImageAtlas::~NzGuillotineImageAtlas() = default;
 void NzGuillotineImageAtlas::Clear()
 {
 	m_layers.clear();
-	NotifyCleared();
+	Notify(Listener::OnAtlasCleared);
 }
 
 void NzGuillotineImageAtlas::Free(NzSparsePtr<const NzRectui> rects, NzSparsePtr<unsigned int> layers, unsigned int count)
@@ -187,7 +187,7 @@ bool NzGuillotineImageAtlas::ResizeLayer(Layer& layer, const NzVector2ui& size)
 
 	// On indique à ceux que ça intéresse qu'on a changé de pointeur
 	// (chose très importante pour ceux qui le stockent)
-	NotifyLayerChange(layer.image.get(), newImage.get());
+	Notify(Listener::OnAtlasLayerChange, layer.image.get(), newImage.get());
 
 	// Et on ne met à jour le pointeur qu'après (car cette ligne libère également l'ancienne image)
 	layer.image = std::move(newImage);

src/Nazara/Utility/Node.cpp

@@ -49,6 +49,8 @@ NzNode::~NzNode()
 	}
 
 	SetParent(nullptr);
+
+	NotifyRelease(Listener::OnNodeReleased);
 }
 
 void NzNode::EnsureDerivedUpdate() const
@@ -652,11 +654,13 @@ void NzNode::InvalidateNode()
 
 	for (NzNode* node : m_childs)
 		node->InvalidateNode();
+
+	Notify(Listener::OnNodeInvalidated);
 }
 
 void NzNode::OnParenting(const NzNode* parent)
 {
-	NazaraUnused(parent);
+	Notify(Listener::OnNodeParented, parent);
 }
 
 void NzNode::RemoveChild(NzNode* node) const
@@ -710,3 +714,28 @@ void NzNode::UpdateTransformMatrix() const
 	m_transformMatrix.MakeTransform(m_derivedPosition, m_derivedRotation, m_derivedScale);
 	m_transformMatrixUpdated = true;
 }
+
+NzNode::Listener::~Listener() = default;
+
+bool NzNode::Listener::OnNodeInvalidated(const NzNode* node, void* userdata)
+{
+	NazaraUnused(node);
+	NazaraUnused(userdata);
+
+	return true;
+}
+
+bool NzNode::Listener::OnNodeParented(const NzNode* node, const NzNode* parent, void* userdata)
+{
+	NazaraUnused(node);
+	NazaraUnused(parent);
+	NazaraUnused(userdata);
+
+	return true;
+}
+
+void NzNode::Listener::OnNodeReleased(const NzNode* node, void* userdata)
+{
+	NazaraUnused(node);
+	NazaraUnused(userdata);
+}