Merge remote-tracking branch 'refs/remotes/origin/master' into gui

.gitignore

@@ -4,6 +4,9 @@ build/config.lua
 # Nazara libraries
 lib/*
 
+# Nazara plugin libraries
+plugins/lib/*
+
 # Nazara package
 package/*
 

.travis.yml

@@ -34,8 +34,13 @@ compiler:
   - clang
 
 env:
-  - COMPILER=clang++-3.7 CONFIG=debug
+  global:
-  - COMPILER=clang++-3.7 CONFIG=release
+    - COMPILER=clang++-3.7
+    - CFLAGS="-Wall -Wextra" 
+    - CXXFLAGS="-Wall -Wextra"
+  matrix:
+    - CONFIG=debug
+    - CONFIG=release
 
 script:
   - cd build &&

SDK/include/NDK/Application.inl

@@ -374,8 +374,8 @@ namespace Ndk
 	}
 
 	inline Application::WindowInfo::WindowInfo(std::unique_ptr<Nz::Window>&& window) :
-	window(std::move(window)),
+	renderTarget(nullptr),
-	renderTarget(nullptr)
+	window(std::move(window))
 	{
 	}
 	#endif

SDK/include/NDK/BaseSystem.inl

@@ -15,8 +15,8 @@ namespace Ndk
 	*/
 
 	inline BaseSystem::BaseSystem(SystemIndex systemId) :
-	m_updateEnabled(true),
+	m_systemIndex(systemId),
-	m_systemIndex(systemId)
+	m_updateEnabled(true)
 	{
 		SetUpdateRate(30);
 	}

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/GraphicsComponent.hpp

@@ -74,11 +74,11 @@ namespace Ndk
 				}
 
 				Renderable(Renderable&& renderable) noexcept :
+				renderableInvalidationSlot(std::move(renderable.renderableInvalidationSlot)),
+				renderableReleaseSlot(std::move(renderable.renderableReleaseSlot)),
 				data(std::move(renderable.data)),
 				renderable(std::move(renderable.renderable)),
-				dataUpdated(renderable.dataUpdated),
+				dataUpdated(renderable.dataUpdated)
-				renderableInvalidationSlot(std::move(renderable.renderableInvalidationSlot)),
-				renderableReleaseSlot(std::move(renderable.renderableReleaseSlot))
 				{
 				}
 

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/Components/VelocityComponent.hpp

@@ -12,7 +12,6 @@
 
 namespace Ndk
 {
-	class Entity;
 	class VelocityComponent;
 
 	using VelocityComponentHandle = Nz::ObjectHandle<VelocityComponent>;

SDK/include/NDK/LuaAPI.hpp

@@ -24,7 +24,7 @@ namespace Ndk
 			LuaAPI() = delete;
 			~LuaAPI() = delete;
 
-			static inline LuaBinding* GetBinding();
+			static LuaBinding* GetBinding();
 
 			static bool Initialize();
 

SDK/include/NDK/LuaAPI.inl

@@ -10,6 +10,7 @@
 #include <Nazara/Math/Vector3.hpp>
 #include <Nazara/Network/IpAddress.hpp>
 #include <Nazara/Utility/Font.hpp>
+#include <Nazara/Utility/Image.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 #include <NDK/Application.hpp>
 #include <NDK/Components.hpp>
@@ -21,22 +22,10 @@
 #include <Nazara/Audio/Music.hpp>
 #include <Nazara/Audio/SoundBuffer.hpp>
 #include <Nazara/Graphics/Model.hpp>
+#include <Nazara/Renderer/Texture.hpp>
 #include <NDK/Console.hpp>
 #endif
 
-namespace Ndk
-{
-	/*!
-	* \brief Gets the internal binding for Lua
-	* \return A pointer to the binding
-	*/
-
-	inline LuaBinding* LuaAPI::GetBinding()
-	{
-		return s_binding;
-	}
-}
-
 namespace Nz
 {
 	/*!
@@ -143,6 +132,104 @@ namespace Nz
 		return 1;
 	}
 
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param params Resulting parameters for an image
+	*/
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, ImageParams* params, TypeTag<ImageParams>)
+	{
+		instance.CheckType(index, Nz::LuaType_Table);
+
+		params->levelCount = instance.CheckField<Nz::UInt8>("LevelCount");
+		params->loadFormat = instance.CheckField<Nz::PixelFormatType>("LoadFormat");
+
+		return 1;
+	}
+
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param address Resulting IP address
+	*/
+
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, IpAddress* address, TypeTag<IpAddress>)
+	{
+		switch (instance.GetType(index))
+		{
+			case Nz::LuaType_String:
+				address->BuildFromAddress(instance.CheckString(index));
+				return 1;
+
+			default:
+				*address = *static_cast<IpAddress*>(instance.CheckUserdata(index, "IpAddress"));
+				return 1;
+		}
+	}
+
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param quat Resulting quaternion
+	*/
+
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, Matrix4d* mat, TypeTag<Matrix4d>)
+	{
+		switch (instance.GetType(index))
+		{
+			case Nz::LuaType_Table:
+			{
+				double values[16];
+				for (std::size_t i = 0; i < 16; ++i)
+				{
+					instance.PushInteger(i + 1);
+					instance.GetTable();
+
+					values[i] = instance.CheckNumber(-1);
+					instance.Pop();
+				}
+
+				mat->Set(values);
+				return 1;
+			}
+
+			default:
+			{
+				if (instance.IsOfType(index, "Matrix4"))
+					mat->Set(*static_cast<Matrix4d*>(instance.ToUserdata(index)));
+
+				return 1;
+			}
+		}
+	}
+
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param quat Resulting quaternion
+	*/
+
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, Matrix4f* mat, TypeTag<Matrix4f>)
+	{
+		Matrix4d matDouble;
+		unsigned int ret = LuaImplQueryArg(instance, index, &matDouble, TypeTag<Matrix4d>());
+
+		mat->Set(matDouble);
+		return ret;
+	}
+
 	/*!
 	* \brief Queries arguments for Lua
 	* \return 1 in case of success
@@ -159,12 +246,59 @@ namespace Nz
 		params->animated             = instance.CheckField<bool>("Animated", params->animated);
 		params->center               = instance.CheckField<bool>("Center", params->center);
 		params->flipUVs              = instance.CheckField<bool>("FlipUVs", params->flipUVs);
-		//params->matrix = instance.CheckField<Matrix4f>("Matrix", params->matrix);
+		params->matrix               = instance.CheckField<Matrix4f>("Matrix", params->matrix);
 		params->optimizeIndexBuffers = instance.CheckField<bool>("OptimizeIndexBuffers", params->optimizeIndexBuffers);
 
 		return 1;
 	}
 
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param quat Resulting quaternion
+	*/
+
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, Quaterniond* quat, TypeTag<Quaterniond>)
+	{
+		switch (instance.GetType(index))
+		{
+			case Nz::LuaType_Table:
+				quat->Set(instance.CheckField<double>("w", index), instance.CheckField<double>("x", index), instance.CheckField<double>("y", index), instance.CheckField<double>("z", index));
+				return 1;
+
+			default:
+			{
+				if (instance.IsOfType(index, "EulerAngles"))
+					quat->Set(*static_cast<EulerAnglesd*>(instance.ToUserdata(index)));
+				else
+					quat->Set(*static_cast<Quaterniond*>(instance.CheckUserdata(index, "Quaternion")));
+
+				return 1;
+			}
+		}
+	}
+
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param quat Resulting quaternion
+	*/
+
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, Quaternionf* quat, TypeTag<Quaternionf>)
+	{
+		Quaterniond quatDouble;
+		unsigned int ret = LuaImplQueryArg(instance, index, &quatDouble, TypeTag<Quaterniond>());
+
+		quat->Set(quatDouble);
+		return ret;
+	}
+
 	/*!
 	* \brief Queries arguments for Lua
 	* \return 1 in case of success
@@ -222,76 +356,6 @@ namespace Nz
 		return ret;
 	}
 
-	/*!
-	* \brief Queries arguments for Lua
-	* \return 1 in case of success
-	*
-	* \param instance Lua instance to interact with
-	* \param index Index type
-	* \param quat Resulting quaternion
-	*/
-
-	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, Quaterniond* quat, TypeTag<Quaterniond>)
-	{
-		switch (instance.GetType(index))
-		{
-			case Nz::LuaType_Table:
-				quat->Set(instance.CheckField<double>("w", index), instance.CheckField<double>("x", index), instance.CheckField<double>("y", index), instance.CheckField<double>("z", index));
-				return 1;
-
-			default:
-			{
-				if (instance.IsOfType(index, "EulerAngles"))
-					quat->Set(*static_cast<EulerAnglesd*>(instance.ToUserdata(index)));
-				else
-					quat->Set(*static_cast<Quaterniond*>(instance.CheckUserdata(index, "Quaternion")));
-
-				return 1;
-			}
-		}
-	}
-
-	/*!
-	* \brief Queries arguments for Lua
-	* \return 1 in case of success
-	*
-	* \param instance Lua instance to interact with
-	* \param index Index type
-	* \param quat Resulting quaternion
-	*/
-
-	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, Quaternionf* quat, TypeTag<Quaternionf>)
-	{
-		Quaterniond quatDouble;
-		unsigned int ret = LuaImplQueryArg(instance, index, &quatDouble, TypeTag<Quaterniond>());
-
-		quat->Set(quatDouble);
-		return ret;
-	}
-
-	/*!
-	* \brief Queries arguments for Lua
-	* \return 1 in case of success
-	*
-	* \param instance Lua instance to interact with
-	* \param index Index type
-	* \param address Resulting IP address
-	*/
-
-	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, IpAddress* address, TypeTag<IpAddress>)
-	{
-		switch (instance.GetType(index))
-		{
-			case Nz::LuaType_String:
-				address->BuildFromAddress(instance.CheckString(index));
-				return 1;
-
-			default:
-				*address = *static_cast<IpAddress*>(instance.CheckUserdata(index, "IpAddress"));
-				return 1;
-		}
-	}
-
 	/*!
 	* \brief Queries arguments for Lua
 	* \return 1 in case of success
@@ -469,10 +533,31 @@ namespace Nz
 
 	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, InstancedRenderableRef* renderable, TypeTag<InstancedRenderableRef>)
 	{
-		if (instance.IsOfType(index, "InstancedRenderable"))
+		if (instance.IsOfType(index, "InstancedRenderable") ||
-			*renderable = *static_cast<InstancedRenderableRef*>(instance.CheckUserdata(index, "InstancedRenderable"));
+		    instance.IsOfType(index, "Model") ||
+		    instance.IsOfType(index, "Sprite"))
+		{
+			*renderable = *static_cast<InstancedRenderableRef*>(instance.ToUserdata(index));
+		}
 		else
-			*renderable = *static_cast<InstancedRenderableRef*>(instance.CheckUserdata(index, "Model"));
+			instance.ArgError(index, "is not a InstancedRenderable instance");
+
+		return 1;
+	}
+
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param renderable Resulting reference to a material
+	*/
+
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, MaterialRef* materialRef, TypeTag<MaterialRef>)
+	{
+		*materialRef = *static_cast<MaterialRef*>(instance.CheckUserdata(index, "Material"));
+
 		return 1;
 	}
 
@@ -495,6 +580,7 @@ namespace Nz
 		params->loadHeightMap   = instance.CheckField<bool>("LoadHeightMap", params->loadHeightMap);
 		params->loadNormalMap   = instance.CheckField<bool>("LoadNormalMap", params->loadNormalMap);
 		params->loadSpecularMap = instance.CheckField<bool>("LoadSpecularMap", params->loadSpecularMap);
+		params->shaderName      = instance.CheckField<String>("ShaderName", params->shaderName);
 
 		return 1;
 	}
@@ -556,8 +642,59 @@ namespace Nz
 		return 1;
 	}
 
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param renderable Resulting reference to a sprite
+	*/
+
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, SpriteRef* spriteRef, TypeTag<SpriteRef>)
+	{
+		*spriteRef = *static_cast<SpriteRef*>(instance.CheckUserdata(index, "Sprite"));
+
+		return 1;
+	}
+
+	/*!
+	* \brief Queries arguments for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param index Index type
+	* \param fontRef Resulting reference to a font
+	*/
+
+	inline unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, TextureRef* textureRef, TypeTag<TextureRef>)
+	{
+		*textureRef = *static_cast<TextureRef*>(instance.CheckUserdata(index, "Texture"));
+
+		return 1;
+	}
+
 #endif
 
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param val Resulting color
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, Color&& val, TypeTag<Color>)
+	{
+		instance.PushTable();
+		instance.PushField("r", val.r);
+		instance.PushField("g", val.g);
+		instance.PushField("b", val.b);
+		instance.PushField("a", val.a);
+
+		return 1;
+	}
+
 	/*!
 	* \brief Replies by value for Lua
 	* \return 1 in case of success
@@ -619,6 +756,65 @@ namespace Nz
 		return 1;
 	}
 
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param val Resulting ImageParams
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, ImageParams&& val, TypeTag<ImageParams>)
+	{
+		instance.PushTable(0, 2);
+			instance.PushField("LevelCount", val.levelCount);
+			instance.PushField("LoadFormat", val.loadFormat);
+
+		return 1;
+	}
+
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param val Resulting IP address
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, IpAddress&& val, TypeTag<IpAddress>)
+	{
+		instance.PushInstance<IpAddress>("IpAddress", val);
+		return 1;
+	}
+
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param val Resulting rectangle
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, Matrix4d&& val, TypeTag<Matrix4d>)
+	{
+		instance.PushInstance<Matrix4d>("Matrix4", val);
+		return 1;
+	}
+
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param val Resulting rectangle
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, Matrix4f&& val, TypeTag<Matrix4f>)
+	{
+		instance.PushInstance<Matrix4d>("Matrix4", val);
+		return 1;
+	}
+
 	/*!
 	* \brief Replies by value for Lua
 	* \return 1 in case of success
@@ -647,20 +843,6 @@ namespace Nz
 		return 1;
 	}
 
-	/*!
-	* \brief Replies by value for Lua
-	* \return 1 in case of success
-	*
-	* \param instance Lua instance to interact with
-	* \param val Resulting IP address
-	*/
-
-	inline int LuaImplReplyVal(const LuaInstance& instance, IpAddress&& val, TypeTag<IpAddress>)
-	{
-		instance.PushInstance<IpAddress>("IpAddress", val);
-		return 1;
-	}
-
 	/*!
 	* \brief Replies by value for Lua
 	* \return 1 in case of success
@@ -669,7 +851,7 @@ namespace Nz
 	* \param val Resulting rectangle
 	*/
 
-	inline int LuaImplReplyVal(const LuaInstance& instance, Rectd&& val, TypeTag<Rectf>)
+	inline int LuaImplReplyVal(const LuaInstance& instance, Rectd&& val, TypeTag<Rectd>)
 	{
 		instance.PushInstance<Rectd>("Rect", val);
 		return 1;
@@ -887,6 +1069,62 @@ namespace Nz
 
 #ifndef NDK_SERVER
 
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param handle Resulting material
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, MaterialRef&& handle, TypeTag<MaterialRef>)
+	{
+		instance.PushInstance<MaterialRef>("Material", handle);
+		return 1;
+	}
+
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param val Resulting sound buffer
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, const SoundBuffer* val, TypeTag<const SoundBuffer*>)
+	{
+		instance.PushInstance<SoundBufferConstRef>("SoundBuffer", val);
+		return 1;
+	}
+
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param handle Resulting sprite
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, SpriteRef&& handle, TypeTag<SpriteRef>)
+	{
+		instance.PushInstance<SpriteRef>("Sprite", handle);
+		return 1;
+	}
+
+	/*!
+	* \brief Replies by value for Lua
+	* \return 1 in case of success
+	*
+	* \param instance Lua instance to interact with
+	* \param handle Resulting texture
+	*/
+
+	inline int LuaImplReplyVal(const LuaInstance& instance, TextureRef&& handle, TypeTag<TextureRef>)
+	{
+		instance.PushInstance<TextureRef>("Texture", handle);
+		return 1;
+	}
+
 	/*!
 	* \brief Replies by value for Lua
 	* \return 1 in case of success
@@ -914,21 +1152,6 @@ namespace Nz
 		instance.PushInstance<Ndk::GraphicsComponentHandle>("GraphicsComponent", handle);
 		return 1;
 	}
-
-	/*!
-	* \brief Replies by value for Lua
-	* \return 1 in case of success
-	*
-	* \param instance Lua instance to interact with
-	* \param val Resulting sound buffer
-	*/
-
-	inline int LuaImplReplyVal(const LuaInstance& instance, const SoundBuffer* val, TypeTag<const SoundBuffer*>)
-	{
-		instance.PushInstance<SoundBufferConstRef>("SoundBuffer", val);
-		return 1;
-	}
-
 #endif
 
 }

SDK/include/NDK/LuaBinding.hpp

@@ -38,47 +38,56 @@ namespace Ndk
 			void RegisterClasses(Nz::LuaInstance& instance);
 
 			// Core
-			Nz::LuaClass<Nz::Clock> clockClass;
+			Nz::LuaClass<Nz::Clock> clock;
-			Nz::LuaClass<Nz::Directory> directoryClass;
+			Nz::LuaClass<Nz::Directory> directory;
-			Nz::LuaClass<Nz::File> fileClass;
+			Nz::LuaClass<Nz::File> file;
-			Nz::LuaClass<Nz::Stream> streamClass;
+			Nz::LuaClass<Nz::Stream> stream;
 
 			// Math
-			Nz::LuaClass<Nz::EulerAnglesd> eulerAnglesClass;
+			Nz::LuaClass<Nz::EulerAnglesd> eulerAngles;
-			Nz::LuaClass<Nz::Quaterniond> quaternionClass;
+			Nz::LuaClass<Nz::Matrix4d> matrix4d;
-			Nz::LuaClass<Nz::Rectd> rectClass;
+			Nz::LuaClass<Nz::Quaterniond> quaternion;
-			Nz::LuaClass<Nz::Vector2d> vector2dClass;
+			Nz::LuaClass<Nz::Rectd> rect;
-			Nz::LuaClass<Nz::Vector3d> vector3dClass;
+			Nz::LuaClass<Nz::Vector2d> vector2d;
+			Nz::LuaClass<Nz::Vector3d> vector3d;
 
 			// Network
-			Nz::LuaClass<Nz::AbstractSocket> abstractSocketClass;
+			Nz::LuaClass<Nz::AbstractSocket> abstractSocket;
-			Nz::LuaClass<Nz::IpAddress> ipAddressClass;
+			Nz::LuaClass<Nz::IpAddress> ipAddress;
 
 			// Utility
-			Nz::LuaClass<Nz::AbstractImage*> abstractImage;
+			Nz::LuaClass<Nz::AbstractImageRef> abstractImage;
-			Nz::LuaClass<Nz::FontRef> fontClass;
+			Nz::LuaClass<Nz::FontRef> font;
-			Nz::LuaClass<Nz::Node> nodeClass;
+			Nz::LuaClass<Nz::Node> node;
 
 			// SDK
 			Nz::LuaClass<Application*> application;
-			Nz::LuaClass<EntityHandle> entityClass;
+			Nz::LuaClass<EntityHandle> entity;
 			Nz::LuaClass<NodeComponentHandle> nodeComponent;
 			Nz::LuaClass<VelocityComponentHandle> velocityComponent;
-			Nz::LuaClass<WorldHandle> worldClass;
+			Nz::LuaClass<WorldHandle> world;
 
 			#ifndef NDK_SERVER
 			// Audio
-			Nz::LuaClass<Nz::Music> musicClass;
+			Nz::LuaClass<Nz::Music> music;
-			Nz::LuaClass<Nz::Sound> soundClass;
+			Nz::LuaClass<Nz::Sound> sound;
 			Nz::LuaClass<Nz::SoundBufferRef> soundBuffer;
 			Nz::LuaClass<Nz::SoundEmitter> soundEmitter;
 
 			// Graphics
 			Nz::LuaClass<Nz::InstancedRenderableRef> instancedRenderable;
-			Nz::LuaClass<Nz::ModelRef> modelClass;
+			Nz::LuaClass<Nz::MaterialRef> material;
+			Nz::LuaClass<Nz::ModelRef> model;
+			Nz::LuaClass<Nz::SpriteRef> sprite;
+			Nz::LuaClass<Nz::SpriteLibrary> spriteLibrary;
+			Nz::LuaClass<Nz::TextureLibrary> textureLibrary;
+			Nz::LuaClass<Nz::TextureManager> textureManager;
+
+			// Renderer
+			Nz::LuaClass<Nz::TextureRef> texture;
 
 			// SDK
-			Nz::LuaClass<ConsoleHandle> consoleClass;
+			Nz::LuaClass<ConsoleHandle> console;
 			Nz::LuaClass<GraphicsComponentHandle> graphicsComponent;
 			#endif
 
@@ -117,7 +126,7 @@ namespace Ndk
 				Nz::String name;
 			};
 
-			ComponentBinding* QueryComponentIndex(Nz::LuaInstance& lua, int argIndex = 1);
+			ComponentBinding* QueryComponentIndex(Nz::LuaInstance& lua, int argIndex = 2);
 
 			std::vector<ComponentBinding> m_componentBinding;
 			std::unordered_map<Nz::String, ComponentIndex> m_componentBindingByName;

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,40 +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>
-
-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 OnEntityValidation(Entity* entity, bool justAdded) override;
-			void OnUpdate(float elapsedTime) override;
-
-			EntityList m_dynamicObjects;
-			EntityList m_staticObjects;
-			Nz::PhysWorld m_world;
-	};
-}
-
-#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,9 +9,12 @@ namespace Ndk
 	* \return A reference to the physical world
 	*/
 
-	inline Nz::PhysWorld& PhysicsSystem::GetWorld()
+	inline Nz::PhysWorld3D& PhysicsSystem3D::GetWorld()
 	{
-		return m_world;
+		if (!m_world)
+			CreatePhysWorld();
+
+		return *m_world;
 	}
 
 	/*!
@@ -19,8 +22,11 @@ namespace Ndk
 	* \return A constant reference to the physical world
 	*/
 
-	inline const Nz::PhysWorld& PhysicsSystem::GetWorld() const
+	inline const Nz::PhysWorld3D& PhysicsSystem3D::GetWorld() const
 	{
-		return m_world;
+		if (!m_world)
+			CreatePhysWorld();
+
+		return *m_world;
 	}
 }

SDK/src/NDK/Application.cpp

@@ -98,9 +98,7 @@ namespace Ndk
 
 			++it;
 		}
-		#endif
 
-		#ifndef NDK_SERVER
 		if (m_exitOnClosedWindows && !hasAtLeastOneActiveWindow)
 			return false;
 		#endif

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/GraphicsComponent.cpp

@@ -131,8 +131,6 @@ namespace Ndk
 	{
 		NazaraAssert(m_entity && m_entity->HasComponent<NodeComponent>(), "GraphicsComponent requires NodeComponent");
 
-		Ndk::RenderSystem& renderSystem = m_entity->GetWorld()->GetSystem<Ndk::RenderSystem>();
-
 		m_transformMatrix = m_entity->GetComponent<NodeComponent>().GetTransformMatrix();
 		m_transformMatrixUpdated = true;
 	}

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/LuaAPI.cpp

@@ -1,6 +1,7 @@
 // This file was automatically generated on 26 May 2014 at 01:05:31
 
 #include <NDK/LuaAPI.hpp>
+#include <Nazara/Core/ErrorFlags.hpp>
 #include <NDK/LuaBinding.hpp>
 
 namespace Ndk
@@ -11,6 +12,21 @@ namespace Ndk
 	* \brief NDK class that represents the api used for Lua
 	*/
 
+	/*!
+	* \brief Gets the internal binding for Lua
+	* \return A pointer to the binding
+	*/
+	LuaBinding* LuaAPI::GetBinding()
+	{
+		if (!s_binding && !Initialize())
+		{
+			NazaraError("Failed to initialize binding");
+			return nullptr;
+		}
+
+		return s_binding;
+	}
+
 	/*!
 	* \brief Initializes the LuaAPI module
 	* \return true if initialization is successful
@@ -30,13 +46,8 @@ namespace Ndk
 
 	void LuaAPI::RegisterClasses(Nz::LuaInstance& instance)
 	{
-		if (!s_binding && !Initialize())
+		Nz::ErrorFlags errFlags(Nz::ErrorFlag_ThrowException, true);
-		{
+		GetBinding()->RegisterClasses(instance);
-			NazaraError("Failed to initialize binding");
-			return;
-		}
-
-		s_binding->RegisterClasses(instance);
 	}
 
 	/*!

SDK/src/NDK/LuaBinding.cpp

@@ -16,49 +16,58 @@ namespace Ndk
 
 	LuaBinding::LuaBinding() :
 	// Core
-	clockClass("Clock"),
+	clock("Clock"),
-	directoryClass("Directory"),
+	directory("Directory"),
-	fileClass("File"),
+	file("File"),
-	streamClass("Stream"),
+	stream("Stream"),
 
 	// Math
-	eulerAnglesClass("EulerAngles"),
+	eulerAngles("EulerAngles"),
-	quaternionClass("Quaternion"),
+	matrix4d("Matrix4"),
-	rectClass("Rect"),
+	quaternion("Quaternion"),
-	vector2dClass("Vector2"),
+	rect("Rect"),
-	vector3dClass("Vector3"),
+	vector2d("Vector2"),
+	vector3d("Vector3"),
 
 	// Network
-	abstractSocketClass("AbstractSocket"),
+	abstractSocket("AbstractSocket"),
-	ipAddressClass("IpAddress"),
+	ipAddress("IpAddress"),
 
 	// Utility
 	abstractImage("AbstractImage"),
-	fontClass("Font"),
+	font("Font"),
-	nodeClass("Node"),
+	node("Node"),
 
 	// SDK
 	application("Application"),
-	entityClass("Entity"),
+	entity("Entity"),
 	nodeComponent("NodeComponent"),
 	velocityComponent("VelocityComponent"),
-	worldClass("World")
+	world("World")
 
 	#ifndef NDK_SERVER
 	,
 
 	// Audio
-	musicClass("Music"),
+	music("Music"),
-	soundClass("Sound"),
+	sound("Sound"),
 	soundBuffer("SoundBuffer"),
 	soundEmitter("SoundEmitter"),
 
 	// Graphics
 	instancedRenderable("InstancedRenderable"),
-	modelClass("Model"),
+	material("Material"),
+	model("Model"),
+	sprite("Sprite"),
+	spriteLibrary("SpriteLibrary"),
+	textureLibrary("TextureLibrary"),
+	textureManager("TextureManager"),
+
+	// Renderer
+	texture("Texture"),
 
 	// SDK
-	consoleClass("Console"),
+	console("Console"),
 	graphicsComponent("GraphicsComponent")
 	#endif
 	{

SDK/src/NDK/LuaBinding_Audio.cpp

@@ -13,35 +13,35 @@ namespace Ndk
 	void LuaBinding::BindAudio()
 	{
 		/*********************************** Nz::Music **********************************/
