Merge branch 'master' into console-widget

SDK/include/NDK/Components.hpp

@@ -11,6 +11,7 @@
 #include <NDK/Components/ConstraintComponent2D.hpp>
 #include <NDK/Components/DebugComponent.hpp>
 #include <NDK/Components/GraphicsComponent.hpp>
+#include <NDK/Components/LifetimeComponent.hpp>
 #include <NDK/Components/LightComponent.hpp>
 #include <NDK/Components/ListenerComponent.hpp>
 #include <NDK/Components/NodeComponent.hpp>

SDK/include/NDK/Components/CollisionComponent2D.hpp

@@ -20,8 +20,9 @@ namespace Ndk
 
 	class NDK_API CollisionComponent2D : public Component<CollisionComponent2D>
 	{
-		friend class PhysicsSystem2D;
 		friend class ConstraintComponent2D;
+		friend class PhysicsComponent2D;
+		friend class PhysicsSystem2D;
 
 		public:
 			CollisionComponent2D(Nz::Collider2DRef geom = Nz::Collider2DRef());
@@ -30,8 +31,12 @@ namespace Ndk
 
 			Nz::Rectf GetAABB() const;
 			const Nz::Collider2DRef& GetGeom() const;
+			const Nz::Vector2f& GetGeomOffset() const;
+
+			void Recenter(const Nz::Vector2f& origin);
 
 			void SetGeom(Nz::Collider2DRef geom);
+			void SetGeomOffset(const Nz::Vector2f& geomOffset);
 
 			CollisionComponent2D& operator=(Nz::Collider2DRef geom);
 			CollisionComponent2D& operator=(CollisionComponent2D&& collision) = default;
@@ -40,7 +45,10 @@ namespace Ndk
 
 		private:
 			void InitializeStaticBody();
+			Nz::RigidBody2D* GetRigidBody();
+			const Nz::RigidBody2D* GetRigidBody() const;
 			Nz::RigidBody2D* GetStaticBody();
+			const Nz::RigidBody2D* GetStaticBody() const;
 
 			void OnAttached() override;
 			void OnComponentAttached(BaseComponent& component) override;

SDK/include/NDK/Components/CollisionComponent2D.inl

@@ -28,16 +28,6 @@ namespace Ndk
 	{
 	}
 
-	/*!
-	* \brief Gets the collision box representing the entity
-	* \return The physics collision box
-	*/
-
-	inline Nz::Rectf CollisionComponent2D::GetAABB() const
-	{
-		return m_staticBody->GetAABB();
-	}
-
 	/*!
 	* \brief Gets the geometry representing the entity
 	* \return A constant reference to the physics geometry
@@ -62,13 +52,13 @@ namespace Ndk
 		return *this;
 	}
 
-	/*!
-	* \brief Gets the static body used by the entity
-	* \return A pointer to the entity
-	*/
-
 	inline Nz::RigidBody2D* CollisionComponent2D::GetStaticBody()
 	{
 		return m_staticBody.get();
 	}
+
+	inline const Nz::RigidBody2D* CollisionComponent2D::GetStaticBody() const
+	{
+		return m_staticBody.get();
+	}
 }

SDK/include/NDK/Components/DebugComponent.hpp

