Merge pull request #84 from DigitalPulseSoftware/physics-refactor

Physics refactor to prepare Physics2D module

SDK/include/NDK/Components.hpp

@@ -6,14 +6,14 @@
 #define NDK_COMPONENTS_GLOBAL_HPP
 
 #include <NDK/Components/CameraComponent.hpp>
-#include <NDK/Components/CollisionComponent.hpp>
+#include <NDK/Components/CollisionComponent3D.hpp>
 #include <NDK/Components/GraphicsComponent.hpp>
 #include <NDK/Components/LightComponent.hpp>
 #include <NDK/Components/ListenerComponent.hpp>
 #include <NDK/Components/NodeComponent.hpp>
 #include <NDK/Components/ParticleEmitterComponent.hpp>
 #include <NDK/Components/ParticleGroupComponent.hpp>
-#include <NDK/Components/PhysicsComponent.hpp>
+#include <NDK/Components/PhysicsComponent3D.hpp>
 #include <NDK/Components/VelocityComponent.hpp>
 
 #endif // NDK_COMPONENTS_GLOBAL_HPP

SDK/include/NDK/Components/CollisionComponent3D.hpp

@@ -7,53 +7,53 @@
 #ifndef NDK_COMPONENTS_COLLISIONCOMPONENT_HPP
 #define NDK_COMPONENTS_COLLISIONCOMPONENT_HPP
 
-#include <Nazara/Physics/Geom.hpp>
+#include <Nazara/Physics3D/Collider3D.hpp>
 #include <NDK/Component.hpp>
 #include <memory>
 
 namespace Nz
 {
-	class PhysObject;
+	class RigidBody3D;
 }
 
 namespace Ndk
 {
 	class Entity;
 
-	class NDK_API CollisionComponent : public Component<CollisionComponent>
+	class NDK_API CollisionComponent3D : public Component<CollisionComponent3D>
 	{
-		friend class PhysicsSystem;
+		friend class PhysicsSystem3D;
 		friend class StaticCollisionSystem;
 
 		public:
-			CollisionComponent(Nz::PhysGeomRef geom = Nz::PhysGeomRef());
+			CollisionComponent3D(Nz::Collider3DRef geom = Nz::Collider3DRef());
-			CollisionComponent(const CollisionComponent& collision);
+			CollisionComponent3D(const CollisionComponent3D& collision);
-			~CollisionComponent() = default;
+			~CollisionComponent3D() = default;
 
-			const Nz::PhysGeomRef& GetGeom() const;
+			const Nz::Collider3DRef& GetGeom() const;
 
-			void SetGeom(Nz::PhysGeomRef geom);
+			void SetGeom(Nz::Collider3DRef geom);
 
-			CollisionComponent& operator=(Nz::PhysGeomRef geom);
+			CollisionComponent3D& operator=(Nz::Collider3DRef geom);
-			CollisionComponent& operator=(CollisionComponent&& collision) = default;
+			CollisionComponent3D& operator=(CollisionComponent3D&& collision) = default;
 
 			static ComponentIndex componentIndex;
 
 		private:
 			void InitializeStaticBody();
-			Nz::PhysObject* GetStaticBody();
+			Nz::RigidBody3D* GetStaticBody();
 
 			void OnAttached() override;
 			void OnComponentAttached(BaseComponent& component) override;
 			void OnComponentDetached(BaseComponent& component) override;
 			void OnDetached() override;
 
-			std::unique_ptr<Nz::PhysObject> m_staticBody;
+			std::unique_ptr<Nz::RigidBody3D> m_staticBody;
-			Nz::PhysGeomRef m_geom;
+			Nz::Collider3DRef m_geom;
 			bool m_bodyUpdated;
 	};
 }
 
-#include <NDK/Components/CollisionComponent.inl>
+#include <NDK/Components/CollisionComponent3D.inl>
 
 #endif // NDK_COMPONENTS_COLLISIONCOMPONENT_HPP

SDK/include/NDK/Components/CollisionComponent3D.inl

@@ -4,30 +4,30 @@
 
 #include <NDK/Entity.hpp>
 #include <NDK/World.hpp>