-		musicClass.Inherit(soundEmitter);
+		music.Inherit(soundEmitter);
 
-		musicClass.BindDefaultConstructor();
+		music.BindDefaultConstructor();
 
 		//musicClass.SetMethod("Create", &Nz::Music::Create);
 		//musicClass.SetMethod("Destroy", &Nz::Music::Destroy);
 
-		musicClass.BindMethod("EnableLooping", &Nz::Music::EnableLooping);
+		music.BindMethod("EnableLooping", &Nz::Music::EnableLooping);
 
-		musicClass.BindMethod("GetDuration", &Nz::Music::GetDuration);
+		music.BindMethod("GetDuration", &Nz::Music::GetDuration);
-		musicClass.BindMethod("GetFormat", &Nz::Music::GetFormat);
+		music.BindMethod("GetFormat", &Nz::Music::GetFormat);
-		musicClass.BindMethod("GetPlayingOffset", &Nz::Music::GetPlayingOffset);
+		music.BindMethod("GetPlayingOffset", &Nz::Music::GetPlayingOffset);
-		musicClass.BindMethod("GetSampleCount", &Nz::Music::GetSampleCount);
+		music.BindMethod("GetSampleCount", &Nz::Music::GetSampleCount);
-		musicClass.BindMethod("GetSampleRate", &Nz::Music::GetSampleRate);
+		music.BindMethod("GetSampleRate", &Nz::Music::GetSampleRate);
-		musicClass.BindMethod("GetStatus", &Nz::Music::GetStatus);
+		music.BindMethod("GetStatus", &Nz::Music::GetStatus);
 
-		musicClass.BindMethod("IsLooping", &Nz::Music::IsLooping);
+		music.BindMethod("IsLooping", &Nz::Music::IsLooping);
 
-		musicClass.BindMethod("OpenFromFile", &Nz::Music::OpenFromFile, Nz::MusicParams());
+		music.BindMethod("OpenFromFile", &Nz::Music::OpenFromFile, Nz::MusicParams());
 
-		musicClass.BindMethod("Pause", &Nz::Music::Pause);
+		music.BindMethod("Pause", &Nz::Music::Pause);
-		musicClass.BindMethod("Play", &Nz::Music::Play);
+		music.BindMethod("Play", &Nz::Music::Play);
 
-		musicClass.BindMethod("SetPlayingOffset", &Nz::Music::SetPlayingOffset);
+		music.BindMethod("SetPlayingOffset", &Nz::Music::SetPlayingOffset);
 
-		musicClass.BindMethod("Stop", &Nz::Music::Stop);
+		music.BindMethod("Stop", &Nz::Music::Stop);
 
 		// Manual
-		musicClass.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::Music& music) -> int
+		music.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::Music& music, std::size_t /*argumentCount*/) -> int
 		{
 			Nz::StringStream stream("Music(");
 			stream << music.GetFilePath() << ')';
@@ -51,21 +51,21 @@ namespace Ndk
 		});
 
 		/*********************************** Nz::Sound **********************************/
-		soundClass.Inherit(soundEmitter);
+		sound.Inherit(soundEmitter);
 
-		soundClass.BindDefaultConstructor();
+		sound.BindDefaultConstructor();
 
-		soundClass.BindMethod("GetBuffer", &Nz::Sound::GetBuffer);
+		sound.BindMethod("GetBuffer", &Nz::Sound::GetBuffer);
 
-		soundClass.BindMethod("IsPlayable", &Nz::Sound::IsPlayable);
+		sound.BindMethod("IsPlayable", &Nz::Sound::IsPlayable);
-		soundClass.BindMethod("IsPlaying", &Nz::Sound::IsPlaying);
+		sound.BindMethod("IsPlaying", &Nz::Sound::IsPlaying);
 
-		soundClass.BindMethod("LoadFromFile", &Nz::Sound::LoadFromFile, Nz::SoundBufferParams());
+		sound.BindMethod("LoadFromFile", &Nz::Sound::LoadFromFile, Nz::SoundBufferParams());
 
-		soundClass.BindMethod("SetPlayingOffset", &Nz::Sound::SetPlayingOffset);
+		sound.BindMethod("SetPlayingOffset", &Nz::Sound::SetPlayingOffset);
 
 		// Manual
-		soundClass.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::Sound& sound) -> int
+		sound.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::Sound& sound, std::size_t /*argumentCount*/) -> int
 		{
 			Nz::StringStream stream("Sound(");
 			if (const Nz::SoundBuffer* buffer = sound.GetBuffer())
@@ -101,9 +101,9 @@ namespace Ndk
 		soundBuffer.BindStaticMethod("IsFormatSupported", &Nz::SoundBuffer::IsFormatSupported);
 
 		// Manual
-		soundBuffer.BindMethod("Create", [] (Nz::LuaInstance& lua, Nz::SoundBufferRef& instance) -> int
+		soundBuffer.BindMethod("Create", [] (Nz::LuaInstance& lua, Nz::SoundBufferRef& instance, std::size_t /*argumentCount*/) -> int
 		{
-			int index = 1;
+			int index = 2;
 			Nz::AudioFormat format = lua.Check<Nz::AudioFormat>(&index);
 			unsigned int sampleCount = lua.Check<unsigned int>(&index);
 			unsigned int sampleRate = lua.Check<unsigned int>(&index);
@@ -116,13 +116,13 @@ namespace Ndk
 			return 1;
 		});
 
-		soundBuffer.BindMethod("GetSamples", [] (Nz::LuaInstance& lua, Nz::SoundBufferRef& instance) -> int
+		soundBuffer.BindMethod("GetSamples", [] (Nz::LuaInstance& lua, Nz::SoundBufferRef& instance, std::size_t /*argumentCount*/) -> int
 		{
 			lua.PushString(reinterpret_cast<const char*>(instance->GetSamples()), instance->GetSampleCount() * sizeof(Nz::Int16));
 			return 1;
 		});
 
-		soundBuffer.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::SoundBufferRef& instance) -> int
+		soundBuffer.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::SoundBufferRef& instance, std::size_t /*argumentCount*/) -> int
 		{
 			Nz::StringStream stream("SoundBuffer(");
 			if (instance->IsValid())
@@ -177,8 +177,8 @@ namespace Ndk
 
 	void LuaBinding::RegisterAudio(Nz::LuaInstance& instance)
 	{
-		musicClass.Register(instance);
+		music.Register(instance);
-		soundClass.Register(instance);
+		sound.Register(instance);
 		soundBuffer.Register(instance);
 		soundEmitter.Register(instance);
 	}

SDK/src/NDK/LuaBinding_Core.cpp

@@ -13,9 +13,9 @@ namespace Ndk
 	void LuaBinding::BindCore()
 	{
 		/*********************************** Nz::Clock **********************************/
-		clockClass.SetConstructor([](Nz::LuaInstance& lua, Nz::Clock* clock, std::size_t argumentCount)
+		clock.SetConstructor([](Nz::LuaInstance& lua, Nz::Clock* clock, std::size_t /*argumentCount*/)
 		{
-			int argIndex = 1;
+			int argIndex = 2;
 			Nz::Int64 startingValue = lua.Check<Nz::Int64>(&argIndex, 0);
 			bool paused = lua.Check<bool>(&argIndex, false);
 
@@ -23,16 +23,16 @@ namespace Ndk
 			return true;
 		});
 
-		clockClass.BindMethod("GetMicroseconds", &Nz::Clock::GetMicroseconds);
+		clock.BindMethod("GetMicroseconds", &Nz::Clock::GetMicroseconds);
-		clockClass.BindMethod("GetMilliseconds", &Nz::Clock::GetMilliseconds);
+		clock.BindMethod("GetMilliseconds", &Nz::Clock::GetMilliseconds);
-		clockClass.BindMethod("GetSeconds", &Nz::Clock::GetSeconds);
+		clock.BindMethod("GetSeconds", &Nz::Clock::GetSeconds);
-		clockClass.BindMethod("IsPaused", &Nz::Clock::IsPaused);
+		clock.BindMethod("IsPaused", &Nz::Clock::IsPaused);
-		clockClass.BindMethod("Pause", &Nz::Clock::Pause);
+		clock.BindMethod("Pause", &Nz::Clock::Pause);
-		clockClass.BindMethod("Restart", &Nz::Clock::Restart);
+		clock.BindMethod("Restart", &Nz::Clock::Restart);
-		clockClass.BindMethod("Unpause", &Nz::Clock::Unpause);
+		clock.BindMethod("Unpause", &Nz::Clock::Unpause);
 
 		// Manual
-		clockClass.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::Clock& clock) -> int {
+		clock.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::Clock& clock, std::size_t /*argumentCount*/) -> int {
 			Nz::StringStream stream("Clock(Elapsed: ");
 			stream << clock.GetSeconds();
 			stream << "s, Paused: ";
@@ -44,11 +44,11 @@ namespace Ndk
 		});
 
 		/********************************* Nz::Directory ********************************/
-		directoryClass.SetConstructor([](Nz::LuaInstance& lua, Nz::Directory* directory, std::size_t argumentCount)
+		directory.SetConstructor([](Nz::LuaInstance& lua, Nz::Directory* directory, std::size_t argumentCount)
 		{
 			std::size_t argCount = std::min<std::size_t>(argumentCount, 1U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 0:
@@ -63,29 +63,29 @@ namespace Ndk
 			return false;
 		});
 
-		directoryClass.BindMethod("Close", &Nz::Directory::Close);
+		directory.BindMethod("Close", &Nz::Directory::Close);
-		directoryClass.BindMethod("Exists", &Nz::Directory::Exists);
+		directory.BindMethod("Exists", &Nz::Directory::Exists);
-		directoryClass.BindMethod("GetPath", &Nz::Directory::GetPath);
+		directory.BindMethod("GetPath", &Nz::Directory::GetPath);
-		directoryClass.BindMethod("GetPattern", &Nz::Directory::GetPattern);
+		directory.BindMethod("GetPattern", &Nz::Directory::GetPattern);
-		directoryClass.BindMethod("GetResultName", &Nz::Directory::GetResultName);
+		directory.BindMethod("GetResultName", &Nz::Directory::GetResultName);
-		directoryClass.BindMethod("GetResultPath", &Nz::Directory::GetResultPath);
+		directory.BindMethod("GetResultPath", &Nz::Directory::GetResultPath);
-		directoryClass.BindMethod("GetResultSize", &Nz::Directory::GetResultSize);
+		directory.BindMethod("GetResultSize", &Nz::Directory::GetResultSize);
-		directoryClass.BindMethod("IsOpen",  &Nz::Directory::IsOpen);
+		directory.BindMethod("IsOpen",  &Nz::Directory::IsOpen);
-		directoryClass.BindMethod("IsResultDirectory",  &Nz::Directory::IsResultDirectory);
+		directory.BindMethod("IsResultDirectory",  &Nz::Directory::IsResultDirectory);
-		directoryClass.BindMethod("NextResult", &Nz::Directory::NextResult, true);
+		directory.BindMethod("NextResult", &Nz::Directory::NextResult, true);
-		directoryClass.BindMethod("Open", &Nz::Directory::Open);
+		directory.BindMethod("Open", &Nz::Directory::Open);
-		directoryClass.BindMethod("SetPath", &Nz::Directory::SetPath);
+		directory.BindMethod("SetPath", &Nz::Directory::SetPath);
-		directoryClass.BindMethod("SetPattern", &Nz::Directory::SetPattern);
+		directory.BindMethod("SetPattern", &Nz::Directory::SetPattern);
 
-		directoryClass.BindStaticMethod("Copy", Nz::Directory::Copy);
+		directory.BindStaticMethod("Copy", Nz::Directory::Copy);
-		directoryClass.BindStaticMethod("Create", Nz::Directory::Create);
+		directory.BindStaticMethod("Create", Nz::Directory::Create);
-		directoryClass.BindStaticMethod("Exists", Nz::Directory::Exists);
+		directory.BindStaticMethod("Exists", Nz::Directory::Exists);
-		directoryClass.BindStaticMethod("GetCurrent", Nz::Directory::GetCurrent);
+		directory.BindStaticMethod("GetCurrent", Nz::Directory::GetCurrent);
-		directoryClass.BindStaticMethod("Remove", Nz::Directory::Remove);
+		directory.BindStaticMethod("Remove", Nz::Directory::Remove);
-		directoryClass.BindStaticMethod("SetCurrent", Nz::Directory::SetCurrent);
+		directory.BindStaticMethod("SetCurrent", Nz::Directory::SetCurrent);
 
 		// Manual
-		directoryClass.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::Directory& directory) -> int {
+		directory.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::Directory& directory, std::size_t /*argumentCount*/) -> int {
 			Nz::StringStream stream("Directory(");
 			stream << directory.GetPath();
 			stream << ')';
@@ -95,23 +95,23 @@ namespace Ndk
 		});
 
 		/*********************************** Nz::Stream ***********************************/
-		streamClass.BindMethod("EnableTextMode", &Nz::Stream::EnableTextMode);
+		stream.BindMethod("EnableTextMode", &Nz::Stream::EnableTextMode);
-		streamClass.BindMethod("Flush", &Nz::Stream::Flush);
+		stream.BindMethod("Flush", &Nz::Stream::Flush);
-		streamClass.BindMethod("GetCursorPos", &Nz::Stream::GetCursorPos);
+		stream.BindMethod("GetCursorPos", &Nz::Stream::GetCursorPos);
-		streamClass.BindMethod("GetDirectory", &Nz::Stream::GetDirectory);
+		stream.BindMethod("GetDirectory", &Nz::Stream::GetDirectory);
-		streamClass.BindMethod("GetPath", &Nz::Stream::GetPath);
+		stream.BindMethod("GetPath", &Nz::Stream::GetPath);
-		streamClass.BindMethod("GetOpenMode", &Nz::Stream::GetOpenMode);
+		stream.BindMethod("GetOpenMode", &Nz::Stream::GetOpenMode);
-		streamClass.BindMethod("GetStreamOptions", &Nz::Stream::GetStreamOptions);
+		stream.BindMethod("GetStreamOptions", &Nz::Stream::GetStreamOptions);
-		streamClass.BindMethod("GetSize", &Nz::Stream::GetSize);
+		stream.BindMethod("GetSize", &Nz::Stream::GetSize);
-		streamClass.BindMethod("ReadLine", &Nz::Stream::ReadLine, 0U);
+		stream.BindMethod("ReadLine", &Nz::Stream::ReadLine, 0U);
-		streamClass.BindMethod("IsReadable", &Nz::Stream::IsReadable);
+		stream.BindMethod("IsReadable", &Nz::Stream::IsReadable);
-		streamClass.BindMethod("IsSequential", &Nz::Stream::IsSequential);
+		stream.BindMethod("IsSequential", &Nz::Stream::IsSequential);
-		streamClass.BindMethod("IsTextModeEnabled", &Nz::Stream::IsTextModeEnabled);
+		stream.BindMethod("IsTextModeEnabled", &Nz::Stream::IsTextModeEnabled);
-		streamClass.BindMethod("IsWritable", &Nz::Stream::IsWritable);
+		stream.BindMethod("IsWritable", &Nz::Stream::IsWritable);
-		streamClass.BindMethod("SetCursorPos", &Nz::Stream::SetCursorPos);
+		stream.BindMethod("SetCursorPos", &Nz::Stream::SetCursorPos);
 
-		streamClass.BindMethod("Read", [] (Nz::LuaInstance& lua, Nz::Stream& stream) -> int {
+		stream.BindMethod("Read", [] (Nz::LuaInstance& lua, Nz::Stream& stream, std::size_t /*argumentCount*/) -> int {
-			int argIndex = 1;
+			int argIndex = 2;
 
 			std::size_t length = lua.Check<std::size_t>(&argIndex);
 
@@ -122,8 +122,8 @@ namespace Ndk
 			return 1;
 		});
 
-		streamClass.BindMethod("Write", [] (Nz::LuaInstance& lua, Nz::Stream& stream) -> int {
+		stream.BindMethod("Write", [] (Nz::LuaInstance& lua, Nz::Stream& stream, std::size_t /*argumentCount*/) -> int {
-			int argIndex = 1;
+			int argIndex = 2;
 
 			std::size_t bufferSize = 0;
 			const char* buffer = lua.CheckString(argIndex, &bufferSize);
@@ -136,13 +136,13 @@ namespace Ndk
 		});
 
 		/*********************************** Nz::File ***********************************/
-		fileClass.Inherit(streamClass);
+		file.Inherit(stream);
 
-		fileClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::File* file, std::size_t argumentCount)
+		file.SetConstructor([] (Nz::LuaInstance& lua, Nz::File* file, std::size_t argumentCount)
 		{
 			std::size_t argCount = std::min<std::size_t>(argumentCount, 1U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 0:
@@ -171,41 +171,41 @@ namespace Ndk
 			return false;
 		});
 
-		fileClass.BindMethod("Close", &Nz::File::Close);
+		file.BindMethod("Close", &Nz::File::Close);
-		fileClass.BindMethod("Copy", &Nz::File::Copy);
+		file.BindMethod("Copy", &Nz::File::Copy);
-		fileClass.BindMethod("Delete", &Nz::File::Delete);
+		file.BindMethod("Delete", &Nz::File::Delete);
-		fileClass.BindMethod("EndOfFile", &Nz::File::EndOfFile);
+		file.BindMethod("EndOfFile", &Nz::File::EndOfFile);
-		fileClass.BindMethod("Exists", &Nz::File::Exists);
+		file.BindMethod("Exists", &Nz::File::Exists);
-		fileClass.BindMethod("GetCreationTime", &Nz::File::GetCreationTime);
+		file.BindMethod("GetCreationTime", &Nz::File::GetCreationTime);
-		fileClass.BindMethod("GetFileName", &Nz::File::GetFileName);
+		file.BindMethod("GetFileName", &Nz::File::GetFileName);
-		fileClass.BindMethod("GetLastAccessTime", &Nz::File::GetLastAccessTime);
+		file.BindMethod("GetLastAccessTime", &Nz::File::GetLastAccessTime);
-		fileClass.BindMethod("GetLastWriteTime", &Nz::File::GetLastWriteTime);
+		file.BindMethod("GetLastWriteTime", &Nz::File::GetLastWriteTime);
-		fileClass.BindMethod("IsOpen", &Nz::File::IsOpen);
+		file.BindMethod("IsOpen", &Nz::File::IsOpen);
-		fileClass.BindMethod("Rename", &Nz::File::GetLastWriteTime);
+		file.BindMethod("Rename", &Nz::File::GetLastWriteTime);
-		fileClass.BindMethod("GetLastWriteTime", &Nz::File::GetLastWriteTime);
+		file.BindMethod("GetLastWriteTime", &Nz::File::GetLastWriteTime);
-		fileClass.BindMethod("SetFile", &Nz::File::GetLastWriteTime);
+		file.BindMethod("SetFile", &Nz::File::GetLastWriteTime);
 
-		fileClass.BindStaticMethod("AbsolutePath", &Nz::File::AbsolutePath);
+		file.BindStaticMethod("AbsolutePath", &Nz::File::AbsolutePath);
-		fileClass.BindStaticMethod("ComputeHash", (Nz::ByteArray (*)(Nz::HashType, const Nz::String&)) &Nz::File::ComputeHash);
+		file.BindStaticMethod("ComputeHash", (Nz::ByteArray (*)(Nz::HashType, const Nz::String&)) &Nz::File::ComputeHash);
-		fileClass.BindStaticMethod("Copy", &Nz::File::Copy);
+		file.BindStaticMethod("Copy", &Nz::File::Copy);
-		fileClass.BindStaticMethod("Delete", &Nz::File::Delete);
+		file.BindStaticMethod("Delete", &Nz::File::Delete);
-		fileClass.BindStaticMethod("Exists", &Nz::File::Exists);
+		file.BindStaticMethod("Exists", &Nz::File::Exists);
 		//fileClass.SetStaticMethod("GetCreationTime", &Nz::File::GetCreationTime);
-		fileClass.BindStaticMethod("GetDirectory", &Nz::File::GetDirectory);
+		file.BindStaticMethod("GetDirectory", &Nz::File::GetDirectory);
 		//fileClass.SetStaticMethod("GetLastAccessTime", &Nz::File::GetLastAccessTime);
 		//fileClass.SetStaticMethod("GetLastWriteTime", &Nz::File::GetLastWriteTime);
-		fileClass.BindStaticMethod("GetSize", &Nz::File::GetSize);
+		file.BindStaticMethod("GetSize", &Nz::File::GetSize);
-		fileClass.BindStaticMethod("IsAbsolute", &Nz::File::IsAbsolute);
+		file.BindStaticMethod("IsAbsolute", &Nz::File::IsAbsolute);
-		fileClass.BindStaticMethod("NormalizePath", &Nz::File::NormalizePath);
+		file.BindStaticMethod("NormalizePath", &Nz::File::NormalizePath);
-		fileClass.BindStaticMethod("NormalizeSeparators", &Nz::File::NormalizeSeparators);
+		file.BindStaticMethod("NormalizeSeparators", &Nz::File::NormalizeSeparators);
-		fileClass.BindStaticMethod("Rename", &Nz::File::Rename);
+		file.BindStaticMethod("Rename", &Nz::File::Rename);
 
 		// Manual
-		fileClass.BindMethod("Open", [] (Nz::LuaInstance& lua, Nz::File& file) -> int
+		file.BindMethod("Open", [] (Nz::LuaInstance& lua, Nz::File& file, std::size_t argumentCount) -> int
 		{
-			unsigned int argCount = std::min(lua.GetStackTop(), 2U);
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 2U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 0:
@@ -224,11 +224,11 @@ namespace Ndk
 			return 0;
 		});
 
-		fileClass.BindMethod("SetCursorPos", [] (Nz::LuaInstance& lua, Nz::File& file) -> int
+		file.BindMethod("SetCursorPos", [] (Nz::LuaInstance& lua, Nz::File& file, std::size_t argumentCount) -> int
 		{
-			unsigned int argCount = std::min(lua.GetStackTop(), 2U);
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 2U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 1:
@@ -246,7 +246,7 @@ namespace Ndk
 			return 0;
 		});
 
-		fileClass.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::File& file) -> int {
+		file.BindMethod("__tostring", [] (Nz::LuaInstance& lua, Nz::File& file, std::size_t /*argumentCount*/) -> int {
 			Nz::StringStream stream("File(");
 			if (file.IsOpen())
 				stream << "Path: " << file.GetPath();
@@ -267,10 +267,10 @@ namespace Ndk
 	void LuaBinding::RegisterCore(Nz::LuaInstance& instance)
 	{
 		// Classes
-		clockClass.Register(instance);
+		clock.Register(instance);
-		directoryClass.Register(instance);
+		directory.Register(instance);
-		fileClass.Register(instance);
+		file.Register(instance);
-		streamClass.Register(instance);
+		stream.Register(instance);
 
 		// Enums
 

SDK/src/NDK/LuaBinding_Graphics.cpp

@@ -14,36 +14,305 @@ namespace Ndk
 	{
 		/*********************************** Nz::InstancedRenderable ***********************************/
 
+		/*********************************** Nz::Material ***********************************/
+		material.SetConstructor([] (Nz::LuaInstance& lua, Nz::MaterialRef* instance, std::size_t argumentCount)
+		{
+			switch (argumentCount)
+			{
+				case 0:
+					Nz::PlacementNew(instance, Nz::Material::New());
+					return true;
+
+				case 1:
+				{
+					int argIndex = 1;
+					if (lua.IsOfType(argIndex, "MaterialPipeline"))
+					{
+						Nz::PlacementNew(instance, Nz::Material::New(*static_cast<Nz::MaterialPipelineRef*>(lua.ToUserdata(argIndex))));
+						return true;
+					}
+					else if (lua.IsOfType(argIndex, "Material"))
+					{
+						Nz::PlacementNew(instance, Nz::Material::New(**static_cast<Nz::MaterialRef*>(lua.ToUserdata(argIndex))));
+						return true;
+					}
+					else
+					{
+						Nz::PlacementNew(instance, Nz::Material::New(lua.Check<Nz::String>(&argIndex)));
+						return true;
+					}
+				}
+			}
+
+			lua.Error("No matching overload for constructor");
+			return false;
+		});
+
+		material.BindMethod("Configure", [] (Nz::LuaInstance& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "MaterialPipeline"))
+			{
+				instance->Configure(*static_cast<Nz::MaterialPipelineRef*>(lua.ToUserdata(argIndex)));
+				return 0;
+			}
+			else
+			{
+				lua.Push(instance->Configure(lua.Check<Nz::String>(&argIndex)));
+				return 1;
+			}
+		});
+
+		material.BindMethod("EnableAlphaTest",        &Nz::Material::EnableAlphaTest);
+		material.BindMethod("EnableBlending",         &Nz::Material::EnableBlending);
+		material.BindMethod("EnableColorWrite",       &Nz::Material::EnableColorWrite);
+		material.BindMethod("EnableDepthBuffer",      &Nz::Material::EnableDepthBuffer);
+		material.BindMethod("EnableDepthSorting",     &Nz::Material::EnableDepthSorting);
+		material.BindMethod("EnableDepthWrite",       &Nz::Material::EnableDepthWrite);
+		material.BindMethod("EnableFaceCulling",      &Nz::Material::EnableFaceCulling);
+		material.BindMethod("EnableScissorTest",      &Nz::Material::EnableScissorTest);
+		material.BindMethod("EnableShadowCasting",    &Nz::Material::EnableShadowCasting);
+		material.BindMethod("EnableShadowReceive",    &Nz::Material::EnableShadowReceive);
+		material.BindMethod("EnableStencilTest",      &Nz::Material::EnableStencilTest);
+
+		material.BindMethod("EnsurePipelineUpdate",   &Nz::Material::EnsurePipelineUpdate);
+
+		material.BindMethod("GetAlphaMap",            &Nz::Material::GetAlphaMap);
+		material.BindMethod("GetAlphaThreshold",      &Nz::Material::GetAlphaThreshold);
+		material.BindMethod("GetAmbientColor",        &Nz::Material::GetAmbientColor);
+		material.BindMethod("GetDepthFunc",           &Nz::Material::GetDepthFunc);
+		material.BindMethod("GetDepthMaterial",       &Nz::Material::GetDepthMaterial);
+		material.BindMethod("GetDiffuseColor",        &Nz::Material::GetDiffuseColor);
+		material.BindMethod("GetDiffuseMap",          &Nz::Material::GetDiffuseMap);
+		//material.BindMethod("GetDiffuseSampler",    &Nz::Material::GetDiffuseSampler);
+		material.BindMethod("GetDstBlend",            &Nz::Material::GetDstBlend);
+		material.BindMethod("GetEmissiveMap",         &Nz::Material::GetEmissiveMap);
+		material.BindMethod("GetFaceCulling",         &Nz::Material::GetFaceCulling);
+		material.BindMethod("GetFaceFilling",         &Nz::Material::GetFaceFilling);
+		material.BindMethod("GetHeightMap",           &Nz::Material::GetHeightMap);
+		material.BindMethod("GetLineWidth",           &Nz::Material::GetLineWidth);
+		material.BindMethod("GetNormalMap",           &Nz::Material::GetNormalMap);
+		//material.BindMethod("GetPipeline",            &Nz::Material::GetPipeline);
+		//material.BindMethod("GetPipelineInfo",        &Nz::Material::GetPipelineInfo);
+		material.BindMethod("GetPointSize",           &Nz::Material::GetPointSize);
+		//material.BindMethod("GetShader",              &Nz::Material::GetShader);
+		material.BindMethod("GetShininess",           &Nz::Material::GetShininess);
+		material.BindMethod("GetSpecularColor",       &Nz::Material::GetSpecularColor);
+		material.BindMethod("GetSpecularMap",         &Nz::Material::GetSpecularMap);
+		//material.BindMethod("GetSpecularSampler",   &Nz::Material::GetSpecularSampler);
+		material.BindMethod("GetSrcBlend",            &Nz::Material::GetSrcBlend);
+
+		material.BindMethod("HasAlphaMap",            &Nz::Material::HasAlphaMap);
+		material.BindMethod("HasDepthMaterial",       &Nz::Material::HasDepthMaterial);
+		material.BindMethod("HasDiffuseMap",          &Nz::Material::HasDiffuseMap);
+		material.BindMethod("HasEmissiveMap",         &Nz::Material::HasEmissiveMap);
+		material.BindMethod("HasHeightMap",           &Nz::Material::HasHeightMap);
+		material.BindMethod("HasNormalMap",           &Nz::Material::HasNormalMap);
+		material.BindMethod("HasSpecularMap",         &Nz::Material::HasSpecularMap);
+
+		material.BindMethod("IsAlphaTestEnabled",     &Nz::Material::IsAlphaTestEnabled);
+		material.BindMethod("IsBlendingEnabled",      &Nz::Material::IsBlendingEnabled);
+		material.BindMethod("IsColorWriteEnabled",    &Nz::Material::IsColorWriteEnabled);
+		material.BindMethod("IsDepthBufferEnabled",   &Nz::Material::IsDepthBufferEnabled);
+		material.BindMethod("IsDepthSortingEnabled",  &Nz::Material::IsDepthSortingEnabled);
+		material.BindMethod("IsDepthWriteEnabled",    &Nz::Material::IsDepthWriteEnabled);
+		material.BindMethod("IsFaceCullingEnabled",   &Nz::Material::IsFaceCullingEnabled);
+		material.BindMethod("IsScissorTestEnabled",   &Nz::Material::IsScissorTestEnabled);
+		material.BindMethod("IsStencilTestEnabled",   &Nz::Material::IsStencilTestEnabled);
+		material.BindMethod("IsShadowCastingEnabled", &Nz::Material::IsShadowCastingEnabled);
+		material.BindMethod("IsShadowReceiveEnabled", &Nz::Material::IsShadowReceiveEnabled);
+
+		material.BindMethod("LoadFromFile",           &Nz::Material::LoadFromFile);
+
+		material.BindMethod("Reset",                  &Nz::Material::Reset);
+
+		material.BindMethod("SetAlphaThreshold",      &Nz::Material::SetAlphaThreshold);
+		material.BindMethod("SetAmbientColor",        &Nz::Material::SetAmbientColor);
+		material.BindMethod("SetDepthFunc",           &Nz::Material::SetDepthFunc);
+		material.BindMethod("SetDepthFunc",           &Nz::Material::SetDepthFunc);
+		material.BindMethod("SetDepthMaterial",       &Nz::Material::SetDepthMaterial);
+		material.BindMethod("SetDiffuseColor",        &Nz::Material::SetDiffuseColor);
+		//material.BindMethod("SetDiffuseSampler",      &Nz::Material::SetDiffuseSampler);
+		material.BindMethod("SetDstBlend",            &Nz::Material::SetDstBlend);
+		material.BindMethod("SetFaceCulling",         &Nz::Material::SetFaceCulling);
+		material.BindMethod("SetFaceFilling",         &Nz::Material::SetFaceFilling);
+		material.BindMethod("SetLineWidth",           &Nz::Material::SetLineWidth);
+		material.BindMethod("SetPointSize",           &Nz::Material::SetPointSize);
+		material.BindMethod("SetShininess",           &Nz::Material::SetShininess);
+		material.BindMethod("SetSpecularColor",       &Nz::Material::SetSpecularColor);
+		material.BindMethod("SetSpecularColor",       &Nz::Material::SetSpecularColor);
+		//material.BindMethod("SetSpecularSampler",     &Nz::Material::SetSpecularSampler);
+		material.BindMethod("SetSrcBlend",            &Nz::Material::SetSrcBlend);
+
+		material.BindStaticMethod("GetDefault",       &Nz::Material::GetDefault);
+
+		material.BindMethod("SetAlphaMap", [] (Nz::LuaInstance& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "Texture"))
+			{
+				instance->SetAlphaMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
+				return 0;
+			}
+			else
+				return lua.Push(instance->SetAlphaMap(lua.Check<Nz::String>(&argIndex)));
+		});
+
+		material.BindMethod("SetDiffuseMap", [] (Nz::LuaInstance& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "Texture"))
+			{
+				instance->SetDiffuseMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
+				return 0;
+			}
+			else
+				return lua.Push(instance->SetDiffuseMap(lua.Check<Nz::String>(&argIndex)));
+		});
+
+		material.BindMethod("SetEmissiveMap", [] (Nz::LuaInstance& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "Texture"))
+			{
+				instance->SetEmissiveMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
+				return 0;
+			}
+			else
+				return lua.Push(instance->SetEmissiveMap(lua.Check<Nz::String>(&argIndex)));
+		});
+
+		material.BindMethod("SetHeightMap", [] (Nz::LuaInstance& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "Texture"))
+			{
+				instance->SetHeightMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
+				return 0;
+			}
+			else
+				return lua.Push(instance->SetHeightMap(lua.Check<Nz::String>(&argIndex)));
+		});
+
+		material.BindMethod("SetNormalMap", [] (Nz::LuaInstance& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "Texture"))
+			{
+				instance->SetNormalMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
+				return 0;
+			}
+			else
+				return lua.Push(instance->SetNormalMap(lua.Check<Nz::String>(&argIndex)));
+		});
+
+		material.BindMethod("SetShader", [] (Nz::LuaInstance& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "UberShader"))
+			{
+				instance->SetShader(*static_cast<Nz::UberShaderRef*>(lua.ToUserdata(argIndex)));
+				return 0;
+			}
+			else
+				return lua.Push(instance->SetShader(lua.Check<Nz::String>(&argIndex)));
+		});
+
+		material.BindMethod("SetSpecularMap", [] (Nz::LuaInstance& lua, Nz::MaterialRef& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "Texture"))
+			{
+				instance->SetSpecularMap(*static_cast<Nz::TextureRef*>(lua.ToUserdata(argIndex)));
+				return 0;
+			}
+			else
+				return lua.Push(instance->SetSpecularMap(lua.Check<Nz::String>(&argIndex)));
+		});
+
 		/*********************************** Nz::Model ***********************************/