@@ -16,7 +16,7 @@ namespace Ndk
 {
 	enum class DebugDraw
 	{
-		//TODO: Collider2D
+		Collider2D,
 		Collider3D,
 		GraphicsAABB,
 		GraphicsOBB,

SDK/include/NDK/Components/LifetimeComponent.hpp

@@ -0,0 +1,40 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#pragma once
+
+#ifndef NDK_COMPONENTS_LIFETIMECOMPONENT_HPP
+#define NDK_COMPONENTS_LIFETIMECOMPONENT_HPP
+
+#include <NDK/Component.hpp>
+
+namespace Ndk
+{
+	class LifetimeComponent;
+
+	using LifetimeComponentHandle = Nz::ObjectHandle<LifetimeComponent>;
+
+	class NDK_API LifetimeComponent : public Component<LifetimeComponent>
+	{
+		friend class LifetimeSystem;
+
+		public:
+			inline LifetimeComponent(float lifetime);
+			LifetimeComponent(const LifetimeComponent&) = default;
+			~LifetimeComponent() = default;
+
+			inline float GetRemainingTime() const;
+
+			static ComponentIndex componentIndex;
+
+		private:
+			inline bool UpdateLifetime(float elapsedTime);
+
+			float m_lifetime;
+	};
+}
+
+#include <NDK/Components/LifetimeComponent.inl>
+
+#endif // NDK_COMPONENTS_LIFETIMECOMPONENT_HPP

SDK/include/NDK/Components/LifetimeComponent.inl

@@ -0,0 +1,24 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#include <NDK/Components/LifetimeComponent.hpp>
+
+namespace Ndk
+{
+	inline LifetimeComponent::LifetimeComponent(float lifetime) :
+	m_lifetime(lifetime)
+	{
+	}
+
+	inline float Ndk::LifetimeComponent::GetRemainingTime() const
+	{
+		return m_lifetime;
+	}
+
+	inline bool LifetimeComponent::UpdateLifetime(float elapsedTime)
+	{
+		m_lifetime -= elapsedTime;
+		return m_lifetime < 0.f;
+	}
+}

SDK/include/NDK/Components/PhysicsComponent2D.hpp

@@ -24,6 +24,8 @@ namespace Ndk
 		friend class ConstraintComponent2D;
 
 		public:
+			using VelocityFunc = Nz::RigidBody2D::VelocityFunc;
+
 			PhysicsComponent2D();
 			PhysicsComponent2D(const PhysicsComponent2D& physics);
 			~PhysicsComponent2D() = default;
@@ -38,6 +40,8 @@ namespace Ndk
 
 			inline void EnableNodeSynchronization(bool nodeSynchronization);
 
+			inline void ForEachArbiter(const std::function<void(Nz::Arbiter2D&)>& callback);
+
 			inline Nz::Rectf GetAABB() const;
 			inline float GetAngularDamping() const;
 			inline Nz::RadianAnglef GetAngularVelocity() const;
@@ -53,9 +57,13 @@ namespace Ndk
 			inline Nz::Vector2f GetSurfaceVelocity(std::size_t shapeIndex = 0) const;
 			inline std::size_t GetShapeCount() const;
 			inline Nz::Vector2f GetVelocity() const;
+			const VelocityFunc& GetVelocityFunction() const;
 
 			inline bool IsNodeSynchronizationEnabled() const;
 			inline bool IsSleeping() const;
+			inline bool IsValid() const;
+
+			inline void ResetVelocityFunction();
 
 			inline void SetAngularDamping(float angularDamping);
 			inline void SetAngularVelocity(const Nz::RadianAnglef& angularVelocity);
@@ -71,6 +79,9 @@ namespace Ndk
 			inline void SetSurfaceVelocity(const Nz::Vector2f& velocity);
 			inline void SetSurfaceVelocity(std::size_t shapeIndex, const Nz::Vector2f& velocity);
 			inline void SetVelocity(const Nz::Vector2f& velocity);
+			inline void SetVelocityFunction(VelocityFunc velocityFunc);
+
+			inline void UpdateVelocity(const Nz::Vector2f& gravity, float damping, float deltaTime);
 
 			static ComponentIndex componentIndex;
 

SDK/include/NDK/Components/PhysicsComponent2D.inl

@@ -138,6 +138,15 @@ namespace Ndk
 			m_entity->Invalidate();
 	}
 
+	/*!
+	TODO
+	*/
+	inline void PhysicsComponent2D::ForEachArbiter(const std::function<void(Nz::Arbiter2D&)>& callback)
+	{
+		NazaraAssert(m_object, "Invalid physics object");
+
+		return m_object->ForEachArbiter(callback);
+	}
 	/*!
 	* \brief Gets the AABB of the physics object
 	* \return AABB of the object
@@ -329,7 +338,6 @@ namespace Ndk
 	*
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
-
 	inline Nz::Vector2f PhysicsComponent2D::GetVelocity() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
@@ -337,6 +345,19 @@ namespace Ndk
 		return m_object->GetVelocity();
 	}
 
+	/*!
+	* \brief Gets the custom velocity function of the physics object
+	* \return Velocity function of the object (may be empty if default function is used)
+	*
+	* \remark Produces a NazaraAssert if the physics object is invalid
+	*/
+	inline auto PhysicsComponent2D::GetVelocityFunction() const -> const VelocityFunc&
+	{
+		NazaraAssert(m_object, "Invalid physics object");
+
+		return m_object->GetVelocityFunction();
+	}
+
 	/*!
 	* \brief Checks if position & rotation are synchronized with NodeComponent
 	* \return true If synchronization is enabled
@@ -361,6 +382,30 @@ namespace Ndk
 		return m_object->IsSleeping();
 	}
 
+	/*!
+	* \brief Checks if this component is bound to a valid rigid body
+	*
+	* A component may not be bound to a rigid body if the component is not bound to an entity or if this entity is being destroyed
+	* 
+	* \return true If bound, false otherwise
+	*/
+	inline bool PhysicsComponent2D::IsValid() const
+	{
+		return bool(m_object);
+	}
+
+	/*!
+	* \brief Reset velocity function to default one
+	*
+	* \remark Produces a NazaraAssert if the physics object is invalid
+	*/
+	inline void PhysicsComponent2D::ResetVelocityFunction()
+	{
+		NazaraAssert(m_object, "Invalid physics object");
+
+		return m_object->ResetVelocityFunction();
+	}
+
 	/*!
 	* \brief Sets the angular damping or moment of inertia of the physics object
 	*
@@ -571,6 +616,39 @@ namespace Ndk
 		m_object->SetVelocity(velocity);
 	}
 
+	/*!
+	* \brief Sets a custom velocity function for the physics object
+	*
+	* A velocity function is called (for non-kinematic and non-static objects) at every physics update to compute the new velocity of the object.
+	* You may call UpdateVelocity (the default velocity function) to let the physics engine compute that itself and then adjust it using GetVelocity/SetVelocity as you need.
+	*
+	* \param velocityFunc New custom velocity function
+	*
+	* \remark Passing an empty VelocityFunc has the same effect as calling ResetVelocityFunction
+	* \see ResetVelocityFunction
+	* \see UpdateVelocity
+	*/
+	inline void PhysicsComponent2D::SetVelocityFunction(VelocityFunc velocityFunc)
+	{
+		NazaraAssert(m_object, "Invalid physics object");
+
+		m_object->SetVelocityFunction(std::move(velocityFunc));
+	}
+
+	/*!
+	* \brief Calls the physics engine default velocity function
+	*
+	* \param gravity Physics system gravity
+	* \param damping Physics system damping (adjusted to deltaTime)
+	* \param deltaTime Elapsed time since last physics update
+	*/
+	inline void PhysicsComponent2D::UpdateVelocity(const Nz::Vector2f& gravity, float damping, float deltaTime)
+	{
+		NazaraAssert(m_object, "Invalid physics object");
+
+		m_object->UpdateVelocity(gravity, damping, deltaTime);
+	}
+
 	/*!
 	* \brief Gets the underlying physics object
 	* \return A reference to the physics object

SDK/include/NDK/Components/VelocityComponent.hpp

@@ -19,10 +19,11 @@ namespace Ndk
 	class NDK_API VelocityComponent : public Component<VelocityComponent>
 	{
 		public:
-			VelocityComponent(const Nz::Vector3f& velocity = Nz::Vector3f::Zero());
+			VelocityComponent(const Nz::Vector3f& velocity = Nz::Vector3f::Zero(), Nz::CoordSys coordSystem = Nz::CoordSys_Global);
 			~VelocityComponent() = default;
 
 			Nz::Vector3f linearVelocity;
+			Nz::CoordSys coordSys;
 
 			VelocityComponent& operator=(const Nz::Vector3f& vel);
 

SDK/include/NDK/Components/VelocityComponent.inl

@@ -16,8 +16,9 @@ namespace Ndk
 	* \param velocity Linear velocity
 	*/
 
-	inline VelocityComponent::VelocityComponent(const Nz::Vector3f& velocity) :
-	linearVelocity(velocity)
+	inline VelocityComponent::VelocityComponent(const Nz::Vector3f& velocity, Nz::CoordSys coordSystem) :
+		linearVelocity(velocity),
+		coordSys(coordSystem)
 	{
 	}
 

SDK/include/NDK/StateMachine.inl

@@ -159,8 +159,13 @@ namespace Ndk
 	*/
 	inline bool StateMachine::Update(float elapsedTime)
 	{
-		for (StateTransition& transition : m_transitions)
+		// Use a classic for instead of a range-for because some state may push/pop on enter/leave, adding new transitions as we iterate
+		// (range-for is a problem here because it doesn't handle mutable containers)
+
+		for (std::size_t i = 0; i < m_transitions.size(); ++i)
 		{
+			StateTransition& transition = m_transitions[i];
+
 			switch (transition.type)
 			{
 				case TransitionType::Pop:

SDK/include/NDK/Systems.hpp

@@ -6,6 +6,7 @@
 #define NDK_SYSTEMS_GLOBAL_HPP
 
 #include <NDK/Systems/DebugSystem.hpp>
+#include <NDK/Systems/LifetimeSystem.hpp>
 #include <NDK/Systems/ListenerSystem.hpp>
 #include <NDK/Systems/ParticleSystem.hpp>
 #include <NDK/Systems/PhysicsSystem2D.hpp>

SDK/include/NDK/Systems/DebugSystem.hpp

@@ -26,6 +26,7 @@ namespace Ndk
 
 		private:
 			Nz::InstancedRenderableRef GenerateBox(Nz::Boxf box);
+			Nz::InstancedRenderableRef GenerateCollision2DMesh(Entity* entity, Nz::Vector3f* offset);
 			Nz::InstancedRenderableRef GenerateCollision3DMesh(Entity* entity);
 
 			Nz::MaterialRef GetCollisionMaterial();

SDK/include/NDK/Systems/LifetimeSystem.hpp

@@ -0,0 +1,29 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
+
+#pragma once
+
+#ifndef NDK_SYSTEMS_LIFETIMESYSTEM_HPP
+#define NDK_SYSTEMS_LIFETIMESYSTEM_HPP
+
+#include <NDK/System.hpp>
+
+namespace Ndk
+{
+	class NDK_API LifetimeSystem : public System<LifetimeSystem>
+	{
+		public:
+			LifetimeSystem();
+			~LifetimeSystem() = default;
+
+			static SystemIndex systemIndex;
+
+		private:
+			void OnUpdate(float elapsedTime) override;
+	};
+}
+
+#include <NDK/Systems/LifetimeSystem.inl>
+
+#endif // NDK_SYSTEMS_LIFETIMESYSTEM_HPP

SDK/include/NDK/Systems/LifetimeSystem.inl

@@ -0,0 +1,3 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequisites.hpp

SDK/include/NDK/Systems/PhysicsSystem2D.hpp

@@ -51,9 +51,11 @@ namespace Ndk
 			bool NearestBodyQuery(const Nz::Vector2f& from, float maxDistance, Nz::UInt32 collisionGroup, Nz::UInt32 categoryMask, Nz::UInt32 collisionMask, EntityHandle* nearestBody = nullptr);
 			bool NearestBodyQuery(const Nz::Vector2f& from, float maxDistance, Nz::UInt32 collisionGroup, Nz::UInt32 categoryMask, Nz::UInt32 collisionMask, NearestQueryResult* result);
 
+			void RaycastQuery(const Nz::Vector2f& from, const Nz::Vector2f& to, float radius, Nz::UInt32 collisionGroup, Nz::UInt32 categoryMask, Nz::UInt32 collisionMask, const std::function<void(const RaycastHit&)>& callback);
 			bool RaycastQuery(const Nz::Vector2f& from, const Nz::Vector2f& to, float radius, Nz::UInt32 collisionGroup, Nz::UInt32 categoryMask, Nz::UInt32 collisionMask, std::vector<RaycastHit>* hitInfos);
 			bool RaycastQueryFirst(const Nz::Vector2f& from, const Nz::Vector2f& to, float radius, Nz::UInt32 collisionGroup, Nz::UInt32 categoryMask, Nz::UInt32 collisionMask, RaycastHit* hitInfo = nullptr);
 
+			void RegionQuery(const Nz::Rectf& boundingBox, Nz::UInt32 collisionGroup, Nz::UInt32 categoryMask, Nz::UInt32 collisionMask, const std::function<void(const EntityHandle&)>& callback);
 			void RegionQuery(const Nz::Rectf& boundingBox, Nz::UInt32 collisionGroup, Nz::UInt32 categoryMask, Nz::UInt32 collisionMask, std::vector<EntityHandle>* bodies);
 
 			void RegisterCallbacks(unsigned int collisionId, Callback callbacks);

SDK/include/NDK/Widgets.hpp

@@ -5,6 +5,7 @@
 #ifndef NDK_WIDGETS_GLOBAL_HPP
 #define NDK_WIDGETS_GLOBAL_HPP
 
+#include <NDK/Widgets/BoxLayout.hpp>
 #include <NDK/Widgets/ButtonWidget.hpp>
 #include <NDK/Widgets/CheckboxWidget.hpp>
 #include <NDK/Widgets/Enums.hpp>

SDK/include/NDK/Widgets/TextAreaWidget.hpp

@@ -50,6 +50,8 @@ namespace Ndk
 			inline std::size_t GetGlyphIndex(const Nz::Vector2ui& cursorPosition) const;
 			inline const Nz::String& GetText() const;
 			inline const Nz::Color& GetTextColor() const;
+			inline const Nz::Color& GetTextOulineColor() const;
+			inline float GetTextOulineThickness() const;
 
 			Nz::Vector2ui GetHoveredGlyph(float x, float y) const;
 
@@ -71,6 +73,8 @@ namespace Ndk
 			inline void SetSelection(Nz::Vector2ui fromPosition, Nz::Vector2ui toPosition);
 			inline void SetText(const Nz::String& text);
 			inline void SetTextColor(const Nz::Color& text);
+			inline void SetTextOutlineColor(const Nz::Color& color);
+			inline void SetTextOutlineThickness(float thickness);
 
 			inline void Write(const Nz::String& text);
 			inline void Write(const Nz::String& text, const Nz::Vector2ui& glyphPosition);

SDK/include/NDK/Widgets/TextAreaWidget.inl

@@ -107,6 +107,16 @@ namespace Ndk
 		return m_drawer.GetColor();
 	}
 
+	inline const Nz::Color& TextAreaWidget::GetTextOulineColor() const
+	{
+		return m_drawer.GetOutlineColor();
+	}
+
+	inline float TextAreaWidget::GetTextOulineThickness() const
+	{
+		return m_drawer.GetOutlineThickness();
+	}
+
 	inline bool TextAreaWidget::HasSelection() const
 	{
 		return m_cursorPositionBegin != m_cursorPositionEnd;
@@ -246,7 +256,21 @@ namespace Ndk
 	{
 		m_drawer.SetColor(text);
 
-		m_textSprite->Update(m_drawer);
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextOutlineColor(const Nz::Color& color)
+	{
+		m_drawer.SetOutlineColor(color);
+
+		UpdateDisplayText();
+	}
+
+	inline void TextAreaWidget::SetTextOutlineThickness(float thickness)
+	{
+		m_drawer.SetOutlineThickness(thickness);
+
+		UpdateDisplayText();
 	}
 
 	inline void TextAreaWidget::Write(const Nz::String& text)

SDK/include/NDK/World.hpp

@@ -98,6 +98,12 @@ namespace Ndk
 			inline void InvalidateSystemOrder();
 			void ReorderSystems();
 
+			struct DoubleBitset
+			{
+				Nz::Bitset<Nz::UInt64> front;
+				Nz::Bitset<Nz::UInt64> back;
+			};
+
 			struct EntityBlock
 			{
 				EntityBlock(Entity&& e) :
@@ -119,9 +125,9 @@ namespace Ndk
 			std::vector<std::unique_ptr<EntityBlock>> m_waitingEntities;
 			EntityList m_aliveEntities;
 			ProfilerData m_profilerData;
-			Nz::Bitset<Nz::UInt64> m_dirtyEntities;
+			DoubleBitset m_dirtyEntities;
 			Nz::Bitset<Nz::UInt64> m_freeEntityIds;
-			Nz::Bitset<Nz::UInt64> m_killedEntities;
+			DoubleBitset m_killedEntities;
 			bool m_orderedSystemsUpdated;
 			bool m_isProfilerEnabled;
 	};

SDK/include/NDK/World.inl

@@ -308,7 +308,7 @@ namespace Ndk
 	inline void World::KillEntity(Entity* entity)
 	{
 		if (IsEntityValid(entity))
-			m_killedEntities.UnboundedSet(entity->GetId(), true);
+			m_killedEntities.front.UnboundedSet(entity->GetId(), true);
 	}
 
 	/*!
@@ -343,7 +343,7 @@ namespace Ndk
 	*/
 	inline bool World::IsEntityDying(EntityId id) const
 	{
-		return m_killedEntities.UnboundedTest(id);
+		return m_killedEntities.front.UnboundedTest(id);
 	}
 
 	/*!
@@ -467,13 +467,13 @@ namespace Ndk
 
 	inline void World::Invalidate()
 	{
-		m_dirtyEntities.Resize(m_entityBlocks.size(), false);
-		m_dirtyEntities.Set(true); // Activation of all bits
+		m_dirtyEntities.front.Resize(m_entityBlocks.size(), false);
+		m_dirtyEntities.front.Set(true); // Activation of all bits
 	}
 
 	inline void World::Invalidate(EntityId id)
 	{
-		m_dirtyEntities.UnboundedSet(id, true);
+		m_dirtyEntities.front.UnboundedSet(id, true);
 	}
 
 	inline void World::InvalidateSystemOrder()