-#include <NDK/Components/PhysicsComponent.hpp>
+#include <NDK/Components/PhysicsComponent3D.hpp>
-#include <NDK/Systems/PhysicsSystem.hpp>
+#include <NDK/Systems/PhysicsSystem3D.hpp>
 
 namespace Ndk
 {
 	/*!
-	* \brief Constructs a CollisionComponent object with a geometry
+	* \brief Constructs a CollisionComponent3D object with a geometry
 	*
 	* \param geom Reference to a geometry symbolizing the entity
 	*/
 
-	inline CollisionComponent::CollisionComponent(Nz::PhysGeomRef geom) :
+	inline CollisionComponent3D::CollisionComponent3D(Nz::Collider3DRef geom) :
 	m_geom(std::move(geom)),
 	m_bodyUpdated(false)
 	{
 	}
 
 	/*!
-	* \brief Constructs a CollisionComponent object by copy semantic
+	* \brief Constructs a CollisionComponent3D object by copy semantic
 	*
-	* \param collision CollisionComponent to copy
+	* \param collision CollisionComponent3D to copy
 	*/
 
-	inline CollisionComponent::CollisionComponent(const CollisionComponent& collision) :
+	inline CollisionComponent3D::CollisionComponent3D(const CollisionComponent3D& collision) :
 	m_geom(collision.m_geom),
 	m_bodyUpdated(false)
 	{
@@ -38,7 +38,7 @@ namespace Ndk
 	* \return A constant reference to the physics geometry
 	*/
 
-	inline const Nz::PhysGeomRef& CollisionComponent::GetGeom() const
+	inline const Nz::Collider3DRef& CollisionComponent3D::GetGeom() const
 	{
 		return m_geom;
 	}
@@ -50,7 +50,7 @@ namespace Ndk
 	* \param geom Reference to a geometry symbolizing the entity
 	*/
 
-	inline CollisionComponent& CollisionComponent::operator=(Nz::PhysGeomRef geom)
+	inline CollisionComponent3D& CollisionComponent3D::operator=(Nz::Collider3DRef geom)
 	{
 		SetGeom(geom);
 
@@ -62,7 +62,7 @@ namespace Ndk
 	* \return A pointer to the entity
 	*/
 
-	inline Nz::PhysObject* CollisionComponent::GetStaticBody()
+	inline Nz::RigidBody3D* CollisionComponent3D::GetStaticBody()
 	{
 		return m_staticBody.get();
 	}

SDK/include/NDK/Components/PhysicsComponent3D.hpp

@@ -4,10 +4,10 @@
 
 #pragma once
 
-#ifndef NDK_COMPONENTS_PHYSICSCOMPONENT_HPP
+#ifndef NDK_COMPONENTS_PHYSICSCOMPONENT3D_HPP
-#define NDK_COMPONENTS_PHYSICSCOMPONENT_HPP
+#define NDK_COMPONENTS_PHYSICSCOMPONENT3D_HPP
 
-#include <Nazara/Physics/PhysObject.hpp>
+#include <Nazara/Physics3D/RigidBody3D.hpp>
 #include <NDK/Component.hpp>
 #include <memory>
 
@@ -15,15 +15,15 @@ namespace Ndk
 {
 	class Entity;
 
-	class NDK_API PhysicsComponent : public Component<PhysicsComponent>
+	class NDK_API PhysicsComponent3D : public Component<PhysicsComponent3D>
 	{
-		friend class CollisionComponent;
+		friend class CollisionComponent3D;
-		friend class PhysicsSystem;
+		friend class PhysicsSystem3D;
 
 		public:
-			PhysicsComponent() = default;
+			PhysicsComponent3D() = default;
-			PhysicsComponent(const PhysicsComponent& physics);
+			PhysicsComponent3D(const PhysicsComponent3D& physics);
-			~PhysicsComponent() = default;
+			~PhysicsComponent3D() = default;
 
 			void AddForce(const Nz::Vector3f& force, Nz::CoordSys coordSys = Nz::CoordSys_Global);
 			void AddForce(const Nz::Vector3f& force, const Nz::Vector3f& point, Nz::CoordSys coordSys = Nz::CoordSys_Global);
@@ -56,17 +56,17 @@ namespace Ndk
 			static ComponentIndex componentIndex;
 
 		private:
-			Nz::PhysObject& GetPhysObject();
+			Nz::RigidBody3D& GetPhysObject();
 
 			void OnAttached() override;
 			void OnComponentAttached(BaseComponent& component) override;
 			void OnComponentDetached(BaseComponent& component) override;
 			void OnDetached() override;
 
-			std::unique_ptr<Nz::PhysObject> m_object;
+			std::unique_ptr<Nz::RigidBody3D> m_object;
 	};
 }
 
-#include <NDK/Components/PhysicsComponent.inl>
+#include <NDK/Components/PhysicsComponent3D.inl>
 
-#endif // NDK_COMPONENTS_PHYSICSCOMPONENT_HPP
+#endif // NDK_COMPONENTS_PHYSICSCOMPONENT3D_HPP

SDK/include/NDK/Components/PhysicsComponent3D.inl

@@ -7,12 +7,12 @@
 namespace Ndk
 {
 	/*!
-	* \brief Constructs a PhysicsComponent object by copy semantic
+	* \brief Constructs a PhysicsComponent3D object by copy semantic
 	*
-	* \param physics PhysicsComponent to copy
+	* \param physics PhysicsComponent3D to copy
 	*/
 
-	inline PhysicsComponent::PhysicsComponent(const PhysicsComponent& physics)
+	inline PhysicsComponent3D::PhysicsComponent3D(const PhysicsComponent3D& physics)
 	{
 		// No copy of physical object (because we only create it when attached to an entity)
 		NazaraUnused(physics);
@@ -27,7 +27,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::AddForce(const Nz::Vector3f& force, Nz::CoordSys coordSys)
+	inline void PhysicsComponent3D::AddForce(const Nz::Vector3f& force, Nz::CoordSys coordSys)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -44,7 +44,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::AddForce(const Nz::Vector3f& force, const Nz::Vector3f& point, Nz::CoordSys coordSys)
+	inline void PhysicsComponent3D::AddForce(const Nz::Vector3f& force, const Nz::Vector3f& point, Nz::CoordSys coordSys)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -60,7 +60,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::AddTorque(const Nz::Vector3f& torque, Nz::CoordSys coordSys)
+	inline void PhysicsComponent3D::AddTorque(const Nz::Vector3f& torque, Nz::CoordSys coordSys)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -75,7 +75,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::EnableAutoSleep(bool autoSleep)
+	inline void PhysicsComponent3D::EnableAutoSleep(bool autoSleep)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -89,7 +89,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline Nz::Boxf PhysicsComponent::GetAABB() const
+	inline Nz::Boxf PhysicsComponent3D::GetAABB() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -103,7 +103,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline Nz::Vector3f PhysicsComponent::GetAngularVelocity() const
+	inline Nz::Vector3f PhysicsComponent3D::GetAngularVelocity() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -117,7 +117,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline float PhysicsComponent::GetGravityFactor() const
+	inline float PhysicsComponent3D::GetGravityFactor() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -131,7 +131,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline float PhysicsComponent::GetMass() const
+	inline float PhysicsComponent3D::GetMass() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -147,7 +147,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline Nz::Vector3f PhysicsComponent::GetMassCenter(Nz::CoordSys coordSys) const
+	inline Nz::Vector3f PhysicsComponent3D::GetMassCenter(Nz::CoordSys coordSys) const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -161,7 +161,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline const Nz::Matrix4f& PhysicsComponent::GetMatrix() const
+	inline const Nz::Matrix4f& PhysicsComponent3D::GetMatrix() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -175,7 +175,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline Nz::Vector3f PhysicsComponent::GetPosition() const
+	inline Nz::Vector3f PhysicsComponent3D::GetPosition() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -189,7 +189,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline Nz::Quaternionf PhysicsComponent::GetRotation() const
+	inline Nz::Quaternionf PhysicsComponent3D::GetRotation() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -203,7 +203,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline Nz::Vector3f PhysicsComponent::GetVelocity() const
+	inline Nz::Vector3f PhysicsComponent3D::GetVelocity() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -217,7 +217,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline bool PhysicsComponent::IsAutoSleepEnabled() const
+	inline bool PhysicsComponent3D::IsAutoSleepEnabled() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -231,7 +231,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline bool PhysicsComponent::IsSleeping() const
+	inline bool PhysicsComponent3D::IsSleeping() const
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -246,7 +246,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::SetAngularVelocity(const Nz::Vector3f& angularVelocity)
+	inline void PhysicsComponent3D::SetAngularVelocity(const Nz::Vector3f& angularVelocity)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -261,7 +261,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::SetGravityFactor(float gravityFactor)
+	inline void PhysicsComponent3D::SetGravityFactor(float gravityFactor)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -277,7 +277,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the mass is negative
 	*/
 
-	inline void PhysicsComponent::SetMass(float mass)
+	inline void PhysicsComponent3D::SetMass(float mass)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 		NazaraAssert(mass > 0.f, "Mass should be positive");
@@ -293,7 +293,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::SetMassCenter(const Nz::Vector3f& center)
+	inline void PhysicsComponent3D::SetMassCenter(const Nz::Vector3f& center)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -308,7 +308,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::SetPosition(const Nz::Vector3f& position)
+	inline void PhysicsComponent3D::SetPosition(const Nz::Vector3f& position)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -323,7 +323,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::SetRotation(const Nz::Quaternionf& rotation)
+	inline void PhysicsComponent3D::SetRotation(const Nz::Quaternionf& rotation)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -338,7 +338,7 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the physics object is invalid
 	*/
 
-	inline void PhysicsComponent::SetVelocity(const Nz::Vector3f& velocity)
+	inline void PhysicsComponent3D::SetVelocity(const Nz::Vector3f& velocity)
 	{
 		NazaraAssert(m_object, "Invalid physics object");
 
@@ -350,7 +350,7 @@ namespace Ndk
 	* \return A reference to the physics object
 	*/
 
-	inline Nz::PhysObject& PhysicsComponent::GetPhysObject()
+	inline Nz::RigidBody3D& PhysicsComponent3D::GetPhysObject()
 	{
 		return *m_object.get();
 	}

SDK/include/NDK/Systems.hpp

@@ -7,7 +7,7 @@
 
 #include <NDK/Systems/ListenerSystem.hpp>
 #include <NDK/Systems/ParticleSystem.hpp>
-#include <NDK/Systems/PhysicsSystem.hpp>
+#include <NDK/Systems/PhysicsSystem3D.hpp>
 #include <NDK/Systems/RenderSystem.hpp>
 #include <NDK/Systems/VelocitySystem.hpp>
 

SDK/include/NDK/Systems/PhysicsSystem.hpp

@@ -1,42 +0,0 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Development Kit"
-// For conditions of distribution and use, see copyright notice in Prerequesites.hpp
-
-#pragma once
-
-#ifndef NDK_SYSTEMS_PHYSICSSYSTEM_HPP
-#define NDK_SYSTEMS_PHYSICSSYSTEM_HPP
-
-#include <Nazara/Physics/PhysWorld.hpp>
-#include <NDK/EntityList.hpp>
-#include <NDK/System.hpp>
-#include <memory>
-
-namespace Ndk
-{
-	class NDK_API PhysicsSystem : public System<PhysicsSystem>
-	{
-		public:
-			PhysicsSystem();
-			PhysicsSystem(const PhysicsSystem& system);
-			~PhysicsSystem() = default;
-
-			Nz::PhysWorld& GetWorld();
-			const Nz::PhysWorld& GetWorld() const;
-
-			static SystemIndex systemIndex;
-
-		private:
-			void CreatePhysWorld() const;
-			void OnEntityValidation(Entity* entity, bool justAdded) override;
-			void OnUpdate(float elapsedTime) override;
-
-			EntityList m_dynamicObjects;
-			EntityList m_staticObjects;
-			mutable std::unique_ptr<Nz::PhysWorld> m_world; ///TODO: std::optional (Should I make a Nz::Optional class?)
-	};
-}
-
-#include <NDK/Systems/PhysicsSystem.inl>
-
-#endif // NDK_SYSTEMS_PHYSICSSYSTEM_HPP

SDK/include/NDK/Systems/PhysicsSystem3D.hpp

@@ -0,0 +1,42 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Development Kit"
+// For conditions of distribution and use, see copyright notice in Prerequesites.hpp
+
+#pragma once
+
+#ifndef NDK_SYSTEMS_PHYSICSSYSTEM3D_HPP
+#define NDK_SYSTEMS_PHYSICSSYSTEM3D_HPP
+
+#include <Nazara/Physics3D/PhysWorld3D.hpp>
+#include <NDK/EntityList.hpp>
+#include <NDK/System.hpp>
+#include <memory>
+
+namespace Ndk
+{
+	class NDK_API PhysicsSystem3D : public System<PhysicsSystem3D>
+	{
+		public:
+			PhysicsSystem3D();
+			PhysicsSystem3D(const PhysicsSystem3D& system);
+			~PhysicsSystem3D() = default;
+
+			Nz::PhysWorld3D& GetWorld();
+			const Nz::PhysWorld3D& GetWorld() const;
+
+			static SystemIndex systemIndex;
+
+		private:
+			void CreatePhysWorld() const;
+			void OnEntityValidation(Entity* entity, bool justAdded) override;
+			void OnUpdate(float elapsedTime) override;
+
+			EntityList m_dynamicObjects;
+			EntityList m_staticObjects;
+			mutable std::unique_ptr<Nz::PhysWorld3D> m_world; ///TODO: std::optional (Should I make a Nz::Optional class?)
+	};
+}
+
+#include <NDK/Systems/PhysicsSystem3D.inl>
+
+#endif // NDK_SYSTEMS_PHYSICSSYSTEM3D_HPP

SDK/include/NDK/Systems/PhysicsSystem3D.inl

@@ -9,7 +9,7 @@ namespace Ndk
 	* \return A reference to the physical world
 	*/
 
-	inline Nz::PhysWorld& PhysicsSystem::GetWorld()
+	inline Nz::PhysWorld3D& PhysicsSystem3D::GetWorld()
 	{
 		if (!m_world)
 			CreatePhysWorld();
@@ -22,7 +22,7 @@ namespace Ndk
 	* \return A constant reference to the physical world
 	*/
 
-	inline const Nz::PhysWorld& PhysicsSystem::GetWorld() const
+	inline const Nz::PhysWorld3D& PhysicsSystem3D::GetWorld() const
 	{
 		if (!m_world)
 			CreatePhysWorld();

SDK/src/NDK/Components/CollisionComponent3D.cpp

@@ -2,18 +2,18 @@
 // This file is part of the "Nazara Development Kit"
 // For conditions of distribution and use, see copyright notice in Prerequesites.hpp
 
-#include <NDK/Components/CollisionComponent.hpp>
+#include <NDK/Components/CollisionComponent3D.hpp>
-#include <Nazara/Physics/PhysObject.hpp>
+#include <Nazara/Physics3D/RigidBody3D.hpp>
 #include <NDK/Algorithm.hpp>
 #include <NDK/World.hpp>
-#include <NDK/Components/PhysicsComponent.hpp>
+#include <NDK/Components/PhysicsComponent3D.hpp>
-#include <NDK/Systems/PhysicsSystem.hpp>
+#include <NDK/Systems/PhysicsSystem3D.hpp>
 
 namespace Ndk
 {
 	/*!
 	* \ingroup NDK
-	* \class Ndk::CollisionComponent
+	* \class Ndk::CollisionComponent3D
 	* \brief NDK class that represents the component for collision (meant for static objects)
 	*/
 
@@ -25,14 +25,14 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the entity has no physics component and has no static body
 	*/
 
-	void CollisionComponent::SetGeom(Nz::PhysGeomRef geom)
+	void CollisionComponent3D::SetGeom(Nz::Collider3DRef geom)
 	{
 		m_geom = std::move(geom);
 
-		if (m_entity->HasComponent<PhysicsComponent>())
+		if (m_entity->HasComponent<PhysicsComponent3D>())
 		{
-			// We update the geometry of the PhysiscsObject linked to the PhysicsComponent
+			// We update the geometry of the PhysiscsObject linked to the PhysicsComponent3D
-			PhysicsComponent& physComponent = m_entity->GetComponent<PhysicsComponent>();
+			PhysicsComponent3D& physComponent = m_entity->GetComponent<PhysicsComponent3D>();
 			physComponent.GetPhysObject().SetGeom(m_geom);
 		}
 		else
@@ -49,16 +49,16 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if entity is not linked to a world, or the world has no physics system
 	*/
 
-	void CollisionComponent::InitializeStaticBody()
+	void CollisionComponent3D::InitializeStaticBody()
 	{
 		NazaraAssert(m_entity, "Invalid entity");
 		World* entityWorld = m_entity->GetWorld();
 
 		NazaraAssert(entityWorld, "Entity must have world");
-		NazaraAssert(entityWorld->HasSystem<PhysicsSystem>(), "World must have a physics system");
+		NazaraAssert(entityWorld->HasSystem<PhysicsSystem3D>(), "World must have a physics system");
-		Nz::PhysWorld& physWorld = entityWorld->GetSystem<PhysicsSystem>().GetWorld();
+		Nz::PhysWorld3D& physWorld = entityWorld->GetSystem<PhysicsSystem3D>().GetWorld();
 
-		m_staticBody.reset(new Nz::PhysObject(&physWorld, m_geom));
+		m_staticBody.reset(new Nz::RigidBody3D(&physWorld, m_geom));
 		m_staticBody->EnableAutoSleep(false);
 	}
 
@@ -66,9 +66,9 @@ namespace Ndk
 	* \brief Operation to perform when component is attached to an entity
 	*/
 
-	void CollisionComponent::OnAttached()
+	void CollisionComponent3D::OnAttached()
 	{
-		if (!m_entity->HasComponent<PhysicsComponent>())
+		if (!m_entity->HasComponent<PhysicsComponent3D>())
 			InitializeStaticBody();
 	}
 
@@ -78,9 +78,9 @@ namespace Ndk
 	* \param component Component being attached
 	*/
 
-	void CollisionComponent::OnComponentAttached(BaseComponent& component)
+	void CollisionComponent3D::OnComponentAttached(BaseComponent& component)
 	{
-		if (IsComponent<PhysicsComponent>(component))
+		if (IsComponent<PhysicsComponent3D>(component))
 			m_staticBody.reset();
 	}
 
@@ -90,9 +90,9 @@ namespace Ndk
 	* \param component Component being detached
 	*/
 
-	void CollisionComponent::OnComponentDetached(BaseComponent& component)
+	void CollisionComponent3D::OnComponentDetached(BaseComponent& component)
 	{
-		if (IsComponent<PhysicsComponent>(component))
+		if (IsComponent<PhysicsComponent3D>(component))
 			InitializeStaticBody();
 	}
 
@@ -100,10 +100,10 @@ namespace Ndk
 	* \brief Operation to perform when component is detached from an entity
 	*/
 
-	void CollisionComponent::OnDetached()
+	void CollisionComponent3D::OnDetached()
 	{
 		m_staticBody.reset();
 	}
 
-	ComponentIndex CollisionComponent::componentIndex;
+	ComponentIndex CollisionComponent3D::componentIndex;
 }

SDK/src/NDK/Components/PhysicsComponent3D.cpp

@@ -2,19 +2,19 @@
 // This file is part of the "Nazara Development Kit"
 // For conditions of distribution and use, see copyright notice in Prerequesites.hpp
 
-#include <NDK/Components/PhysicsComponent.hpp>
+#include <NDK/Components/PhysicsComponent3D.hpp>
-#include <Nazara/Physics/PhysObject.hpp>
+#include <Nazara/Physics3D/RigidBody3D.hpp>
 #include <NDK/Algorithm.hpp>
 #include <NDK/World.hpp>
-#include <NDK/Components/CollisionComponent.hpp>
+#include <NDK/Components/CollisionComponent3D.hpp>
 #include <NDK/Components/NodeComponent.hpp>
-#include <NDK/Systems/PhysicsSystem.hpp>
+#include <NDK/Systems/PhysicsSystem3D.hpp>
 
 namespace Ndk
 {
 	/*!
 	* \ingroup NDK
-	* \class Ndk::PhysicsComponent
+	* \class Ndk::PhysicsComponent3D
 	* \brief NDK class that represents the component for physics (meant for dynamic objects)
 	*/
 
@@ -24,16 +24,16 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if the world does not have a physics system
 	*/
 
-	void PhysicsComponent::OnAttached()
+	void PhysicsComponent3D::OnAttached()
 	{
 		World* entityWorld = m_entity->GetWorld();
-		NazaraAssert(entityWorld->HasSystem<PhysicsSystem>(), "World must have a physics system");
+		NazaraAssert(entityWorld->HasSystem<PhysicsSystem3D>(), "World must have a physics system");
 
-		Nz::PhysWorld& world = entityWorld->GetSystem<PhysicsSystem>().GetWorld();
+		Nz::PhysWorld3D& world = entityWorld->GetSystem<PhysicsSystem3D>().GetWorld();
 
-		Nz::PhysGeomRef geom;
+		Nz::Collider3DRef geom;
-		if (m_entity->HasComponent<CollisionComponent>())
+		if (m_entity->HasComponent<CollisionComponent3D>())
-			geom = m_entity->GetComponent<CollisionComponent>().GetGeom();
+			geom = m_entity->GetComponent<CollisionComponent3D>().GetGeom();
 
 		Nz::Matrix4f matrix;
 		if (m_entity->HasComponent<NodeComponent>())
@@ -41,7 +41,7 @@ namespace Ndk
 		else
 			matrix.MakeIdentity();
 
-		m_object.reset(new Nz::PhysObject(&world, geom, matrix));
+		m_object.reset(new Nz::RigidBody3D(&world, geom, matrix));
 		m_object->SetMass(1.f);
 	}
 
@@ -53,12 +53,12 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if physical object is invalid
 	*/
 
-	void PhysicsComponent::OnComponentAttached(BaseComponent& component)
+	void PhysicsComponent3D::OnComponentAttached(BaseComponent& component)
 	{
-		if (IsComponent<CollisionComponent>(component))
+		if (IsComponent<CollisionComponent3D>(component))
 		{
 			NazaraAssert(m_object, "Invalid object");
-			m_object->SetGeom(static_cast<CollisionComponent&>(component).GetGeom());
+			m_object->SetGeom(static_cast<CollisionComponent3D&>(component).GetGeom());
 		}
 	}
 
@@ -70,12 +70,12 @@ namespace Ndk
 	* \remark Produces a NazaraAssert if physical object is invalid
 	*/
 
-	void PhysicsComponent::OnComponentDetached(BaseComponent& component)
+	void PhysicsComponent3D::OnComponentDetached(BaseComponent& component)
 	{
-		if (IsComponent<CollisionComponent>(component))
+		if (IsComponent<CollisionComponent3D>(component))
 		{
 			NazaraAssert(m_object, "Invalid object");
-			m_object->SetGeom(Nz::NullGeom::New());
+			m_object->SetGeom(Nz::NullCollider3D::New());
 		}
 	}
 
@@ -83,10 +83,10 @@ namespace Ndk
 	* \brief Operation to perform when component is detached from an entity
 	*/
 
-	void PhysicsComponent::OnDetached()
+	void PhysicsComponent3D::OnDetached()
 	{
 		m_object.reset();
 	}
 
-	ComponentIndex PhysicsComponent::componentIndex;
+	ComponentIndex PhysicsComponent3D::componentIndex;
 }

SDK/src/NDK/Sdk.cpp

@@ -9,15 +9,15 @@
 #include <Nazara/Graphics/Graphics.hpp>
 #include <Nazara/Lua/Lua.hpp>
 #include <Nazara/Noise/Noise.hpp>
-#include <Nazara/Physics/Physics.hpp>
+#include <Nazara/Physics3D/Physics3D.hpp>
 #include <Nazara/Utility/Utility.hpp>
 #include <NDK/Algorithm.hpp>
 #include <NDK/BaseSystem.hpp>
-#include <NDK/Components/CollisionComponent.hpp>
+#include <NDK/Components/CollisionComponent3D.hpp>
 #include <NDK/Components/NodeComponent.hpp>
-#include <NDK/Components/PhysicsComponent.hpp>
+#include <NDK/Components/PhysicsComponent3D.hpp>
 #include <NDK/Components/VelocityComponent.hpp>
-#include <NDK/Systems/PhysicsSystem.hpp>
+#include <NDK/Systems/PhysicsSystem3D.hpp>
 #include <NDK/Systems/VelocitySystem.hpp>
 
 #ifndef NDK_SERVER
@@ -68,7 +68,7 @@ namespace Ndk
 
 			Nz::Lua::Initialize();
 			Nz::Noise::Initialize();
-			Nz::Physics::Initialize();
+			Nz::Physics3D::Initialize();
 			Nz::Utility::Initialize();
 
 			#ifndef NDK_SERVER
@@ -83,9 +83,9 @@ namespace Ndk
 			BaseComponent::Initialize();
 
 			// Shared components
-			InitializeComponent<CollisionComponent>("NdkColli");
+			InitializeComponent<CollisionComponent3D>("NdkColli");
 			InitializeComponent<NodeComponent>("NdkNode");
-			InitializeComponent<PhysicsComponent>("NdkPhys");
+			InitializeComponent<PhysicsComponent3D>("NdkPhys");
 			InitializeComponent<VelocityComponent>("NdkVeloc");
 
 			#ifndef NDK_SERVER
@@ -103,7 +103,7 @@ namespace Ndk
 			BaseSystem::Initialize();
 
 			// Shared systems
-			InitializeSystem<PhysicsSystem>();
+			InitializeSystem<PhysicsSystem3D>();
 			InitializeSystem<VelocitySystem>();
 
 			#ifndef NDK_SERVER
@@ -161,7 +161,7 @@ namespace Ndk
 		// Shared modules
 		Nz::Lua::Uninitialize();
 		Nz::Noise::Uninitialize();
-		Nz::Physics::Uninitialize();
+		Nz::Physics3D::Uninitialize();
 		Nz::Utility::Uninitialize();
 
 		NazaraNotice("Uninitialized: SDK");

SDK/src/NDK/Systems/PhysicsSystem3D.cpp

@@ -2,11 +2,11 @@
 // This file is part of the "Nazara Development Kit"
 // For conditions of distribution and use, see copyright notice in Prerequesites.hpp
 
-#include <NDK/Systems/PhysicsSystem.hpp>
+#include <NDK/Systems/PhysicsSystem3D.hpp>
-#include <Nazara/Physics/PhysObject.hpp>
+#include <Nazara/Physics3D/RigidBody3D.hpp>
-#include <NDK/Components/CollisionComponent.hpp>
+#include <NDK/Components/CollisionComponent3D.hpp>
 #include <NDK/Components/NodeComponent.hpp>
-#include <NDK/Components/PhysicsComponent.hpp>
+#include <NDK/Components/PhysicsComponent3D.hpp>
 
 namespace Ndk
 {
@@ -15,7 +15,7 @@ namespace Ndk
 	* \class Ndk::PhysicsSystem
 	* \brief NDK class that represents the physics system
 	*
-	* \remark This system is enabled if the entity has the trait: NodeComponent and any of these two: CollisionComponent or PhysicsComponent
+	* \remark This system is enabled if the entity has the trait: NodeComponent and any of these two: CollisionComponent3D or PhysicsComponent3D
 	* \remark Static objects do not have a velocity specified by the physical engine
 	*/
 
@@ -23,10 +23,10 @@ namespace Ndk
 	* \brief Constructs an PhysicsSystem object by default
 	*/
 
-	PhysicsSystem::PhysicsSystem()
+	PhysicsSystem3D::PhysicsSystem3D()
 	{
 		Requires<NodeComponent>();
-		RequiresAny<CollisionComponent, PhysicsComponent>();
+		RequiresAny<CollisionComponent3D, PhysicsComponent3D>();
 	}
 
 	/*!
@@ -35,17 +35,17 @@ namespace Ndk
 	* \param system PhysicsSystem to copy
 	*/
 
-	PhysicsSystem::PhysicsSystem(const PhysicsSystem& system) :
+	PhysicsSystem3D::PhysicsSystem3D(const PhysicsSystem3D& system) :
 	System(system),
 	m_world()
 	{
 	}
 
-	void PhysicsSystem::CreatePhysWorld() const
+	void PhysicsSystem3D::CreatePhysWorld() const
 	{
 		NazaraAssert(!m_world, "Physics world should not be created twice");
 
-		m_world = std::make_unique<Nz::PhysWorld>();
+		m_world = std::make_unique<Nz::PhysWorld3D>();
 	}
 
 	/*!
@@ -55,17 +55,17 @@ namespace Ndk
 	* \param justAdded Is the entity newly added
 	*/
 
-	void PhysicsSystem::OnEntityValidation(Entity* entity, bool justAdded)
+	void PhysicsSystem3D::OnEntityValidation(Entity* entity, bool justAdded)
 	{
-		// It's possible our entity got revalidated because of the addition/removal of a PhysicsComponent
+		// It's possible our entity got revalidated because of the addition/removal of a PhysicsComponent3D
 		if (!justAdded)
 		{
 			// We take the opposite array from which the entity should belong to
-			auto& entities = (entity->HasComponent<PhysicsComponent>()) ? m_staticObjects : m_dynamicObjects;
+			auto& entities = (entity->HasComponent<PhysicsComponent3D>()) ? m_staticObjects : m_dynamicObjects;
 			entities.Remove(entity);
 		}
 
-		auto& entities = (entity->HasComponent<PhysicsComponent>()) ? m_dynamicObjects : m_staticObjects;
+		auto& entities = (entity->HasComponent<PhysicsComponent3D>()) ? m_dynamicObjects : m_staticObjects;
 		entities.Insert(entity);
 
 		if (!m_world)
@@ -78,7 +78,7 @@ namespace Ndk
 	* \param elapsedTime Delta time used for the update
 	*/
 
-	void PhysicsSystem::OnUpdate(float elapsedTime)
+	void PhysicsSystem3D::OnUpdate(float elapsedTime)
 	{
 		if (!m_world)
 			return;
@@ -88,9 +88,9 @@ namespace Ndk
 		for (const Ndk::EntityHandle& entity : m_dynamicObjects)
 		{
 			NodeComponent& node = entity->GetComponent<NodeComponent>();
-			PhysicsComponent& phys = entity->GetComponent<PhysicsComponent>();
+			PhysicsComponent3D& phys = entity->GetComponent<PhysicsComponent3D>();
 
-			Nz::PhysObject& physObj = phys.GetPhysObject();
+			Nz::RigidBody3D& physObj = phys.GetPhysObject();
 			node.SetRotation(physObj.GetRotation(), Nz::CoordSys_Global);
 			node.SetPosition(physObj.GetPosition(), Nz::CoordSys_Global);
 		}
@@ -98,10 +98,10 @@ namespace Ndk
 		float invElapsedTime = 1.f / elapsedTime;
 		for (const Ndk::EntityHandle& entity : m_staticObjects)
 		{
-			CollisionComponent& collision = entity->GetComponent<CollisionComponent>();
+			CollisionComponent3D& collision = entity->GetComponent<CollisionComponent3D>();
 			NodeComponent& node = entity->GetComponent<NodeComponent>();
 
-			Nz::PhysObject* physObj = collision.GetStaticBody();
+			Nz::RigidBody3D* physObj = collision.GetStaticBody();
 
 			Nz::Quaternionf oldRotation = physObj->GetRotation();
 			Nz::Vector3f oldPosition = physObj->GetPosition();
@@ -134,5 +134,5 @@ namespace Ndk
 		}
 	}
 
-	SystemIndex PhysicsSystem::systemIndex;
+	SystemIndex PhysicsSystem3D::systemIndex;
 }

SDK/src/NDK/Systems/VelocitySystem.cpp

@@ -4,7 +4,7 @@
 
 #include <NDK/Systems/VelocitySystem.hpp>
 #include <NDK/Components/NodeComponent.hpp>
-#include <NDK/Components/PhysicsComponent.hpp>
+#include <NDK/Components/PhysicsComponent3D.hpp>
 #include <NDK/Components/VelocityComponent.hpp>
 
 namespace Ndk
@@ -15,7 +15,7 @@ namespace Ndk
 	* \brief NDK class that represents the velocity system
 	*
 	* \remark This system is enabled if the entity owns the trait: NodeComponent and VelocityComponent
-	* but it's disabled with the trait: PhysicsComponent
+	* but it's disabled with the trait: PhysicsComponent3D
 	*/
 
 	/*!
@@ -25,7 +25,7 @@ namespace Ndk
 	VelocitySystem::VelocitySystem()
 	{
 		Requires<NodeComponent, VelocityComponent>();
-		Excludes<PhysicsComponent>();
+		Excludes<PhysicsComponent3D>();
 	}
 
 	/*!

SDK/src/NDK/World.cpp

@@ -5,7 +5,7 @@
 #include <NDK/World.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <NDK/BaseComponent.hpp>
-#include <NDK/Systems/PhysicsSystem.hpp>
+#include <NDK/Systems/PhysicsSystem3D.hpp>
 #include <NDK/Systems/VelocitySystem.hpp>
 
 #ifndef NDK_SERVER
@@ -40,7 +40,7 @@ namespace Ndk
 
 	void World::AddDefaultSystems()
 	{
-		AddSystem<PhysicsSystem>();
+		AddSystem<PhysicsSystem3D>();
 		AddSystem<VelocitySystem>();
 
 		#ifndef NDK_SERVER

build/scripts/modules/physics3d.lua

@@ -1,4 +1,4 @@
-MODULE.Name = "Physics"
+MODULE.Name = "Physics3D"
 
 MODULE.Libraries = {
 	"NazaraCore",

include/Nazara/Physics/Geom.hpp

@@ -1,273 +0,0 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_GEOM_HPP
-#define NAZARA_GEOM_HPP
-
-#include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/PrimitiveList.hpp>
-#include <Nazara/Core/ObjectLibrary.hpp>
-#include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/RefCounted.hpp>
-#include <Nazara/Core/Signal.hpp>
-#include <Nazara/Math/Box.hpp>
-#include <Nazara/Math/Quaternion.hpp>
-#include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Physics/Config.hpp>
-#include <Nazara/Physics/Enums.hpp>
-#include <unordered_map>
-
-class NewtonCollision;
-
-namespace Nz
-{
-	///TODO: CollisionModifier
-	///TODO: HeightfieldGeom
-	///TODO: PlaneGeom ?
-	///TODO: SceneGeom
-	///TODO: TreeGeom
-
-	class PhysGeom;
-	class PhysWorld;
-
-	using PhysGeomConstRef = ObjectRef<const PhysGeom>;
-	using PhysGeomLibrary = ObjectLibrary<PhysGeom>;
-	using PhysGeomRef = ObjectRef<PhysGeom>;
-
-	class NAZARA_PHYSICS_API PhysGeom : public RefCounted
-	{
-		friend PhysGeomLibrary;
-		friend class Physics;
-
-		public:
-			PhysGeom() = default;
-			PhysGeom(const PhysGeom&) = delete;
-			PhysGeom(PhysGeom&&) = delete;
-			virtual ~PhysGeom();
-
-			Boxf ComputeAABB(const Vector3f& translation, const Quaternionf& rotation, const Vector3f& scale) const;
-			virtual Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const;
-			virtual void ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const;
-			virtual float ComputeVolume() const;
-
-			NewtonCollision* GetHandle(PhysWorld* world) const;
-			virtual GeomType GetType() const = 0;
-
-			PhysGeom& operator=(const PhysGeom&) = delete;
-			PhysGeom& operator=(PhysGeom&&) = delete;
-
-			static PhysGeomRef Build(const PrimitiveList& list);
-
-			// Signals:
-			NazaraSignal(OnPhysGeomRelease, const PhysGeom* /*physGeom*/);
-
-		protected:
-			virtual NewtonCollision* CreateHandle(PhysWorld* world) const = 0;
-
-			static bool Initialize();
-			static void Uninitialize();
-
-			mutable std::unordered_map<PhysWorld*, NewtonCollision*> m_handles;
-
-			static PhysGeomLibrary::LibraryMap s_library;
-	};
-
-	class BoxGeom;
-
-	using BoxGeomConstRef = ObjectRef<const BoxGeom>;
-	using BoxGeomRef = ObjectRef<BoxGeom>;
-
-	class NAZARA_PHYSICS_API BoxGeom : public PhysGeom
-	{
-		public:
-			BoxGeom(const Vector3f& lengths, const Matrix4f& transformMatrix = Matrix4f::Identity());
-			BoxGeom(const Vector3f& lengths, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
-
-			Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const override;
-			float ComputeVolume() const override;
-
-			Vector3f GetLengths() const;
-			GeomType GetType() const override;
-
-			template<typename... Args> static BoxGeomRef New(Args&&... args);
-
-		private:
-			NewtonCollision* CreateHandle(PhysWorld* world) const override;
-
-			Matrix4f m_matrix;
-			Vector3f m_lengths;
-	};
-
-	class CapsuleGeom;
-
-	using CapsuleGeomConstRef = ObjectRef<const CapsuleGeom>;
-	using CapsuleGeomRef = ObjectRef<CapsuleGeom>;
-
-	class NAZARA_PHYSICS_API CapsuleGeom : public PhysGeom
-	{
-		public:
-			CapsuleGeom(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
-			CapsuleGeom(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
-
-			float GetLength() const;
-			float GetRadius() const;
-			GeomType GetType() const override;
-
-			template<typename... Args> static CapsuleGeomRef New(Args&&... args);
-
-		private:
-			NewtonCollision* CreateHandle(PhysWorld* world) const override;
-
-			Matrix4f m_matrix;
-			float m_length;
-			float m_radius;
-	};
-
-	class CompoundGeom;
-
-	using CompoundGeomConstRef = ObjectRef<const CompoundGeom>;
-	using CompoundGeomRef = ObjectRef<CompoundGeom>;
-
-	class NAZARA_PHYSICS_API CompoundGeom : public PhysGeom
-	{
-		public:
-			CompoundGeom(PhysGeom** geoms, std::size_t geomCount);
-
-			const std::vector<PhysGeomRef>& GetGeoms() const;
-			GeomType GetType() const override;
-
-			template<typename... Args> static CompoundGeomRef New(Args&&... args);
-
-		private:
-			NewtonCollision* CreateHandle(PhysWorld* world) const override;
-
-			std::vector<PhysGeomRef> m_geoms;
-	};
-
-	class ConeGeom;
-
-	using ConeGeomConstRef = ObjectRef<const ConeGeom>;
-	using ConeGeomRef = ObjectRef<ConeGeom>;
-
-	class NAZARA_PHYSICS_API ConeGeom : public PhysGeom
-	{
-		public:
-			ConeGeom(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
-			ConeGeom(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
-
-			float GetLength() const;
-			float GetRadius() const;
-			GeomType GetType() const override;
-
-			template<typename... Args> static ConeGeomRef New(Args&&... args);
-
-		private:
-			NewtonCollision* CreateHandle(PhysWorld* world) const override;
-
-			Matrix4f m_matrix;
-			float m_length;
-			float m_radius;
-	};
-
-	class ConvexHullGeom;
-
-	using ConvexHullGeomConstRef = ObjectRef<const ConvexHullGeom>;
-	using ConvexHullGeomRef = ObjectRef<ConvexHullGeom>;
-
-	class NAZARA_PHYSICS_API ConvexHullGeom : public PhysGeom
-	{
-		public:
-			ConvexHullGeom(const void* vertices, unsigned int vertexCount, unsigned int stride = sizeof(Vector3f), float tolerance = 0.002f, const Matrix4f& transformMatrix = Matrix4f::Identity());
-			ConvexHullGeom(const void* vertices, unsigned int vertexCount, unsigned int stride, float tolerance, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
-
-			GeomType GetType() const override;
-
-			template<typename... Args> static ConvexHullGeomRef New(Args&&... args);
-
-		private:
-			NewtonCollision* CreateHandle(PhysWorld* world) const override;
-
-			std::vector<Vector3f> m_vertices;
-			Matrix4f m_matrix;
-			float m_tolerance;
-			unsigned int m_vertexStride;
-	};
-
-	class CylinderGeom;
-
-	using CylinderGeomConstRef = ObjectRef<const CylinderGeom>;
-	using CylinderGeomRef = ObjectRef<CylinderGeom>;
-
-	class NAZARA_PHYSICS_API CylinderGeom : public PhysGeom
-	{
-		public:
-			CylinderGeom(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
-			CylinderGeom(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
-
-			float GetLength() const;
-			float GetRadius() const;
-			GeomType GetType() const override;
-
-			template<typename... Args> static CylinderGeomRef New(Args&&... args);
-
-		private:
-			NewtonCollision* CreateHandle(PhysWorld* world) const override;
-
-			Matrix4f m_matrix;
-			float m_length;
-			float m_radius;
-	};
-
-	class NullGeom;
-
-	using NullGeomConstRef = ObjectRef<const NullGeom>;
-	using NullGeomRef = ObjectRef<NullGeom>;
-
-	class NAZARA_PHYSICS_API NullGeom : public PhysGeom
-	{
-		public:
-			NullGeom();
-
-			void ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const override;
-
-			GeomType GetType() const override;
-
-			template<typename... Args> static NullGeomRef New(Args&&... args);
-
-		private:
-			NewtonCollision* CreateHandle(PhysWorld* world) const override;
-	};
-
-	class SphereGeom;
-
-	using SphereGeomConstRef = ObjectRef<const SphereGeom>;
-	using SphereGeomRef = ObjectRef<SphereGeom>;
-
-	class NAZARA_PHYSICS_API SphereGeom : public PhysGeom
-	{
-		public:
-			SphereGeom(float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
-			SphereGeom(float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
-
-			Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const override;
-			float ComputeVolume() const override;
-
-			float GetRadius() const;
-			GeomType GetType() const override;
-
-			template<typename... Args> static SphereGeomRef New(Args&&... args);
-
-		private:
-			NewtonCollision* CreateHandle(PhysWorld* world) const override;
-
-			Vector3f m_position;
-			float m_radius;
-	};
-}
-
-#include <Nazara/Physics/Geom.inl>
-
-#endif // NAZARA_PHYSWORLD_HPP

include/Nazara/Physics/Geom.inl

@@ -1,83 +0,0 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <memory>
-#include <Nazara/Physics/Debug.hpp>
-
-namespace Nz
-{
-	template<typename... Args>
-	BoxGeomRef BoxGeom::New(Args&&... args)
-	{
-		std::unique_ptr<BoxGeom> object(new BoxGeom(std::forward<Args>(args)...));
-		object->SetPersistent(false);
-
-		return object.release();
-	}
-
-	template<typename... Args>
-	CapsuleGeomRef CapsuleGeom::New(Args&&... args)
-	{
-		std::unique_ptr<CapsuleGeom> object(new CapsuleGeom(std::forward<Args>(args)...));
-		object->SetPersistent(false);
-
-		return object.release();
-	}
-
-	template<typename... Args>
-	CompoundGeomRef CompoundGeom::New(Args&&... args)
-	{
-		std::unique_ptr<CompoundGeom> object(new CompoundGeom(std::forward<Args>(args)...));
-		object->SetPersistent(false);
-
-		return object.release();
-	}
-
-	template<typename... Args>
-	ConeGeomRef ConeGeom::New(Args&&... args)
-	{
-		std::unique_ptr<ConeGeom> object(new ConeGeom(std::forward<Args>(args)...));
-		object->SetPersistent(false);
-
-		return object.release();
-	}
-
-	template<typename... Args>
-	ConvexHullGeomRef ConvexHullGeom::New(Args&&... args)
-	{
-		std::unique_ptr<ConvexHullGeom> object(new ConvexHullGeom(std::forward<Args>(args)...));
-		object->SetPersistent(false);
-
-		return object.release();
-	}
-
-	template<typename... Args>
-	CylinderGeomRef CylinderGeom::New(Args&&... args)
-	{
-		std::unique_ptr<CylinderGeom> object(new CylinderGeom(std::forward<Args>(args)...));
-		object->SetPersistent(false);
-
-		return object.release();
-	}
-
-	template<typename... Args>
-	NullGeomRef NullGeom::New(Args&&... args)
-	{
-		std::unique_ptr<NullGeom> object(new NullGeom(std::forward<Args>(args)...));
-		object->SetPersistent(false);
-
-		return object.release();
-	}
-
-	template<typename... Args>
-	SphereGeomRef SphereGeom::New(Args&&... args)
-	{
-		std::unique_ptr<SphereGeom> object(new SphereGeom(std::forward<Args>(args)...));
-		object->SetPersistent(false);
-
-		return object.release();
-	}
-}
-
-#include <Nazara/Physics/DebugOff.hpp>

include/Nazara/Physics3D/Collider3D.hpp

@@ -0,0 +1,273 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Physics 3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_COLLIDER3D_HPP
+#define NAZARA_COLLIDER3D_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/PrimitiveList.hpp>
+#include <Nazara/Core/ObjectLibrary.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
+#include <Nazara/Core/RefCounted.hpp>
+#include <Nazara/Core/Signal.hpp>
+#include <Nazara/Math/Box.hpp>
+#include <Nazara/Math/Quaternion.hpp>
+#include <Nazara/Math/Vector3.hpp>
+#include <Nazara/Physics3D/Config.hpp>
+#include <Nazara/Physics3D/Enums.hpp>
+#include <unordered_map>
+
+class NewtonCollision;
+
+namespace Nz
+{
+	///TODO: CollisionModifier
+	///TODO: HeightfieldGeom
+	///TODO: PlaneGeom ?
+	///TODO: SceneGeom
+	///TODO: TreeGeom
+
+	class Collider3D;
+	class PhysWorld3D;
+
+	using Collider3DConstRef = ObjectRef<const Collider3D>;
+	using Collider3DLibrary = ObjectLibrary<Collider3D>;
+	using Collider3DRef = ObjectRef<Collider3D>;
+
+	class NAZARA_PHYSICS3D_API Collider3D : public RefCounted
+	{
+		friend Collider3DLibrary;
+		friend class Physics3D;
+
+		public:
+			Collider3D() = default;
+			Collider3D(const Collider3D&) = delete;
+			Collider3D(Collider3D&&) = delete;
+			virtual ~Collider3D();
+
+			Boxf ComputeAABB(const Vector3f& translation, const Quaternionf& rotation, const Vector3f& scale) const;
+			virtual Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const;
+			virtual void ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const;
+			virtual float ComputeVolume() const;
+
+			NewtonCollision* GetHandle(PhysWorld3D* world) const;
+			virtual GeomType GetType() const = 0;
+
+			Collider3D& operator=(const Collider3D&) = delete;
+			Collider3D& operator=(Collider3D&&) = delete;
+
+			static Collider3DRef Build(const PrimitiveList& list);
+
+			// Signals:
+			NazaraSignal(OnColliderRelease, const Collider3D* /*collider*/);
+
+		protected:
+			virtual NewtonCollision* CreateHandle(PhysWorld3D* world) const = 0;
+
+			static bool Initialize();
+			static void Uninitialize();
+
+			mutable std::unordered_map<PhysWorld3D*, NewtonCollision*> m_handles;
+
+			static Collider3DLibrary::LibraryMap s_library;
+	};
+
+	class BoxCollider3D;
+
+	using BoxCollider3DConstRef = ObjectRef<const BoxCollider3D>;
+	using BoxCollider3DRef = ObjectRef<BoxCollider3D>;
+
+	class NAZARA_PHYSICS3D_API BoxCollider3D : public Collider3D
+	{
+		public:
+			BoxCollider3D(const Vector3f& lengths, const Matrix4f& transformMatrix = Matrix4f::Identity());
+			BoxCollider3D(const Vector3f& lengths, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
+
+			Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const override;
+			float ComputeVolume() const override;
+
+			Vector3f GetLengths() const;
+			GeomType GetType() const override;
+
+			template<typename... Args> static BoxCollider3DRef New(Args&&... args);
+
+		private:
+			NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
+
+			Matrix4f m_matrix;
+			Vector3f m_lengths;
+	};
+
+	class CapsuleCollider3D;
+
+	using CapsuleCollider3DConstRef = ObjectRef<const CapsuleCollider3D>;
+	using CapsuleCollider3DRef = ObjectRef<CapsuleCollider3D>;
+
+	class NAZARA_PHYSICS3D_API CapsuleCollider3D : public Collider3D
+	{
+		public:
+			CapsuleCollider3D(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
+			CapsuleCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
+
+			float GetLength() const;
+			float GetRadius() const;
+			GeomType GetType() const override;
+
+			template<typename... Args> static CapsuleCollider3DRef New(Args&&... args);
+
+		private:
+			NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
+
+			Matrix4f m_matrix;
+			float m_length;
+			float m_radius;
+	};
+
+	class CompoundCollider3D;
+
+	using CompoundCollider3DConstRef = ObjectRef<const CompoundCollider3D>;
+	using CompoundCollider3DRef = ObjectRef<CompoundCollider3D>;
+
+	class NAZARA_PHYSICS3D_API CompoundCollider3D : public Collider3D
+	{
+		public:
+			CompoundCollider3D(Collider3D** geoms, std::size_t geomCount);
+
+			const std::vector<Collider3DRef>& GetGeoms() const;
+			GeomType GetType() const override;
+
+			template<typename... Args> static CompoundCollider3DRef New(Args&&... args);
+
+		private:
+			NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
+
+			std::vector<Collider3DRef> m_geoms;
+	};
+
+	class ConeCollider3D;
+
+	using ConeCollider3DConstRef = ObjectRef<const ConeCollider3D>;
+	using ConeCollider3DRef = ObjectRef<ConeCollider3D>;
+
+	class NAZARA_PHYSICS3D_API ConeCollider3D : public Collider3D
+	{
+		public:
+			ConeCollider3D(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
+			ConeCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
+
+			float GetLength() const;
+			float GetRadius() const;
+			GeomType GetType() const override;
+
+			template<typename... Args> static ConeCollider3DRef New(Args&&... args);
+
+		private:
+			NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
+
+			Matrix4f m_matrix;
+			float m_length;
+			float m_radius;
+	};
+
+	class ConvexCollider3D;
+
+	using ConvexCollider3DConstRef = ObjectRef<const ConvexCollider3D>;
+	using ConvexCollider3DRef = ObjectRef<ConvexCollider3D>;
+
+	class NAZARA_PHYSICS3D_API ConvexCollider3D : public Collider3D
+	{
+		public:
+			ConvexCollider3D(const void* vertices, unsigned int vertexCount, unsigned int stride = sizeof(Vector3f), float tolerance = 0.002f, const Matrix4f& transformMatrix = Matrix4f::Identity());
+			ConvexCollider3D(const void* vertices, unsigned int vertexCount, unsigned int stride, float tolerance, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
+
+			GeomType GetType() const override;
+
+			template<typename... Args> static ConvexCollider3DRef New(Args&&... args);
+
+		private:
+			NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
+
+			std::vector<Vector3f> m_vertices;
+			Matrix4f m_matrix;
+			float m_tolerance;
+			unsigned int m_vertexStride;
+	};
+
+	class CylinderCollider3D;
+
+	using CylinderCollider3DConstRef = ObjectRef<const CylinderCollider3D>;
+	using CylinderCollider3DRef = ObjectRef<CylinderCollider3D>;
+
+	class NAZARA_PHYSICS3D_API CylinderCollider3D : public Collider3D
+	{
+		public:
+			CylinderCollider3D(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
+			CylinderCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
+
+			float GetLength() const;
+			float GetRadius() const;
+			GeomType GetType() const override;
+
+			template<typename... Args> static CylinderCollider3DRef New(Args&&... args);
+
+		private:
+			NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
+
+			Matrix4f m_matrix;
+			float m_length;
+			float m_radius;
+	};
+
+	class NullCollider3D;
+
+	using NullCollider3DConstRef = ObjectRef<const NullCollider3D>;
+	using NullCollider3DRef = ObjectRef<NullCollider3D>;
+
+	class NAZARA_PHYSICS3D_API NullCollider3D : public Collider3D
+	{
+		public:
+			NullCollider3D();
+
+			void ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const override;
+
+			GeomType GetType() const override;
+
+			template<typename... Args> static NullCollider3DRef New(Args&&... args);
+
+		private:
+			NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
+	};
+
+	class SphereCollider3D;
+
+	using SphereCollider3DConstRef = ObjectRef<const SphereCollider3D>;
+	using SphereCollider3DRef = ObjectRef<SphereCollider3D>;
+
+	class NAZARA_PHYSICS3D_API SphereCollider3D : public Collider3D
+	{
+		public:
+			SphereCollider3D(float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
+			SphereCollider3D(float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
+
+			Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const override;
+			float ComputeVolume() const override;
+
+			float GetRadius() const;
+			GeomType GetType() const override;
+
+			template<typename... Args> static SphereCollider3DRef New(Args&&... args);
+
+		private:
+			NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
+
+			Vector3f m_position;
+			float m_radius;
+	};
+}
+
+#include <Nazara/Physics3D/Collider3D.inl>
+
+#endif // NAZARA_COLLIDER3D_HPP

include/Nazara/Physics3D/Collider3D.inl

@@ -0,0 +1,83 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Physics 3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <memory>
+#include <Nazara/Physics3D/Debug.hpp>
+
+namespace Nz
+{
+	template<typename... Args>
+	BoxCollider3DRef BoxCollider3D::New(Args&&... args)
+	{
+		std::unique_ptr<BoxCollider3D> object(new BoxCollider3D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	template<typename... Args>
+	CapsuleCollider3DRef CapsuleCollider3D::New(Args&&... args)
+	{
+		std::unique_ptr<CapsuleCollider3D> object(new CapsuleCollider3D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	template<typename... Args>
+	CompoundCollider3DRef CompoundCollider3D::New(Args&&... args)
+	{
+		std::unique_ptr<CompoundCollider3D> object(new CompoundCollider3D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	template<typename... Args>
+	ConeCollider3DRef ConeCollider3D::New(Args&&... args)
+	{
+		std::unique_ptr<ConeCollider3D> object(new ConeCollider3D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	template<typename... Args>
+	ConvexCollider3DRef ConvexCollider3D::New(Args&&... args)
+	{
+		std::unique_ptr<ConvexCollider3D> object(new ConvexCollider3D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	template<typename... Args>
+	CylinderCollider3DRef CylinderCollider3D::New(Args&&... args)
+	{
+		std::unique_ptr<CylinderCollider3D> object(new CylinderCollider3D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	template<typename... Args>
+	NullCollider3DRef NullCollider3D::New(Args&&... args)
+	{
+		std::unique_ptr<NullCollider3D> object(new NullCollider3D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	template<typename... Args>
+	SphereCollider3DRef SphereCollider3D::New(Args&&... args)
+	{
+		std::unique_ptr<SphereCollider3D> object(new SphereCollider3D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+}
+
+#include <Nazara/Physics3D/DebugOff.hpp>

include/Nazara/Physics3D/Config.hpp

@@ -1,5 +1,5 @@
 /*
-	Nazara Engine - Physics module
+	Nazara Engine - Physics 3D module
 
 	Copyright (C) 2015 Jérôme "Lynix" Leclercq (Lynix680@gmail.com)
 
@@ -24,28 +24,28 @@
 
 #pragma once
 
-#ifndef NAZARA_CONFIG_PHYSICS_HPP
+#ifndef NAZARA_CONFIG_PHYSICS3D_HPP
-#define NAZARA_CONFIG_PHYSICS_HPP
+#define NAZARA_CONFIG_PHYSICS3D_HPP
 
 /// Chaque modification d'un paramètre du module nécessite une recompilation de celui-ci
 
 // Utilise un manager de mémoire pour gérer les allocations dynamiques (détecte les leaks au prix d'allocations/libérations dynamiques plus lentes)
-#define NAZARA_PHYSICS_MANAGE_MEMORY 0
+#define NAZARA_PHYSICS3D_MANAGE_MEMORY 0
 
 // Active les tests de sécurité basés sur le code (Conseillé pour le développement)
-#define NAZARA_PHYSICS_SAFE 1
+#define NAZARA_PHYSICS3D_SAFE 1
 
 /// Vérification des valeurs et types de certaines constantes
-#include <Nazara/Physics/ConfigCheck.hpp>
+#include <Nazara/Physics3D/ConfigCheck.hpp>
 
 #if defined(NAZARA_STATIC)
-	#define NAZARA_PHYSICS_API
+	#define NAZARA_PHYSICS3D_API
 #else
-	#ifdef NAZARA_PHYSICS_BUILD
+	#ifdef NAZARA_PHYSICS3D_BUILD
-		#define NAZARA_PHYSICS_API NAZARA_EXPORT
+		#define NAZARA_PHYSICS3D_API NAZARA_EXPORT
 	#else
-		#define NAZARA_PHYSICS_API NAZARA_IMPORT
+		#define NAZARA_PHYSICS3D_API NAZARA_IMPORT
 	#endif
 #endif
 
-#endif // NAZARA_CONFIG_PHYSICS_HPP
+#endif // NAZARA_CONFIG_PHYSICS3D_HPP

include/Nazara/Physics3D/ConfigCheck.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
@@ -12,7 +12,7 @@
 // On force la valeur de MANAGE_MEMORY en mode debug
 #if defined(NAZARA_DEBUG) && !NAZARA_PHYSICS_MANAGE_MEMORY
 	#undef NAZARA_PHYSICS_MANAGE_MEMORY
-	#define NAZARA_PHYSICS_MANAGE_MEMORY 0
+	#define NAZARA_PHYSICS3D_MANAGE_MEMORY 0
 #endif
 
 #endif // NAZARA_CONFIG_CHECK_PHYSICS_HPP

include/Nazara/Physics3D/Debug.hpp

@@ -1,8 +1,8 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics/Config.hpp>
+#include <Nazara/Physics3D/Config.hpp>
 #if NAZARA_PHYSICS_MANAGE_MEMORY
 	#include <Nazara/Core/Debug/NewRedefinition.hpp>
 #endif

include/Nazara/Physics3D/DebugOff.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 // On suppose que Debug.hpp a déjà été inclus, tout comme Config.hpp

include/Nazara/Physics3D/Enums.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once

include/Nazara/Physics3D/PhysWorld3D.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
@@ -10,19 +10,19 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Physics/Config.hpp>
+#include <Nazara/Physics3D/Config.hpp>
 
 class NewtonWorld;
 
 namespace Nz
 {
-	class NAZARA_PHYSICS_API PhysWorld
+	class NAZARA_PHYSICS3D_API PhysWorld3D
 	{
 		public:
-			PhysWorld();
+			PhysWorld3D();
-			PhysWorld(const PhysWorld&) = delete;
+			PhysWorld3D(const PhysWorld3D&) = delete;
-			PhysWorld(PhysWorld&&) = delete; ///TODO
+			PhysWorld3D(PhysWorld3D&&) = delete; ///TODO
-			~PhysWorld();
+			~PhysWorld3D();
 
 			Vector3f GetGravity() const;
 			NewtonWorld* GetHandle() const;
@@ -34,8 +34,8 @@ namespace Nz
 
 			void Step(float timestep);
 
-			PhysWorld& operator=(const PhysWorld&) = delete;
+			PhysWorld3D& operator=(const PhysWorld3D&) = delete;
-			PhysWorld& operator=(PhysWorld&&) = delete; ///TODO
+			PhysWorld3D& operator=(PhysWorld3D&&) = delete; ///TODO
 
 		private:
 			Vector3f m_gravity;

include/Nazara/Physics3D/Physics3D.hpp

@@ -1,23 +1,23 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS_HPP
+#ifndef NAZARA_PHYSICS3D_HPP
-#define NAZARA_PHYSICS_HPP
+#define NAZARA_PHYSICS3D_HPP
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Initializer.hpp>
-#include <Nazara/Physics/Config.hpp>
+#include <Nazara/Physics3D/Config.hpp>
 
 namespace Nz
 {
-	class NAZARA_PHYSICS_API Physics
+	class NAZARA_PHYSICS3D_API Physics3D
 	{
 		public:
-			Physics() = delete;
+			Physics3D() = delete;
-			~Physics() = delete;
+			~Physics3D() = delete;
 
 			static unsigned int GetMemoryUsed();
 
@@ -32,4 +32,4 @@ namespace Nz
 	};
 }
 
-#endif // NAZARA_PHYSICS_HPP
+#endif // NAZARA_PHYSICS3D_HPP

include/Nazara/Physics3D/RigidBody3D.hpp

@@ -1,34 +1,34 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
 
-#ifndef NAZARA_PHYSOBJECT_HPP
+#ifndef NAZARA_RIGIDBODY3D_HPP
-#define NAZARA_PHYSOBJECT_HPP
+#define NAZARA_RIGIDBODY3D_HPP
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Enums.hpp>
 #include <Nazara/Math/Matrix4.hpp>
 #include <Nazara/Math/Quaternion.hpp>
 #include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Physics/Config.hpp>
+#include <Nazara/Physics3D/Config.hpp>
-#include <Nazara/Physics/Geom.hpp>
+#include <Nazara/Physics3D/Collider3D.hpp>
 
 class NewtonBody;
 
 namespace Nz
 {
-	class PhysWorld;
+	class PhysWorld3D;
 
-	class NAZARA_PHYSICS_API PhysObject
+	class NAZARA_PHYSICS3D_API RigidBody3D
 	{
 		public:
-			PhysObject(PhysWorld* world, const Matrix4f& mat = Matrix4f::Identity());
+			RigidBody3D(PhysWorld3D* world, const Matrix4f& mat = Matrix4f::Identity());
-			PhysObject(PhysWorld* world, PhysGeomRef geom, const Matrix4f& mat = Matrix4f::Identity());
+			RigidBody3D(PhysWorld3D* world, Collider3DRef geom, const Matrix4f& mat = Matrix4f::Identity());
-			PhysObject(const PhysObject& object);
+			RigidBody3D(const RigidBody3D& object);
-			PhysObject(PhysObject&& object);
+			RigidBody3D(RigidBody3D&& object);
-			~PhysObject();
+			~RigidBody3D();
 
 			void AddForce(const Vector3f& force, CoordSys coordSys = CoordSys_Global);
 			void AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys = CoordSys_Global);
@@ -38,7 +38,7 @@ namespace Nz
 
 			Boxf GetAABB() const;
 			Vector3f GetAngularVelocity() const;
-			const PhysGeomRef& GetGeom() const;
+			const Collider3DRef& GetGeom() const;
 			float GetGravityFactor() const;
 			NewtonBody* GetHandle() const;
 			float GetMass() const;
@@ -53,7 +53,7 @@ namespace Nz
 			bool IsSleeping() const;
 
 			void SetAngularVelocity(const Vector3f& angularVelocity);
-			void SetGeom(PhysGeomRef geom);
+			void SetGeom(Collider3DRef geom);
 			void SetGravityFactor(float gravityFactor);
 			void SetMass(float mass);
 			void SetMassCenter(const Vector3f& center);
@@ -61,23 +61,23 @@ namespace Nz
 			void SetRotation(const Quaternionf& rotation);
 			void SetVelocity(const Vector3f& velocity);
 
-			PhysObject& operator=(const PhysObject& object);
+			RigidBody3D& operator=(const RigidBody3D& object);
-			PhysObject& operator=(PhysObject&& object);
+			RigidBody3D& operator=(RigidBody3D&& object);
 
 		private:
 			void UpdateBody();
 			static void ForceAndTorqueCallback(const NewtonBody* body, float timeStep, int threadIndex);
 			static void TransformCallback(const NewtonBody* body, const float* matrix, int threadIndex);
 
+			Collider3DRef m_geom;
 			Matrix4f m_matrix;
-			PhysGeomRef m_geom;
 			Vector3f m_forceAccumulator;
 			Vector3f m_torqueAccumulator;
 			NewtonBody* m_body;
-			PhysWorld* m_world;
+			PhysWorld3D* m_world;
 			float m_gravityFactor;
 			float m_mass;
 	};
 }
 
-#endif // NAZARA_PHYSOBJECT_HPP
+#endif // NAZARA_RIGIDBODY3D_HPP

src/Nazara/Physics3D/Collider3D.cpp

@@ -1,59 +1,59 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics/Geom.hpp>
+#include <Nazara/Physics3D/Collider3D.hpp>
-#include <Nazara/Physics/PhysWorld.hpp>
+#include <Nazara/Physics3D/PhysWorld3D.hpp>
 #include <Newton/Newton.h>
 #include <memory>
-#include <Nazara/Physics/Debug.hpp>
+#include <Nazara/Physics3D/Debug.hpp>
 
 namespace Nz
 {
 	namespace
 	{
-		PhysGeomRef CreateGeomFromPrimitive(const Primitive& primitive)
+		Collider3DRef CreateGeomFromPrimitive(const Primitive& primitive)
 		{
 			switch (primitive.type)
 			{
 				case PrimitiveType_Box:
-					return BoxGeom::New(primitive.box.lengths, primitive.matrix);
+					return BoxCollider3D::New(primitive.box.lengths, primitive.matrix);
 
 				case PrimitiveType_Cone:
-					return ConeGeom::New(primitive.cone.length, primitive.cone.radius, primitive.matrix);
+					return ConeCollider3D::New(primitive.cone.length, primitive.cone.radius, primitive.matrix);
 
 				case PrimitiveType_Plane:
-					return BoxGeom::New(Vector3f(primitive.plane.size.x, 0.01f, primitive.plane.size.y), primitive.matrix);
+					return BoxCollider3D::New(Vector3f(primitive.plane.size.x, 0.01f, primitive.plane.size.y), primitive.matrix);
 					///TODO: PlaneGeom?
 
 				case PrimitiveType_Sphere:
-					return SphereGeom::New(primitive.sphere.size, primitive.matrix.GetTranslation());
+					return SphereCollider3D::New(primitive.sphere.size, primitive.matrix.GetTranslation());
 			}
 
 			NazaraError("Primitive type not handled (0x" + String::Number(primitive.type, 16) + ')');
-			return PhysGeomRef();
+			return Collider3DRef();
 		}
 	}
 
-	PhysGeom::~PhysGeom()
+	Collider3D::~Collider3D()
 	{
 		for (auto& pair : m_handles)
 			NewtonDestroyCollision(pair.second);
 	}
 
-	Boxf PhysGeom::ComputeAABB(const Vector3f& translation, const Quaternionf& rotation, const Vector3f& scale) const
+	Boxf Collider3D::ComputeAABB(const Vector3f& translation, const Quaternionf& rotation, const Vector3f& scale) const
 	{
 		return ComputeAABB(Matrix4f::Transform(translation, rotation), scale);
 	}
 
-	Boxf PhysGeom::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
+	Boxf Collider3D::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
 	{
 		Vector3f min, max;
 
 		// Si nous n'avons aucune instance, nous en créons une temporaire
 		if (m_handles.empty())
 		{
-			PhysWorld world;
+			PhysWorld3D world;
 
 			NewtonCollision* collision = CreateHandle(&world);
 			{
@@ -67,7 +67,7 @@ namespace Nz
 		return Boxf(scale * min, scale * max);
 	}
 
-	void PhysGeom::ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const
+	void Collider3D::ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const
 	{
 		float inertiaMatrix[3];
 		float origin[3];
@@ -75,7 +75,7 @@ namespace Nz
 		// Si nous n'avons aucune instance, nous en créons une temporaire
 		if (m_handles.empty())
 		{
-			PhysWorld world;
+			PhysWorld3D world;
 
 			NewtonCollision* collision = CreateHandle(&world);
 			{
@@ -93,14 +93,14 @@ namespace Nz
 			center->Set(origin);
 	}
 
-	float PhysGeom::ComputeVolume() const
+	float Collider3D::ComputeVolume() const
 	{
 		float volume;
 
 		// Si nous n'avons aucune instance, nous en créons une temporaire
 		if (m_handles.empty())
 		{
-			PhysWorld world;
+			PhysWorld3D world;
 
 			NewtonCollision* collision = CreateHandle(&world);
 			{
@@ -114,7 +114,7 @@ namespace Nz
 		return volume;
 	}
 
-	NewtonCollision* PhysGeom::GetHandle(PhysWorld* world) const
+	NewtonCollision* Collider3D::GetHandle(PhysWorld3D* world) const
 	{
 		auto it = m_handles.find(world);
 		if (it == m_handles.end())
@@ -123,27 +123,27 @@ namespace Nz
 		return it->second;
 	}
 
-	PhysGeomRef PhysGeom::Build(const PrimitiveList& list)
+	Collider3DRef Collider3D::Build(const PrimitiveList& list)
 	{
 		std::size_t primitiveCount = list.GetSize();
 		if (primitiveCount > 1)
 		{
-			std::vector<PhysGeom*> geoms(primitiveCount);
+			std::vector<Collider3D*> geoms(primitiveCount);
 
 			for (unsigned int i = 0; i < primitiveCount; ++i)
 				geoms[i] = CreateGeomFromPrimitive(list.GetPrimitive(i));
 
-			return CompoundGeom::New(&geoms[0], primitiveCount);
+			return CompoundCollider3D::New(&geoms[0], primitiveCount);
 		}
 		else if (primitiveCount > 0)
 			return CreateGeomFromPrimitive(list.GetPrimitive(0));
 		else
-			return NullGeom::New();
+			return NullCollider3D::New();
 	}
 
-	bool PhysGeom::Initialize()
+	bool Collider3D::Initialize()
 	{
-		if (!PhysGeomLibrary::Initialize())
+		if (!Collider3DLibrary::Initialize())
 		{
 			NazaraError("Failed to initialise library");
 			return false;
@@ -152,27 +152,27 @@ namespace Nz
 		return true;
 	}
 
-	void PhysGeom::Uninitialize()
+	void Collider3D::Uninitialize()
 	{
-		PhysGeomLibrary::Uninitialize();
+		Collider3DLibrary::Uninitialize();
 	}
 
-	PhysGeomLibrary::LibraryMap PhysGeom::s_library;
+	Collider3DLibrary::LibraryMap Collider3D::s_library;
 
-	/********************************** BoxGeom **********************************/
+	/********************************** BoxCollider3D **********************************/
 
-	BoxGeom::BoxGeom(const Vector3f& lengths, const Matrix4f& transformMatrix) :
+	BoxCollider3D::BoxCollider3D(const Vector3f& lengths, const Matrix4f& transformMatrix) :
 	m_matrix(transformMatrix),
 	m_lengths(lengths)
 	{
 	}
 
-	BoxGeom::BoxGeom(const Vector3f& lengths, const Vector3f& translation, const Quaternionf& rotation) :
+	BoxCollider3D::BoxCollider3D(const Vector3f& lengths, const Vector3f& translation, const Quaternionf& rotation) :
-	BoxGeom(lengths, Matrix4f::Transform(translation, rotation))
+	BoxCollider3D(lengths, Matrix4f::Transform(translation, rotation))
 	{
 	}
 
-	Boxf BoxGeom::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
+	Boxf BoxCollider3D::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
 	{
 		Vector3f halfLengths(m_lengths * 0.5f);
 
@@ -183,90 +183,90 @@ namespace Nz
 		return aabb;
 	}
 
-	float BoxGeom::ComputeVolume() const
+	float BoxCollider3D::ComputeVolume() const
 	{
 		return m_lengths.x * m_lengths.y * m_lengths.z;
 	}
 
-	Vector3f BoxGeom::GetLengths() const
+	Vector3f BoxCollider3D::GetLengths() const
 	{
 		return m_lengths;
 	}
 
-	GeomType BoxGeom::GetType() const
+	GeomType BoxCollider3D::GetType() const
 	{
 		return GeomType_Box;
 	}
 
-	NewtonCollision* BoxGeom::CreateHandle(PhysWorld* world) const
+	NewtonCollision* BoxCollider3D::CreateHandle(PhysWorld3D* world) const
 	{
 		return NewtonCreateBox(world->GetHandle(), m_lengths.x, m_lengths.y, m_lengths.z, 0, m_matrix);
 	}
 
-	/******************************** CapsuleGeom ********************************/
+	/******************************** CapsuleCollider3D ********************************/
 
-	CapsuleGeom::CapsuleGeom(float length, float radius, const Matrix4f& transformMatrix) :
+	CapsuleCollider3D::CapsuleCollider3D(float length, float radius, const Matrix4f& transformMatrix) :
 	m_matrix(transformMatrix),
 	m_length(length),
 	m_radius(radius)
 	{
 	}
 
-	CapsuleGeom::CapsuleGeom(float length, float radius, const Vector3f& translation, const Quaternionf& rotation) :
+	CapsuleCollider3D::CapsuleCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation) :
-	CapsuleGeom(length, radius, Matrix4f::Transform(translation, rotation))
+	CapsuleCollider3D(length, radius, Matrix4f::Transform(translation, rotation))
 	{
 	}
 
-	float CapsuleGeom::GetLength() const
+	float CapsuleCollider3D::GetLength() const
 	{
 		return m_length;
 	}
 
-	float CapsuleGeom::GetRadius() const
+	float CapsuleCollider3D::GetRadius() const
 	{
 		return m_radius;
 	}
 
-	GeomType CapsuleGeom::GetType() const
+	GeomType CapsuleCollider3D::GetType() const
 	{
 		return GeomType_Capsule;
 	}
 
-	NewtonCollision* CapsuleGeom::CreateHandle(PhysWorld* world) const
+	NewtonCollision* CapsuleCollider3D::CreateHandle(PhysWorld3D* world) const
 	{
 		return NewtonCreateCapsule(world->GetHandle(), m_radius, m_length, 0, m_matrix);
 	}
 
-	/******************************* CompoundGeom ********************************/
+	/******************************* CompoundCollider3D ********************************/
 
-	CompoundGeom::CompoundGeom(PhysGeom** geoms, std::size_t geomCount)
+	CompoundCollider3D::CompoundCollider3D(Collider3D** geoms, std::size_t geomCount)
 	{
 		m_geoms.reserve(geomCount);
 		for (std::size_t i = 0; i < geomCount; ++i)
 			m_geoms.emplace_back(geoms[i]);
 	}
 
-	const std::vector<PhysGeomRef>& CompoundGeom::GetGeoms() const
+	const std::vector<Collider3DRef>& CompoundCollider3D::GetGeoms() const
 	{
 		return m_geoms;
 	}
 
-	GeomType CompoundGeom::GetType() const
+	GeomType CompoundCollider3D::GetType() const
 	{
 		return GeomType_Compound;
 	}
 
-	NewtonCollision* CompoundGeom::CreateHandle(PhysWorld* world) const
+	NewtonCollision* CompoundCollider3D::CreateHandle(PhysWorld3D* world) const
 	{
 		NewtonCollision* compoundCollision = NewtonCreateCompoundCollision(world->GetHandle(), 0);
 
 		NewtonCompoundCollisionBeginAddRemove(compoundCollision);
-		for (const PhysGeomRef& geom : m_geoms)
+		for (const Collider3DRef& geom : m_geoms)
 		{
 			if (geom->GetType() == GeomType_Compound)
 			{
-				CompoundGeom* compoundGeom = static_cast<CompoundGeom*>(geom.Get());
+				CompoundCollider3D* compoundGeom = static_cast<CompoundCollider3D*>(geom.Get());
-				for (const PhysGeomRef& piece : compoundGeom->GetGeoms())
+				for (const Collider3DRef& piece : compoundGeom->GetGeoms())
 					NewtonCompoundCollisionAddSubCollision(compoundCollision, piece->GetHandle(world));
 			}
 			else
@@ -277,43 +277,43 @@ namespace Nz
 		return compoundCollision;
 	}
 
-	/********************************* ConeGeom **********************************/
+	/********************************* ConeCollider3D **********************************/
 
-	ConeGeom::ConeGeom(float length, float radius, const Matrix4f& transformMatrix) :
+	ConeCollider3D::ConeCollider3D(float length, float radius, const Matrix4f& transformMatrix) :
 	m_matrix(transformMatrix),
 	m_length(length),
 	m_radius(radius)
 	{
 	}
 
-	ConeGeom::ConeGeom(float length, float radius, const Vector3f& translation, const Quaternionf& rotation) :
+	ConeCollider3D::ConeCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation) :
-	ConeGeom(length, radius, Matrix4f::Transform(translation, rotation))
+	ConeCollider3D(length, radius, Matrix4f::Transform(translation, rotation))
 	{
 	}
 
-	float ConeGeom::GetLength() const
+	float ConeCollider3D::GetLength() const
 	{
 		return m_length;
 	}
 
-	float ConeGeom::GetRadius() const
+	float ConeCollider3D::GetRadius() const
 	{
 		return m_radius;
 	}
 
-	GeomType ConeGeom::GetType() const
+	GeomType ConeCollider3D::GetType() const
 	{
 		return GeomType_Cone;
 	}
 
-	NewtonCollision* ConeGeom::CreateHandle(PhysWorld* world) const
+	NewtonCollision* ConeCollider3D::CreateHandle(PhysWorld3D* world) const
 	{
 		return NewtonCreateCone(world->GetHandle(), m_radius, m_length, 0, m_matrix);
 	}
 
-	/****************************** ConvexHullGeom *******************************/
+	/****************************** ConvexCollider3D *******************************/
 
-	ConvexHullGeom::ConvexHullGeom(const void* vertices, unsigned int vertexCount, unsigned int stride, float tolerance, const Matrix4f& transformMatrix) :
+	ConvexCollider3D::ConvexCollider3D(const void* vertices, unsigned int vertexCount, unsigned int stride, float tolerance, const Matrix4f& transformMatrix) :
 	m_matrix(transformMatrix),
 	m_tolerance(tolerance),
 	m_vertexStride(stride)
@@ -330,67 +330,67 @@ namespace Nz
 			std::memcpy(m_vertices.data(), vertices, vertexCount*sizeof(Vector3f));
 	}
 
-	ConvexHullGeom::ConvexHullGeom(const void* vertices, unsigned int vertexCount, unsigned int stride, float tolerance, const Vector3f& translation, const Quaternionf& rotation) :
+	ConvexCollider3D::ConvexCollider3D(const void* vertices, unsigned int vertexCount, unsigned int stride, float tolerance, const Vector3f& translation, const Quaternionf& rotation) :
-	ConvexHullGeom(vertices, vertexCount, stride, tolerance, Matrix4f::Transform(translation, rotation))
+	ConvexCollider3D(vertices, vertexCount, stride, tolerance, Matrix4f::Transform(translation, rotation))
 	{
 	}
 
-	GeomType ConvexHullGeom::GetType() const
+	GeomType ConvexCollider3D::GetType() const
 	{
 		return GeomType_Compound;
 	}
 
-	NewtonCollision* ConvexHullGeom::CreateHandle(PhysWorld* world) const
+	NewtonCollision* ConvexCollider3D::CreateHandle(PhysWorld3D* world) const
 	{
 		return NewtonCreateConvexHull(world->GetHandle(), static_cast<int>(m_vertices.size()), reinterpret_cast<const float*>(m_vertices.data()), sizeof(Vector3f), m_tolerance, 0, m_matrix);
 	}
 
-	/******************************* CylinderGeom ********************************/
+	/******************************* CylinderCollider3D ********************************/
 
-	CylinderGeom::CylinderGeom(float length, float radius, const Matrix4f& transformMatrix) :
+	CylinderCollider3D::CylinderCollider3D(float length, float radius, const Matrix4f& transformMatrix) :
 	m_matrix(transformMatrix),
 	m_length(length),
 	m_radius(radius)
 	{
 	}
 
-	CylinderGeom::CylinderGeom(float length, float radius, const Vector3f& translation, const Quaternionf& rotation) :
+	CylinderCollider3D::CylinderCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation) :
-	CylinderGeom(length, radius, Matrix4f::Transform(translation, rotation))
+	CylinderCollider3D(length, radius, Matrix4f::Transform(translation, rotation))
 	{
 	}
 
-	float CylinderGeom::GetLength() const
+	float CylinderCollider3D::GetLength() const
 	{
 		return m_length;
 	}
 
-	float CylinderGeom::GetRadius() const
+	float CylinderCollider3D::GetRadius() const
 	{
 		return m_radius;
 	}
 
-	GeomType CylinderGeom::GetType() const
+	GeomType CylinderCollider3D::GetType() const
 	{
 		return GeomType_Cylinder;
 	}
 
-	NewtonCollision* CylinderGeom::CreateHandle(PhysWorld* world) const
+	NewtonCollision* CylinderCollider3D::CreateHandle(PhysWorld3D* world) const
 	{
 		return NewtonCreateCylinder(world->GetHandle(), m_radius, m_length, 0, m_matrix);
 	}
 
-	/********************************* NullGeom **********************************/
+	/********************************* NullCollider3D **********************************/
 
-	NullGeom::NullGeom()
+	NullCollider3D::NullCollider3D()
 	{
 	}
 
-	GeomType NullGeom::GetType() const
+	GeomType NullCollider3D::GetType() const
 	{
 		return GeomType_Null;
 	}
 
-	void NullGeom::ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const
+	void NullCollider3D::ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const
 	{
 		if (inertia)
 			inertia->MakeUnit();
@@ -399,26 +399,26 @@ namespace Nz
 			center->MakeZero();
 	}
 
-	NewtonCollision* NullGeom::CreateHandle(PhysWorld* world) const
+	NewtonCollision* NullCollider3D::CreateHandle(PhysWorld3D* world) const
 	{
 		return NewtonCreateNull(world->GetHandle());
 	}
 
-	/******************************** SphereGeom *********************************/
+	/******************************** SphereCollider3D *********************************/
 
-	SphereGeom::SphereGeom(float radius, const Matrix4f& transformMatrix) :
+	SphereCollider3D::SphereCollider3D(float radius, const Matrix4f& transformMatrix) :
-	SphereGeom(radius, transformMatrix.GetTranslation())
+	SphereCollider3D(radius, transformMatrix.GetTranslation())
 	{
 	}
 
-	SphereGeom::SphereGeom(float radius, const Vector3f& translation, const Quaternionf& rotation) :
+	SphereCollider3D::SphereCollider3D(float radius, const Vector3f& translation, const Quaternionf& rotation) :
 	m_position(translation),
 	m_radius(radius)
 	{
 		NazaraUnused(rotation);
 	}
 
-	Boxf SphereGeom::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
+	Boxf SphereCollider3D::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
 	{
 		Vector3f size(m_radius * NazaraSuffixMacro(M_SQRT3, f) * scale);
 		Vector3f position(offsetMatrix.GetTranslation());
@@ -426,22 +426,22 @@ namespace Nz
 		return Boxf(position - size, position + size);
 	}
 
-	float SphereGeom::ComputeVolume() const
+	float SphereCollider3D::ComputeVolume() const
 	{
 		return float(M_PI) * m_radius * m_radius * m_radius / 3.f;
 	}
 
-	float SphereGeom::GetRadius() const
+	float SphereCollider3D::GetRadius() const
 	{
 		return m_radius;
 	}
 
-	GeomType SphereGeom::GetType() const
+	GeomType SphereCollider3D::GetType() const
 	{
 		return GeomType_Sphere;
 	}
 
-	NewtonCollision* SphereGeom::CreateHandle(PhysWorld* world) const
+	NewtonCollision* SphereCollider3D::CreateHandle(PhysWorld3D* world) const
 	{
 		return NewtonCreateSphere(world->GetHandle(), m_radius, 0, Matrix4f::Translate(m_position));
 	}

src/Nazara/Physics3D/Debug/NewOverload.cpp

@@ -1,8 +1,8 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics/Config.hpp>
+#include <Nazara/Physics3D/Config.hpp>
 #if NAZARA_PHYSICS_MANAGE_MEMORY
 
 #include <Nazara/Core/MemoryManager.hpp>

src/Nazara/Physics3D/PhysWorld3D.cpp

@@ -1,14 +1,14 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics/PhysWorld.hpp>
+#include <Nazara/Physics3D/PhysWorld3D.hpp>
 #include <Newton/Newton.h>
-#include <Nazara/Physics/Debug.hpp>
+#include <Nazara/Physics3D/Debug.hpp>
 
 namespace Nz
 {
-	PhysWorld::PhysWorld() :
+	PhysWorld3D::PhysWorld3D() :
 	m_gravity(Vector3f::Zero()),
 	m_stepSize(0.005f),
 	m_timestepAccumulator(0.f)
@@ -17,42 +17,42 @@ namespace Nz
 		NewtonWorldSetUserData(m_world, this);
 	}
 
-	PhysWorld::~PhysWorld()
+	PhysWorld3D::~PhysWorld3D()
 	{
 		NewtonDestroy(m_world);
 	}
 
-	Vector3f PhysWorld::GetGravity() const
+	Vector3f PhysWorld3D::GetGravity() const
 	{
 		return m_gravity;
 	}
 
-	NewtonWorld* PhysWorld::GetHandle() const
+	NewtonWorld* PhysWorld3D::GetHandle() const
 	{
 		return m_world;
 	}
 
-	float PhysWorld::GetStepSize() const
+	float PhysWorld3D::GetStepSize() const
 	{
 		return m_stepSize;
 	}
 
-	void PhysWorld::SetGravity(const Vector3f& gravity)
+	void PhysWorld3D::SetGravity(const Vector3f& gravity)
 	{
 		m_gravity = gravity;
 	}
 
-	void PhysWorld::SetSolverModel(unsigned int model)
+	void PhysWorld3D::SetSolverModel(unsigned int model)
 	{
 		NewtonSetSolverModel(m_world, model);
 	}
 
-	void PhysWorld::SetStepSize(float stepSize)
+	void PhysWorld3D::SetStepSize(float stepSize)
 	{
 		m_stepSize = stepSize;
 	}
 
-	void PhysWorld::Step(float timestep)
+	void PhysWorld3D::Step(float timestep)
 	{
 		m_timestepAccumulator += timestep;
 

src/Nazara/Physics3D/Physics3D.cpp

@@ -1,24 +1,24 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics/Physics.hpp>
+#include <Nazara/Physics3D/Physics3D.hpp>
 #include <Nazara/Core/Core.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Log.hpp>
-#include <Nazara/Physics/Config.hpp>
+#include <Nazara/Physics3D/Config.hpp>
-#include <Nazara/Physics/Geom.hpp>
+#include <Nazara/Physics3D/Collider3D.hpp>
 #include <Newton/Newton.h>
-#include <Nazara/Physics/Debug.hpp>
+#include <Nazara/Physics3D/Debug.hpp>
 
 namespace Nz
 {
-	unsigned int Physics::GetMemoryUsed()
+	unsigned int Physics3D::GetMemoryUsed()
 	{
 		return NewtonGetMemoryUsed();
 	}
 
-	bool Physics::Initialize()
+	bool Physics3D::Initialize()
 	{
 		if (s_moduleReferenceCounter > 0)
 		{
@@ -36,22 +36,22 @@ namespace Nz
 		s_moduleReferenceCounter++;
 
 		// Initialisation du module
-		if (!PhysGeom::Initialize())
+		if (!Collider3D::Initialize())
 		{
 			NazaraError("Failed to initialize geoms");
 			return false;
 		}
 
-		NazaraNotice("Initialized: Physics module");
+		NazaraNotice("Initialized: Physics3D module");
 		return true;
 	}
 
-	bool Physics::IsInitialized()
+	bool Physics3D::IsInitialized()
 	{
 		return s_moduleReferenceCounter != 0;
 	}
 
-	void Physics::Uninitialize()
+	void Physics3D::Uninitialize()
 	{
 		if (s_moduleReferenceCounter != 1)
 		{
@@ -63,15 +63,15 @@ namespace Nz
 		}
 
 		// Libération du module
-		PhysGeom::Uninitialize();
+		Collider3D::Uninitialize();
 
 		s_moduleReferenceCounter = 0;
 
-		NazaraNotice("Uninitialized: Physics module");
+		NazaraNotice("Uninitialized: Physics3D module");
 
 		// Libération des dépendances
 		Core::Uninitialize();
 	}
 
-	unsigned int Physics::s_moduleReferenceCounter = 0;
+	unsigned int Physics3D::s_moduleReferenceCounter = 0;
 }

src/Nazara/Physics3D/RigidBody3D.cpp

@@ -1,25 +1,25 @@
 // Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Physics module"
+// This file is part of the "Nazara Engine - Physics 3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics/PhysObject.hpp>
+#include <Nazara/Physics3D/RigidBody3D.hpp>
 #include <Nazara/Math/Algorithm.hpp>
-#include <Nazara/Physics/Config.hpp>
+#include <Nazara/Physics3D/Config.hpp>
-#include <Nazara/Physics/PhysWorld.hpp>
+#include <Nazara/Physics3D/PhysWorld3D.hpp>
 #include <Newton/Newton.h>
 #include <algorithm>
-#include <Nazara/Physics/Debug.hpp>
+#include <Nazara/Physics3D/Debug.hpp>
 
 namespace Nz
 {
-	PhysObject::PhysObject(PhysWorld* world, const Matrix4f& mat) :
+	RigidBody3D::RigidBody3D(PhysWorld3D* world, const Matrix4f& mat) :
-	PhysObject(world, NullGeom::New(), mat)
+	RigidBody3D(world, NullCollider3D::New(), mat)
 	{
 	}
 
-	PhysObject::PhysObject(PhysWorld* world, PhysGeomRef geom, const Matrix4f& mat) :
+	RigidBody3D::RigidBody3D(PhysWorld3D* world, Collider3DRef geom, const Matrix4f& mat) :
-	m_matrix(mat),
 	m_geom(std::move(geom)),
+	m_matrix(mat),
 	m_forceAccumulator(Vector3f::Zero()),
 	m_torqueAccumulator(Vector3f::Zero()),
 	m_world(world),
@@ -29,15 +29,15 @@ namespace Nz
 		NazaraAssert(m_world, "Invalid world");
 
 		if (!m_geom)
-			m_geom = NullGeom::New();
+			m_geom = NullCollider3D::New();
 
 		m_body = NewtonCreateDynamicBody(m_world->GetHandle(), m_geom->GetHandle(m_world), m_matrix);
 		NewtonBodySetUserData(m_body, this);
 	}
 
-	PhysObject::PhysObject(const PhysObject& object) :
+	RigidBody3D::RigidBody3D(const RigidBody3D& object) :
-	m_matrix(object.m_matrix),
 	m_geom(object.m_geom),
+	m_matrix(object.m_matrix),
 	m_forceAccumulator(Vector3f::Zero()),
 	m_torqueAccumulator(Vector3f::Zero()),
 	m_world(object.m_world),
@@ -52,9 +52,9 @@ namespace Nz
 		SetMass(object.m_mass);
 	}
 
-	PhysObject::PhysObject(PhysObject&& object) :
+	RigidBody3D::RigidBody3D(RigidBody3D&& object) :
-	m_matrix(std::move(object.m_matrix)),
 	m_geom(std::move(object.m_geom)),
+	m_matrix(std::move(object.m_matrix)),
 	m_forceAccumulator(std::move(object.m_forceAccumulator)),
 	m_torqueAccumulator(std::move(object.m_torqueAccumulator)),
 	m_body(object.m_body),
@@ -65,13 +65,13 @@ namespace Nz
 		object.m_body = nullptr;
 	}
 
-	PhysObject::~PhysObject()
+	RigidBody3D::~RigidBody3D()
 	{
 		if (m_body)
 			NewtonDestroyBody(m_body);
 	}
 
-	void PhysObject::AddForce(const Vector3f& force, CoordSys coordSys)
+	void RigidBody3D::AddForce(const Vector3f& force, CoordSys coordSys)
 	{
 		switch (coordSys)
 		{
@@ -88,7 +88,7 @@ namespace Nz
 		NewtonBodySetSleepState(m_body, 0);
 	}
 
-	void PhysObject::AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys)
+	void RigidBody3D::AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys)
 	{
 		switch (coordSys)
 		{
@@ -105,7 +105,7 @@ namespace Nz
 		NewtonBodySetSleepState(m_body, 0);
 	}
 
-	void PhysObject::AddTorque(const Vector3f& torque, CoordSys coordSys)
+	void RigidBody3D::AddTorque(const Vector3f& torque, CoordSys coordSys)
 	{
 		switch (coordSys)
 		{
@@ -122,12 +122,12 @@ namespace Nz
 		NewtonBodySetSleepState(m_body, 0);
 	}
 
-	void PhysObject::EnableAutoSleep(bool autoSleep)
+	void RigidBody3D::EnableAutoSleep(bool autoSleep)
 	{
 		NewtonBodySetAutoSleep(m_body, autoSleep);
 	}
 
-	Boxf PhysObject::GetAABB() const
+	Boxf RigidBody3D::GetAABB() const
 	{
 		Vector3f min, max;
 		NewtonBodyGetAABB(m_body, min, max);
@@ -135,7 +135,7 @@ namespace Nz
 		return Boxf(min, max);
 	}
 
-	Vector3f PhysObject::GetAngularVelocity() const
+	Vector3f RigidBody3D::GetAngularVelocity() const
 	{
 		Vector3f angularVelocity;
 		NewtonBodyGetOmega(m_body, angularVelocity);
@@ -143,27 +143,27 @@ namespace Nz
 		return angularVelocity;
 	}
 
-	const PhysGeomRef& PhysObject::GetGeom() const
+	const Collider3DRef& RigidBody3D::GetGeom() const
 	{
 		return m_geom;
 	}
 
-	float PhysObject::GetGravityFactor() const
+	float RigidBody3D::GetGravityFactor() const
 	{
 		return m_gravityFactor;
 	}
 
-	NewtonBody* PhysObject::GetHandle() const
+	NewtonBody* RigidBody3D::GetHandle() const
 	{
 		return m_body;
 	}
 
-	float PhysObject::GetMass() const
+	float RigidBody3D::GetMass() const
 	{
 		return m_mass;
 	}
 
-	Vector3f PhysObject::GetMassCenter(CoordSys coordSys) const
+	Vector3f RigidBody3D::GetMassCenter(CoordSys coordSys) const
 	{
 		Vector3f center;
 		NewtonBodyGetCentreOfMass(m_body, center);
@@ -181,22 +181,22 @@ namespace Nz
 		return center;
 	}
 
-	const Matrix4f& PhysObject::GetMatrix() const
+	const Matrix4f& RigidBody3D::GetMatrix() const
 	{
 		return m_matrix;
 	}
 
-	Vector3f PhysObject::GetPosition() const
+	Vector3f RigidBody3D::GetPosition() const
 	{
 		return m_matrix.GetTranslation();
 	}
 
-	Quaternionf PhysObject::GetRotation() const
+	Quaternionf RigidBody3D::GetRotation() const
 	{
 		return m_matrix.GetRotation();
 	}
 
-	Vector3f PhysObject::GetVelocity() const
+	Vector3f RigidBody3D::GetVelocity() const
 	{
 		Vector3f velocity;
 		NewtonBodyGetVelocity(m_body, velocity);
@@ -204,50 +204,52 @@ namespace Nz
 		return velocity;
 	}
 
-	bool PhysObject::IsAutoSleepEnabled() const
+	bool RigidBody3D::IsAutoSleepEnabled() const
 	{
 		return NewtonBodyGetAutoSleep(m_body) != 0;
 	}
 
-	bool PhysObject::IsMoveable() const
+	bool RigidBody3D::IsMoveable() const
 	{
 		return m_mass > 0.f;
 	}
 
-	bool PhysObject::IsSleeping() const
+	bool RigidBody3D::IsSleeping() const
 	{
 		return NewtonBodyGetSleepState(m_body) != 0;
 	}
 
-	void PhysObject::SetAngularVelocity(const Vector3f& angularVelocity)
+	void RigidBody3D::SetAngularVelocity(const Vector3f& angularVelocity)
 	{
 		NewtonBodySetOmega(m_body, angularVelocity);
 	}
 
-	void PhysObject::SetGeom(PhysGeomRef geom)
+	void RigidBody3D::SetGeom(Collider3DRef geom)
 	{
 		if (m_geom.Get() != geom)
 		{
 			if (geom)
 				m_geom = geom;
 			else
-				m_geom = NullGeom::New();
+				m_geom = NullCollider3D::New();
 
 			NewtonBodySetCollision(m_body, m_geom->GetHandle(m_world));
 		}
 	}
 
-	void PhysObject::SetGravityFactor(float gravityFactor)
+	void RigidBody3D::SetGravityFactor(float gravityFactor)
 	{
 		m_gravityFactor = gravityFactor;
 	}
 
-	void PhysObject::SetMass(float mass)
+	void RigidBody3D::SetMass(float mass)
 	{
 		if (m_mass > 0.f)
 		{
+			// If we already have a mass, we already have an inertial matrix as well, just rescale it
 			float Ix, Iy, Iz;
 			NewtonBodyGetMassMatrix(m_body, &m_mass, &Ix, &Iy, &Iz);
+
 			float scale = mass/m_mass;
 			NewtonBodySetMassMatrix(m_body, mass, Ix*scale, Iy*scale, Iz*scale);
 		}
@@ -265,41 +267,44 @@ namespace Nz
 		m_mass = mass;
 	}
 
-	void PhysObject::SetMassCenter(const Vector3f& center)
+	void RigidBody3D::SetMassCenter(const Vector3f& center)
 	{
 		if (m_mass > 0.f)
 			NewtonBodySetCentreOfMass(m_body, center);
 	}
 
-	void PhysObject::SetPosition(const Vector3f& position)
+	void RigidBody3D::SetPosition(const Vector3f& position)
 	{
 		m_matrix.SetTranslation(position);
+
 		UpdateBody();
 	}
 
-	void PhysObject::SetRotation(const Quaternionf& rotation)
+	void RigidBody3D::SetRotation(const Quaternionf& rotation)
 	{
 		m_matrix.SetRotation(rotation);
+
 		UpdateBody();
 	}
 
-	void PhysObject::SetVelocity(const Vector3f& velocity)
+	void RigidBody3D::SetVelocity(const Vector3f& velocity)
 	{
 		NewtonBodySetVelocity(m_body, velocity);
 	}
 
-	PhysObject& PhysObject::operator=(const PhysObject& object)
+	RigidBody3D& RigidBody3D::operator=(const RigidBody3D& object)
 	{
-		PhysObject physObj(object);
+		RigidBody3D physObj(object);
 		return operator=(std::move(physObj));
 	}
 
-	void PhysObject::UpdateBody()
+	void RigidBody3D::UpdateBody()
 	{
 		NewtonBodySetMatrix(m_body, m_matrix);
 
 		if (NumberEquals(m_mass, 0.f))
 		{
+			// Moving a static body in Newton does not update bodies at the target location
 			// http://newtondynamics.com/wiki/index.php5?title=Can_i_dynamicly_move_a_TriMesh%3F
 			Vector3f min, max;
 			NewtonBodyGetAABB(m_body, min, max);
@@ -312,11 +317,9 @@ namespace Nz
 			}, 
 			nullptr);
 		}
-		/*for (std::set<PhysObjectListener*>::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it)
-			(*it)->PhysObjectOnUpdate(this);*/
 	}
 
-	PhysObject& PhysObject::operator=(PhysObject&& object)
+	RigidBody3D& RigidBody3D::operator=(RigidBody3D&& object)
 	{
 		if (m_body)
 			NewtonDestroyBody(m_body);
@@ -335,36 +338,30 @@ namespace Nz
 		return *this;
 	}
 
-	void PhysObject::ForceAndTorqueCallback(const NewtonBody* body, float timeStep, int threadIndex)
+	void RigidBody3D::ForceAndTorqueCallback(const NewtonBody* body, float timeStep, int threadIndex)
 	{
 		NazaraUnused(timeStep);
 		NazaraUnused(threadIndex);
 
-		PhysObject* me = static_cast<PhysObject*>(NewtonBodyGetUserData(body));
+		RigidBody3D* me = static_cast<RigidBody3D*>(NewtonBodyGetUserData(body));
 
 		if (!NumberEquals(me->m_gravityFactor, 0.f))
 			me->m_forceAccumulator += me->m_world->GetGravity() * me->m_gravityFactor * me->m_mass;
 
-		/*for (std::set<PhysObjectListener*>::iterator it = me->m_listeners.begin(); it != me->m_listeners.end(); ++it)
-			(*it)->PhysObjectApplyForce(me);*/
-
 		NewtonBodySetForce(body, me->m_forceAccumulator);
 		NewtonBodySetTorque(body, me->m_torqueAccumulator);
 
 		me->m_torqueAccumulator.Set(0.f);
 		me->m_forceAccumulator.Set(0.f);
 
-		///TODO: Implanter la force gyroscopique?
+		///TODO: Implement gyroscopic force?
 	}
 
-	void PhysObject::TransformCallback(const NewtonBody* body, const float* matrix, int threadIndex)
+	void RigidBody3D::TransformCallback(const NewtonBody* body, const float* matrix, int threadIndex)
 	{
 		NazaraUnused(threadIndex);
 
-		PhysObject* me = static_cast<PhysObject*>(NewtonBodyGetUserData(body));
+		RigidBody3D* me = static_cast<RigidBody3D*>(NewtonBodyGetUserData(body));
 		me->m_matrix.Set(matrix);
-
+	}
-		/*for (std::set<PhysObjectListener*>::iterator it = me->m_listeners.begin(); it != me->m_listeners.end(); ++it)
-			(*it)->PhysObjectOnUpdate(me);*/
-		}
 }

tests/SDK/NDK/Systems/PhysicsSystem3D.cpp

@@ -1,8 +1,8 @@
-#include <NDK/Systems/PhysicsSystem.hpp>
+#include <NDK/Systems/PhysicsSystem3D.hpp>
 #include <NDK/World.hpp>
-#include <NDK/Components/CollisionComponent.hpp>
+#include <NDK/Components/CollisionComponent3D.hpp>
 #include <NDK/Components/NodeComponent.hpp>
-#include <NDK/Components/PhysicsComponent.hpp>
+#include <NDK/Components/PhysicsComponent3D.hpp>
 #include <Catch/catch.hpp>
 
 SCENARIO("PhysicsSystem", "[NDK][PHYSICSSYSTEM]")
@@ -11,12 +11,12 @@ SCENARIO("PhysicsSystem", "[NDK][PHYSICSSYSTEM]")
 	{
 		Ndk::World world;
 		const Ndk::EntityHandle& staticEntity = world.CreateEntity();
-		Ndk::CollisionComponent& collisionComponentStatic = staticEntity->AddComponent<Ndk::CollisionComponent>();
+		Ndk::CollisionComponent3D& collisionComponentStatic = staticEntity->AddComponent<Ndk::CollisionComponent3D>();
 		Ndk::NodeComponent& nodeComponentStatic = staticEntity->AddComponent<Ndk::NodeComponent>();
 
 		const Ndk::EntityHandle& dynamicEntity = world.CreateEntity();
 		Ndk::NodeComponent& nodeComponentDynamic = dynamicEntity->AddComponent<Ndk::NodeComponent>();
-		Ndk::PhysicsComponent& physicsComponentDynamic = dynamicEntity->AddComponent<Ndk::PhysicsComponent>();
+		Ndk::PhysicsComponent3D& physicsComponentDynamic = dynamicEntity->AddComponent<Ndk::PhysicsComponent3D>();
 
 		WHEN("We make collide these two entities")
 		{