-		modelClass.Inherit<Nz::InstancedRenderableRef>(instancedRenderable, [] (Nz::ModelRef* model) -> Nz::InstancedRenderableRef*
+		model.Inherit<Nz::InstancedRenderableRef>(instancedRenderable, [] (Nz::ModelRef* model) -> Nz::InstancedRenderableRef*
 		{
 			return reinterpret_cast<Nz::InstancedRenderableRef*>(model); //TODO: Make a ObjectRefCast
 		});
 
-		modelClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::ModelRef* model, std::size_t argumentCount)
+		model.SetConstructor([] (Nz::LuaInstance& /*lua*/, Nz::ModelRef* model, std::size_t /*argumentCount*/)
 		{
-			NazaraUnused(argumentCount);
-
 			Nz::PlacementNew(model, Nz::Model::New());
 			return true;
 		});
 
-		//modelClass.SetMethod("GetMaterial", &Nz::Model::GetMaterial);
+		//model.BindMethod("GetMaterial", &Nz::Model::GetMaterial);
-		modelClass.BindMethod("GetMaterialCount", &Nz::Model::GetMaterialCount);
+		model.BindMethod("GetMaterialCount", &Nz::Model::GetMaterialCount);
 		//modelClass.SetMethod("GetMesh", &Nz::Model::GetMesh);
-		modelClass.BindMethod("GetSkin", &Nz::Model::GetSkin);
+		model.BindMethod("GetSkin", &Nz::Model::GetSkin);
-		modelClass.BindMethod("GetSkinCount", &Nz::Model::GetSkinCount);
+		model.BindMethod("GetSkinCount", &Nz::Model::GetSkinCount);
 
-		modelClass.BindMethod("IsAnimated", &Nz::Model::IsAnimated);
+		model.BindMethod("IsAnimated", &Nz::Model::IsAnimated);
-		modelClass.BindMethod("LoadFromFile", &Nz::Model::LoadFromFile, Nz::ModelParameters());
+		model.BindMethod("LoadFromFile", &Nz::Model::LoadFromFile, Nz::ModelParameters());
 
-		modelClass.BindMethod("Reset", &Nz::Model::Reset);
+		model.BindMethod("Reset", &Nz::Model::Reset);
 
-		//modelClass.SetMethod("SetMaterial", &Nz::Model::SetMaterial);
+		//model.BindMethod("SetMaterial", &Nz::Model::SetMaterial);
 		//modelClass.SetMethod("SetMesh", &Nz::Model::SetMesh);
 		//modelClass.SetMethod("SetSequence", &Nz::Model::SetSequence);
-		modelClass.BindMethod("SetSkin", &Nz::Model::SetSkin);
+		model.BindMethod("SetSkin", &Nz::Model::SetSkin);
-		modelClass.BindMethod("SetSkinCount", &Nz::Model::SetSkinCount);
+		model.BindMethod("SetSkinCount", &Nz::Model::SetSkinCount);
+
+		/*********************************** Nz::Sprite ***********************************/
+		sprite.Inherit<Nz::InstancedRenderableRef>(instancedRenderable, [] (Nz::SpriteRef* sprite) -> Nz::InstancedRenderableRef*
+		{
+			return reinterpret_cast<Nz::InstancedRenderableRef*>(sprite); //TODO: Make a ObjectRefCast
+		});
+
+		sprite.SetConstructor([] (Nz::LuaInstance& /*lua*/, Nz::SpriteRef* sprite, std::size_t /*argumentCount*/)
+		{
+			Nz::PlacementNew(sprite, Nz::Sprite::New());
+			return true;
+		});
+
+		sprite.BindMethod("GetColor", &Nz::Sprite::GetColor);
+		sprite.BindMethod("GetCornerColor", &Nz::Sprite::GetCornerColor);
+		sprite.BindMethod("GetMaterial", &Nz::Sprite::GetMaterial);
+		sprite.BindMethod("GetOrigin", &Nz::Sprite::GetOrigin);
+		sprite.BindMethod("GetSize", &Nz::Sprite::GetSize);
+		sprite.BindMethod("GetTextureCoords", &Nz::Sprite::GetTextureCoords);
+
+		sprite.BindMethod("SetColor", &Nz::Sprite::SetColor);
+		sprite.BindMethod("SetCornerColor", &Nz::Sprite::SetCornerColor);
+		sprite.BindMethod("SetDefaultMaterial", &Nz::Sprite::SetDefaultMaterial);
+		sprite.BindMethod("SetMaterial", &Nz::Sprite::SetMaterial, true);
+		sprite.BindMethod("SetOrigin", &Nz::Sprite::SetOrigin);
+		sprite.BindMethod("SetSize", (void(Nz::Sprite::*)(const Nz::Vector2f&)) &Nz::Sprite::SetSize);
+		sprite.BindMethod("SetTexture", &Nz::Sprite::SetTexture, true);
+		sprite.BindMethod("SetTextureCoords", &Nz::Sprite::SetTextureCoords);
+		sprite.BindMethod("SetTextureRect", &Nz::Sprite::SetTextureRect);
+
+		/*********************************** Nz::SpriteLibrary ***********************************/
+
+		spriteLibrary.BindStaticMethod("Get",        &Nz::SpriteLibrary::Get);
+		spriteLibrary.BindStaticMethod("Has",        &Nz::SpriteLibrary::Has);
+		spriteLibrary.BindStaticMethod("Register",   &Nz::SpriteLibrary::Register);
+		spriteLibrary.BindStaticMethod("Query",      &Nz::SpriteLibrary::Query);
+		spriteLibrary.BindStaticMethod("Unregister", &Nz::SpriteLibrary::Unregister);
+
+		/*********************************** Nz::TextureLibrary ***********************************/
+
+		textureLibrary.BindStaticMethod("Get",        &Nz::TextureLibrary::Get);
+		textureLibrary.BindStaticMethod("Has",        &Nz::TextureLibrary::Has);
+		textureLibrary.BindStaticMethod("Register",   &Nz::TextureLibrary::Register);
+		textureLibrary.BindStaticMethod("Query",      &Nz::TextureLibrary::Query);
+		textureLibrary.BindStaticMethod("Unregister", &Nz::TextureLibrary::Unregister);
+
+		/*********************************** Nz::TextureManager ***********************************/
+
+		textureManager.BindStaticMethod("Clear",                &Nz::TextureManager::Clear);
+		textureManager.BindStaticMethod("Get",                  &Nz::TextureManager::Get);
+		textureManager.BindStaticMethod("GetDefaultParameters", &Nz::TextureManager::GetDefaultParameters);
+		textureManager.BindStaticMethod("Purge",                &Nz::TextureManager::Purge);
+		textureManager.BindStaticMethod("Register",             &Nz::TextureManager::Register);
+		textureManager.BindStaticMethod("SetDefaultParameters", &Nz::TextureManager::SetDefaultParameters);
+		textureManager.BindStaticMethod("Unregister",           &Nz::TextureManager::Unregister);
 	}
 
 	/*!
@@ -55,6 +324,11 @@ namespace Ndk
 	void LuaBinding::RegisterGraphics(Nz::LuaInstance& instance)
 	{
 		instancedRenderable.Register(instance);
-		modelClass.Register(instance);
+		material.Register(instance);
+		model.Register(instance);
+		sprite.Register(instance);
+		spriteLibrary.Register(instance);
+		textureLibrary.Register(instance);
+		textureManager.Register(instance);
 	}
 }

SDK/src/NDK/LuaBinding_Math.cpp

@@ -14,7 +14,7 @@ namespace Ndk
 	void LuaBinding::BindMath()
 	{
 		/*********************************** Nz::EulerAngles **********************************/
-		eulerAnglesClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::EulerAnglesd* angles, std::size_t argumentCount)
+		eulerAngles.SetConstructor([] (Nz::LuaInstance& lua, Nz::EulerAnglesd* angles, std::size_t argumentCount)
 		{
 			std::size_t argCount = std::min<std::size_t>(argumentCount, 1U);
 
@@ -37,12 +37,12 @@ namespace Ndk
 			return false;
 		});
 
-		eulerAnglesClass.BindMethod("__tostring", &Nz::EulerAnglesd::ToString);
+		eulerAngles.BindMethod("__tostring", &Nz::EulerAnglesd::ToString);
 
-		eulerAnglesClass.SetGetter([] (Nz::LuaInstance& lua, Nz::EulerAnglesd& instance)
+		eulerAngles.SetGetter([] (Nz::LuaInstance& lua, Nz::EulerAnglesd& instance)
 		{
 			std::size_t length;
-			const char* ypr = lua.CheckString(1, &length);
+			const char* ypr = lua.CheckString(2, &length);
 
 			switch (length)
 			{
@@ -96,11 +96,11 @@ namespace Ndk
 			return false;
 		});
 
-		eulerAnglesClass.SetSetter([] (Nz::LuaInstance& lua, Nz::EulerAnglesd& instance)
+		eulerAngles.SetSetter([] (Nz::LuaInstance& lua, Nz::EulerAnglesd& instance)
 		{
 			std::size_t length;
-			const char* ypr = lua.CheckString(1, &length);
+			const char* ypr = lua.CheckString(2, &length);
-			double value = lua.CheckNumber(2);
+			double value = lua.CheckNumber(3);
 
 			switch (length)
 			{
@@ -154,8 +154,213 @@ namespace Ndk
 			return false;
 		});
 
+		
+		/*********************************** Nz::Matrix4 **********************************/
+		matrix4d.SetConstructor([] (Nz::LuaInstance& lua, Nz::Matrix4d* matrix, std::size_t argumentCount)
+		{
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 3U);
+
+			switch (argCount)
+			{
+				case 0:
+					Nz::PlacementNew(matrix, Nz::Matrix4d::Zero());
+					return true;
+
+				case 1:
+					if (lua.IsOfType(1, "Matrix4"))
+						Nz::PlacementNew(matrix, *static_cast<Nz::Matrix4d*>(lua.ToUserdata(1)));
+					break;
+
+				case 16:
+				{
+					double values[16];
+					for (std::size_t i = 0; i < 16; ++i)
+						values[i] = lua.CheckNumber(i);
+
+					Nz::PlacementNew(matrix, values);
+
+					return true;
+				}
+			}
+
+			lua.Error("No matching overload for constructor");
+			return false;
+		});
+
+		matrix4d.BindMethod("ApplyRotation",        &Nz::Matrix4d::ApplyRotation);
+		matrix4d.BindMethod("ApplyScale",           &Nz::Matrix4d::ApplyScale);
+		matrix4d.BindMethod("ApplyTranslation",     &Nz::Matrix4d::ApplyTranslation);
+
+		matrix4d.BindMethod("Concatenate",          &Nz::Matrix4d::Concatenate);
+		matrix4d.BindMethod("ConcatenateAffine",    &Nz::Matrix4d::ConcatenateAffine);
+
+		//matrix4d.BindMethod("GetColumn",            &Nz::Matrix4d::GetColumn);
+		matrix4d.BindMethod("GetDeterminant",       &Nz::Matrix4d::GetDeterminant);
+		matrix4d.BindMethod("GetDeterminantAffine", &Nz::Matrix4d::GetDeterminantAffine);
+
+		matrix4d.BindMethod("GetInverse", [] (Nz::LuaInstance& lua, Nz::Matrix4d& instance, std::size_t /*argumentCount*/) -> int
+		{
+			Nz::Matrix4d result;
+			if (instance.GetInverse(&result))
+				return lua.Push(true, result);
+			else
+				return lua.Push(false);
+		});
+
+		matrix4d.BindMethod("GetInverseAffine", [] (Nz::LuaInstance& lua, Nz::Matrix4d& instance, std::size_t /*argumentCount*/) -> int
+		{
+			Nz::Matrix4d result;
+			if (instance.GetInverseAffine(&result))
+				return lua.Push(true, result);
+			else
+				return lua.Push(false);
+		});
+
+		matrix4d.BindMethod("GetRotation", &Nz::Matrix4d::GetRotation);
+
+		//matrix4d.BindMethod("GetRow", &Nz::Matrix4d::GetRow);
+		matrix4d.BindMethod("GetScale", &Nz::Matrix4d::GetScale);
+		matrix4d.BindMethod("GetSquaredScale", &Nz::Matrix4d::GetSquaredScale);
+		matrix4d.BindMethod("GetTranslation", &Nz::Matrix4d::GetTranslation);
+
+		matrix4d.BindMethod("GetTransposed", [] (Nz::LuaInstance& lua, Nz::Matrix4d& instance, std::size_t /*argumentCount*/) -> int
+		{
+			Nz::Matrix4d result;
+			instance.GetTransposed(&result);
+			
+			return lua.Push(result);
+		});
+
+		matrix4d.BindMethod("HasNegativeScale", &Nz::Matrix4d::HasNegativeScale);
+		matrix4d.BindMethod("HasScale", &Nz::Matrix4d::HasScale);
+
+		matrix4d.BindMethod("Inverse", [] (Nz::LuaInstance& lua, Nz::Matrix4d& instance, std::size_t /*argumentCount*/) -> int
+		{
+			bool succeeded;
+			instance.Inverse(&succeeded);
+
+			return lua.Push(succeeded);
+		});
+
+		matrix4d.BindMethod("InverseAffine", [] (Nz::LuaInstance& lua, Nz::Matrix4d& instance, std::size_t /*argumentCount*/) -> int
+		{
+			bool succeeded;
+			instance.InverseAffine(&succeeded);
+
+			return lua.Push(succeeded);
+		});
+
+		matrix4d.BindMethod("IsAffine", &Nz::Matrix4d::IsAffine);
+		matrix4d.BindMethod("IsIdentity", &Nz::Matrix4d::IsIdentity);
+
+		matrix4d.BindMethod("MakeIdentity", &Nz::Matrix4d::MakeIdentity);
+		matrix4d.BindMethod("MakeLookAt", &Nz::Matrix4d::MakeLookAt, Nz::Vector3d::Up());
+		matrix4d.BindMethod("MakeOrtho", &Nz::Matrix4d::MakeOrtho, -1.0, 1.0);
+		matrix4d.BindMethod("MakePerspective", &Nz::Matrix4d::MakePerspective);
+		matrix4d.BindMethod("MakeRotation", &Nz::Matrix4d::MakeRotation);
+		matrix4d.BindMethod("MakeScale", &Nz::Matrix4d::MakeScale);
+		matrix4d.BindMethod("MakeTranslation", &Nz::Matrix4d::MakeTranslation);
+		matrix4d.BindMethod("MakeTransform", (Nz::Matrix4d&(Nz::Matrix4d::*)(const Nz::Vector3d&, const Nz::Quaterniond&, const Nz::Vector3d&)) &Nz::Matrix4d::MakeTransform, Nz::Vector3d::Unit());
+		matrix4d.BindMethod("MakeViewMatrix", &Nz::Matrix4d::MakeViewMatrix);
+		matrix4d.BindMethod("MakeZero", &Nz::Matrix4d::MakeZero);
+
+		matrix4d.BindMethod("Set", [] (Nz::LuaInstance& lua, Nz::Matrix4d& instance, std::size_t argumentCount) -> int
+		{
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 3U);
+
+			int argIndex = 2;
+			switch (argCount)
+			{
+				case 1:
+					if (lua.IsOfType(argIndex, "Matrix4"))
+						instance.Set(*static_cast<Nz::Matrix4d*>(lua.ToUserdata(argIndex)));
+					break;
+
+				case 16:
+				{
+					double values[16];
+					for (std::size_t i = 0; i < 16; ++i)
+						values[i] = lua.CheckNumber(argIndex++);
+
+					instance.Set(values);
+
+					return 0;
+				}
+			}
+
+			lua.Error("No matching overload for method Set");
+			return 0;
+		});
+
+		matrix4d.BindMethod("SetRotation", &Nz::Matrix4d::SetRotation);
+		matrix4d.BindMethod("SetScale", &Nz::Matrix4d::SetScale);
+		matrix4d.BindMethod("SetTranslation", &Nz::Matrix4d::SetTranslation);
+
+		matrix4d.BindMethod("Transform", [] (Nz::LuaInstance& lua, Nz::Matrix4d& instance, std::size_t /*argumentCount*/) -> int
+		{
+			int argIndex = 2;
+			if (lua.IsOfType(argIndex, "Vector2"))
+			{
+				double z(lua.CheckNumber(argIndex+1, 0.0));
+				double w(lua.CheckNumber(argIndex+2, 1.0));
+
+				return lua.Push(instance.Transform(*static_cast<Nz::Vector2d*>(lua.ToUserdata(argIndex)), z, w));
+			}
+			else if (lua.IsOfType(argIndex, "Vector3"))
+			{
+				double w(lua.CheckNumber(argIndex+1, 1.0));
+
+				return lua.Push(instance.Transform(*static_cast<Nz::Vector3d*>(lua.ToUserdata(argIndex)), w));
+			}
+			//else if (lua.IsOfType(2, "Vector4"))
+			//	return lua.Push(instance.Transform(*static_cast<Nz::Vector4d*>(lua.ToUserdata(1))));
+
+			lua.Error("No matching overload for method Transform");
+			return 0;
+		});
+
+		matrix4d.BindMethod("Transpose", &Nz::Matrix4d::Transpose);
+
+		matrix4d.BindMethod("__tostring", &Nz::Matrix4d::ToString);
+
+		matrix4d.BindStaticMethod("Concatenate",       &Nz::Matrix4d::Concatenate);
+		matrix4d.BindStaticMethod("ConcatenateAffine", &Nz::Matrix4d::ConcatenateAffine);
+		matrix4d.BindStaticMethod("Identity",          &Nz::Matrix4d::Identity);
+		matrix4d.BindStaticMethod("LookAt",            &Nz::Matrix4d::LookAt, Nz::Vector3d::Up());
+		matrix4d.BindStaticMethod("Ortho",             &Nz::Matrix4d::Ortho, -1.0, 1.0);
+		matrix4d.BindStaticMethod("Perspective",       &Nz::Matrix4d::Perspective);
+		matrix4d.BindStaticMethod("Rotate",            &Nz::Matrix4d::Rotate);
+		matrix4d.BindStaticMethod("Scale",             &Nz::Matrix4d::Scale);
+		matrix4d.BindStaticMethod("Translate",         &Nz::Matrix4d::Translate);
+		matrix4d.BindStaticMethod("Transform",         (Nz::Matrix4d(*)(const Nz::Vector3d&, const Nz::Quaterniond&, const Nz::Vector3d&)) &Nz::Matrix4d::Transform, Nz::Vector3d::Unit());
+		matrix4d.BindStaticMethod("ViewMatrix",        &Nz::Matrix4d::ViewMatrix);
+		matrix4d.BindStaticMethod("Zero",              &Nz::Matrix4d::Zero);
+
+		matrix4d.SetGetter([] (Nz::LuaInstance& lua, Nz::Matrix4d& instance)
+		{
+			bool succeeded = false;
+			std::size_t index = static_cast<std::size_t>(lua.ToInteger(2, &succeeded));
+			if (!succeeded || index < 1 || index > 16)
+				return false;
+
+			lua.Push(instance[index - 1]);
+			return true;
+		});
+
+		matrix4d.SetSetter([] (Nz::LuaInstance& lua, Nz::Matrix4d& instance)
+		{
+			bool succeeded = false;
+			std::size_t index = static_cast<std::size_t>(lua.ToInteger(2, &succeeded));
+			if (!succeeded || index < 1 || index > 16)
+				return false;
+
+			instance[index - 1] = lua.CheckNumber(3);
+
+			return true;
+		});
+
 		/*********************************** Nz::Rect **********************************/
-		rectClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::Rectd* rect, std::size_t argumentCount)
+		rect.SetConstructor([] (Nz::LuaInstance& lua, Nz::Rectd* rect, std::size_t argumentCount)
 		{
 			std::size_t argCount = std::min<std::size_t>(argumentCount, 4U);
 
@@ -203,15 +408,15 @@ namespace Ndk
 			return false;
 		});
 
-		rectClass.BindMethod("__tostring", &Nz::Rectd::ToString);
+		rect.BindMethod("__tostring", &Nz::Rectd::ToString);
 
-		rectClass.SetGetter([] (Nz::LuaInstance& lua, Nz::Rectd& instance)
+		rect.SetGetter([] (Nz::LuaInstance& lua, Nz::Rectd& instance)
 		{
-			switch (lua.GetType(1))
+			switch (lua.GetType(2))
 			{
 				case Nz::LuaType_Number:
 				{
-					auto index = lua.CheckBoundInteger<std::size_t>(1);
+					auto index = lua.CheckBoundInteger<std::size_t>(2);
 					if (index < 1 || index > 4)
 						return false;
 
@@ -222,7 +427,7 @@ namespace Ndk
 				case Nz::LuaType_String:
 				{
 					std::size_t length;
-					const char* xywh = lua.CheckString(1, &length);
+					const char* xywh = lua.CheckString(2, &length);
 
 					if (length != 1)
 						break;
@@ -258,13 +463,13 @@ namespace Ndk
 			return false;
 		});
 
-		rectClass.SetSetter([] (Nz::LuaInstance& lua, Nz::Rectd& instance)
+		rect.SetSetter([] (Nz::LuaInstance& lua, Nz::Rectd& instance)
 		{
-			switch (lua.GetType(1))
+			switch (lua.GetType(2))
 			{
 				case Nz::LuaType_Number:
 				{
-					auto index = lua.CheckBoundInteger<std::size_t>(1);
+					auto index = lua.CheckBoundInteger<std::size_t>(2);
 					if (index < 1 || index > 4)
 						return false;
 
@@ -275,12 +480,12 @@ namespace Ndk
 				case Nz::LuaType_String:
 				{
 					std::size_t length;
-					const char* xywh = lua.CheckString(1, &length);
+					const char* xywh = lua.CheckString(2, &length);
 
 					if (length != 1)
 						break;
 
-					double value = lua.CheckNumber(2);
+					double value = lua.CheckNumber(3);
 
 					switch (xywh[0])
 					{
@@ -311,7 +516,7 @@ namespace Ndk
 		});
 
 		/*********************************** Nz::Quaternion **********************************/
-		quaternionClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::Quaterniond* quaternion, std::size_t argumentCount)
+		quaternion.SetConstructor([] (Nz::LuaInstance& lua, Nz::Quaterniond* quaternion, std::size_t argumentCount)
 		{
 			std::size_t argCount = std::min<std::size_t>(argumentCount, 4U);
 
@@ -349,12 +554,12 @@ namespace Ndk
 			return false;
 		});
 
-		quaternionClass.BindMethod("__tostring", &Nz::Quaterniond::ToString);
+		quaternion.BindMethod("__tostring", &Nz::Quaterniond::ToString);
 
-		quaternionClass.SetGetter([] (Nz::LuaInstance& lua, Nz::Quaterniond& instance)
+		quaternion.SetGetter([] (Nz::LuaInstance& lua, Nz::Quaterniond& instance)
 		{
 			std::size_t length;
-			const char* wxyz = lua.CheckString(1, &length);
+			const char* wxyz = lua.CheckString(2, &length);
 
 			if (length != 1)
 				return false;
@@ -381,15 +586,15 @@ namespace Ndk
 			return false;
 		});
 
-		quaternionClass.SetSetter([] (Nz::LuaInstance& lua, Nz::Quaterniond& instance)
+		quaternion.SetSetter([] (Nz::LuaInstance& lua, Nz::Quaterniond& instance)
 		{
 			std::size_t length;
-			const char* wxyz = lua.CheckString(1, &length);
+			const char* wxyz = lua.CheckString(2, &length);
 
 			if (length != 1)
 				return false;
 
-			double value = lua.CheckNumber(2);
+			double value = lua.CheckNumber(3);
 
 			switch (wxyz[0])
 			{
@@ -417,7 +622,7 @@ namespace Ndk
 		});
 
 		/*********************************** Nz::Vector2 **********************************/
-		vector2dClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::Vector2d* vector, std::size_t argumentCount)
+		vector2d.SetConstructor([] (Nz::LuaInstance& lua, Nz::Vector2d* vector, std::size_t argumentCount)
 		{
 			std::size_t argCount = std::min<std::size_t>(argumentCount, 2U);
 
@@ -445,15 +650,15 @@ namespace Ndk
 			return false;
 		});
 
-		vector2dClass.BindMethod("__tostring", &Nz::Vector2d::ToString);
+		vector2d.BindMethod("__tostring", &Nz::Vector2d::ToString);
 
-		vector2dClass.SetGetter([](Nz::LuaInstance& lua, Nz::Vector2d& instance)
+		vector2d.SetGetter([](Nz::LuaInstance& lua, Nz::Vector2d& instance)
 		{
-			switch (lua.GetType(1))
+			switch (lua.GetType(2))
 			{
 				case Nz::LuaType_Number:
 				{
-					long long index = lua.CheckInteger(1);
+					long long index = lua.CheckInteger(2);
 					if (index < 1 || index > 2)
 						return false;
 
@@ -464,7 +669,7 @@ namespace Ndk
 				case Nz::LuaType_String:
 				{
 					std::size_t length;
-					const char* xy = lua.CheckString(1, &length);
+					const char* xy = lua.CheckString(2, &length);
 
 					if (length != 1)
 						break;
@@ -492,29 +697,29 @@ namespace Ndk
 			return false;
 		});
 
-		vector2dClass.SetSetter([](Nz::LuaInstance& lua, Nz::Vector2d& instance)
+		vector2d.SetSetter([](Nz::LuaInstance& lua, Nz::Vector2d& instance)
 		{
-			switch (lua.GetType(1))
+			switch (lua.GetType(2))
 			{
 				case Nz::LuaType_Number:
 				{
-					long long index = lua.CheckInteger(1);
+					long long index = lua.CheckInteger(2);
 					if (index < 1 || index > 2)
 						return false;
 
-					instance[index - 1] = lua.CheckNumber(2);
+					instance[index - 1] = lua.CheckNumber(3);
 					return true;
 				}
 
 				case Nz::LuaType_String:
 				{
 					std::size_t length;
-					const char* xy = lua.CheckString(1, &length);
+					const char* xy = lua.CheckString(2, &length);
 
 					if (length != 1)
 						break;
 
-					double value = lua.CheckNumber(2);
+					double value = lua.CheckNumber(3);
 
 					switch (xy[0])
 					{
@@ -540,7 +745,7 @@ namespace Ndk
 		});
 
 		/*********************************** Nz::Vector3 **********************************/
-		vector3dClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::Vector3d* vector, std::size_t argumentCount)
+		vector3d.SetConstructor([] (Nz::LuaInstance& lua, Nz::Vector3d* vector, std::size_t argumentCount)
 		{
 			std::size_t argCount = std::min<std::size_t>(argumentCount, 3U);
 
@@ -582,15 +787,15 @@ namespace Ndk
 			return false;
 		});
 
-		vector3dClass.BindMethod("__tostring", &Nz::Vector3d::ToString);
+		vector3d.BindMethod("__tostring", &Nz::Vector3d::ToString);
 
-		vector3dClass.SetGetter([] (Nz::LuaInstance& lua, Nz::Vector3d& instance)
+		vector3d.SetGetter([] (Nz::LuaInstance& lua, Nz::Vector3d& instance)
 		{
-			switch (lua.GetType(1))
+			switch (lua.GetType(2))
 			{
 				case Nz::LuaType_Number:
 				{
-					long long index = lua.CheckInteger(1);
+					long long index = lua.CheckInteger(2);
 					if (index < 1 || index > 3)
 						return false;
 
@@ -601,7 +806,7 @@ namespace Ndk
 				case Nz::LuaType_String:
 				{
 					std::size_t length;
-					const char* xyz = lua.CheckString(1, &length);
+					const char* xyz = lua.CheckString(2, &length);
 
 					if (length != 1)
 						break;
@@ -633,29 +838,29 @@ namespace Ndk
 			return false;
 		});
 
-		vector3dClass.SetSetter([] (Nz::LuaInstance& lua, Nz::Vector3d& instance)
+		vector3d.SetSetter([] (Nz::LuaInstance& lua, Nz::Vector3d& instance)
 		{
-			switch (lua.GetType(1))
+			switch (lua.GetType(2))
 			{
 				case Nz::LuaType_Number:
 				{
-					long long index = lua.CheckInteger(1);
+					long long index = lua.CheckInteger(2);
 					if (index < 1 || index > 3)
 						return false;
 
-					instance[index - 1] = lua.CheckNumber(2);
+					instance[index - 1] = lua.CheckNumber(3);
 					return true;
 				}
 
 				case Nz::LuaType_String:
 				{
 					std::size_t length;
-					const char* xyz = lua.CheckString(1, &length);
+					const char* xyz = lua.CheckString(2, &length);
 
 					if (length != 1)
 						break;
 
-					double value = lua.CheckNumber(2);
+					double value = lua.CheckNumber(3);
 
 					switch (xyz[0])
 					{
@@ -693,10 +898,11 @@ namespace Ndk
 
 	void LuaBinding::RegisterMath(Nz::LuaInstance& instance)
 	{
-		eulerAnglesClass.Register(instance);
+		eulerAngles.Register(instance);
-		quaternionClass.Register(instance);
+		matrix4d.Register(instance);
-		rectClass.Register(instance);
+		quaternion.Register(instance);
-		vector2dClass.Register(instance);
+		rect.Register(instance);
-		vector3dClass.Register(instance);
+		vector2d.Register(instance);
+		vector3d.Register(instance);
 	}
 }

SDK/src/NDK/LuaBinding_Network.cpp

@@ -12,20 +12,20 @@ namespace Ndk
 	void LuaBinding::BindNetwork()
 	{
 		/*********************************** Nz::AbstractSocket **********************************/
-		abstractSocketClass.BindMethod("Close", &Nz::AbstractSocket::Close);
+		abstractSocket.BindMethod("Close", &Nz::AbstractSocket::Close);
-		abstractSocketClass.BindMethod("EnableBlocking", &Nz::AbstractSocket::EnableBlocking);
+		abstractSocket.BindMethod("EnableBlocking", &Nz::AbstractSocket::EnableBlocking);
-		abstractSocketClass.BindMethod("GetLastError", &Nz::AbstractSocket::GetLastError);
+		abstractSocket.BindMethod("GetLastError", &Nz::AbstractSocket::GetLastError);
-		abstractSocketClass.BindMethod("GetState", &Nz::AbstractSocket::GetState);
+		abstractSocket.BindMethod("GetState", &Nz::AbstractSocket::GetState);
-		abstractSocketClass.BindMethod("GetType", &Nz::AbstractSocket::GetType);
+		abstractSocket.BindMethod("GetType", &Nz::AbstractSocket::GetType);
-		abstractSocketClass.BindMethod("IsBlockingEnabled", &Nz::AbstractSocket::IsBlockingEnabled);
+		abstractSocket.BindMethod("IsBlockingEnabled", &Nz::AbstractSocket::IsBlockingEnabled);
-		abstractSocketClass.BindMethod("QueryAvailableBytes", &Nz::AbstractSocket::QueryAvailableBytes);
+		abstractSocket.BindMethod("QueryAvailableBytes", &Nz::AbstractSocket::QueryAvailableBytes);
 
 		/*********************************** Nz::IpAddress **********************************/
-		ipAddressClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::IpAddress* address, std::size_t argumentCount)
+		ipAddress.SetConstructor([] (Nz::LuaInstance& lua, Nz::IpAddress* address, std::size_t argumentCount)
 		{
 			std::size_t argCount = std::min<std::size_t>(argumentCount, 9U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 0:
@@ -71,19 +71,19 @@ namespace Ndk
 			return false;
 		});
 
-		ipAddressClass.BindMethod("GetPort",     &Nz::IpAddress::GetPort);
+		ipAddress.BindMethod("GetPort",     &Nz::IpAddress::GetPort);
-		ipAddressClass.BindMethod("GetProtocol", &Nz::IpAddress::GetProtocol);
+		ipAddress.BindMethod("GetProtocol", &Nz::IpAddress::GetProtocol);
-		ipAddressClass.BindMethod("IsLoopback",  &Nz::IpAddress::IsLoopback);
+		ipAddress.BindMethod("IsLoopback",  &Nz::IpAddress::IsLoopback);
-		ipAddressClass.BindMethod("IsValid",     &Nz::IpAddress::IsValid);
+		ipAddress.BindMethod("IsValid",     &Nz::IpAddress::IsValid);
-		ipAddressClass.BindMethod("ToUInt32",    &Nz::IpAddress::ToUInt32);
+		ipAddress.BindMethod("ToUInt32",    &Nz::IpAddress::ToUInt32);
-		ipAddressClass.BindMethod("__tostring",  &Nz::IpAddress::ToString);
+		ipAddress.BindMethod("__tostring",  &Nz::IpAddress::ToString);
 
-		ipAddressClass.BindStaticMethod("ResolveAddress", [] (Nz::LuaInstance& instance) -> int
+		ipAddress.BindStaticMethod("ResolveAddress", [] (Nz::LuaInstance& instance) -> int
 		{
 			Nz::String service;
 			Nz::ResolveError error = Nz::ResolveError_Unknown;
 
-			int argIndex = 1;
+			int argIndex = 2;
 			Nz::String hostName = Nz::IpAddress::ResolveAddress(instance.Check<Nz::IpAddress>(&argIndex), &service, &error);
 
 			if (error == Nz::ResolveError_NoError)
@@ -100,11 +100,11 @@ namespace Ndk
 			}
 		});
 
-		ipAddressClass.BindStaticMethod("ResolveHostname", [] (Nz::LuaInstance& instance) -> int
+		ipAddress.BindStaticMethod("ResolveHostname", [] (Nz::LuaInstance& instance) -> int
 		{
 			Nz::ResolveError error = Nz::ResolveError_Unknown;
 
-			int argIndex = 1;
+			int argIndex = 2;
 			Nz::NetProtocol protocol = instance.Check<Nz::NetProtocol>(&argIndex);
 			Nz::String      hostname = instance.Check<Nz::String>(&argIndex);
 			Nz::String      service  = instance.Check<Nz::String>(&argIndex, "http");
@@ -145,8 +145,8 @@ namespace Ndk
 	void LuaBinding::RegisterNetwork(Nz::LuaInstance& instance)
 	{
 		// Classes
-		abstractSocketClass.Register(instance);
+		abstractSocket.Register(instance);
-		ipAddressClass.Register(instance);
+		ipAddress.Register(instance);
 
 		// Enums
 

SDK/src/NDK/LuaBinding_Renderer.cpp

@@ -10,9 +10,58 @@ namespace Ndk
 	/*!
 	* \brief Binds Renderer module to Lua
 	*/
-
 	void LuaBinding::BindRenderer()
 	{
+		/*********************************** Nz::Texture ***********************************/
+		texture.Inherit<Nz::AbstractImageRef>(abstractImage, [] (Nz::TextureRef* texture) -> Nz::AbstractImageRef*
+		{
+			return reinterpret_cast<Nz::AbstractImageRef*>(texture); //TODO: Make a ObjectRefCast
+		});
+
+		texture.SetConstructor([] (Nz::LuaInstance& /*lua*/, Nz::TextureRef* texture, std::size_t /*argumentCount*/)
+		{
+			Nz::PlacementNew(texture, Nz::Texture::New());
+			return true;
+		});
+
+		texture.BindMethod("Create", &Nz::Texture::Create, static_cast<Nz::UInt8>(1), 1U);
+		texture.BindMethod("Destroy", &Nz::Texture::Destroy);
+
+		//texture.BindMethod("Download", &Nz::Texture::Download);
+		
+		texture.BindMethod("EnableMipmapping", &Nz::Texture::EnableMipmapping);
+		texture.BindMethod("EnsureMipmapsUpdate", &Nz::Texture::EnsureMipmapsUpdate);
+		texture.BindMethod("HasMipmaps", &Nz::Texture::HasMipmaps);
+		texture.BindMethod("InvalidateMipmaps", &Nz::Texture::InvalidateMipmaps);
+		texture.BindMethod("IsValid", &Nz::Texture::IsValid);
+
+		texture.BindMethod("LoadFromFile", &Nz::Texture::LoadFromFile, true, Nz::ImageParams());
+		//bool LoadFromImage(const Image& image, bool generateMipmaps = true);
+		//bool LoadFromMemory(const void* data, std::size_t size, const ImageParams& params = ImageParams(), bool generateMipmaps = true);
+		//bool LoadFromStream(Stream& stream, const ImageParams& params = ImageParams(), bool generateMipmaps = true);
+
+		texture.BindMethod("LoadArrayFromFile", &Nz::Texture::LoadArrayFromFile, Nz::Vector2ui(2, 2), true, Nz::ImageParams());
+		//bool LoadArrayFromImage(const Image& image, bool generateMipmaps = true, const Vector2ui& atlasSize = Vector2ui(2, 2));
+		//bool LoadArrayFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const Vector2ui& atlasSize = Vector2ui(2, 2));
+		//bool LoadArrayFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const Vector2ui& atlasSize = Vector2ui(2, 2));
+
+		//bool LoadCubemapFromFile(const String& filePath, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const CubemapParams& cubemapParams = CubemapParams());
+		//bool LoadCubemapFromImage(const Image& image, bool generateMipmaps = true, const CubemapParams& params = CubemapParams());
+		//bool LoadCubemapFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const CubemapParams& cubemapParams = CubemapParams());
+		//bool LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const CubemapParams& cubemapParams = CubemapParams());
+
+		texture.BindMethod("LoadFaceFromFile", &Nz::Texture::LoadFaceFromFile, Nz::ImageParams());
+		//bool LoadFaceFromMemory(CubemapFace face, const void* data, std::size_t size, const ImageParams& params = ImageParams());
+		//bool LoadFaceFromStream(CubemapFace face, Stream& stream, const ImageParams& params = ImageParams());
+
+		texture.BindMethod("SaveToFile", &Nz::Texture::SaveToFile, Nz::ImageParams());
+		//bool SaveToStream(Stream& stream, const String& format, const ImageParams& params = ImageParams());
+
+		texture.BindMethod("SetMipmapRange", &Nz::Texture::SetMipmapRange);
+
+		texture.BindStaticMethod("IsFormatSupported", &Nz::Texture::IsFormatSupported);
+		texture.BindStaticMethod("IsMipmappingSupported", &Nz::Texture::IsMipmappingSupported);
+		texture.BindStaticMethod("IsTypeSupported", &Nz::Texture::IsTypeSupported);
 	}
 
 	/*!
@@ -20,8 +69,8 @@ namespace Ndk
 	*
 	* \param instance Lua instance that will interact with the Renderer classes
 	*/
-
 	void LuaBinding::RegisterRenderer(Nz::LuaInstance& instance)
 	{
+		texture.Register(instance);
 	}
 }

SDK/src/NDK/LuaBinding_SDK.cpp

@@ -25,7 +25,7 @@ namespace Ndk
 		application.BindMethod("IsFPSCounterEnabled", &Application::IsFPSCounterEnabled);
 		#endif
 
-		application.BindMethod("AddWorld", [] (Nz::LuaInstance& instance, Application* application) -> int
+		application.BindMethod("AddWorld", [] (Nz::LuaInstance& instance, Application* application, std::size_t /*argumentCount*/) -> int
 		{
 			instance.Push(application->AddWorld().CreateHandle());
 			return 1;
@@ -36,58 +36,58 @@ namespace Ndk
 
 		/*********************************** Ndk::Console **********************************/
 		#ifndef NDK_SERVER
-		consoleClass.Inherit<Nz::Node>(nodeClass, [] (ConsoleHandle* handle) -> Nz::Node*
+		console.Inherit<Nz::Node>(node, [] (ConsoleHandle* handle) -> Nz::Node*
 		{
 			return handle->GetObject();
 		});
 
-		consoleClass.BindMethod("AddLine", &Console::AddLine, Nz::Color::White);
+		console.BindMethod("AddLine", &Console::AddLine, Nz::Color::White);
-		consoleClass.BindMethod("Clear", &Console::Clear);
+		console.BindMethod("Clear", &Console::Clear);
-		consoleClass.BindMethod("GetCharacterSize", &Console::GetCharacterSize);
+		console.BindMethod("GetCharacterSize", &Console::GetCharacterSize);
-		consoleClass.BindMethod("GetHistory", &Console::GetHistory);
+		console.BindMethod("GetHistory", &Console::GetHistory);
-		consoleClass.BindMethod("GetHistoryBackground", &Console::GetHistoryBackground);
+		console.BindMethod("GetHistoryBackground", &Console::GetHistoryBackground);
-		consoleClass.BindMethod("GetInput", &Console::GetInput);
+		console.BindMethod("GetInput", &Console::GetInput);
-		consoleClass.BindMethod("GetInputBackground", &Console::GetInputBackground);
+		console.BindMethod("GetInputBackground", &Console::GetInputBackground);
-		consoleClass.BindMethod("GetSize", &Console::GetSize);
+		console.BindMethod("GetSize", &Console::GetSize);
-		consoleClass.BindMethod("GetTextFont", &Console::GetTextFont);
+		console.BindMethod("GetTextFont", &Console::GetTextFont);
 
-		consoleClass.BindMethod("IsVisible", &Console::IsVisible);
+		console.BindMethod("IsVisible", &Console::IsVisible);
 
-		consoleClass.BindMethod("SendCharacter", &Console::SendCharacter);
+		console.BindMethod("SendCharacter", &Console::SendCharacter);
 		//consoleClass.SetMethod("SendEvent", &Console::SendEvent);
 
-		consoleClass.BindMethod("SetCharacterSize", &Console::SetCharacterSize);
+		console.BindMethod("SetCharacterSize", &Console::SetCharacterSize);
-		consoleClass.BindMethod("SetSize", &Console::SetSize);
+		console.BindMethod("SetSize", &Console::SetSize);
-		consoleClass.BindMethod("SetTextFont", &Console::SetTextFont);
+		console.BindMethod("SetTextFont", &Console::SetTextFont);
 		
-		consoleClass.BindMethod("Show", &Console::Show, true);
+		console.BindMethod("Show", &Console::Show, true);
 		#endif
 
 		/*********************************** Ndk::Entity **********************************/
-		entityClass.BindMethod("Enable", &Entity::Enable, true);
+		entity.BindMethod("Enable", &Entity::Enable, true);
-		entityClass.BindMethod("GetId", &Entity::GetId);
+		entity.BindMethod("GetId", &Entity::GetId);
-		entityClass.BindMethod("GetWorld", &Entity::GetWorld);
+		entity.BindMethod("GetWorld", &Entity::GetWorld);
-		entityClass.BindMethod("Kill", &Entity::Kill);
+		entity.BindMethod("Kill", &Entity::Kill);
-		entityClass.BindMethod("IsEnabled", &Entity::IsEnabled);
+		entity.BindMethod("IsEnabled", &Entity::IsEnabled);
-		entityClass.BindMethod("IsValid", &Entity::IsValid);
+		entity.BindMethod("IsValid", &Entity::IsValid);
-		entityClass.BindMethod("RemoveAllComponents", &Entity::RemoveAllComponents);
+		entity.BindMethod("RemoveAllComponents", &Entity::RemoveAllComponents);
-		entityClass.BindMethod("__tostring", &EntityHandle::ToString);
+		entity.BindMethod("__tostring", &EntityHandle::ToString);
 
-		entityClass.BindMethod("AddComponent", [this] (Nz::LuaInstance& instance, EntityHandle& handle) -> int
+		entity.BindMethod("AddComponent", [this] (Nz::LuaInstance& instance, EntityHandle& handle, std::size_t /*argumentCount*/) -> int
 		{
 			ComponentBinding* binding = QueryComponentIndex(instance);
 
 			return binding->adder(instance, handle);
 		});
 
-		entityClass.BindMethod("GetComponent", [this] (Nz::LuaInstance& instance, EntityHandle& handle) -> int
+		entity.BindMethod("GetComponent", [this] (Nz::LuaInstance& instance, EntityHandle& handle, std::size_t /*argumentCount*/) -> int
 		{
 			ComponentBinding* binding = QueryComponentIndex(instance);
 
 			return binding->getter(instance, handle->GetComponent(binding->index));
 		});
 
-		entityClass.BindMethod("RemoveComponent", [this] (Nz::LuaInstance& instance, EntityHandle& handle) -> int
+		entity.BindMethod("RemoveComponent", [this] (Nz::LuaInstance& instance, EntityHandle& handle, std::size_t /*argumentCount*/) -> int
 		{
 			ComponentBinding* binding = QueryComponentIndex(instance);
 
@@ -96,7 +96,7 @@ namespace Ndk
 		});
 
 		/*********************************** Ndk::NodeComponent **********************************/
-		nodeComponent.Inherit<Nz::Node>(nodeClass, [] (NodeComponentHandle* handle) -> Nz::Node*
+		nodeComponent.Inherit<Nz::Node>(node, [] (NodeComponentHandle* handle) -> Nz::Node*
 		{
 			return handle->GetObject();
 		});
@@ -105,7 +105,7 @@ namespace Ndk
 		velocityComponent.SetGetter([] (Nz::LuaInstance& lua, VelocityComponentHandle& instance)
 		{
 			std::size_t length;
-			const char* member = lua.CheckString(1, &length);
+			const char* member = lua.CheckString(2, &length);
 
 			if (std::strcmp(member, "Linear") == 0)
 			{
@@ -119,9 +119,9 @@ namespace Ndk
 		velocityComponent.SetSetter([] (Nz::LuaInstance& lua, VelocityComponentHandle& instance)
 		{
 			std::size_t length;
-			const char* member = lua.CheckString(1, &length);
+			const char* member = lua.CheckString(2, &length);
 
-			int argIndex = 2;
+			int argIndex = 3;
 			if (std::strcmp(member, "Linear") == 0)
 			{
 				instance->linearVelocity = lua.Check<Nz::Vector3f>(&argIndex);
@@ -132,14 +132,69 @@ namespace Ndk
 		});
 
 		/*********************************** Ndk::World **********************************/
-		worldClass.BindMethod("CreateEntity", &World::CreateEntity);
+		world.BindMethod("CreateEntity", &World::CreateEntity);
-		worldClass.BindMethod("CreateEntities", &World::CreateEntities);
+		world.BindMethod("CreateEntities", &World::CreateEntities);
-		worldClass.BindMethod("Clear", &World::Clear);
+		world.BindMethod("Clear", &World::Clear);
 
 
 		#ifndef NDK_SERVER
 		/*********************************** Ndk::GraphicsComponent **********************************/
-		graphicsComponent.BindMethod("Attach", (void(Ndk::GraphicsComponent::*)(Nz::InstancedRenderableRef, int)) &GraphicsComponent::Attach, 0);
+		graphicsComponent.BindMethod("Attach", [] (Nz::LuaInstance& lua, Ndk::GraphicsComponent *gfxComponent, std::size_t argumentCount) -> int
+		{
+			/*
+			void Attach(Nz::InstancedRenderableRef renderable, int renderOrder = 0);
+			void Attach(Nz::InstancedRenderableRef renderable, const Nz::Matrix4f& localMatrix, int renderOrder = 0);
+			*/
+
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 3U);
+
+			switch (argCount)
+			{
+				case 1:
+				{
+					int argIndex = 2;
+					gfxComponent->Attach(lua.Check<Nz::InstancedRenderableRef>(&argIndex));
+					return 0;
+				}
+
+				case 2:
+				{
+					int argIndex = 2;
+					Nz::InstancedRenderableRef renderable = lua.Check<Nz::InstancedRenderableRef>(&argIndex);
+
+					if (lua.IsOfType(argIndex, Nz::LuaType_Number))
+					{
+						int renderOrder = lua.Check<int>(&argIndex);
+
+						gfxComponent->Attach(renderable, renderOrder);
+					}
+					else if (lua.IsOfType(argIndex, "Matrix4"))
+					{
+						Nz::Matrix4f localMatrix = lua.Check<Nz::Matrix4f>(&argIndex);
+
+						gfxComponent->Attach(renderable, localMatrix);
+					}
+					else
+						break;
+
+					return 0;
+				}
+
+				case 3:
+				{
+					int argIndex = 2;
+					Nz::InstancedRenderableRef renderable = lua.Check<Nz::InstancedRenderableRef>(&argIndex);
+					Nz::Matrix4f localMatrix = lua.Check<Nz::Matrix4f>(&argIndex);
+					int renderOrder = lua.Check<int>(&argIndex);
+
+					gfxComponent->Attach(renderable, localMatrix, renderOrder);
+					return 0;
+				}
+			}
+
+			lua.Error("No matching overload for method GetMemoryUsage");
+			return 0;
+		});
 		#endif
 
 
@@ -164,13 +219,13 @@ namespace Ndk
 	{
 		// Classes
 		application.Register(instance);
-		entityClass.Register(instance);
+		entity.Register(instance);
 		nodeComponent.Register(instance);
 		velocityComponent.Register(instance);
-		worldClass.Register(instance);
+		world.Register(instance);
 
 		#ifndef NDK_SERVER
-		consoleClass.Register(instance);
+		console.Register(instance);
 		graphicsComponent.Register(instance);
 		#endif
 

SDK/src/NDK/LuaBinding_Utility.cpp

@@ -25,9 +25,9 @@ namespace Ndk
 		abstractImage.BindMethod("IsCompressed", &Nz::AbstractImage::IsCompressed);
 		abstractImage.BindMethod("IsCubemap", &Nz::AbstractImage::IsCubemap);
 
-		abstractImage.BindMethod("GetMemoryUsage", [] (Nz::LuaInstance& lua, Nz::AbstractImage* abstractImage) -> int
+		abstractImage.BindMethod("GetMemoryUsage", [] (Nz::LuaInstance& lua, Nz::AbstractImage* abstractImage, std::size_t argumentCount) -> int
 		{
-			unsigned int argCount = std::min(lua.GetStackTop(), 1U);
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 1U);
 			switch (argCount)
 			{
 				case 0:
@@ -35,8 +35,8 @@ namespace Ndk
 
 				case 1:
 				{
-					int index = 1;
+					int argIndex = 2;
-					Nz::UInt8 level(lua.Check<Nz::UInt8>(&index));
+					Nz::UInt8 level(lua.Check<Nz::UInt8>(&argIndex));
 
 					return lua.Push(abstractImage->GetMemoryUsage(level));
 				}
@@ -46,10 +46,10 @@ namespace Ndk
 			return 0;
 		});
 
-		abstractImage.BindMethod("Update", [] (Nz::LuaInstance& lua, Nz::AbstractImage* abstractImage) -> int
+		abstractImage.BindMethod("Update", [] (Nz::LuaInstance& lua, Nz::AbstractImage* abstractImage, std::size_t argumentCount) -> int
 		{
-			unsigned int argCount = std::min(lua.GetStackTop(), 6U);
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 6U);
-			int argIndex = 1;
+			int argIndex = 2;
 
 			std::size_t bufferSize = 0;
 			const Nz::UInt8* pixels = reinterpret_cast<const Nz::UInt8*>(lua.CheckString(argIndex++, &bufferSize));
@@ -93,25 +93,23 @@ namespace Ndk
 		});
 
 		/*********************************** Nz::Font **********************************/
-		fontClass.SetConstructor([] (Nz::LuaInstance& lua, Nz::FontRef* font, std::size_t argumentCount)
+		font.SetConstructor([] (Nz::LuaInstance& /*lua*/, Nz::FontRef* font, std::size_t /*argumentCount*/)
 		{
-			NazaraUnused(argumentCount);
-
 			Nz::PlacementNew(font, Nz::Font::New());
 			return true;
 		});
 
-		fontClass.BindMethod("ClearGlyphCache",    &Nz::Font::ClearGlyphCache);
+		font.BindMethod("ClearGlyphCache",    &Nz::Font::ClearGlyphCache);
-		fontClass.BindMethod("ClearKerningCache",  &Nz::Font::ClearKerningCache);
+		font.BindMethod("ClearKerningCache",  &Nz::Font::ClearKerningCache);
-		fontClass.BindMethod("ClearSizeInfoCache", &Nz::Font::ClearSizeInfoCache);
+		font.BindMethod("ClearSizeInfoCache", &Nz::Font::ClearSizeInfoCache);
 
-		fontClass.BindMethod("Destroy", &Nz::Font::Destroy);
+		font.BindMethod("Destroy", &Nz::Font::Destroy);
 
-		fontClass.BindMethod("GetCachedGlyphCount", [] (Nz::LuaInstance& lua, Nz::FontRef& instance) -> int
+		font.BindMethod("GetCachedGlyphCount", [] (Nz::LuaInstance& lua, Nz::FontRef& instance, std::size_t argumentCount) -> int
 		{
-			unsigned int argCount = std::min(lua.GetStackTop(), 2U);
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 2U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 0:
@@ -132,78 +130,78 @@ namespace Ndk
 			return 0;
 		});
 
-		fontClass.BindMethod("GetFamilyName",      &Nz::Font::GetFamilyName);
+		font.BindMethod("GetFamilyName",      &Nz::Font::GetFamilyName);
-		fontClass.BindMethod("GetKerning",         &Nz::Font::GetKerning);
+		font.BindMethod("GetKerning",         &Nz::Font::GetKerning);
-		fontClass.BindMethod("GetGlyphBorder",     &Nz::Font::GetGlyphBorder);
+		font.BindMethod("GetGlyphBorder",     &Nz::Font::GetGlyphBorder);
-		fontClass.BindMethod("GetMinimumStepSize", &Nz::Font::GetMinimumStepSize);
+		font.BindMethod("GetMinimumStepSize", &Nz::Font::GetMinimumStepSize);
-		fontClass.BindMethod("GetSizeInfo",        &Nz::Font::GetSizeInfo);
+		font.BindMethod("GetSizeInfo",        &Nz::Font::GetSizeInfo);
-		fontClass.BindMethod("GetStyleName",       &Nz::Font::GetStyleName);
+		font.BindMethod("GetStyleName",       &Nz::Font::GetStyleName);
 
-		fontClass.BindMethod("IsValid", &Nz::Font::IsValid);
+		font.BindMethod("IsValid", &Nz::Font::IsValid);
 
-		fontClass.BindMethod("Precache", (bool(Nz::Font::*)(unsigned int, Nz::UInt32, const Nz::String&) const) &Nz::Font::Precache);
+		font.BindMethod("Precache", (bool(Nz::Font::*)(unsigned int, Nz::UInt32, const Nz::String&) const) &Nz::Font::Precache);
 
-		fontClass.BindMethod("OpenFromFile", &Nz::Font::OpenFromFile, Nz::FontParams());
+		font.BindMethod("OpenFromFile", &Nz::Font::OpenFromFile, Nz::FontParams());
 
-		fontClass.BindMethod("SetGlyphBorder",     &Nz::Font::SetGlyphBorder);
+		font.BindMethod("SetGlyphBorder",     &Nz::Font::SetGlyphBorder);
-		fontClass.BindMethod("SetMinimumStepSize", &Nz::Font::SetMinimumStepSize);
+		font.BindMethod("SetMinimumStepSize", &Nz::Font::SetMinimumStepSize);
 
-		fontClass.BindStaticMethod("GetDefault",                &Nz::Font::GetDefault);
+		font.BindStaticMethod("GetDefault",                &Nz::Font::GetDefault);
-		fontClass.BindStaticMethod("GetDefaultGlyphBorder",     &Nz::Font::GetDefaultGlyphBorder);
+		font.BindStaticMethod("GetDefaultGlyphBorder",     &Nz::Font::GetDefaultGlyphBorder);
-		fontClass.BindStaticMethod("GetDefaultMinimumStepSize", &Nz::Font::GetDefaultMinimumStepSize);
+		font.BindStaticMethod("GetDefaultMinimumStepSize", &Nz::Font::GetDefaultMinimumStepSize);
 
-		fontClass.BindStaticMethod("SetDefaultGlyphBorder",     &Nz::Font::SetDefaultGlyphBorder);
+		font.BindStaticMethod("SetDefaultGlyphBorder",     &Nz::Font::SetDefaultGlyphBorder);
-		fontClass.BindStaticMethod("SetDefaultMinimumStepSize", &Nz::Font::SetDefaultMinimumStepSize);
+		font.BindStaticMethod("SetDefaultMinimumStepSize", &Nz::Font::SetDefaultMinimumStepSize);
 
 		/*********************************** Nz::Node **********************************/
-		nodeClass.BindMethod("GetBackward", &Nz::Node::GetBackward);
+		node.BindMethod("GetBackward", &Nz::Node::GetBackward);
 		//nodeClass.SetMethod("GetChilds", &Nz::Node::GetChilds);
-		nodeClass.BindMethod("GetDown", &Nz::Node::GetDown);
+		node.BindMethod("GetDown", &Nz::Node::GetDown);
-		nodeClass.BindMethod("GetForward", &Nz::Node::GetForward);
+		node.BindMethod("GetForward", &Nz::Node::GetForward);
-		nodeClass.BindMethod("GetInheritPosition", &Nz::Node::GetInheritPosition);
+		node.BindMethod("GetInheritPosition", &Nz::Node::GetInheritPosition);
-		nodeClass.BindMethod("GetInheritRotation", &Nz::Node::GetInheritRotation);
+		node.BindMethod("GetInheritRotation", &Nz::Node::GetInheritRotation);
-		nodeClass.BindMethod("GetInheritScale", &Nz::Node::GetInheritScale);
+		node.BindMethod("GetInheritScale", &Nz::Node::GetInheritScale);
-		nodeClass.BindMethod("GetInitialPosition", &Nz::Node::GetInitialPosition);
+		node.BindMethod("GetInitialPosition", &Nz::Node::GetInitialPosition);
 		//nodeClass.SetMethod("GetInitialRotation", &Nz::Node::GetInitialRotation);
-		nodeClass.BindMethod("GetInitialScale", &Nz::Node::GetInitialScale);
+		node.BindMethod("GetInitialScale", &Nz::Node::GetInitialScale);
-		nodeClass.BindMethod("GetLeft", &Nz::Node::GetLeft);
+		node.BindMethod("GetLeft", &Nz::Node::GetLeft);
-		nodeClass.BindMethod("GetNodeType", &Nz::Node::GetNodeType);
+		node.BindMethod("GetNodeType", &Nz::Node::GetNodeType);
 		//nodeClass.SetMethod("GetParent", &Nz::Node::GetParent);
-		nodeClass.BindMethod("GetPosition", &Nz::Node::GetPosition, Nz::CoordSys_Global);
+		node.BindMethod("GetPosition", &Nz::Node::GetPosition, Nz::CoordSys_Global);
-		nodeClass.BindMethod("GetRight", &Nz::Node::GetRight);
+		node.BindMethod("GetRight", &Nz::Node::GetRight);
 		//nodeClass.SetMethod("GetRotation", &Nz::Node::GetRotation, Nz::CoordSys_Global);
-		nodeClass.BindMethod("GetScale", &Nz::Node::GetScale, Nz::CoordSys_Global);
+		node.BindMethod("GetScale", &Nz::Node::GetScale, Nz::CoordSys_Global);
 		//nodeClass.SetMethod("GetTransformMatrix", &Nz::Node::GetTransformMatrix);
-		nodeClass.BindMethod("GetUp", &Nz::Node::GetUp);
+		node.BindMethod("GetUp", &Nz::Node::GetUp);
 
-		nodeClass.BindMethod("HasChilds", &Nz::Node::HasChilds);
+		node.BindMethod("HasChilds", &Nz::Node::HasChilds);
 
-		nodeClass.BindMethod("GetBackward", &Nz::Node::GetBackward);
+		node.BindMethod("GetBackward", &Nz::Node::GetBackward);
-		nodeClass.BindMethod("GetDown", &Nz::Node::GetDown);
+		node.BindMethod("GetDown", &Nz::Node::GetDown);
-		nodeClass.BindMethod("GetForward", &Nz::Node::GetForward);
+		node.BindMethod("GetForward", &Nz::Node::GetForward);
-		nodeClass.BindMethod("GetInheritPosition", &Nz::Node::GetInheritPosition);
+		node.BindMethod("GetInheritPosition", &Nz::Node::GetInheritPosition);
-		nodeClass.BindMethod("GetInheritRotation", &Nz::Node::GetInheritRotation);
+		node.BindMethod("GetInheritRotation", &Nz::Node::GetInheritRotation);
-		nodeClass.BindMethod("GetInheritScale", &Nz::Node::GetInheritScale);
+		node.BindMethod("GetInheritScale", &Nz::Node::GetInheritScale);
-		nodeClass.BindMethod("GetInitialPosition", &Nz::Node::GetInitialPosition);
+		node.BindMethod("GetInitialPosition", &Nz::Node::GetInitialPosition);
-		nodeClass.BindMethod("GetInitialRotation", &Nz::Node::GetInitialRotation);
+		node.BindMethod("GetInitialRotation", &Nz::Node::GetInitialRotation);
-		nodeClass.BindMethod("GetInitialScale", &Nz::Node::GetInitialScale);
+		node.BindMethod("GetInitialScale", &Nz::Node::GetInitialScale);
-		nodeClass.BindMethod("GetLeft", &Nz::Node::GetLeft);
+		node.BindMethod("GetLeft", &Nz::Node::GetLeft);
-		nodeClass.BindMethod("GetNodeType", &Nz::Node::GetNodeType);
+		node.BindMethod("GetNodeType", &Nz::Node::GetNodeType);
-		nodeClass.BindMethod("GetPosition", &Nz::Node::GetPosition, Nz::CoordSys_Global);
+		node.BindMethod("GetPosition", &Nz::Node::GetPosition, Nz::CoordSys_Global);
-		nodeClass.BindMethod("GetRight", &Nz::Node::GetRight);
+		node.BindMethod("GetRight", &Nz::Node::GetRight);
-		nodeClass.BindMethod("GetRotation", &Nz::Node::GetRotation, Nz::CoordSys_Global);
+		node.BindMethod("GetRotation", &Nz::Node::GetRotation, Nz::CoordSys_Global);
-		nodeClass.BindMethod("GetScale", &Nz::Node::GetScale, Nz::CoordSys_Global);
+		node.BindMethod("GetScale", &Nz::Node::GetScale, Nz::CoordSys_Global);
-		nodeClass.BindMethod("GetUp", &Nz::Node::GetUp);
+		node.BindMethod("GetUp", &Nz::Node::GetUp);
 
-		nodeClass.BindMethod("SetInitialPosition", (void(Nz::Node::*)(const Nz::Vector3f&)) &Nz::Node::SetInitialPosition);
+		node.BindMethod("SetInitialPosition", (void(Nz::Node::*)(const Nz::Vector3f&)) &Nz::Node::SetInitialPosition);
-		nodeClass.BindMethod("SetInitialRotation", (void(Nz::Node::*)(const Nz::Quaternionf&)) &Nz::Node::SetInitialRotation);
+		node.BindMethod("SetInitialRotation", (void(Nz::Node::*)(const Nz::Quaternionf&)) &Nz::Node::SetInitialRotation);
 
-		nodeClass.BindMethod("SetPosition", (void(Nz::Node::*)(const Nz::Vector3f&, Nz::CoordSys)) &Nz::Node::SetPosition, Nz::CoordSys_Local);
+		node.BindMethod("SetPosition", (void(Nz::Node::*)(const Nz::Vector3f&, Nz::CoordSys)) &Nz::Node::SetPosition, Nz::CoordSys_Local);
-		nodeClass.BindMethod("SetRotation", (void(Nz::Node::*)(const Nz::Quaternionf&, Nz::CoordSys)) &Nz::Node::SetRotation, Nz::CoordSys_Local);
+		node.BindMethod("SetRotation", (void(Nz::Node::*)(const Nz::Quaternionf&, Nz::CoordSys)) &Nz::Node::SetRotation, Nz::CoordSys_Local);
 
-		nodeClass.BindMethod("Move", [] (Nz::LuaInstance& lua, Nz::Node& node) -> int
+		node.BindMethod("Move", [] (Nz::LuaInstance& lua, Nz::Node& node, std::size_t /*argumentCount*/) -> int
 		{
-			int argIndex = 1;
+			int argIndex = 2;
 
 			Nz::Vector3f offset = lua.Check<Nz::Vector3f>(&argIndex);
 			Nz::CoordSys coordSys = lua.Check<Nz::CoordSys>(&argIndex, Nz::CoordSys_Local);
@@ -212,9 +210,9 @@ namespace Ndk
 			return 0;
 		});
 
-		nodeClass.BindMethod("Rotate", [] (Nz::LuaInstance& lua, Nz::Node& node) -> int
+		node.BindMethod("Rotate", [] (Nz::LuaInstance& lua, Nz::Node& node, std::size_t /*argumentCount*/) -> int
 		{
-			int argIndex = 1;
+			int argIndex = 2;
 
 			Nz::Quaternionf rotation = lua.Check<Nz::Quaternionf>(&argIndex);
 			Nz::CoordSys coordSys = lua.Check<Nz::CoordSys>(&argIndex, Nz::CoordSys_Local);
@@ -223,11 +221,11 @@ namespace Ndk
 			return 0;
 		});
 
-		nodeClass.BindMethod("Scale", [] (Nz::LuaInstance& lua, Nz::Node& node) -> int
+		node.BindMethod("Scale", [] (Nz::LuaInstance& lua, Nz::Node& node, std::size_t argumentCount) -> int
 		{
-			unsigned int argCount = std::min(lua.GetStackTop(), 4U);
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 4U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 1:
@@ -249,11 +247,11 @@ namespace Ndk
 			return 0;
 		});
 
-		nodeClass.BindMethod("SetScale", [] (Nz::LuaInstance& lua, Nz::Node& node) -> int
+		node.BindMethod("SetScale", [] (Nz::LuaInstance& lua, Nz::Node& node, std::size_t argumentCount) -> int
 		{
-			unsigned int argCount = std::min(lua.GetStackTop(), 4U);
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 4U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 1:
@@ -286,11 +284,11 @@ namespace Ndk
 			return 0;
 		});
 
-		nodeClass.BindMethod("SetInitialScale", [] (Nz::LuaInstance& lua, Nz::Node& node) -> int
+		node.BindMethod("SetInitialScale", [] (Nz::LuaInstance& lua, Nz::Node& node, std::size_t argumentCount) -> int
 		{
-			unsigned int argCount = std::min(lua.GetStackTop(), 4U);
+			std::size_t argCount = std::min<std::size_t>(argumentCount, 4U);
 
-			int argIndex = 1;
+			int argIndex = 2;
 			switch (argCount)
 			{
 				case 1:
@@ -323,7 +321,7 @@ namespace Ndk
 	void LuaBinding::RegisterUtility(Nz::LuaInstance& instance)
 	{
 		abstractImage.Register(instance);
-		fontClass.Register(instance);
+		font.Register(instance);
-		nodeClass.Register(instance);
+		node.Register(instance);
 	}
 }

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,12 +35,19 @@ namespace Ndk
 	* \param system PhysicsSystem to copy
 	*/
 
-	PhysicsSystem::PhysicsSystem(const PhysicsSystem& system) :
+	PhysicsSystem3D::PhysicsSystem3D(const PhysicsSystem3D& system) :
 	System(system),
 	m_world()
 	{
 	}
 
+	void PhysicsSystem3D::CreatePhysWorld() const
+	{
+		NazaraAssert(!m_world, "Physics world should not be created twice");
+
+		m_world = std::make_unique<Nz::PhysWorld3D>();
+	}
+
 	/*!
 	* \brief Operation to perform when entity is validated for the system
 	*
@@ -48,18 +55,21 @@ namespace Ndk
 	* \param justAdded Is the entity newly added
 	*/
 
-	void PhysicsSystem::OnEntityValidation(Entity* entity, bool justAdded)
+	void PhysicsSystem3D::OnEntityValidation(Entity* entity, bool justAdded)
 	{
-		// If entity has not been just added to the system, it is possible that it does not own to the right array
+		// It's possible our entity got revalidated because of the addition/removal of a PhysicsComponent3D
 		if (!justAdded)
 		{
-			// We take the inverted array from which the entity should belong to
+			// 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)
+			CreatePhysWorld();
 	}
 
 	/*!
@@ -68,16 +78,19 @@ namespace Ndk
 	* \param elapsedTime Delta time used for the update
 	*/
 
-	void PhysicsSystem::OnUpdate(float elapsedTime)
+	void PhysicsSystem3D::OnUpdate(float elapsedTime)
 	{
-		m_world.Step(elapsedTime);
+		if (!m_world)
+			return;
+
+		m_world->Step(elapsedTime);
 
 		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);
 		}
@@ -85,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();
@@ -121,5 +134,5 @@ namespace Ndk
 		}
 	}
 
-	SystemIndex PhysicsSystem::systemIndex;
+	SystemIndex PhysicsSystem3D::systemIndex;
 }

SDK/src/NDK/Systems/RenderSystem.cpp

@@ -147,7 +147,6 @@ namespace Ndk
 			for (const Ndk::EntityHandle& drawable : m_drawables)
 			{
 				GraphicsComponent& graphicsComponent = drawable->GetComponent<GraphicsComponent>();
-				NodeComponent& drawableNode = drawable->GetComponent<NodeComponent>();
 
 				graphicsComponent.AddToRenderQueue(renderQueue);
 			}
@@ -186,7 +185,7 @@ namespace Ndk
 	* \param viewer Viewer of the scene
 	*/
 
-	void RenderSystem::UpdateDirectionalShadowMaps(const Nz::AbstractViewer& viewer)
+	void RenderSystem::UpdateDirectionalShadowMaps(const Nz::AbstractViewer& /*viewer*/)
 	{
 		if (!m_shadowRT.IsValid())
 			m_shadowRT.Create();
@@ -217,7 +216,6 @@ namespace Ndk
 			for (const Ndk::EntityHandle& drawable : m_drawables)
 			{
 				GraphicsComponent& graphicsComponent = drawable->GetComponent<GraphicsComponent>();
-				NodeComponent& drawableNode = drawable->GetComponent<NodeComponent>();
 
 				graphicsComponent.AddToRenderQueue(renderQueue);
 			}
@@ -290,7 +288,6 @@ namespace Ndk
 						for (const Ndk::EntityHandle& drawable : m_drawables)
 						{
 							GraphicsComponent& graphicsComponent = drawable->GetComponent<GraphicsComponent>();
-							NodeComponent& drawableNode = drawable->GetComponent<NodeComponent>();
 
 							graphicsComponent.AddToRenderQueue(renderQueue);
 						}
@@ -318,7 +315,6 @@ namespace Ndk
 					for (const Ndk::EntityHandle& drawable : m_drawables)
 					{
 						GraphicsComponent& graphicsComponent = drawable->GetComponent<GraphicsComponent>();
-						NodeComponent& drawableNode = drawable->GetComponent<NodeComponent>();
 
 						graphicsComponent.AddToRenderQueue(renderQueue);
 					}

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/common.lua

@@ -312,7 +312,7 @@ function NazaraBuild:Execute()
 				if (toolTable.Kind == "library") then
 					targetdir(toolTable.TargetDirectory .. "/" .. makeLibDir .. "/x86")
 				elseif (toolTable.Kind == "plugin") then
-					targetdir("../plugins/" .. toolTable.Name .. "/lib/" .. makeLibDir .. "/x86")
+					targetdir("../plugins/lib/" .. makeLibDir .. "/x86")
 				end
 
 			configuration({"codeblocks or codelite or gmake", "x64"})
@@ -321,7 +321,7 @@ function NazaraBuild:Execute()
 				if (toolTable.Kind == "library") then
 					targetdir(toolTable.TargetDirectory .. "/" .. makeLibDir .. "/x64")
 				elseif (toolTable.Kind == "plugin") then
-					targetdir("../plugins/" .. toolTable.Name .. "/lib/" .. makeLibDir .. "/x64")
+					targetdir("../plugins/lib/" .. makeLibDir .. "/x64")
 				end
 
 			configuration({"vs*", "x32"})
@@ -330,7 +330,7 @@ function NazaraBuild:Execute()
 				if (toolTable.Kind == "library") then
 					targetdir(toolTable.TargetDirectory .. "/msvc/x86")
 				elseif (toolTable.Kind == "plugin") then
-					targetdir("../plugins/" .. toolTable.Name .. "/lib/msvc/x86")
+					targetdir("../plugins/lib/msvc/x86")
 				end
 
 			configuration({"vs*", "x64"})
@@ -339,7 +339,7 @@ function NazaraBuild:Execute()
 				if (toolTable.Kind == "library") then
 					targetdir(toolTable.TargetDirectory .. "/msvc/x64")
 				elseif (toolTable.Kind == "plugin") then
-					targetdir("../plugins/" .. toolTable.Name .. "/lib/msvc/x64")
+					targetdir("../plugins/lib/msvc/x64")
 				end
 
 			configuration({"xcode3 or xcode4", "x32"})
@@ -348,7 +348,7 @@ function NazaraBuild:Execute()
 				if (toolTable.Kind == "library") then
 					targetdir(toolTable.TargetDirectory .. "/xcode/x86")
 				elseif (toolTable.Kind == "plugin") then
-					targetdir("../plugins/" .. toolTable.Name .. "/lib/xcode/x86")
+					targetdir("../plugins/lib/xcode/x86")
 				end
 
 			configuration({"xcode3 or xcode4", "x64"})
@@ -357,7 +357,7 @@ function NazaraBuild:Execute()
 				if (toolTable.Kind == "library") then
 					targetdir(toolTable.TargetDirectory .. "/xcode/x64")
 				elseif (toolTable.Kind == "plugin") then
-					targetdir("../plugins/" .. toolTable.Name .. "/lib/xcode/x64")
+					targetdir("../plugins/lib/xcode/x64")
 				end
 
 			configuration("*Static")

build/scripts/modules/physics2d.lua

@@ -0,0 +1,6 @@
+MODULE.Name = "Physics2D"
+
+MODULE.Libraries = {
+	"NazaraCore",
+	"chipmunk-s"
+}

build/scripts/modules/physics3d.lua

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

build/scripts/tools/ndk_server.lua

@@ -46,6 +46,7 @@ TOOL.Libraries = {
 	"NazaraLua",
 	"NazaraNetwork",
 	"NazaraNoise",
-	"NazaraPhysics",
+	"NazaraPhysics2D",
+	"NazaraPhysics3D",
 	"NazaraUtility"
 }

build/scripts/tools/unittests.lua

@@ -14,7 +14,9 @@ TOOL.Includes = {
 
 TOOL.Files = {
 	"../tests/main.cpp",
+	"../tests/Engine/**.hpp",
 	"../tests/Engine/**.cpp",
+	"../tests/SDK/**.hpp",
 	"../tests/SDK/**.cpp"
 }
 

build/scripts/tools/unittests_server.lua

@@ -15,7 +15,9 @@ TOOL.Includes = {
 
 TOOL.Files = {
 	"../tests/main.cpp",
+	"../tests/Engine/**.hpp",
 	"../tests/Engine/**.cpp",
+	"../tests/SDK/**.hpp",
 	"../tests/SDK/**.cpp"
 }
 
@@ -23,6 +25,7 @@ TOOL.Files = {
 TOOL.FilesExcluded = {
 	"../tests/Engine/Audio/**",
 	"../tests/Engine/Graphics/**",
+	"../tests/Engine/Utility/**",
 	"../tests/SDK/NDK/Application.cpp",
 	"../tests/SDK/NDK/Systems/ListenerSystem.cpp",
 	"../tests/SDK/NDK/Systems/RenderSystem.cpp"

examples/Tut00/build.lua

@@ -13,7 +13,8 @@ EXAMPLE.Libraries = {
     "NazaraLua",
     "NazaraNetwork",
     "NazaraNoise",
-    "NazaraPhysics",
+    "NazaraPhysics2D",
+    "NazaraPhysics3D",
     "NazaraRenderer",
     "NazaraUtility",
     "NazaraSDK"

examples/Tut00/main.cpp

@@ -4,7 +4,8 @@
 #include <Nazara/Lua.hpp>
 #include <Nazara/Network.hpp>
 #include <Nazara/Noise.hpp>
-#include <Nazara/Physics.hpp>
+#include <Nazara/Physics2D.hpp>
+#include <Nazara/Physics3D.hpp>
 #include <Nazara/Renderer.hpp>
 #include <Nazara/Utility.hpp>
 #include <NDK/Application.hpp>

include/Nazara/Core/AbstractLogger.hpp

@@ -21,7 +21,7 @@ namespace Nz
 
 			virtual void EnableStdReplication(bool enable) = 0;
 
-			virtual bool IsStdReplicationEnabled() = 0;
+			virtual bool IsStdReplicationEnabled() const = 0;
 
 			virtual void Write(const String& string) = 0;
 			virtual void WriteError(ErrorType type, const String& error, unsigned int line = 0, const char* file = nullptr, const char* function = nullptr);

include/Nazara/Core/Algorithm.hpp

@@ -20,8 +20,8 @@ namespace Nz
 	class AbstractHash;
 	class ByteArray;
 
-	template<typename F, typename Tuple> auto Apply(F&& fn, Tuple&& t);
+	template<typename F, typename Tuple> decltype(auto) Apply(F&& fn, Tuple&& t);
-	template<typename O, typename F, typename Tuple> auto Apply(O& object, F&& fn, Tuple&& t);
+	template<typename O, typename F, typename Tuple> decltype(auto) Apply(O& object, F&& fn, Tuple&& t);
 	template<typename T> ByteArray ComputeHash(HashType hash, const T& v);
 	template<typename T> ByteArray ComputeHash(AbstractHash* hash, const T& v);
 	template<typename T, std::size_t N> constexpr std::size_t CountOf(T(&name)[N]) noexcept;

include/Nazara/Core/Algorithm.inl

@@ -19,13 +19,13 @@ namespace Nz
 	{
 		// http://www.cppsamples.com/common-tasks/apply-tuple-to-function.html
 		template<typename F, typename Tuple, size_t... S>
-		auto ApplyImplFunc(F&& fn, Tuple&& t, std::index_sequence<S...>)
+		decltype(auto) ApplyImplFunc(F&& fn, Tuple&& t, std::index_sequence<S...>)
 		{
 			return std::forward<F>(fn)(std::get<S>(std::forward<Tuple>(t))...);
 		}
 
 		template<typename O, typename F, typename Tuple, size_t... S>
-		auto ApplyImplMethod(O& object, F&& fn, Tuple&& t, std::index_sequence<S...>)
+		decltype(auto) ApplyImplMethod(O& object, F&& fn, Tuple&& t, std::index_sequence<S...>)
 		{
 			return (object .* std::forward<F>(fn))(std::get<S>(std::forward<Tuple>(t))...);
 		}
@@ -44,7 +44,7 @@ namespace Nz
 	* \see Apply
 	*/
 	template<typename F, typename Tuple>
-	auto Apply(F&& fn, Tuple&& t)
+	decltype(auto) Apply(F&& fn, Tuple&& t)
 	{
 		constexpr std::size_t tSize = std::tuple_size<typename std::remove_reference<Tuple>::type>::value;
 
@@ -63,7 +63,7 @@ namespace Nz
 	* \see Apply
 	*/
 	template<typename O, typename F, typename Tuple>
-	auto Apply(O& object, F&& fn, Tuple&& t)
+	decltype(auto) Apply(O& object, F&& fn, Tuple&& t)
 	{
 		constexpr std::size_t tSize = std::tuple_size<typename std::remove_reference<Tuple>::type>::value;
 
@@ -123,9 +123,8 @@ namespace Nz
 	* \see CountOf
 	*/
 	template<typename T, std::size_t N>
-	constexpr std::size_t CountOf(T(&name)[N]) noexcept
+	constexpr std::size_t CountOf(T(&)[N]) noexcept
 	{
-		// NazaraUnused(name); //< Because "body of function is not a return-statement" >.>
 		return N;
 	}
 

include/Nazara/Core/FileLogger.hpp

@@ -25,8 +25,8 @@ namespace Nz
 			void EnableTimeLogging(bool enable);
 			void EnableStdReplication(bool enable) override;
 
-			bool IsStdReplicationEnabled() override;
+			bool IsStdReplicationEnabled() const override;
-			bool IsTimeLoggingEnabled();
+			bool IsTimeLoggingEnabled() const;
 
 			void Write(const String& string) override;
 			void WriteError(ErrorType type, const String& error, unsigned int line = 0, const char* file = nullptr, const char* function = nullptr) override;

include/Nazara/Core/HandledObject.inl

@@ -71,6 +71,8 @@ namespace Nz
 	template<typename T>
 	HandledObject<T>& HandledObject<T>::operator=(const HandledObject& object)
 	{
+		NazaraUnused(object);
+
 		// Nothing to do
 		return *this; 
 	}

include/Nazara/Core/ObjectRef.hpp

@@ -56,7 +56,7 @@ namespace Nz
 	template<typename T> bool operator<(const T& lhs, const ObjectRef<T>& rhs);
 	template<typename T> bool operator<(const ObjectRef<T>& lhs, const T& rhs);
 
-	template<typename T> bool operator<=(const ObjectRef<T>, const ObjectRef<T>& rhs);
+	template<typename T> bool operator<=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs);
 	template<typename T> bool operator<=(const T& lhs, const ObjectRef<T>& rhs);
 	template<typename T> bool operator<=(const ObjectRef<T>& lhs, const T& rhs);
 

include/Nazara/Core/ResourceManager.inl

@@ -78,7 +78,7 @@ namespace Nz
 		while (it != Type::s_managerMap.end())
 		{
 			const ObjectRef<Type>& ref = it->second;
-			if (ref.GetReferenceCount() == 1) // Are we the only ones to own the resource ?
+			if (ref->GetReferenceCount() == 1) // Are we the only ones to own the resource ?
 			{
 				NazaraDebug("Purging resource from file " + ref->GetFilePath());
 				Type::s_managerMap.erase(it++); // Then we erase it

include/Nazara/Core/StdLogger.hpp

@@ -22,7 +22,7 @@ namespace Nz
 
 			void EnableStdReplication(bool enable) override;
 
-			bool IsStdReplicationEnabled() override;
+			bool IsStdReplicationEnabled() const override;
 
 			void Write(const String& string) override;
 			void WriteError(ErrorType type, const String& error, unsigned int line = 0, const char* file = nullptr, const char* function = nullptr) override;

include/Nazara/Graphics/TextSprite.hpp

@@ -78,7 +78,6 @@ namespace Nz
 			Color m_color;
 			MaterialRef m_material;
 			Recti m_localBounds;
-			mutable bool m_verticesUpdated;
 			float m_scale;
 
 			static TextSpriteLibrary::LibraryMap s_library;

include/Nazara/Lua/LuaClass.hpp

@@ -26,7 +26,7 @@ namespace Nz
 		friend class LuaClass;
 
 		public:
-			using ClassFunc = std::function<int(LuaInstance& lua, T& instance)>;
+			using ClassFunc = std::function<int(LuaInstance& lua, T& instance, std::size_t argumentCount)>;
 			using ClassIndexFunc = std::function<bool(LuaInstance& lua, T& instance)>;
 			using ConstructorFunc = std::function<bool(LuaInstance& lua, T* instance, std::size_t argumentCount)>;
 			template<typename P> using ConvertToParent = std::function<P*(T*)>;
@@ -34,6 +34,7 @@ namespace Nz
 			using StaticIndexFunc = std::function<bool(LuaInstance& lua)>;
 			using StaticFunc = std::function<int(LuaInstance& lua)>;
 
+			LuaClass() = default;
 			LuaClass(const String& name);
 
 			void BindDefaultConstructor();
@@ -50,6 +51,9 @@ namespace Nz
 			template<class P> void Inherit(LuaClass<P>& parent);
 			template<class P> void Inherit(LuaClass<P>& parent, ConvertToParent<P> convertFunc);
 
+			void Reset();
+			void Reset(const String& name);
+
 			void Register(LuaInstance& lua);
 
 			void PushGlobalTable(LuaInstance& lua);
@@ -62,6 +66,19 @@ namespace Nz
 			void SetStaticSetter(StaticIndexFunc getter);
 
 		private:
+			template<typename U, bool HasDestructor>
+			friend struct LuaClassImplFinalizerSetupProxy;
+
+			void PushClassInfo(LuaInstance& lua);
+			void SetupConstructor(LuaInstance& lua);
+			void SetupDefaultToString(LuaInstance& lua);
+			void SetupFinalizer(LuaInstance& lua);
+			void SetupGetter(LuaInstance& lua, LuaCFunction proxy);
+			void SetupGlobalTable(LuaInstance& lua);
+			void SetupMetatable(LuaInstance& lua);
+			void SetupMethod(LuaInstance& lua, LuaCFunction proxy, const String& name, std::size_t methodIndex);
+			void SetupSetter(LuaInstance& lua, LuaCFunction proxy);
+
 			using ParentFunc = std::function<void(LuaInstance& lua, T* instance)>;
 			using InstanceGetter = std::function<T*(LuaInstance& lua)>;
 

include/Nazara/Lua/LuaClass.inl

@@ -2,6 +2,7 @@
 // This file is part of the "Nazara Engine - Lua scripting module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
+#include <Nazara/Lua/LuaClass.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/MemoryHelper.hpp>
 #include <type_traits>
@@ -10,10 +11,9 @@
 namespace Nz
 {
 	template<class T>
-	LuaClass<T>::LuaClass(const String& name) :
+	LuaClass<T>::LuaClass(const String& name)
-	m_info(new ClassInfo)
 	{
-		m_info->name = name;
+		Reset(name);
 	}
 
 	template<class T>
@@ -58,147 +58,37 @@ namespace Nz
 		});
 	}
 
+
 	template<class T>
-	void LuaClass<T>::Register(LuaInstance& lua)
+	void LuaClass<T>::Reset()
 	{
-		// Le ClassInfo doit rester en vie jusqu'à la fin du script
+		m_info.reset();
-		// Obliger l'instance de LuaClass à rester en vie dans cette fin serait contraignant pour l'utilisateur
-		// J'utilise donc une astuce, la stocker dans une UserData associée avec chaque fonction de la metatable du type,
-		// cette UserData disposera d'un finalizer qui libérera le ClassInfo
-		// Ainsi c'est Lua qui va s'occuper de la destruction pour nous :-)
-		// De même, l'utilisation d'un shared_ptr permet de garder la structure en vie même si l'instance est libérée avant le LuaClass
-		std::shared_ptr<ClassInfo>* info = static_cast<std::shared_ptr<ClassInfo>*>(lua.PushUserdata(sizeof(std::shared_ptr<ClassInfo>)));
-		PlacementNew(info, m_info);
-
-		// On créé la table qui contiendra une méthode (Le finalizer) pour libérer le ClassInfo
-		lua.PushTable(0, 1);
-			lua.PushLightUserdata(info);
-			lua.PushCFunction(InfoDestructor, 1);
-			lua.SetField("__gc");
-		lua.SetMetatable(-2); // La table devient la metatable de l'UserData
-
-		// Maintenant, nous allons associer l'UserData avec chaque fonction, de sorte qu'il reste en vie
-		// aussi longtemps que nécessaire, et que le pointeur soit transmis à chaque méthode
-
-		if (!lua.NewMetatable(m_info->name))
-			NazaraWarning("Class \"" + m_info->name + "\" already registred in this instance");
-		{
-			// Set the type in a __type field
-			lua.PushString(m_info->name);
-			lua.SetField("__type");
-
-			// In case a __tostring method is missing, add a default implementation returning the type
-			if (m_methods.find("__tostring") == m_methods.end())
-			{
-				// Define the Finalizer
-				lua.PushValue(1); // shared_ptr on UserData
-				lua.PushCFunction(ToStringProxy, 1);
-				lua.SetField("__tostring");
 	}
 
-			// Define the Finalizer
+	template<class T>
-			lua.PushValue(1);
+	void LuaClass<T>::Reset(const String& name)
-			lua.PushCFunction(FinalizerProxy, 1);
-			lua.SetField("__gc");
-
-			if (m_info->getter || !m_info->parentGetters.empty())
 	{
-				lua.PushValue(1);  // shared_ptr on UserData
+		m_info = std::make_shared<ClassInfo>();
-				lua.PushValue(-2); // Metatable
+		m_info->name = name;
-				lua.PushCFunction(GetterProxy, 2);
-			}
-			else
-				// Optimisation, plutôt que de rediriger vers une fonction C qui ne fera rien d'autre que rechercher
-				// dans la table, nous envoyons directement la table, de sorte que Lua fasse directement la recherche
-				// Ceci n'est possible que si nous n'avons ni getter, ni parent
-				lua.PushValue(-1); // Metatable
-
-			lua.SetField("__index"); // Getter
-
-			if (m_info->setter)
-			{
-				lua.PushValue(1); // shared_ptr on UserData
-				lua.PushCFunction(SetterProxy, 1);
-				lua.SetField("__newindex"); // Setter
-			}
-
-			m_info->methods.reserve(m_methods.size());
-			for (auto& pair : m_methods)
-			{
-				std::size_t methodIndex = m_info->methods.size();
-				m_info->methods.push_back(pair.second);
-
-				lua.PushValue(1); // shared_ptr on UserData
-				lua.PushInteger(methodIndex);
-
-				lua.PushCFunction(MethodProxy, 2);
-				lua.SetField(pair.first); // Method name
-			}
 
 		m_info->instanceGetters[m_info->name] = [info = m_info] (LuaInstance& instance)
 		{
 			return static_cast<T*>(instance.CheckUserdata(1, info->name));
 		};
 	}
-		lua.Pop(); // On pop la metatable
 
-		if (m_info->constructor || m_info->staticGetter || m_info->staticSetter || !m_info->staticMethods.empty())
+	template<class T>
+	void LuaClass<T>::Register(LuaInstance& lua)
 	{
-			// Création de l'instance globale
+		PushClassInfo(lua);
-			lua.PushTable(); // Class = {}
 
-			// Création de la metatable associée à la table globale
+		// Let's create the metatable which will be associated with every instance.
-			lua.PushTable(); // ClassMeta = {}
+		SetupMetatable(lua);
 
-			if (m_info->constructor)
+		if (m_info->constructor || m_info->staticGetter || m_info->staticSetter || !m_staticMethods.empty())
-			{
+			SetupGlobalTable(lua);
-				lua.PushValue(1); // ClassInfo
-				lua.PushCFunction(ConstructorProxy, 1);
-				lua.SetField("__call"); // ClassMeta.__call = ConstructorProxy
-			}
 
-			if (m_info->staticGetter)
+		lua.Pop(); // Pop our ClassInfo, which is now referenced by all our functions
-			{
-				lua.PushValue(1);  // shared_ptr on UserData
-				lua.PushValue(-2); // ClassMeta
-				lua.PushCFunction(StaticGetterProxy, 2);
-			}
-			else
-				// Optimisation, plutôt que de rediriger vers une fonction C qui ne fera rien d'autre que rechercher
-				// dans la table, nous envoyons directement la table, de sorte que Lua fasse directement la recherche
-				// Ceci n'est possible que si nous n'avons ni getter, ni parent
-				lua.PushValue(-1); // ClassMeta
-
-			lua.SetField("__index"); // ClassMeta.__index = StaticGetterProxy/ClassMeta
-
-			if (m_info->staticSetter)
-			{
-				lua.PushValue(1); // shared_ptr on UserData
-				lua.PushCFunction(StaticSetterProxy, 1);
-				lua.SetField("__newindex"); // ClassMeta.__newindex = StaticSetterProxy
-			}
-
-			m_info->staticMethods.reserve(m_staticMethods.size());
-			for (auto& pair : m_staticMethods)
-			{
-				std::size_t methodIndex = m_info->staticMethods.size();
-				m_info->staticMethods.push_back(pair.second);
-
-				lua.PushValue(1); // shared_ptr on UserData
-				lua.PushInteger(methodIndex);
-
-				lua.PushCFunction(StaticMethodProxy, 2);
-				lua.SetField(pair.first); // ClassMeta.method = StaticMethodProxy
-			}
-
-			lua.SetMetatable(-2); // setmetatable(Class, ClassMeta)
-
-			lua.PushValue(-1); // Copie
-			lua.SetGlobal(m_info->name); // Class
-
-			m_info->globalTableRef = lua.CreateReference();
-		}
-		lua.Pop(); // On pop l'Userdata (contenant nos informations)
 	}
 
 	template<class T>
@@ -237,7 +127,7 @@ namespace Nz
 	{
 		typename LuaImplMethodProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
 
-		BindMethod(name, [func, handler] (LuaInstance& lua, T& object) -> int
+		BindMethod(name, [func, handler] (LuaInstance& lua, T& object, std::size_t /*argumentCount*/) -> int
 		{
 			handler.ProcessArgs(lua);
 
@@ -251,7 +141,7 @@ namespace Nz
 	{
 		typename LuaImplMethodProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
 
-		BindMethod(name, [func, handler] (LuaInstance& lua, T& object) -> int
+		BindMethod(name, [func, handler] (LuaInstance& lua, T& object, std::size_t /*argumentCount*/) -> int
 		{
 			handler.ProcessArgs(lua);
 
@@ -265,7 +155,7 @@ namespace Nz
 	{
 		typename LuaImplMethodProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
 
-		BindMethod(name, [func, handler] (LuaInstance& lua, T& object) -> int
+		BindMethod(name, [func, handler] (LuaInstance& lua, T& object, std::size_t /*argumentCount*/) -> int
 		{
 			handler.ProcessArgs(lua);
 
@@ -279,7 +169,7 @@ namespace Nz
 	{
 		typename LuaImplMethodProxy<Args...>::template Impl<DefArgs...> handler(std::forward<DefArgs>(defArgs)...);
 
-		BindMethod(name, [func, handler] (LuaInstance& lua, T& object) -> int
+		BindMethod(name, [func, handler] (LuaInstance& lua, T& object, std::size_t /*argumentCount*/) -> int
 		{
 			handler.ProcessArgs(lua);
 
@@ -325,6 +215,176 @@ namespace Nz
 		m_info->staticSetter = setter;
 	}
 
+	template<class T>
+	void LuaClass<T>::PushClassInfo(LuaInstance& lua)
+	{
+		// Our ClassInfo has to outlive the LuaClass, because we don't want to force the user to keep the LuaClass alive
+		// To do that, each Registration creates a tiny shared_ptr wrapper whose life is directly managed by Lua.
+		// This shared_ptr object gets pushed as a up-value for every proxy function set in the metatable.
+		// This way, there is no way our ClassInfo gets freed before any instance and the global class gets destroyed.
+		std::shared_ptr<ClassInfo>* info = static_cast<std::shared_ptr<ClassInfo>*>(lua.PushUserdata(sizeof(std::shared_ptr<ClassInfo>)));
+		PlacementNew(info, m_info);
+
+		// Setup a tiny metatable to let Lua know how to destroy our ClassInfo
+		lua.PushTable(0, 1);
+			lua.PushLightUserdata(info);
+			lua.PushCFunction(InfoDestructor, 1);
+			lua.SetField("__gc");
+		lua.SetMetatable(-2);
+	}
+
+	template<class T>
+	void LuaClass<T>::SetupConstructor(LuaInstance& lua)
+	{
+			lua.PushValue(1); // ClassInfo
+		lua.PushCFunction(ConstructorProxy, 1);
+		lua.SetField("__call"); // ClassMeta.__call = ConstructorProxy
+	}
+
+	template<class T>
+	void LuaClass<T>::SetupDefaultToString(LuaInstance& lua)
+	{
+			lua.PushValue(1); // shared_ptr on UserData
+		lua.PushCFunction(ToStringProxy, 1);
+		lua.SetField("__tostring");
+	}
+
+	template<typename T, bool HasDestructor>
+	struct LuaClassImplFinalizerSetupProxy;
+
+	template<typename T>
+	struct LuaClassImplFinalizerSetupProxy<T, true>
+	{
+		static void Setup(LuaInstance& lua)
+		{
+			lua.PushValue(1); // ClassInfo
+			lua.PushCFunction(LuaClass<T>::FinalizerProxy, 1);
+			lua.SetField("__gc");
+		}
+	};
+
+	template<typename T>
+	struct LuaClassImplFinalizerSetupProxy<T, false>
+	{
+		static void Setup(LuaInstance&)
+		{
+		}
+	};
+
+	template<class T>
+	void LuaClass<T>::SetupFinalizer(LuaInstance& lua)
+	{
+		LuaClassImplFinalizerSetupProxy<T, std::is_destructible<T>::value>::Setup(lua);
+	}
+
+	template<class T>
+	void LuaClass<T>::SetupGetter(LuaInstance& lua, LuaCFunction proxy)
+	{
+			lua.PushValue(1);  // ClassInfo
+			lua.PushValue(-2); // Metatable
+		lua.PushCFunction(proxy, 2);
+
+		lua.SetField("__index"); // Getter
+	}
+
+	template<class T>
+	void LuaClass<T>::SetupGlobalTable(LuaInstance& lua)
+	{
+		// Create the global table
+		lua.PushTable(); // Class = {}
+
+		// Create a metatable which will be used for our global table
+		lua.PushTable(); // ClassMeta = {}
+
+		if (m_info->constructor)
+			SetupConstructor(lua);
+
+		if (m_info->staticGetter)
+			SetupGetter(lua, StaticGetterProxy);
+		else
+		{
+			// Optimize by assigning the metatable instead of a search function
+			lua.PushValue(-1); // Metatable
+			lua.SetField("__index");
+		}
+
+		if (m_info->staticSetter)
+			SetupSetter(lua, StaticSetterProxy);
+
+		m_info->staticMethods.reserve(m_staticMethods.size());
+		for (auto& pair : m_staticMethods)
+		{
+			std::size_t methodIndex = m_info->staticMethods.size();
+			m_info->staticMethods.push_back(pair.second);
+
+			SetupMethod(lua, StaticMethodProxy, pair.first, methodIndex);
+		}
+
+		lua.SetMetatable(-2); // setmetatable(Class, ClassMeta), pops ClassMeta
+
+		lua.PushValue(-1); // As CreateReference() pops the table, push a copy
+		m_info->globalTableRef = lua.CreateReference();
+
+		lua.SetGlobal(m_info->name); // _G["Class"] = Class
+	}
+
+	template<class T>
+	void LuaClass<T>::SetupMetatable(LuaInstance& lua)
+	{
+		if (!lua.NewMetatable(m_info->name))
+			NazaraWarning("Class \"" + m_info->name + "\" already registred in this instance");
+		{
+			SetupFinalizer(lua);
+			
+			if (m_info->getter || !m_info->parentGetters.empty())
+				SetupGetter(lua, GetterProxy);
+			else
+			{
+				// Optimize by assigning the metatable instead of a search function
+				// This is only possible if we have no custom getter nor parent
+				lua.PushValue(-1); // Metatable
+				lua.SetField("__index");
+			}
+
+			if (m_info->setter)
+				SetupSetter(lua, SetterProxy);
+
+			// In case a __tostring method is missing, add a default implementation returning the class name
+			if (m_methods.find("__tostring") == m_methods.end())
+				SetupDefaultToString(lua);
+
+			m_info->methods.reserve(m_methods.size());
+			for (auto& pair : m_methods)
+			{
+				std::size_t methodIndex = m_info->methods.size();
+				m_info->methods.push_back(pair.second);
+
+				SetupMethod(lua, MethodProxy, pair.first, methodIndex);
+			}
+		}
+		lua.Pop(); //< Pops the metatable, it won't be collected before it's referenced by the Lua registry.
+	}
+
+	template<class T>
+	void LuaClass<T>::SetupMethod(LuaInstance& lua, LuaCFunction proxy, const String& name, std::size_t methodIndex)
+	{
+			lua.PushValue(1); // ClassInfo
+			lua.PushInteger(methodIndex);
+		lua.PushCFunction(proxy, 2);
+
+		lua.SetField(name); // Method name
+	}
+
+	template<class T>
+	void LuaClass<T>::SetupSetter(LuaInstance& lua, LuaCFunction proxy)
+	{
+			lua.PushValue(1); // ClassInfo
+		lua.PushCFunction(proxy, 1);
+
+		lua.SetField("__newindex"); // Setter
+	}
+
+
 	template<class T>
 	int LuaClass<T>::ConstructorProxy(lua_State* state)
 	{
@@ -389,7 +449,7 @@ namespace Nz
 		{
 			// Query from the metatable
 			lua.GetMetatable(info->name); //< Metatable
-			lua.PushValue(1); //< Field
+			lua.PushValue(2); //< Field
 			lua.GetTable(); // Metatable[Field]
 
 			lua.Remove(-2); // Remove Metatable
@@ -416,7 +476,6 @@ namespace Nz
 		std::shared_ptr<ClassInfo>& info = *static_cast<std::shared_ptr<ClassInfo>*>(lua.ToUserdata(lua.GetIndexOfUpValue(1)));
 
 		T* instance = static_cast<T*>(lua.CheckUserdata(1, info->name));
-		lua.Remove(1); //< Remove the instance from the Lua stack
 
 		Get(info, lua, instance);
 		return 1;
@@ -432,7 +491,7 @@ namespace Nz
 		T* instance = nullptr;
 		if (lua.GetMetatable(1))
 		{
-			LuaType type = lua.GetField("__type");
+			LuaType type = lua.GetField("__name");
 			if (type == LuaType_String)
 			{
 				String name = lua.ToString(-1);
@@ -441,8 +500,6 @@ namespace Nz
 					instance = it->second(lua);
 			}
 			lua.Pop(2);
-
-			lua.Remove(1); //< Remove the instance from the Lua stack
 		}
 
 		if (!instance)
@@ -451,9 +508,11 @@ namespace Nz
 			return 0;
 		}
 
+		std::size_t argCount = lua.GetStackTop() - 1U;
+
 		unsigned int index = static_cast<unsigned int>(lua.ToInteger(lua.GetIndexOfUpValue(2)));
 		const ClassFunc& method = info->methods[index];
-		return method(lua, *instance);
+		return method(lua, *instance, argCount);
 	}
 
 	template<class T>
@@ -465,7 +524,6 @@ namespace Nz
 		const ClassIndexFunc& setter = info->setter;
 
 		T& instance = *static_cast<T*>(lua.CheckUserdata(1, info->name));
-		lua.Remove(1); //< Remove the instance from the Lua stack
 
 		if (!setter(lua, instance))
 		{

include/Nazara/Lua/LuaInstance.hpp

@@ -34,10 +34,10 @@ namespace Nz
 			inline LuaInstance(LuaInstance&& instance) noexcept;
 			~LuaInstance();
 
-			void ArgCheck(bool condition, unsigned int argNum, const char* error);
+			void ArgCheck(bool condition, unsigned int argNum, const char* error) const;
-			void ArgCheck(bool condition, unsigned int argNum, const String& error);
+			void ArgCheck(bool condition, unsigned int argNum, const String& error) const;
-			int ArgError(unsigned int argNum, const char* error);
+			int ArgError(unsigned int argNum, const char* error) const;
-			int ArgError(unsigned int argNum, const String& error);
+			int ArgError(unsigned int argNum, const String& error) const;
 
 			bool Call(unsigned int argCount);
 			bool Call(unsigned int argCount, unsigned int resultCount);
@@ -123,6 +123,7 @@ namespace Nz
 			void Pop(unsigned int n = 1U) const;
 
 			template<typename T> int Push(T arg) const;
+			template<typename T, typename T2, typename... Args> int Push(T firstArg, T2 secondArg, Args... args) const;
 			void PushBoolean(bool value) const;
 			void PushCFunction(LuaCFunction func, unsigned int upvalueCount = 0) const;
 			template<typename T> void PushField(const char* name, T&& arg, int tableIndex = -2) const;

include/Nazara/Lua/LuaInstance.inl

@@ -209,6 +209,24 @@ namespace Nz
 		return LuaImplReplyVal(instance, val, TypeTag<T>());
 	}
 
+	template<typename T>
+	std::enable_if_t<!std::is_arithmetic<T>::value && !std::is_enum<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T&>)
+	{
+		return LuaImplReplyVal(instance, std::move(val), TypeTag<T>());
+	}
+
+	template<typename T>
+	std::enable_if_t<!std::is_arithmetic<T>::value && !std::is_enum<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<const T&>)
+	{
+		return LuaImplReplyVal(instance, std::move(val), TypeTag<T>());
+	}
+
+	template<typename T>
+	int LuaImplReplyVal(const LuaInstance& instance, T&& val, TypeTag<T&&>)
+	{
+		return LuaImplReplyVal(instance, std::forward<T>(val), TypeTag<T>());
+	}
+
 	inline int LuaImplReplyVal(const LuaInstance& instance, std::string&& val, TypeTag<std::string>)
 	{
 		instance.PushString(val.c_str(), val.size());
@@ -266,7 +284,7 @@ namespace Nz
 		template<std::size_t N, std::size_t FirstDefArg, typename ArgType, typename ArgContainer, typename DefArgContainer>
 		static unsigned int Process(const LuaInstance& instance, unsigned int argIndex, ArgContainer& args, DefArgContainer& defArgs)
 		{
-			return LuaImplQueryArg(instance, argIndex, &std::get<N>(args), std::get<std::tuple_size<DefArgContainer>() - N + FirstDefArg - 1>(defArgs), TypeTag<ArgType>());
+			return LuaImplQueryArg(instance, argIndex, &std::get<N>(args), std::get<FirstDefArg + std::tuple_size<DefArgContainer>() - N - 1>(defArgs), TypeTag<ArgType>());
 		}
 	};
 
@@ -375,7 +393,7 @@ namespace Nz
 
 					void ProcessArgs(const LuaInstance& instance) const
 					{
-						m_index = 1;
+						m_index = 2; //< 1 being the instance
 						ProcessArgs<0, Args...>(instance);
 					}
 
@@ -394,6 +412,19 @@ namespace Nz
 						return LuaImplReplyVal(instance, std::move(Apply(object, func, m_args)), TypeTag<decltype(Apply(object, func, m_args))>());
 					}
 
+					template<typename T, typename P>
+					std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaInstance& instance, T& object, T&(P::*func)(Args...)) const
+					{
+						T& r = Apply(object, func, m_args);
+						if (&r == &object)
+						{
+							instance.PushValue(1); //< Userdata
+							return 1;
+						}
+						else
+							return LuaImplReplyVal(instance, r, TypeTag<T&>());
+					}
+
 					template<typename T, typename P>
 					std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaInstance& instance, const T& object, void(P::*func)(Args...) const) const
 					{
@@ -409,11 +440,22 @@ namespace Nz
 						return LuaImplReplyVal(instance, std::move(Apply(object, func, m_args)), TypeTag<decltype(Apply(object, func, m_args))>());
 					}
 
+					template<typename T, typename P>
+					std::enable_if_t<std::is_base_of<P, T>::value, int> Invoke(const LuaInstance& instance, const T& object, const T&(P::*func)(Args...) const) const
+					{
+						const T& r = Apply(object, func, m_args);
+						if (&r == &object)
+						{
+							instance.PushValue(1); //< Userdata
+							return 1;
+						}
+						else
+							return LuaImplReplyVal(instance, r, TypeTag<T&>());
+					}
+
 					template<typename T, typename P>
 					std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaInstance& instance, T& object, void(P::*func)(Args...)) const
 					{
-						NazaraUnused(instance);
-
 						if (!object)
 						{
 							instance.Error("Invalid object");
@@ -436,11 +478,28 @@ namespace Nz
 						return LuaImplReplyVal(instance, std::move(Apply(*object, func, m_args)), TypeTag<decltype(Apply(*object, func, m_args))>());
 					}
 
+					template<typename T, typename P>
+					std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaInstance& instance, T& object, typename PointedType<T>::type&(P::*func)(Args...) const) const
+					{
+						if (!object)
+						{
+							instance.Error("Invalid object");
+							return 0;
+						}
+
+						const typename PointedType<T>::type& r = Apply(*object, func, m_args);
+						if (&r == &*object)
+						{
+							instance.PushValue(1); //< Userdata
+							return 1;
+						}
+						else
+							return LuaImplReplyVal(instance, r, TypeTag<T&>());
+					}
+
 					template<typename T, typename P>
 					std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaInstance& instance, const T& object, void(P::*func)(Args...) const) const
 					{
-						NazaraUnused(instance);
-
 						if (!object)
 						{
 							instance.Error("Invalid object");
@@ -463,6 +522,25 @@ namespace Nz
 						return LuaImplReplyVal(instance, std::move(Apply(*object, func, m_args)), TypeTag<decltype(Apply(*object, func, m_args))>());
 					}
 
+					template<typename T, typename P>
+					std::enable_if_t<std::is_base_of<P, typename PointedType<T>::type>::value, int> Invoke(const LuaInstance& instance, const T& object, const typename PointedType<T>::type&(P::*func)(Args...) const) const
+					{
+						if (!object)
+						{
+							instance.Error("Invalid object");
+							return 0;
+						}
+
+						const typename PointedType<T>::type& r = Apply(*object, func, m_args);
+						if (&r == &*object)
+						{
+							instance.PushValue(1); //< Userdata
+							return 1;
+						}
+						else
+							return LuaImplReplyVal(instance, r, TypeTag<T&>());
+					}
+
 				private:
 					using ArgContainer = std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...>;
 					using DefArgContainer = std::tuple<std::remove_cv_t<std::remove_reference_t<DefArgs>>...>;
@@ -606,6 +684,16 @@ namespace Nz
 		return LuaImplReplyVal(*this, std::move(arg), TypeTag<T>());
 	}
 
+	template<typename T, typename T2, typename... Args>
+	int LuaInstance::Push(T firstArg, T2 secondArg, Args... args) const
+	{
+		int valCount = 0;
+		valCount += Push(std::move(firstArg));
+		valCount += Push(secondArg, std::forward<Args>(args)...);
+
+		return valCount;
+	}
+
 	template<typename T>
 	void LuaInstance::PushField(const char* name, T&& arg, int tableIndex) const
 	{
@@ -648,7 +736,7 @@ namespace Nz
 	template<typename T>
 	void LuaInstance::PushInstance(const char* tname, const T& instance) const
 	{
-		T* userdata = static_cast<T*>(PushUserdata(sizeof(T*)));
+		T* userdata = static_cast<T*>(PushUserdata(sizeof(T)));
 		PlacementNew(userdata, instance);
 
 		SetMetatable(tname);
@@ -657,7 +745,7 @@ namespace Nz
 	template<typename T>
 	void LuaInstance::PushInstance(const char* tname, T&& instance) const
 	{
-		T* userdata = static_cast<T*>(PushUserdata(sizeof(T*)));
+		T* userdata = static_cast<T*>(PushUserdata(sizeof(T)));
 		PlacementNew(userdata, std::move(instance));
 
 		SetMetatable(tname);
@@ -666,7 +754,7 @@ namespace Nz
 	template<typename T, typename... Args>
 	void LuaInstance::PushInstance(const char* tname, Args&&... args) const
 	{
-		T* userdata = static_cast<T*>(PushUserdata(sizeof(T*)));
+		T* userdata = static_cast<T*>(PushUserdata(sizeof(T)));
 		PlacementNew(userdata, std::forward<Args>(args)...);
 
 		SetMetatable(tname);

include/Nazara/Math/Matrix4.inl

@@ -242,7 +242,7 @@ namespace Nz
 		}
 		#endif
 
-		T* ptr = (&m11) + column*4;
+		const T* ptr = (&m11) + column*4;
 		return Vector4<T>(ptr);
 	}
 
@@ -636,7 +636,7 @@ namespace Nz
 		}
 		#endif
 
-		T* ptr = &m11;
+		const T* ptr = &m11;
 		return Vector4<T>(ptr[row], ptr[row+4], ptr[row+8], ptr[row+12]);
 	}
 

include/Nazara/Math/Quaternion.inl

@@ -553,9 +553,9 @@ namespace Nz
 	template<typename T>
 	Vector3<T> Quaternion<T>::operator*(const Vector3<T>& vec) const
 	{
-		Vector3f quatVec(x, y, z);
+		Vector3<T> quatVec(x, y, z);
-		Vector3f uv = quatVec.CrossProduct(vec);
+		Vector3<T> uv = quatVec.CrossProduct(vec);
-		Vector3f uuv = quatVec.CrossProduct(uv);
+		Vector3<T> uuv = quatVec.CrossProduct(uv);
 		uv *= F(2.0) * w;
 		uuv *= F(2.0);
 

include/Nazara/Math/Vector2.hpp

@@ -8,6 +8,7 @@
 #define NAZARA_VECTOR2_HPP
 
 #include <Nazara/Core/String.hpp>
+#include <functional>
 
 namespace Nz
 {
@@ -119,6 +120,11 @@ template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Vecto
 template<typename T> Nz::Vector2<T> operator*(T scale, const Nz::Vector2<T>& vec);
 template<typename T> Nz::Vector2<T> operator/(T scale, const Nz::Vector2<T>& vec);
 
+namespace std
+{
+	template<class T> struct hash<Nz::Vector2<T>>;
+}
+
 #include <Nazara/Math/Vector2.inl>
 
 #endif // NAZARA_VECTOR2_HPP

include/Nazara/Math/Vector2.inl

@@ -1057,6 +1057,29 @@ Nz::Vector2<T> operator/(T scale, const Nz::Vector2<T>& vec)
 	return Nz::Vector2<T>(scale / vec.x, scale / vec.y);
 }
 
+namespace std
+{
+	template<class T>
+	struct hash<Nz::Vector2<T>>
+	{
+		/*!
+		* \brief Specialisation of std to hash
+		* \return Result of the hash
+		*
+		* \param v Vector2 to hash
+		*/
+		std::size_t operator()(const Nz::Vector2<T>& v) const
+		{
+			std::size_t seed {};
+
+			Nz::HashCombine(seed, v.x);
+			Nz::HashCombine(seed, v.y);
+
+			return seed;
+		}
+	};
+}
+	
 #undef F
 
 #include <Nazara/Core/DebugOff.hpp>

include/Nazara/Math/Vector3.hpp

@@ -8,6 +8,7 @@
 #define NAZARA_VECTOR3_HPP
 
 #include <Nazara/Core/String.hpp>
+#include <functional>
 
 namespace Nz
 {
@@ -141,6 +142,11 @@ template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Vecto
 template<typename T> Nz::Vector3<T> operator*(T scale, const Nz::Vector3<T>& vec);
 template<typename T> Nz::Vector3<T> operator/(T scale, const Nz::Vector3<T>& vec);
 
+namespace std
+{
+	template<class T> struct hash<Nz::Vector3<T>>;
+}
+
 #include <Nazara/Math/Vector3.inl>
 
 #endif // NAZARA_VECTOR3_HPP

include/Nazara/Math/Vector3.inl

@@ -1347,6 +1347,31 @@ Nz::Vector3<T> operator/(T scale, const Nz::Vector3<T>& vec)
 	return Nz::Vector3<T>(scale / vec.x, scale / vec.y, scale / vec.z);
 }
 
+namespace std
+{
+	template<class T>
+	struct hash<Nz::Vector3<T>>
+	{
+		/*!
+		* \brief Specialisation of std to hash
+		* \return Result of the hash
+		*
+		* \param v Vector3 to hash
+		*/
+
+		std::size_t operator()(const Nz::Vector3<T>& v) const
+		{
+			std::size_t seed {};
+
+			Nz::HashCombine(seed, v.x);
+			Nz::HashCombine(seed, v.y);
+			Nz::HashCombine(seed, v.z);
+
+			return seed;
+		}
+	};
+}
+	
 #undef F
 
 #include <Nazara/Core/DebugOff.hpp>

include/Nazara/Math/Vector4.hpp

@@ -8,6 +8,7 @@
 #define NAZARA_VECTOR4_HPP
 
 #include <Nazara/Core/String.hpp>
+#include <functional>
 
 namespace Nz
 {
@@ -117,6 +118,11 @@ template<typename T> std::ostream& operator<<(std::ostream& out, const Nz::Vecto
 template<typename T> Nz::Vector4<T> operator*(T scale, const Nz::Vector4<T>& vec);
 template<typename T> Nz::Vector4<T> operator/(T scale, const Nz::Vector4<T>& vec);
 
+namespace std
+{
+	template<class T> struct hash<Nz::Vector4<T>>;
+}
+
 #include <Nazara/Math/Vector4.inl>
 
 #endif // NAZARA_VECTOR4_HPP

include/Nazara/Math/Vector4.inl

@@ -1120,6 +1120,31 @@ Nz::Vector4<T> operator/(T scale, const Nz::Vector4<T>& vec)
 	return Nz::Vector4<T>(scale / vec.x, scale / vec.y, scale / vec.z, scale / vec.w);
 }
 
+namespace std
+{
+	template<class T>
+	struct hash<Nz::Vector4<T>>
+	{
+		/*!
+		* \brief Specialisation of std to hash
+		* \return Result of the hash
+		*
+		* \param v Vector4 to hash
+		*/
+		std::size_t operator()(const Nz::Vector4<T>& v) const
+		{
+			std::size_t seed {};
+
+			Nz::HashCombine(seed, v.x);
+			Nz::HashCombine(seed, v.y);
+			Nz::HashCombine(seed, v.z);
+			Nz::HashCombine(seed, v.w);
+
+			return seed;
+		}
+	};
+}
+	
 #undef F
 
 #include <Nazara/Core/DebugOff.hpp>

include/Nazara/Network/IpAddress.inl

@@ -56,7 +56,7 @@ namespace Nz
 	*/
 
 	inline IpAddress::IpAddress(const UInt8& a, const UInt8& b, const UInt8& c, const UInt8& d, UInt16 port) :
-	IpAddress(IPv4{a, b, c, d}, port)
+	IpAddress(IPv4{{a, b, c, d}}, port)
 	{
 	}
 
@@ -68,7 +68,7 @@ namespace Nz
 	*/
 
 	inline IpAddress::IpAddress(const UInt16& a, const UInt16& b, const UInt16& c, const UInt16& d, const UInt16& e, const UInt16& f, const UInt16& g, const UInt16& h, UInt16 port) :
-	IpAddress(IPv6{a, b, c, d, e, f, g, h}, port)
+	IpAddress(IPv6{{a, b, c, d, e, f, g, h}}, port)
 	{
 	}
 

include/Nazara/Network/TcpClient.hpp

@@ -79,8 +79,8 @@ namespace Nz
 			PendingPacket m_pendingPacket;
 			UInt64 m_keepAliveInterval;
 			UInt64 m_keepAliveTime;
-			bool m_isLowDelayEnabled;
 			bool m_isKeepAliveEnabled;
+			bool m_isLowDelayEnabled;
 	};
 }
 

include/Nazara/Noise/HybridMultiFractal.hpp

@@ -25,11 +25,6 @@ namespace Nz
 
 		private:
 			const NoiseBase& m_source;
-			float m_value;
-			float m_remainder;
-			float m_offset;
-			float m_weight;
-			float m_signal;
 	};
 }
 

include/Nazara/Physics/Enums.hpp

@@ -1,27 +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_ENUMS_PHYSICS_HPP
-#define NAZARA_ENUMS_PHYSICS_HPP
-
-enum GeomType
-{
-	GeomType_Box,
-	GeomType_Capsule,
-	GeomType_Cone,
-	GeomType_Compound,
-	GeomType_ConvexHull,
-	GeomType_Cylinder,
-	GeomType_Heightfield,
-	GeomType_Null,
-	GeomType_Scene,
-	GeomType_Sphere,
-	GeomType_Tree,
-
-	GeomType_Max = GeomType_Tree
-};
-
-#endif // NAZARA_ENUMS_PHYSICS_HPP

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/Physics2D.hpp

@@ -1,7 +1,7 @@
-// This file was automatically generated on 24 Jun 2015 at 13:55:50
+// This file was automatically generated on 14 Oct 2016 at 18:58:18
 
 /*
-	Nazara Engine - Physics module
+	Nazara Engine - Physics 2D module
 
 	Copyright (C) 2015 Jérôme "Lynix" Leclercq (Lynix680@gmail.com)
 
@@ -26,14 +26,14 @@
 
 #pragma once
 
-#ifndef NAZARA_GLOBAL_PHYSICS_HPP
+#ifndef NAZARA_GLOBAL_PHYSICS2D_HPP
-#define NAZARA_GLOBAL_PHYSICS_HPP
+#define NAZARA_GLOBAL_PHYSICS2D_HPP
 
-#include <Nazara/Physics/Config.hpp>
+#include <Nazara/Physics2D/PhysWorld2D.hpp>
-#include <Nazara/Physics/Enums.hpp>
+#include <Nazara/Physics2D/Physics2D.hpp>
-#include <Nazara/Physics/Geom.hpp>
+#include <Nazara/Physics2D/Collider2D.hpp>
-#include <Nazara/Physics/Physics.hpp>
+#include <Nazara/Physics2D/Enums.hpp>
-#include <Nazara/Physics/PhysObject.hpp>
+#include <Nazara/Physics2D/Config.hpp>
-#include <Nazara/Physics/PhysWorld.hpp>
+#include <Nazara/Physics2D/RigidBody2D.hpp>
 
-#endif // NAZARA_GLOBAL_PHYSICS_HPP
+#endif // NAZARA_GLOBAL_PHYSICS2D_HPP

include/Nazara/Physics2D/Collider2D.hpp

@@ -0,0 +1,132 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Physics 2D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_COLLIDER2D_HPP
+#define NAZARA_COLLIDER2D_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
+#include <Nazara/Core/ObjectLibrary.hpp>
+#include <Nazara/Core/Signal.hpp>
+#include <Nazara/Math/Rect.hpp>
+#include <Nazara/Math/Vector2.hpp>
+#include <Nazara/Physics2D/Config.hpp>
+#include <Nazara/Physics2D/Enums.hpp>
+#include <vector>
+
+struct cpShape;
+struct cpSpace;
+
+namespace Nz
+{
+	class Collider2D;
+	class RigidBody2D;
+
+	using Collider2DConstRef = ObjectRef<const Collider2D>;
+	using Collider2DLibrary = ObjectLibrary<Collider2D>;
+	using Collider2DRef = ObjectRef<Collider2D>;
+
+	class NAZARA_PHYSICS2D_API Collider2D : public RefCounted
+	{
+		friend Collider2DLibrary;
+		friend RigidBody2D;
+
+		public:
+			Collider2D() = default;
+			Collider2D(const Collider2D&) = delete;
+			Collider2D(Collider2D&&) = delete;
+			virtual ~Collider2D();
+
+			virtual float ComputeInertialMatrix(float mass) const = 0;
+
+			virtual ColliderType2D GetType() const = 0;
+
+			Collider2D& operator=(const Collider2D&) = delete;
+			Collider2D& operator=(Collider2D&&) = delete;
+
+			// Signals:
+			NazaraSignal(OnColliderRelease, const Collider2D* /*collider*/);
+
+		protected:
+			virtual std::vector<cpShape*> CreateShapes(RigidBody2D* body) const = 0;
+
+			static Collider2DLibrary::LibraryMap s_library;
+	};
+
+	class BoxCollider2D;
+
+	using BoxCollider2DConstRef = ObjectRef<const BoxCollider2D>;
+	using BoxCollider2DRef = ObjectRef<BoxCollider2D>;
+
+	class NAZARA_PHYSICS2D_API BoxCollider2D : public Collider2D
+	{
+		public:
+			BoxCollider2D(const Vector2f& size, float radius = 0.f);
+			BoxCollider2D(const Rectf& rect, float radius = 0.f);
+
+			float ComputeInertialMatrix(float mass) const override;
+
+			inline const Rectf& GetRect() const;
+			inline Vector2f GetSize() const;
+			ColliderType2D GetType() const override;
+
+			template<typename... Args> static BoxCollider2DRef New(Args&&... args);
+
+		private:
+			std::vector<cpShape*> CreateShapes(RigidBody2D* body) const override;
+
+			Rectf m_rect;
+			float m_radius;
+	};
+
+	class CircleCollider2D;
+
+	using CircleCollider2DConstRef = ObjectRef<const CircleCollider2D>;
+	using CircleCollider2DRef = ObjectRef<CircleCollider2D>;
+
+	class NAZARA_PHYSICS2D_API CircleCollider2D : public Collider2D
+	{
+		public:
+			CircleCollider2D(float radius, const Vector2f& offset = Vector2f::Zero());
+
+			float ComputeInertialMatrix(float mass) const override;
+
+			inline float GetRadius() const;
+			ColliderType2D GetType() const override;
+
+			template<typename... Args> static CircleCollider2DRef New(Args&&... args);
+
+		private:
+			std::vector<cpShape*> CreateShapes(RigidBody2D* body) const override;
+
+			Vector2f m_offset;
+			float m_radius;
+	};
+
+	class NullCollider2D;
+
+	using NullCollider2DConstRef = ObjectRef<const NullCollider2D>;
+	using NullCollider2DRef = ObjectRef<NullCollider2D>;
+
+	class NAZARA_PHYSICS2D_API NullCollider2D : public Collider2D
+	{
+		public:
+			NullCollider2D() = default;
+
+			float ComputeInertialMatrix(float mass) const override;
+
+			ColliderType2D GetType() const override;
+
+			template<typename... Args> static NullCollider2DRef New(Args&&... args);
+
+		private:
+			std::vector<cpShape*> CreateShapes(RigidBody2D* body) const override;
+	};
+}
+
+#include <Nazara/Physics2D/Collider2D.inl>
+
+#endif // NAZARA_COLLIDER2D_HPP

include/Nazara/Physics2D/Collider2D.inl

@@ -0,0 +1,54 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Physics 2D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <memory>
+#include <Nazara/Physics2D/Debug.hpp>
+
+namespace Nz
+{
+	inline const Rectf& BoxCollider2D::GetRect() const
+	{
+		return m_rect;
+	}
+
+	inline Vector2f BoxCollider2D::GetSize() const
+	{
+		return m_rect.GetLengths();
+	}
+
+	template<typename... Args>
+	BoxCollider2DRef BoxCollider2D::New(Args&&... args)
+	{
+		std::unique_ptr<BoxCollider2D> object(new BoxCollider2D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	inline float CircleCollider2D::GetRadius() const
+	{
+		return m_radius;
+	}
+
+	template<typename... Args>
+	CircleCollider2DRef CircleCollider2D::New(Args&&... args)
+	{
+		std::unique_ptr<CircleCollider2D> object(new CircleCollider2D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+	template<typename... Args>
+	NullCollider2DRef NullCollider2D::New(Args&&... args)
+	{
+		std::unique_ptr<NullCollider2D> object(new NullCollider2D(std::forward<Args>(args)...));
+		object->SetPersistent(false);
+
+		return object.release();
+	}
+
+}
+
+#include <Nazara/Physics2D/DebugOff.hpp>

include/Nazara/Physics2D/Config.hpp

@@ -1,5 +1,5 @@
 /*
-	Nazara Engine - Physics module
+	Nazara Engine - Physics 2D 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_PHYSICS2D_HPP
-#define NAZARA_CONFIG_PHYSICS_HPP
+#define NAZARA_CONFIG_PHYSICS2D_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_PHYSICS2D_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_PHYSICS2D_SAFE 1
 
 /// Vérification des valeurs et types de certaines constantes
-#include <Nazara/Physics/ConfigCheck.hpp>
+#include <Nazara/Physics2D/ConfigCheck.hpp>
 
 #if defined(NAZARA_STATIC)
-	#define NAZARA_PHYSICS_API
+	#define NAZARA_PHYSICS2D_API
 #else
-	#ifdef NAZARA_PHYSICS_BUILD
+	#ifdef NAZARA_PHYSICS2D_BUILD
-		#define NAZARA_PHYSICS_API NAZARA_EXPORT
+		#define NAZARA_PHYSICS2D_API NAZARA_EXPORT
 	#else
-		#define NAZARA_PHYSICS_API NAZARA_IMPORT
+		#define NAZARA_PHYSICS2D_API NAZARA_IMPORT
 	#endif
 #endif
 
-#endif // NAZARA_CONFIG_PHYSICS_HPP
+#endif // NAZARA_CONFIG_PHYSICS3D_HPP

include/Nazara/Physics2D/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 2D 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/Physics2D/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 2D 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/Physics2D/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 2D 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/Physics2D/Enums.hpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Physics 2D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_ENUMS_PHYSICS2D_HPP
+#define NAZARA_ENUMS_PHYSICS2D_HPP
+
+namespace Nz
+{
+	enum ColliderType2D
+	{
+		ColliderType2D_Box,
+		ColliderType2D_Convex,
+		ColliderType2D_Circle,
+		ColliderType2D_Null,
+		ColliderType2D_Segment,
+
+		ColliderType2D_Max = ColliderType2D_Segment
+	};
+}
+
+#endif // NAZARA_ENUMS_PHYSICS2D_HPP

include/Nazara/Physics2D/PhysWorld2D.hpp

@@ -0,0 +1,46 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Physics 2D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_PHYSWORLD2D_HPP
+#define NAZARA_PHYSWORLD2D_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Math/Vector2.hpp>
+#include <Nazara/Physics2D/Config.hpp>
+
+struct cpSpace;
+
+namespace Nz
+{
+	class NAZARA_PHYSICS2D_API PhysWorld2D
+	{
+		public:
+			PhysWorld2D();
+			PhysWorld2D(const PhysWorld2D&) = delete;
+			PhysWorld2D(PhysWorld2D&&) = delete; ///TODO
+			~PhysWorld2D();
+
+			Vector2f GetGravity() const;
+			cpSpace* GetHandle() const;
+			float GetStepSize() const;
+
+			void SetGravity(const Vector2f& gravity);
+			void SetSolverModel(unsigned int model);
+			void SetStepSize(float stepSize);
+
+			void Step(float timestep);
+
+			PhysWorld2D& operator=(const PhysWorld2D&) = delete;
+			PhysWorld2D& operator=(PhysWorld2D&&) = delete; ///TODO
+
+		private:
+			cpSpace* m_handle;
+			float m_stepSize;
+			float m_timestepAccumulator;
+	};
+}
+
+#endif // NAZARA_PHYSWORLD2D_HPP

include/Nazara/Physics2D/Physics2D.hpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Physics 2D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_PHYSICS2D_HPP
+#define NAZARA_PHYSICS2D_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/Initializer.hpp>
+#include <Nazara/Physics2D/Config.hpp>
+
+namespace Nz
+{
+	class NAZARA_PHYSICS2D_API Physics2D
+	{
+		public:
+			Physics2D() = delete;
+			~Physics2D() = delete;
+
+			static bool Initialize();
+
+			static bool IsInitialized();
+
+			static void Uninitialize();
+
+		private:
+			static unsigned int s_moduleReferenceCounter;
+	};
+}
+
+#endif // NAZARA_PHYSICS2D_HPP

include/Nazara/Physics2D/RigidBody2D.hpp

@@ -0,0 +1,74 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Physics 2D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_RIGIDBODY2D_HPP
+#define NAZARA_RIGIDBODY2D_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/Enums.hpp>
+#include <Nazara/Math/Matrix4.hpp>
+#include <Nazara/Math/Quaternion.hpp>
+#include <Nazara/Math/Rect.hpp>
+#include <Nazara/Math/Vector3.hpp>
+#include <Nazara/Physics2D/Config.hpp>
+#include <Nazara/Physics2D/Collider2D.hpp>
+
+struct cpBody;
+
+namespace Nz
+{
+	class PhysWorld2D;
+
+	class NAZARA_PHYSICS2D_API RigidBody2D
+	{
+		public:
+			RigidBody2D(PhysWorld2D* world, float mass);
+			RigidBody2D(PhysWorld2D* world, float mass, Collider2DRef geom);
+			RigidBody2D(const RigidBody2D& object);
+			RigidBody2D(RigidBody2D&& object);
+			~RigidBody2D();
+
+			void AddForce(const Vector2f& force, CoordSys coordSys = CoordSys_Global);
+			void AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys = CoordSys_Global);
+			void AddTorque(float torque);
+
+			Rectf GetAABB() const;
+			float GetAngularVelocity() const;
+			Vector2f GetCenterOfGravity(CoordSys coordSys = CoordSys_Local) const;
+			const Collider2DRef& GetGeom() const;
+			cpBody* GetHandle() const;
+			float GetMass() const;
+			Vector2f GetPosition() const;
+			float GetRotation() const;
+			Vector2f GetVelocity() const;
+
+			bool IsMoveable() const;
+			bool IsSleeping() const;
+
+			void SetAngularVelocity(float angularVelocity);
+			void SetMass(float mass);
+			void SetMassCenter(const Vector2f& center);
+			void SetPosition(const Vector2f& position);
+			void SetRotation(float rotation);
+			void SetVelocity(const Vector2f& velocity);
+
+			RigidBody2D& operator=(const RigidBody2D& object);
+			RigidBody2D& operator=(RigidBody2D&& object);
+
+		private:
+			void Destroy();
+			void SetGeom(Collider2DRef geom);
+
+			std::vector<cpShape*> m_shapes;
+			Collider2DRef m_geom;
+			cpBody* m_handle;
+			PhysWorld2D* m_world;
+			float m_gravityFactor;
+			float m_mass;
+	};
+}
+
+#endif // NAZARA_RIGIDBODY3D_HPP

include/Nazara/Physics3D.hpp

@@ -0,0 +1,39 @@
+// This file was automatically generated on 14 Oct 2016 at 18:58:18
+
+/*
+	Nazara Engine - Physics 3D module
+
+	Copyright (C) 2015 Jérôme "Lynix" Leclercq (Lynix680@gmail.com)
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy of
+	this software and associated documentation files (the "Software"), to deal in
+	the Software without restriction, including without limitation the rights to
+	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+	of the Software, and to permit persons to whom the Software is furnished to do
+	so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in all
+	copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+	SOFTWARE.
+*/
+
+#pragma once
+
+#ifndef NAZARA_GLOBAL_PHYSICS3D_HPP
+#define NAZARA_GLOBAL_PHYSICS3D_HPP
+
+#include <Nazara/Physics3D/PhysWorld3D.hpp>
+#include <Nazara/Physics3D/Physics3D.hpp>
+#include <Nazara/Physics3D/RigidBody3D.hpp>
+#include <Nazara/Physics3D/Enums.hpp>
+#include <Nazara/Physics3D/Config.hpp>
+#include <Nazara/Physics3D/Collider3D.hpp>
+
+#endif // NAZARA_GLOBAL_PHYSICS3D_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/Core/SparsePtr.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 ColliderType3D 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;
+			ColliderType3D 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;
+			ColliderType3D 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;
+			ColliderType3D 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;
+			ColliderType3D 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(SparsePtr<const Vector3f> vertices, unsigned int vertexCount, float tolerance = 0.002f, const Matrix4f& transformMatrix = Matrix4f::Identity());
+			ConvexCollider3D(SparsePtr<const Vector3f> vertices, unsigned int vertexCount, float tolerance, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
+
+			ColliderType3D 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;
+	};
+
+	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;
+			ColliderType3D 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;
+
+			ColliderType3D 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;
+			ColliderType3D 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

@@ -0,0 +1,51 @@
+/*
+	Nazara Engine - Physics 3D module
+
+	Copyright (C) 2015 Jérôme "Lynix" Leclercq (Lynix680@gmail.com)
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy of
+	this software and associated documentation files (the "Software"), to deal in
+	the Software without restriction, including without limitation the rights to
+	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+	of the Software, and to permit persons to whom the Software is furnished to do
+	so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in all
+	copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+	SOFTWARE.
+*/
+
+#pragma once
+
+#ifndef NAZARA_CONFIG_PHYSICS3D_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_PHYSICS3D_MANAGE_MEMORY 0
+
+// Active les tests de sécurité basés sur le code (Conseillé pour le développement)
+#define NAZARA_PHYSICS3D_SAFE 1
+
+/// Vérification des valeurs et types de certaines constantes
+#include <Nazara/Physics3D/ConfigCheck.hpp>
+
+#if defined(NAZARA_STATIC)
+	#define NAZARA_PHYSICS3D_API
+#else
+	#ifdef NAZARA_PHYSICS3D_BUILD
+		#define NAZARA_PHYSICS3D_API NAZARA_EXPORT
+	#else
+		#define NAZARA_PHYSICS3D_API NAZARA_IMPORT
+	#endif
+#endif
+
+#endif // NAZARA_CONFIG_PHYSICS3D_HPP

include/Nazara/Physics3D/ConfigCheck.hpp

@@ -0,0 +1,18 @@
+// 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_CONFIG_CHECK_PHYSICS_HPP
+#define NAZARA_CONFIG_CHECK_PHYSICS_HPP
+
+/// Ce fichier sert à vérifier la valeur des constantes du fichier Config.hpp
+
+// 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_PHYSICS3D_MANAGE_MEMORY 0
+#endif
+
+#endif // NAZARA_CONFIG_CHECK_PHYSICS_HPP

include/Nazara/Physics3D/Debug.hpp

@@ -0,0 +1,8 @@
+// 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 <Nazara/Physics3D/Config.hpp>
+#if NAZARA_PHYSICS_MANAGE_MEMORY
+	#include <Nazara/Core/Debug/NewRedefinition.hpp>
+#endif

include/Nazara/Physics3D/DebugOff.hpp

@@ -0,0 +1,9 @@
+// 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
+
+// On suppose que Debug.hpp a déjà été inclus, tout comme Config.hpp
+#if NAZARA_PHYSICS_MANAGE_MEMORY
+	#undef delete
+	#undef new
+#endif

include/Nazara/Physics3D/Enums.hpp

@@ -0,0 +1,30 @@
+// 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_ENUMS_PHYSICS3D_HPP
+#define NAZARA_ENUMS_PHYSICS3D_HPP
+
+namespace Nz
+{
+	enum ColliderType3D
+	{
+		ColliderType3D_Box,
+		ColliderType3D_Capsule,
+		ColliderType3D_Cone,
+		ColliderType3D_Compound,
+		ColliderType3D_ConvexHull,
+		ColliderType3D_Cylinder,
+		ColliderType3D_Heightfield,
+		ColliderType3D_Null,
+		ColliderType3D_Scene,
+		ColliderType3D_Sphere,
+		ColliderType3D_Tree,
+
+		ColliderType3D_Max = ColliderType3D_Tree
+	};
+};
+
+#endif // NAZARA_ENUMS_PHYSICS3D_HPP

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

include/Nazara/Renderer/Texture.hpp

@@ -10,7 +10,6 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/ObjectLibrary.hpp>
 #include <Nazara/Core/ObjectRef.hpp>
-#include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceManager.hpp>
 #include <Nazara/Core/Signal.hpp>
@@ -31,7 +30,7 @@ namespace Nz
 
 	struct TextureImpl;
 
-	class NAZARA_RENDERER_API Texture : public AbstractImage, public RefCounted, public Resource
+	class NAZARA_RENDERER_API Texture : public AbstractImage, public Resource
 	{
 		friend TextureLibrary;
 		friend TextureManager;
@@ -54,16 +53,16 @@ namespace Nz
 
 			void EnsureMipmapsUpdate() const;
 
-			unsigned int GetDepth(UInt8 level = 0) const;
+			unsigned int GetDepth(UInt8 level = 0) const override;
-			PixelFormatType GetFormat() const;
+			PixelFormatType GetFormat() const override;
-			unsigned int GetHeight(UInt8 level = 0) const;
+			unsigned int GetHeight(UInt8 level = 0) const override;
-			UInt8 GetLevelCount() const;
+			UInt8 GetLevelCount() const override;
-			UInt8 GetMaxLevel() const;
+			UInt8 GetMaxLevel() const override;
-			std::size_t GetMemoryUsage() const;
+			std::size_t GetMemoryUsage() const override;
-			std::size_t GetMemoryUsage(UInt8 level) const;
+			std::size_t GetMemoryUsage(UInt8 level) const override;
-			Vector3ui GetSize(UInt8 level = 0) const;
+			Vector3ui GetSize(UInt8 level = 0) const override;
-			ImageType GetType() const;
+			ImageType GetType() const override;
-			unsigned int GetWidth(UInt8 level = 0) const;
+			unsigned int GetWidth(UInt8 level = 0) const override;
 
 			bool HasMipmaps() const;
 
@@ -102,9 +101,9 @@ namespace Nz
 			bool Update(const Image& image, UInt8 level = 0);
 			bool Update(const Image& image, const Boxui& box, UInt8 level = 0);
 			bool Update(const Image& image, const Rectui& rect, unsigned int z = 0, UInt8 level = 0);
-			bool Update(const UInt8* pixels, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0);
+			bool Update(const UInt8* pixels, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) override;
-			bool Update(const UInt8* pixels, const Boxui& box, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0);
+			bool Update(const UInt8* pixels, const Boxui& box, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) override;
-			bool Update(const UInt8* pixels, const Rectui& rect, unsigned int z = 0, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0);
+			bool Update(const UInt8* pixels, const Rectui& rect, unsigned int z = 0, unsigned int srcWidth = 0, unsigned int srcHeight = 0, UInt8 level = 0) override;
 
 			// Fonctions OpenGL
 			unsigned int GetOpenGLID() const;

include/Nazara/Utility/AbstractImage.hpp

@@ -8,6 +8,7 @@
 #define NAZARA_ABSTRACTIMAGE_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Math/Rect.hpp>
 #include <Nazara/Math/Vector3.hpp>
@@ -16,10 +17,16 @@
 
 namespace Nz
 {
-	class NAZARA_UTILITY_API AbstractImage
+	class AbstractImage;
+
+	using AbstractImageConstRef = ObjectRef<const AbstractImage>;
+	using AbstractImageRef = ObjectRef<AbstractImage>;
+
+	class NAZARA_UTILITY_API AbstractImage : public RefCounted
 	{
 		public:
 			AbstractImage() = default;
+			inline AbstractImage(const AbstractImage& image);
 			virtual ~AbstractImage();
 
 			UInt8 GetBytesPerPixel() const;
@@ -43,4 +50,6 @@ namespace Nz
 	};
 }
 
+#include <Nazara/Utility/AbstractImage.inl>
+
 #endif // NAZARA_IMAGE_HPP

include/Nazara/Utility/AbstractImage.inl

@@ -0,0 +1,16 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Utility module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Utility/AbstractImage.hpp>
+#include <Nazara/Utility/Debug.hpp>
+
+namespace Nz
+{
+	inline AbstractImage::AbstractImage(const AbstractImage&) :
+	RefCounted()
+	{
+	}
+}
+
+#include <Nazara/Utility/DebugOff.hpp>

include/Nazara/Utility/Formats/MTLParser.hpp

@@ -71,7 +71,6 @@ namespace Nz
 			mutable StringStream m_outputStream;
 			bool m_keepLastLine;
 			unsigned int m_lineCount;
-			unsigned int m_streamFlags;
 	};
 }
 

include/Nazara/Utility/Image.hpp

@@ -10,7 +10,6 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Color.hpp>
 #include <Nazara/Core/ObjectLibrary.hpp>
-#include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
@@ -47,7 +46,7 @@ namespace Nz
 	using ImageRef = ObjectRef<Image>;
 	using ImageSaver = ResourceSaver<Image, ImageParams>;
 
-	class NAZARA_UTILITY_API Image : public AbstractImage, public RefCounted, public Resource
+	class NAZARA_UTILITY_API Image : public AbstractImage, public Resource
 	{
 		friend ImageLibrary;
 		friend ImageLoader;

include/Nazara/Utility/PixelFormat.inl

@@ -111,8 +111,8 @@ namespace Nz
 		if (content <= PixelFormatContent_Undefined || content > PixelFormatContent_Max)
 			return false;
 
-		std::array<const Nz::Bitset<>*, 4> masks = {&redMask, &greenMask, &blueMask, &alphaMask};
+		std::array<const Nz::Bitset<>*, 4> masks = { {&redMask, &greenMask, &blueMask, &alphaMask} };
-		std::array<PixelFormatSubType, 4> types = {redType, greenType, blueType, alphaType};
+		std::array<PixelFormatSubType, 4> types = { {redType, greenType, blueType, alphaType} };
 
 		for (unsigned int i = 0; i < 4; ++i)
 		{