Rename Physics3D to BulletPhysics3D

examples/Particles/main.cpp

@@ -2,7 +2,7 @@
 #include <Nazara/Core.hpp>
 #include <Nazara/Graphics.hpp>
 #include <Nazara/Network.hpp>
-#include <Nazara/Physics3D.hpp>
+#include <Nazara/BulletPhysics3D.hpp>
 #include <Nazara/Renderer.hpp>
 #include <Nazara/Utility.hpp>
 #include <NazaraSDK/Application.hpp>

examples/PhysicsDemo/main.cpp

@@ -2,7 +2,7 @@
 #include <Nazara/Platform.hpp>
 #include <Nazara/Graphics.hpp>
 #include <Nazara/Math/PidController.hpp>
-#include <Nazara/Physics3D.hpp>
+#include <Nazara/BulletPhysics3D.hpp>
 #include <Nazara/Renderer.hpp>
 #include <Nazara/Utility.hpp>
 #include <entt/entt.hpp>
@@ -20,14 +20,14 @@ int main()
 	if (!std::filesystem::is_directory(resourceDir) && std::filesystem::is_directory("../.." / resourceDir))
 		resourceDir = "../.." / resourceDir;
 
-	Nz::Application<Nz::Graphics, Nz::Physics3D> app;
+	Nz::Application<Nz::Graphics, Nz::BulletPhysics3D> app;
 
 	auto& windowing = app.AddComponent<Nz::AppWindowingComponent>();
 
 	auto& ecs = app.AddComponent<Nz::AppEntitySystemComponent>();
 
 	auto& world = ecs.AddWorld<Nz::EnttWorld>();
-	Nz::Physics3DSystem& physSytem = world.AddSystem<Nz::Physics3DSystem>();
+	Nz::BulletPhysics3DSystem& physSytem = world.AddSystem<Nz::BulletPhysics3DSystem>();
 	physSytem.GetPhysWorld().SetGravity(Nz::Vector3f::Zero());
 
 	Nz::RenderSystem& renderSystem = world.AddSystem<Nz::RenderSystem>();
@@ -140,7 +140,7 @@ int main()
 		auto& entityNode = playerEntity.emplace<Nz::NodeComponent>();
 		entityNode.SetPosition(Nz::Vector3f(12.5f, 0.f, 25.f));
 
-		auto& entityPhys = playerEntity.emplace<Nz::RigidBody3DComponent>(physSytem.CreateRigidBody(shipCollider));
+		auto& entityPhys = playerEntity.emplace<Nz::BulletRigidBody3DComponent>(physSytem.CreateRigidBody(shipCollider));
 		entityPhys.SetMass(50.f);
 		entityPhys.SetAngularDamping(0.1f);
 		entityPhys.SetLinearDamping(0.5f);
@@ -179,7 +179,7 @@ int main()
 				entityNode.SetPosition(Nz::Vector3f(x * 2.f, y * 1.5f, z * 2.f));
 				entityNode.SetRotation(Nz::EulerAnglesf(0.f, Nz::TurnAnglef(0.5f), 0.f));
 
-				auto& entityPhys = entity.emplace<Nz::RigidBody3DComponent>(physSytem.CreateRigidBody(shipCollider));
+				auto& entityPhys = entity.emplace<Nz::BulletRigidBody3DComponent>(physSytem.CreateRigidBody(shipCollider));
 				entityPhys.SetMass(1.f);
 				entityPhys.SetAngularDamping(0.f);
 				entityPhys.SetLinearDamping(0.f);
@@ -214,13 +214,13 @@ int main()
 			showColliders = !showColliders;
 			if (showColliders)
 			{
-				auto view = world.GetRegistry().view<Nz::GraphicsComponent, Nz::RigidBody3DComponent>();
+				auto view = world.GetRegistry().view<Nz::GraphicsComponent, Nz::BulletRigidBody3DComponent>();
 				for (auto [entity, gfxComponent, _] : view.each())
 					gfxComponent.AttachRenderable(colliderModel, 1);
 			}
 			else
 			{
-				auto view = world.GetRegistry().view<Nz::GraphicsComponent, Nz::RigidBody3DComponent>();
+				auto view = world.GetRegistry().view<Nz::GraphicsComponent, Nz::BulletRigidBody3DComponent>();
 				for (auto [entity, gfxComponent, _] : view.each())
 					gfxComponent.DetachRenderable(colliderModel);
 			}
@@ -235,7 +235,7 @@ int main()
 
 			entity.emplace<Nz::NodeComponent>();
 
-			auto& entityPhys = entity.emplace<Nz::RigidBody3DComponent>(physSytem.CreateRigidBody(shipCollider));
+			auto& entityPhys = entity.emplace<Nz::BulletRigidBody3DComponent>(physSytem.CreateRigidBody(shipCollider));
 			entityPhys.SetMass(1.f);
 			entityPhys.SetAngularDamping(0.f);
 			entityPhys.SetLinearDamping(0.f);
@@ -262,7 +262,7 @@ int main()
 		{
 			float elapsedTime = deltaTime->AsSeconds();
 
-			auto spaceshipView = world.GetRegistry().view<Nz::NodeComponent, Nz::RigidBody3DComponent>();
+			auto spaceshipView = world.GetRegistry().view<Nz::NodeComponent, Nz::BulletRigidBody3DComponent>();
 			for (auto&& [entity, node, _] : spaceshipView.each())
 			{
 				if (entity == playerEntity)
@@ -273,7 +273,7 @@ int main()
 					world.GetRegistry().destroy(entity);
 			}
 
-			Nz::RigidBody3DComponent& playerShipBody = playerEntity.get<Nz::RigidBody3DComponent>();
+			Nz::BulletRigidBody3DComponent& playerShipBody = playerEntity.get<Nz::BulletRigidBody3DComponent>();
 			Nz::Quaternionf currentRotation = playerShipBody.GetRotation();
 
 			Nz::Vector3f desiredHeading = headingEntity.get<Nz::NodeComponent>().GetForward();

examples/PhysicsDemo/xmake.lua

@@ -1,5 +1,5 @@
 target("PhysicsDemo")
-	add_deps("NazaraGraphics", "NazaraPhysics3D")
+	add_deps("NazaraGraphics", "NazaraBulletPhysics3D")
 	add_packages("entt")
 	add_files("main.cpp")
 	add_defines("NAZARA_ENTT")

examples/Showcase/main.cpp

@@ -2,7 +2,7 @@
 #include <Nazara/Platform.hpp>
 #include <Nazara/Graphics.hpp>
 #include <Nazara/Math/PidController.hpp>
-#include <Nazara/Physics3D.hpp>
+#include <Nazara/BulletPhysics3D.hpp>
 #include <Nazara/Renderer.hpp>
 #include <Nazara/Utility.hpp>
 #include <Nazara/Utility/Plugins/AssimpPlugin.hpp>
@@ -30,7 +30,8 @@ int main()
 	auto& world = ecs.AddWorld<Nz::EnttWorld>();
 	world.AddSystem<Nz::SkeletonSystem>();
 
-	Nz::Physics3DSystem& physSytem = world.AddSystem<Nz::Physics3DSystem>();
+	Nz::BulletPhysics3DSystem& physSytem = world.AddSystem<Nz::BulletPhysics3DSystem>();
+	physSytem.GetPhysWorld().SetGravity(Nz::Vector3f::Zero());
 	Nz::RenderSystem& renderSystem = world.AddSystem<Nz::RenderSystem>();
 
 	auto& windowing = app.AddComponent<Nz::AppWindowingComponent>();
@@ -59,7 +60,7 @@ int main()
 
 		auto playerCollider = std::make_shared<Nz::BoxCollider3D>(Nz::Vector3f(0.2f, 1.8f, 0.2f));
 
-		auto& playerBody = playerEntity.emplace<Nz::RigidBody3DComponent>(physSytem.CreateRigidBody(playerCollider));
+		auto& playerBody = playerEntity.emplace<Nz::BulletRigidBody3DComponent>(physSytem.CreateRigidBody(playerCollider));
 		playerBody.SetMass(42.f);
 
 		std::shared_ptr<Nz::Mesh> colliderMesh = Nz::Mesh::Build(playerCollider->GenerateMesh());
@@ -240,6 +241,9 @@ int main()
 			sphereNode.SetInheritScale(false);
 			sphereNode.SetParentJoint(bobEntity, "RightHand");
 
+			auto& sphereBody = sphereEntity.emplace<Nz::BulletRigidBody3DComponent>(&physSytem.GetPhysWorld());
+			sphereBody.SetGeom(std::make_shared<Nz::SphereCollider3D>(0.1f));
+
 			auto& sphereGfx = sphereEntity.emplace<Nz::GraphicsComponent>();
 			sphereGfx.AttachRenderable(sphereModel);
 		}
@@ -331,8 +335,8 @@ int main()
 
 		floorEntity.emplace<Nz::NodeComponent>();
 
-		auto& planeBody = floorEntity.emplace<Nz::RigidBody3DComponent>(&physSytem.GetPhysWorld());
+		auto& planeBody = planeEntity.emplace<Nz::BulletRigidBody3DComponent>(&physSytem.GetPhysWorld());
-		planeBody.SetGeom(std::make_shared<Nz::BoxCollider3D>(Nz::Vector3f(planeSize.x, 0.5f, planeSize.y), Nz::Vector3f(0.f, -0.25f, 0.f)));
+		planeBody.SetGeom(std::make_shared<Nz::BoxCollider3D>(Nz::Vector3f(planeSize.x, 0.5f, planeSize.y)));
 
 		std::shared_ptr<Nz::GraphicalMesh> boxMeshGfx = Nz::GraphicalMesh::Build(Nz::Primitive::Box(Nz::Vector3f(0.5f, 0.5f, 0.5f)), meshPrimitiveParams);
 

examples/Showcase/xmake.lua

@@ -5,7 +5,7 @@ end
 target("Showcase")
 	set_group("Examples")
 	set_kind("binary")
-	add_deps("NazaraAudio", "NazaraGraphics", "NazaraPhysics2D", "NazaraPhysics3D", "NazaraWidgets")
+	add_deps("NazaraAudio", "NazaraGraphics", "NazaraPhysics2D", "NazaraBulletPhysics3D", "NazaraWidgets")
 	if has_config("embed_plugins") then
 		add_deps("PluginAssimp")
 	else

examples/Tut00/main.cpp

@@ -3,7 +3,7 @@
 #include <Nazara/Graphics.hpp>
 #include <Nazara/Network.hpp>
 #include <Nazara/Physics2D.hpp>
-#include <Nazara/Physics3D.hpp>
+#include <Nazara/BulletPhysics3D.hpp>
 #include <Nazara/Renderer.hpp>
 #include <Nazara/Utility.hpp>
 #include <iostream>
@@ -12,7 +12,7 @@ int main(int argc, char* argv[])
 {
 	// This "example" has only one purpose: Giving an empty project for you to test whatever you want
 	// If you wish to have multiple test projects, you only have to copy/paste this directory and change the name in the xmake.lua
-	Nz::Application<Nz::Audio, Nz::Core, Nz::Graphics, Nz::Network, Nz::Physics2D, Nz::Physics3D, Nz::Renderer, Nz::Utility> app;
+	Nz::Application<Nz::Audio, Nz::Core, Nz::Graphics, Nz::Network, Nz::Physics2D, Nz::BulletPhysics3D, Nz::Renderer, Nz::Utility> app;
 
 	return EXIT_SUCCESS;
 }

examples/Tut00/xmake.lua

@@ -1,3 +1,3 @@
 target("Tut00_EmptyProject")
-	add_deps("NazaraAudio", "NazaraGraphics", "NazaraNetwork", "NazaraPhysics2D", "NazaraPhysics3D", "NazaraRenderer", "NazaraUtility")
+	add_deps("NazaraAudio", "NazaraGraphics", "NazaraNetwork", "NazaraPhysics2D", "NazaraBulletPhysics3D", "NazaraRenderer", "NazaraUtility")
 	add_files("main.cpp")

include/Nazara/BulletPhysics3D.hpp

@@ -1,7 +1,7 @@
 // this file was automatically generated and should not be edited
 
 /*
-	Nazara Engine - Physics3D module
+	Nazara Engine - BulletPhysics3D module
 
 	Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
 
@@ -29,18 +29,18 @@
 #ifndef NAZARA_GLOBAL_PHYSICS3D_HPP
 #define NAZARA_GLOBAL_PHYSICS3D_HPP
 
-#include <Nazara/Physics3D/Collider3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletCollider3D.hpp>
-#include <Nazara/Physics3D/Config.hpp>
+#include <Nazara/BulletPhysics3D/Config.hpp>
-#include <Nazara/Physics3D/Constraint3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletConstraint3D.hpp>
-#include <Nazara/Physics3D/Enums.hpp>
+#include <Nazara/BulletPhysics3D/Enums.hpp>
-#include <Nazara/Physics3D/Physics3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletPhysics3D.hpp>
-#include <Nazara/Physics3D/PhysWorld3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletPhysWorld3D.hpp>
-#include <Nazara/Physics3D/RigidBody3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletRigidBody3D.hpp>
 
 #ifdef NAZARA_ENTT
 
-#include <Nazara/Physics3D/Components.hpp>
+#include <Nazara/BulletPhysics3D/Components.hpp>
-#include <Nazara/Physics3D/Systems.hpp>
+#include <Nazara/BulletPhysics3D/Systems.hpp>
 
 #endif
 

include/Nazara/BulletPhysics3D/BulletCollider3D.hpp

@@ -1,22 +1,22 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS3D_COLLIDER3D_HPP
+#ifndef NAZARA_BULLETPHYSICS3D_BULLETCOLLIDER3D_HPP
-#define NAZARA_PHYSICS3D_COLLIDER3D_HPP
+#define NAZARA_BULLETPHYSICS3D_BULLETCOLLIDER3D_HPP
 
 #include <NazaraUtils/Prerequisites.hpp>
+#include <Nazara/BulletPhysics3D/Config.hpp>
+#include <Nazara/BulletPhysics3D/Enums.hpp>
 #include <Nazara/Core/ObjectLibrary.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 <NazaraUtils/Signal.hpp>
 #include <NazaraUtils/SparsePtr.hpp>
-#include <unordered_map>
+#include <memory>
 
 class btBoxShape;
 class btCapsuleShape;
@@ -34,13 +34,13 @@ namespace Nz
 	class StaticMesh;
 	struct Primitive;
 
-	class NAZARA_PHYSICS3D_API Collider3D
+	class NAZARA_BULLETPHYSICS3D_API BulletCollider3D
 	{
 		public:
-			Collider3D() = default;
+			BulletCollider3D() = default;
-			Collider3D(const Collider3D&) = delete;
+			BulletCollider3D(const BulletCollider3D&) = delete;
-			Collider3D(Collider3D&&) = delete;
+			BulletCollider3D(BulletCollider3D&&) = delete;
-			virtual ~Collider3D();
+			virtual ~BulletCollider3D();
 
 			virtual void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix = Matrix4f::Identity()) const = 0;
 
@@ -53,16 +53,16 @@ namespace Nz
 			virtual btCollisionShape* GetShape() const = 0;
 			virtual ColliderType3D GetType() const = 0;
 
-			Collider3D& operator=(const Collider3D&) = delete;
+			BulletCollider3D& operator=(const BulletCollider3D&) = delete;
-			Collider3D& operator=(Collider3D&&) = delete;
+			BulletCollider3D& operator=(BulletCollider3D&&) = delete;
 
-			static std::shared_ptr<Collider3D> Build(const PrimitiveList& list);
+			static std::shared_ptr<BulletCollider3D> Build(const PrimitiveList& list);
 
 		private:
-			static std::shared_ptr<Collider3D> CreateGeomFromPrimitive(const Primitive& primitive);
+			static std::shared_ptr<BulletCollider3D> CreateGeomFromPrimitive(const Primitive& primitive);
 	};
 
-	class NAZARA_PHYSICS3D_API BoxCollider3D final : public Collider3D
+	class NAZARA_BULLETPHYSICS3D_API BoxCollider3D final : public BulletCollider3D
 	{
 		public:
 			BoxCollider3D(const Vector3f& lengths);
@@ -79,7 +79,7 @@ namespace Nz
 			Vector3f m_lengths;
 	};
 
-	class NAZARA_PHYSICS3D_API CapsuleCollider3D final : public Collider3D
+	class NAZARA_BULLETPHYSICS3D_API CapsuleCollider3D final : public BulletCollider3D
 	{
 		public:
 			CapsuleCollider3D(float length, float radius);
@@ -98,7 +98,7 @@ namespace Nz
 			float m_radius;
 	};
 
-	class NAZARA_PHYSICS3D_API CompoundCollider3D final : public Collider3D
+	class NAZARA_BULLETPHYSICS3D_API CompoundCollider3D final : public BulletCollider3D
 	{
 		public:
 			struct ChildCollider;
@@ -114,7 +114,7 @@ namespace Nz
 
 			struct ChildCollider
 			{
-				std::shared_ptr<Collider3D> collider;
+				std::shared_ptr<BulletCollider3D> collider;
 				Matrix4f offsetMatrix;
 			};
 
@@ -123,7 +123,7 @@ namespace Nz
 			std::vector<ChildCollider> m_childs;
 	};
 
-	class NAZARA_PHYSICS3D_API ConeCollider3D final : public Collider3D
+	class NAZARA_BULLETPHYSICS3D_API ConeCollider3D final : public BulletCollider3D
 	{
 		public:
 			ConeCollider3D(float length, float radius);
@@ -142,7 +142,7 @@ namespace Nz
 			float m_radius;
 	};
 
-	class NAZARA_PHYSICS3D_API ConvexCollider3D final : public Collider3D
+	class NAZARA_BULLETPHYSICS3D_API ConvexCollider3D final : public BulletCollider3D
 	{
 		public:
 			ConvexCollider3D(SparsePtr<const Vector3f> vertices, unsigned int vertexCount);
@@ -157,7 +157,7 @@ namespace Nz
 			std::unique_ptr<btConvexHullShape> m_shape;
 	};
 
-	class NAZARA_PHYSICS3D_API CylinderCollider3D final : public Collider3D
+	class NAZARA_BULLETPHYSICS3D_API CylinderCollider3D final : public BulletCollider3D
 	{
 		public:
 			CylinderCollider3D(float length, float radius);
@@ -177,7 +177,7 @@ namespace Nz
 			float m_radius;
 	};
 
-	class NAZARA_PHYSICS3D_API NullCollider3D final : public Collider3D
+	class NAZARA_BULLETPHYSICS3D_API NullCollider3D final : public BulletCollider3D
 	{
 		public:
 			NullCollider3D();
@@ -194,7 +194,7 @@ namespace Nz
 			std::unique_ptr<btEmptyShape> m_shape;
 	};
 
-	class NAZARA_PHYSICS3D_API SphereCollider3D final : public Collider3D
+	class NAZARA_BULLETPHYSICS3D_API SphereCollider3D final : public BulletCollider3D
 	{
 		public:
 			SphereCollider3D(float radius);
@@ -213,6 +213,6 @@ namespace Nz
 	};
 }
 
-#include <Nazara/Physics3D/Collider3D.inl>
+#include <Nazara/BulletPhysics3D/BulletCollider3D.inl>
 
-#endif // NAZARA_PHYSICS3D_COLLIDER3D_HPP
+#endif // NAZARA_BULLETPHYSICS3D_BULLETCOLLIDER3D_HPP

include/Nazara/BulletPhysics3D/BulletCollider3D.inl

@@ -1,12 +1,12 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <memory>
-#include <Nazara/Physics3D/Debug.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
 
 namespace Nz
 {
 }
 
-#include <Nazara/Physics3D/DebugOff.hpp>
+#include <Nazara/BulletPhysics3D/DebugOff.hpp>

include/Nazara/BulletPhysics3D/BulletConstraint3D.hpp

@@ -0,0 +1,74 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_BULLETPHYSICS3D_BULLETCONSTRAINT3D_HPP
+#define NAZARA_BULLETPHYSICS3D_BULLETCONSTRAINT3D_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/BulletPhysics3D/BulletPhysWorld3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletRigidBody3D.hpp>
+#include <Nazara/BulletPhysics3D/Config.hpp>
+#include <Nazara/Core/HandledObject.hpp>
+#include <Nazara/Core/ObjectHandle.hpp>
+
+class btTypedConstraint;
+
+namespace Nz
+{
+	class BulletConstraint3D;
+
+	using BulletConstraint3DHandle = ObjectHandle<BulletConstraint3D>;
+
+	class NAZARA_BULLETPHYSICS3D_API BulletConstraint3D : public HandledObject<BulletConstraint3D>
+	{
+		public:
+			BulletConstraint3D(const BulletConstraint3D&) = delete;
+			BulletConstraint3D(BulletConstraint3D&& constraint) noexcept;
+			virtual ~BulletConstraint3D();
+
+			BulletRigidBody3D& GetBodyA();
+			const BulletRigidBody3D& GetBodyA() const;
+			BulletRigidBody3D& GetBodyB();
+			const BulletRigidBody3D& GetBodyB() const;
+			BulletPhysWorld3D& GetWorld();
+			const BulletPhysWorld3D& GetWorld() const;
+
+			inline bool IsBodyCollisionEnabled() const;
+			bool IsSingleBody() const;
+
+			BulletConstraint3D& operator=(const BulletConstraint3D&) = delete;
+			BulletConstraint3D& operator=(BulletConstraint3D&& constraint) noexcept;
+
+		protected:
+			BulletConstraint3D(std::unique_ptr<btTypedConstraint> constraint, bool disableCollisions = false);
+
+			template<typename T> T* GetConstraint();
+			template<typename T> const T* GetConstraint() const;
+
+		private:
+			std::unique_ptr<btTypedConstraint> m_constraint;
+			bool m_bodyCollisionEnabled;
+	};
+
+	class NAZARA_BULLETPHYSICS3D_API BulletPivotConstraint3D : public BulletConstraint3D
+	{
+		public:
+			BulletPivotConstraint3D(BulletRigidBody3D& first, const Vector3f& pivot);
+			BulletPivotConstraint3D(BulletRigidBody3D& first, BulletRigidBody3D& second, const Vector3f& pivot, bool disableCollisions = false);
+			BulletPivotConstraint3D(BulletRigidBody3D& first, BulletRigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor, bool disableCollisions = false);
+			~BulletPivotConstraint3D() = default;
+
+			Vector3f GetFirstAnchor() const;
+			Vector3f GetSecondAnchor() const;
+
+			void SetFirstAnchor(const Vector3f& firstAnchor);
+			void SetSecondAnchor(const Vector3f& secondAnchor);
+	};
+}
+
+#include <Nazara/BulletPhysics3D/BulletConstraint3D.inl>
+
+#endif // NAZARA_BULLETPHYSICS3D_BULLETCONSTRAINT3D_HPP

include/Nazara/BulletPhysics3D/BulletConstraint3D.inl

@@ -0,0 +1,27 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/BulletPhysics3D/Debug.hpp>
+
+namespace Nz
+{
+	inline bool BulletConstraint3D::IsBodyCollisionEnabled() const
+	{
+		return m_bodyCollisionEnabled;
+	}
+
+	template<typename T>
+	T* BulletConstraint3D::GetConstraint()
+	{
+		return SafeCast<T*>(m_constraint.get());
+	}
+
+	template<typename T>
+	const T* BulletConstraint3D::GetConstraint() const
+	{
+		return SafeCast<const T*>(m_constraint.get());
+	}
+}
+
+#include <Nazara/BulletPhysics3D/DebugOff.hpp>

include/Nazara/BulletPhysics3D/BulletPhysWorld3D.hpp

@@ -1,17 +1,17 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS3D_PHYSWORLD3D_HPP
+#ifndef NAZARA_BULLETPHYSICS3D_BULLETPHYSWORLD3D_HPP
-#define NAZARA_PHYSICS3D_PHYSWORLD3D_HPP
+#define NAZARA_BULLETPHYSICS3D_BULLETPHYSWORLD3D_HPP
 
 #include <NazaraUtils/Prerequisites.hpp>
+#include <Nazara/BulletPhysics3D/Config.hpp>
 #include <Nazara/Core/Time.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Physics3D/Config.hpp>
 #include <NazaraUtils/FunctionRef.hpp>
 #include <NazaraUtils/MovablePtr.hpp>
 
@@ -20,19 +20,19 @@ class btRigidBody;
 
 namespace Nz
 {
-	class RigidBody3D;
+	class BulletRigidBody3D;
 
-	class NAZARA_PHYSICS3D_API PhysWorld3D
+	class NAZARA_BULLETPHYSICS3D_API BulletPhysWorld3D
 	{
-		friend RigidBody3D;
+		friend BulletRigidBody3D;
 
 		public:
 			struct RaycastHit;
 
-			PhysWorld3D();
+			BulletPhysWorld3D();
-			PhysWorld3D(const PhysWorld3D&) = delete;
+			BulletPhysWorld3D(const BulletPhysWorld3D&) = delete;
-			PhysWorld3D(PhysWorld3D&& ph) = delete;
+			BulletPhysWorld3D(BulletPhysWorld3D&& ph) = delete;
-			~PhysWorld3D();
+			~BulletPhysWorld3D();
 
 			btDynamicsWorld* GetDynamicsWorld();
 			Vector3f GetGravity() const;
@@ -47,13 +47,13 @@ namespace Nz
 
 			void Step(Time timestep);
 
-			PhysWorld3D& operator=(const PhysWorld3D&) = delete;
+			BulletPhysWorld3D& operator=(const BulletPhysWorld3D&) = delete;
-			PhysWorld3D& operator=(PhysWorld3D&&) = delete;
+			BulletPhysWorld3D& operator=(BulletPhysWorld3D&&) = delete;
 
 			struct RaycastHit
 			{
 				float fraction;
-				RigidBody3D* hitBody = nullptr;
+				BulletRigidBody3D* hitBody = nullptr;
 				Vector3f hitPosition;
 				Vector3f hitNormal;
 			};
@@ -72,4 +72,4 @@ namespace Nz
 	};
 }
 
-#endif // NAZARA_PHYSICS3D_PHYSWORLD3D_HPP
+#endif // NAZARA_BULLETPHYSICS3D_BULLETPHYSWORLD3D_HPP

include/Nazara/BulletPhysics3D/BulletPhysics3D.hpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_BULLETPHYSICS3D_HPP
+#define NAZARA_BULLETPHYSICS3D_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/BulletPhysics3D/Config.hpp>
+#include <Nazara/Core/Core.hpp>
+
+namespace Nz
+{
+	class NAZARA_BULLETPHYSICS3D_API BulletPhysics3D : public ModuleBase<BulletPhysics3D>
+	{
+		friend ModuleBase;
+
+		public:
+			using Dependencies = TypeList<Core>;
+
+			struct Config {};
+
+			BulletPhysics3D(Config /*config*/);
+			~BulletPhysics3D() = default;
+
+		private:
+			static BulletPhysics3D* s_instance;
+	};
+}
+
+#endif // NAZARA_BULLETPHYSICS3D_HPP

include/Nazara/BulletPhysics3D/BulletRigidBody3D.hpp

@@ -1,35 +1,35 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS3D_RIGIDBODY3D_HPP
+#ifndef NAZARA_BULLETPHYSICS3D_BULLETRIGIDBODY3D_HPP
-#define NAZARA_PHYSICS3D_RIGIDBODY3D_HPP
+#define NAZARA_BULLETPHYSICS3D_BULLETRIGIDBODY3D_HPP
 
 #include <NazaraUtils/Prerequisites.hpp>
+#include <Nazara/BulletPhysics3D/BulletCollider3D.hpp>
+#include <Nazara/BulletPhysics3D/Config.hpp>
 #include <Nazara/Core/Enums.hpp>
 #include <Nazara/Math/Matrix4.hpp>
 #include <Nazara/Math/Quaternion.hpp>
 #include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Physics3D/Collider3D.hpp>
-#include <Nazara/Physics3D/Config.hpp>
 #include <NazaraUtils/MovablePtr.hpp>
 
 class btRigidBody;
 
 namespace Nz
 {
-	class PhysWorld3D;
+	class BulletPhysWorld3D;
 
-	class NAZARA_PHYSICS3D_API RigidBody3D
+	class NAZARA_BULLETPHYSICS3D_API BulletRigidBody3D
 	{
 		public:
-			RigidBody3D(PhysWorld3D* world, const Matrix4f& mat = Matrix4f::Identity());
+			BulletRigidBody3D(BulletPhysWorld3D* world, const Matrix4f& mat = Matrix4f::Identity());
-			RigidBody3D(PhysWorld3D* world, std::shared_ptr<Collider3D> geom, const Matrix4f& mat = Matrix4f::Identity());
+			BulletRigidBody3D(BulletPhysWorld3D* world, std::shared_ptr<BulletCollider3D> geom, const Matrix4f& mat = Matrix4f::Identity());
-			RigidBody3D(const RigidBody3D& object) = delete;
+			BulletRigidBody3D(const BulletRigidBody3D& object) = delete;
-			RigidBody3D(RigidBody3D&& object) noexcept;
+			BulletRigidBody3D(BulletRigidBody3D&& object) noexcept;
-			~RigidBody3D();
+			~BulletRigidBody3D();
 
 			void AddForce(const Vector3f& force, CoordSys coordSys = CoordSys::Global);
 			void AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys = CoordSys::Global);
@@ -43,7 +43,7 @@ namespace Nz
 			Boxf GetAABB() const;
 			float GetAngularDamping() const;
 			Vector3f GetAngularVelocity() const;
-			inline const std::shared_ptr<Collider3D>& GetGeom() const;
+			inline const std::shared_ptr<BulletCollider3D>& GetGeom() const;
 			float GetLinearDamping() const;
 			Vector3f GetLinearVelocity() const;
 			float GetMass() const;
@@ -53,7 +53,7 @@ namespace Nz
 			inline btRigidBody* GetRigidBody() const;
 			Quaternionf GetRotation() const;
 			inline std::size_t GetUniqueIndex() const;
-			inline PhysWorld3D* GetWorld() const;
+			inline BulletPhysWorld3D* GetWorld() const;
 
 			bool IsSimulationEnabled() const;
 			bool IsSleeping() const;
@@ -61,7 +61,7 @@ namespace Nz
 
 			void SetAngularDamping(float angularDamping);
 			void SetAngularVelocity(const Vector3f& angularVelocity);
-			void SetGeom(std::shared_ptr<Collider3D> geom, bool recomputeInertia = true);
+			void SetGeom(std::shared_ptr<BulletCollider3D> geom, bool recomputeInertia = true);
 			void SetLinearDamping(float damping);
 			void SetLinearVelocity(const Vector3f& velocity);
 			void SetMass(float mass);
@@ -76,20 +76,20 @@ namespace Nz
 
 			void WakeUp();
 
-			RigidBody3D& operator=(const RigidBody3D& object) = delete;
+			BulletRigidBody3D& operator=(const BulletRigidBody3D& object) = delete;
-			RigidBody3D& operator=(RigidBody3D&& object) noexcept;
+			BulletRigidBody3D& operator=(BulletRigidBody3D&& object) noexcept;
 
 		protected:
 			void Destroy();
 
 		private:
-			std::shared_ptr<Collider3D> m_geom;
+			std::shared_ptr<BulletCollider3D> m_geom;
 			std::size_t m_bodyPoolIndex;
 			btRigidBody* m_body;
-			PhysWorld3D* m_world;
+			BulletPhysWorld3D* m_world;
 	};
 }
 
-#include <Nazara/Physics3D/RigidBody3D.inl>
+#include <Nazara/BulletPhysics3D/BulletRigidBody3D.inl>
 
-#endif // NAZARA_PHYSICS3D_RIGIDBODY3D_HPP
+#endif // NAZARA_BULLETPHYSICS3D_BULLETRIGIDBODY3D_HPP

include/Nazara/BulletPhysics3D/BulletRigidBody3D.inl

@@ -0,0 +1,34 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/BulletPhysics3D/Debug.hpp>
+
+namespace Nz
+{
+	inline void BulletRigidBody3D::DisableSleeping()
+	{
+		return EnableSleeping(false);
+	}
+
+	inline const std::shared_ptr<BulletCollider3D>& BulletRigidBody3D::GetGeom() const
+	{
+		return m_geom;
+	}
+
+	inline btRigidBody* BulletRigidBody3D::GetRigidBody() const
+	{
+		return m_body;
+	}
+	inline std::size_t BulletRigidBody3D::GetUniqueIndex() const
+	{
+		return m_bodyPoolIndex;
+	}
+
+	inline BulletPhysWorld3D* BulletRigidBody3D::GetWorld() const
+	{
+		return m_world;
+	}
+}
+
+#include <Nazara/BulletPhysics3D/DebugOff.hpp>

include/Nazara/BulletPhysics3D/Components.hpp

@@ -1,7 +1,7 @@
 // this file was automatically generated and should not be edited
 
 /*
-	Nazara Engine - Physics3D module
+	Nazara Engine - BulletPhysics3D module
 
 	Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
 
@@ -26,9 +26,9 @@
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS3D_COMPONENTS_HPP
+#ifndef NAZARA_BULLETPHYSICS3D_COMPONENTS_HPP
-#define NAZARA_PHYSICS3D_COMPONENTS_HPP
+#define NAZARA_BULLETPHYSICS3D_COMPONENTS_HPP
 
-#include <Nazara/Physics3D/Components/RigidBody3DComponent.hpp>
+#include <Nazara/BulletPhysics3D/Components/BulletRigidBody3DComponent.hpp>
 
-#endif // NAZARA_PHYSICS3D_COMPONENTS_HPP
+#endif // NAZARA_BULLETPHYSICS3D_COMPONENTS_HPP

include/Nazara/BulletPhysics3D/Components/BulletRigidBody3DComponent.hpp

@@ -0,0 +1,32 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_BULLETPHYSICS3D_COMPONENTS_BULLETRIGIDBODY3DCOMPONENT_HPP
+#define NAZARA_BULLETPHYSICS3D_COMPONENTS_BULLETRIGIDBODY3DCOMPONENT_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/BulletPhysics3D/BulletRigidBody3D.hpp>
+
+namespace Nz
+{
+	class NAZARA_BULLETPHYSICS3D_API BulletRigidBody3DComponent : public BulletRigidBody3D
+	{
+		friend class BulletPhysics3DSystem;
+
+		public:
+			using BulletRigidBody3D::BulletRigidBody3D;
+			BulletRigidBody3DComponent(const BulletRigidBody3DComponent&) = default;
+			BulletRigidBody3DComponent(BulletRigidBody3DComponent&&) noexcept = default;
+			~BulletRigidBody3DComponent() = default;
+
+			BulletRigidBody3DComponent& operator=(const BulletRigidBody3DComponent&) = default;
+			BulletRigidBody3DComponent& operator=(BulletRigidBody3DComponent&&) noexcept = default;
+	};
+}
+
+#include <Nazara/BulletPhysics3D/Components/BulletRigidBody3DComponent.inl>
+
+#endif // NAZARA_BULLETPHYSICS3D_COMPONENTS_BULLETRIGIDBODY3DCOMPONENT_HPP

include/Nazara/BulletPhysics3D/Components/BulletRigidBody3DComponent.inl

@@ -1,11 +1,11 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics3D/Debug.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
 
 namespace Nz
 {
 }
 
-#include <Nazara/Physics3D/DebugOff.hpp>
+#include <Nazara/BulletPhysics3D/DebugOff.hpp>

include/Nazara/BulletPhysics3D/Config.hpp

@@ -1,5 +1,5 @@
 /*
-	Nazara Engine - Physics3D module
+	Nazara Engine - BulletPhysics3D module
 
 	Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
 
@@ -24,25 +24,25 @@
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS3D_CONFIG_HPP
+#ifndef NAZARA_BULLETPHYSICS3D_CONFIG_HPP
-#define NAZARA_PHYSICS3D_CONFIG_HPP
+#define NAZARA_BULLETPHYSICS3D_CONFIG_HPP
 
 /// Chaque modification d'un paramètre du module nécessite une recompilation de celui-ci
 
 // Active les tests de sécurité basés sur le code (Conseillé pour le développement)
-#define NAZARA_PHYSICS3D_SAFE 1
+#define NAZARA_BULLETPHYSICS3D_SAFE 1
 
 /// Vérification des valeurs et types de certaines constantes
-#include <Nazara/Physics3D/ConfigCheck.hpp>
+#include <Nazara/BulletPhysics3D/ConfigCheck.hpp>
 
 #if defined(NAZARA_STATIC)
-	#define NAZARA_PHYSICS3D_API
+	#define NAZARA_BULLETPHYSICS3D_API
 #else
-	#ifdef NAZARA_PHYSICS3D_BUILD
+	#ifdef NAZARA_BULLETPHYSICS3D_BUILD
-		#define NAZARA_PHYSICS3D_API NAZARA_EXPORT
+		#define NAZARA_BULLETPHYSICS3D_API NAZARA_EXPORT
 	#else
-		#define NAZARA_PHYSICS3D_API NAZARA_IMPORT
+		#define NAZARA_BULLETPHYSICS3D_API NAZARA_IMPORT
 	#endif
 #endif
 
-#endif // NAZARA_PHYSICS3D_CONFIG_HPP
+#endif // NAZARA_BULLETPHYSICS3D_CONFIG_HPP

include/Nazara/BulletPhysics3D/ConfigCheck.hpp

@@ -0,0 +1,10 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_BULLETPHYSICS3D_CONFIGCHECK_HPP
+#define NAZARA_BULLETPHYSICS3D_CONFIGCHECK_HPP
+
+#endif // NAZARA_BULLETPHYSICS3D_CONFIGCHECK_HPP

include/Nazara/BulletPhysics3D/Debug.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 // no header guards

include/Nazara/BulletPhysics3D/DebugOff.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 // no header guards

include/Nazara/BulletPhysics3D/Enums.hpp

@@ -1,11 +1,11 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS3D_ENUMS_HPP
+#ifndef NAZARA_BULLETPHYSICS3D_ENUMS_HPP
-#define NAZARA_PHYSICS3D_ENUMS_HPP
+#define NAZARA_BULLETPHYSICS3D_ENUMS_HPP
 
 namespace Nz
 {
@@ -27,4 +27,4 @@ namespace Nz
 	};
 }
 
-#endif // NAZARA_PHYSICS3D_ENUMS_HPP
+#endif // NAZARA_BULLETPHYSICS3D_ENUMS_HPP

include/Nazara/BulletPhysics3D/Systems.hpp

@@ -1,7 +1,7 @@
 // this file was automatically generated and should not be edited
 
 /*
-	Nazara Engine - Physics3D module
+	Nazara Engine - BulletPhysics3D module
 
 	Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
 
@@ -26,9 +26,9 @@
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS3D_SYSTEMS_HPP
+#ifndef NAZARA_BULLETPHYSICS3D_SYSTEMS_HPP
-#define NAZARA_PHYSICS3D_SYSTEMS_HPP
+#define NAZARA_BULLETPHYSICS3D_SYSTEMS_HPP
 
-#include <Nazara/Physics3D/Systems/Physics3DSystem.hpp>
+#include <Nazara/BulletPhysics3D/Systems/BulletPhysics3DSystem.hpp>
 
-#endif // NAZARA_PHYSICS3D_SYSTEMS_HPP
+#endif // NAZARA_BULLETPHYSICS3D_SYSTEMS_HPP

include/Nazara/BulletPhysics3D/Systems/BulletPhysics3DSystem.hpp

@@ -0,0 +1,65 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_BULLETPHYSICS3D_SYSTEMS_BULLETPHYSICS3DSYSTEM_HPP
+#define NAZARA_BULLETPHYSICS3D_SYSTEMS_BULLETPHYSICS3DSYSTEM_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/BulletPhysics3D/BulletPhysWorld3D.hpp>
+#include <Nazara/BulletPhysics3D/Components/BulletRigidBody3DComponent.hpp>
+#include <Nazara/Core/Time.hpp>
+#include <Nazara/Utils/TypeList.hpp>
+#include <entt/entt.hpp>
+#include <vector>
+
+namespace Nz
+{
+	class NAZARA_BULLETPHYSICS3D_API BulletPhysics3DSystem
+	{
+		public:
+			static constexpr Int64 ExecutionOrder = 0;
+			using Components = TypeList<BulletRigidBody3DComponent, class NodeComponent>;
+
+			struct RaycastHit;
+
+			BulletPhysics3DSystem(entt::registry& registry);
+			BulletPhysics3DSystem(const BulletPhysics3DSystem&) = delete;
+			BulletPhysics3DSystem(BulletPhysics3DSystem&&) = delete;
+			~BulletPhysics3DSystem();
+
+			template<typename... Args> BulletRigidBody3DComponent CreateRigidBody(Args&&... args);
+
+			inline BulletPhysWorld3D& GetPhysWorld();
+			inline const BulletPhysWorld3D& GetPhysWorld() const;
+
+			bool RaycastQueryFirst(const Vector3f& from, const Vector3f& to, RaycastHit* hitInfo = nullptr);
+
+			void Update(Time elapsedTime);
+
+			BulletPhysics3DSystem& operator=(const BulletPhysics3DSystem&) = delete;
+			BulletPhysics3DSystem& operator=(BulletPhysics3DSystem&&) = delete;
+
+			struct RaycastHit : BulletPhysWorld3D::RaycastHit
+			{
+				entt::handle hitEntity;
+			};
+
+		private:
+			void OnConstruct(entt::registry& registry, entt::entity entity);
+			void OnDestruct(entt::registry& registry, entt::entity entity);
+
+			std::vector<entt::entity> m_physicsEntities;
+			entt::registry& m_registry;
+			entt::observer m_physicsConstructObserver;
+			entt::scoped_connection m_constructConnection;
+			entt::scoped_connection m_destructConnection;
+			BulletPhysWorld3D m_physWorld;
+	};
+}
+
+#include <Nazara/BulletPhysics3D/Systems/BulletPhysics3DSystem.inl>
+
+#endif // NAZARA_BULLETPHYSICS3D_SYSTEMS_BULLETPHYSICS3DSYSTEM_HPP

include/Nazara/BulletPhysics3D/Systems/BulletPhysics3DSystem.inl

@@ -0,0 +1,26 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/BulletPhysics3D/Debug.hpp>
+
+namespace Nz
+{
+	template<typename... Args>
+	BulletRigidBody3DComponent BulletPhysics3DSystem::CreateRigidBody(Args&&... args)
+	{
+		return BulletRigidBody3DComponent(&m_physWorld, std::forward<Args>(args)...);
+	}
+
+	inline BulletPhysWorld3D& BulletPhysics3DSystem::GetPhysWorld()
+	{
+		return m_physWorld;
+	}
+
+	inline const BulletPhysWorld3D& BulletPhysics3DSystem::GetPhysWorld() const
+	{
+		return m_physWorld;
+	}
+}
+
+#include <Nazara/BulletPhysics3D/DebugOff.hpp>

include/Nazara/Physics3D/Components/RigidBody3DComponent.hpp

@@ -1,32 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_PHYSICS3D_COMPONENTS_RIGIDBODY3DCOMPONENT_HPP
-#define NAZARA_PHYSICS3D_COMPONENTS_RIGIDBODY3DCOMPONENT_HPP
-
-#include <NazaraUtils/Prerequisites.hpp>
-#include <Nazara/Physics3D/RigidBody3D.hpp>
-
-namespace Nz
-{
-	class NAZARA_PHYSICS3D_API RigidBody3DComponent : public RigidBody3D
-	{
-		friend class Physics3DSystem;
-
-		public:
-			using RigidBody3D::RigidBody3D;
-			RigidBody3DComponent(const RigidBody3DComponent&) = default;
-			RigidBody3DComponent(RigidBody3DComponent&&) noexcept = default;
-			~RigidBody3DComponent() = default;
-
-			RigidBody3DComponent& operator=(const RigidBody3DComponent&) = default;
-			RigidBody3DComponent& operator=(RigidBody3DComponent&&) noexcept = default;
-	};
-}
-
-#include <Nazara/Physics3D/Components/RigidBody3DComponent.inl>
-
-#endif // NAZARA_PHYSICS3D_COMPONENTS_RIGIDBODY3DCOMPONENT_HPP

include/Nazara/Physics3D/ConfigCheck.hpp

@@ -1,10 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_PHYSICS3D_CONFIGCHECK_HPP
-#define NAZARA_PHYSICS3D_CONFIGCHECK_HPP
-
-#endif // NAZARA_PHYSICS3D_CONFIGCHECK_HPP

include/Nazara/Physics3D/Constraint3D.hpp

@@ -1,74 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_PHYSICS3D_CONSTRAINT3D_HPP
-#define NAZARA_PHYSICS3D_CONSTRAINT3D_HPP
-
-#include <Nazara/Prerequisites.hpp>
-#include <Nazara/Core/HandledObject.hpp>
-#include <Nazara/Core/ObjectHandle.hpp>
-#include <Nazara/Physics3D/Config.hpp>
-#include <Nazara/Physics3D/PhysWorld3D.hpp>
-#include <Nazara/Physics3D/RigidBody3D.hpp>
-
-class btTypedConstraint;
-
-namespace Nz
-{
-	class Constraint3D;
-
-	using Constraint3DHandle = ObjectHandle<Constraint3D>;
-
-	class NAZARA_PHYSICS3D_API Constraint3D : public HandledObject<Constraint3D>
-	{
-		public:
-			Constraint3D(const Constraint3D&) = delete;
-			Constraint3D(Constraint3D&& constraint) noexcept;
-			virtual ~Constraint3D();
-
-			RigidBody3D& GetBodyA();
-			const RigidBody3D& GetBodyA() const;
-			RigidBody3D& GetBodyB();
-			const RigidBody3D& GetBodyB() const;
-			PhysWorld3D& GetWorld();
-			const PhysWorld3D& GetWorld() const;
-
-			inline bool IsBodyCollisionEnabled() const;
-			bool IsSingleBody() const;
-
-			Constraint3D& operator=(const Constraint3D&) = delete;
-			Constraint3D& operator=(Constraint3D&& constraint) noexcept;
-
-		protected:
-			Constraint3D(std::unique_ptr<btTypedConstraint> constraint, bool disableCollisions = false);
-
-			template<typename T> T* GetConstraint();
-			template<typename T> const T* GetConstraint() const;
-
-		private:
-			std::unique_ptr<btTypedConstraint> m_constraint;
-			bool m_bodyCollisionEnabled;
-	};
-
-	class NAZARA_PHYSICS3D_API PivotConstraint3D : public Constraint3D
-	{
-		public:
-			PivotConstraint3D(RigidBody3D& first, const Vector3f& pivot);
-			PivotConstraint3D(RigidBody3D& first, RigidBody3D& second, const Vector3f& pivot, bool disableCollisions = false);
-			PivotConstraint3D(RigidBody3D& first, RigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor, bool disableCollisions = false);
-			~PivotConstraint3D() = default;
-
-			Vector3f GetFirstAnchor() const;
-			Vector3f GetSecondAnchor() const;
-
-			void SetFirstAnchor(const Vector3f& firstAnchor);
-			void SetSecondAnchor(const Vector3f& secondAnchor);
-	};
-}
-
-#include <Nazara/Physics3D/Constraint3D.inl>
-
-#endif // NAZARA_PHYSICS3D_CONSTRAINT3D_HPP

include/Nazara/Physics3D/Constraint3D.inl

@@ -1,29 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Physics3D/Constraint3D.hpp>
-#include <Nazara/Physics3D/Debug.hpp>
-#include <Nazara/Physics3D/Debug.hpp>
-
-namespace Nz
-{
-	inline bool Constraint3D::IsBodyCollisionEnabled() const
-	{
-		return m_bodyCollisionEnabled;
-	}
-
-	template<typename T>
-	T* Constraint3D::GetConstraint()
-	{
-		return SafeCast<T*>(m_constraint.get());
-	}
-
-	template<typename T>
-	const T* Constraint3D::GetConstraint() const
-	{
-		return SafeCast<const T*>(m_constraint.get());
-	}
-}
-
-#include <Nazara/Physics3D/DebugOff.hpp>

include/Nazara/Physics3D/Physics3D.hpp

@@ -1,33 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_PHYSICS3D_HPP
-#define NAZARA_PHYSICS3D_HPP
-
-#include <NazaraUtils/Prerequisites.hpp>
-#include <Nazara/Core/Core.hpp>
-#include <Nazara/Physics3D/Config.hpp>
-
-namespace Nz
-{
-	class NAZARA_PHYSICS3D_API Physics3D : public ModuleBase<Physics3D>
-	{
-		friend ModuleBase;
-
-		public:
-			using Dependencies = TypeList<Core>;
-
-			struct Config {};
-
-			Physics3D(Config /*config*/);
-			~Physics3D() = default;
-
-		private:
-			static Physics3D* s_instance;
-	};
-}
-
-#endif // NAZARA_PHYSICS3D_HPP

include/Nazara/Physics3D/RigidBody3D.inl

@@ -1,34 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Physics3D/Debug.hpp>
-
-namespace Nz
-{
-	inline void RigidBody3D::DisableSleeping()
-	{
-		return EnableSleeping(false);
-	}
-
-	inline const std::shared_ptr<Collider3D>& RigidBody3D::GetGeom() const
-	{
-		return m_geom;
-	}
-
-	inline btRigidBody* RigidBody3D::GetRigidBody() const
-	{
-		return m_body;
-	}
-	inline std::size_t RigidBody3D::GetUniqueIndex() const
-	{
-		return m_bodyPoolIndex;
-	}
-
-	inline PhysWorld3D* RigidBody3D::GetWorld() const
-	{
-		return m_world;
-	}
-}
-
-#include <Nazara/Physics3D/DebugOff.hpp>

include/Nazara/Physics3D/Systems/Physics3DSystem.hpp

@@ -1,65 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_PHYSICS3D_SYSTEMS_PHYSICS3DSYSTEM_HPP
-#define NAZARA_PHYSICS3D_SYSTEMS_PHYSICS3DSYSTEM_HPP
-
-#include <NazaraUtils/Prerequisites.hpp>
-#include <Nazara/Core/Time.hpp>
-#include <Nazara/Physics3D/PhysWorld3D.hpp>
-#include <Nazara/Physics3D/Components/RigidBody3DComponent.hpp>
-#include <NazaraUtils/TypeList.hpp>
-#include <entt/entt.hpp>
-#include <vector>
-
-namespace Nz
-{
-	class NAZARA_PHYSICS3D_API Physics3DSystem
-	{
-		public:
-			static constexpr Int64 ExecutionOrder = 0;
-			using Components = TypeList<RigidBody3DComponent, class NodeComponent>;
-
-			struct RaycastHit;
-
-			Physics3DSystem(entt::registry& registry);
-			Physics3DSystem(const Physics3DSystem&) = delete;
-			Physics3DSystem(Physics3DSystem&&) = delete;
-			~Physics3DSystem();
-
-			template<typename... Args> RigidBody3DComponent CreateRigidBody(Args&&... args);
-
-			inline PhysWorld3D& GetPhysWorld();
-			inline const PhysWorld3D& GetPhysWorld() const;
-
-			bool RaycastQueryFirst(const Vector3f& from, const Vector3f& to, RaycastHit* hitInfo = nullptr);
-
-			void Update(Time elapsedTime);
-
-			Physics3DSystem& operator=(const Physics3DSystem&) = delete;
-			Physics3DSystem& operator=(Physics3DSystem&&) = delete;
-
-			struct RaycastHit : PhysWorld3D::RaycastHit
-			{
-				entt::handle hitEntity;
-			};
-
-		private:
-			void OnConstruct(entt::registry& registry, entt::entity entity);
-			void OnDestruct(entt::registry& registry, entt::entity entity);
-
-			std::vector<entt::entity> m_physicsEntities;
-			entt::registry& m_registry;
-			entt::observer m_physicsConstructObserver;
-			entt::scoped_connection m_constructConnection;
-			entt::scoped_connection m_destructConnection;
-			PhysWorld3D m_physWorld;
-	};
-}
-
-#include <Nazara/Physics3D/Systems/Physics3DSystem.inl>
-
-#endif // NAZARA_PHYSICS3D_SYSTEMS_PHYSICS3DSYSTEM_HPP

include/Nazara/Physics3D/Systems/Physics3DSystem.inl

@@ -1,26 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Physics3D/Debug.hpp>
-
-namespace Nz
-{
-	template<typename... Args>
-	RigidBody3DComponent Physics3DSystem::CreateRigidBody(Args&&... args)
-	{
-		return RigidBody3DComponent(&m_physWorld, std::forward<Args>(args)...);
-	}
-
-	inline PhysWorld3D& Physics3DSystem::GetPhysWorld()
-	{
-		return m_physWorld;
-	}
-
-	inline const PhysWorld3D& Physics3DSystem::GetPhysWorld() const
-	{
-		return m_physWorld;
-	}
-}
-
-#include <Nazara/Physics3D/DebugOff.hpp>

src/Nazara/BulletPhysics3D/BulletCollider3D.cpp

@@ -1,10 +1,10 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics3D/Collider3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletCollider3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletHelper.hpp>
 #include <Nazara/Core/PrimitiveList.hpp>
-#include <Nazara/Physics3D/BulletHelper.hpp>
 #include <Nazara/Utility/Algorithm.hpp>
 #include <Nazara/Utility/IndexBuffer.hpp>
 #include <Nazara/Utility/SoftwareBuffer.hpp>
@@ -20,18 +20,18 @@
 #include <BulletCollision/CollisionShapes/btCylinderShape.h>
 #include <BulletCollision/CollisionShapes/btEmptyShape.h>
 #include <BulletCollision/CollisionShapes/btSphereShape.h>
-#include <Nazara/Physics3D/Debug.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
 
 namespace Nz
 {
-	Collider3D::~Collider3D() = default;
+	BulletCollider3D::~BulletCollider3D() = default;
 
-	Boxf Collider3D::ComputeAABB(const Vector3f& translation, const Quaternionf& rotation, const Vector3f& scale) const
+	Boxf BulletCollider3D::ComputeAABB(const Vector3f& translation, const Quaternionf& rotation, const Vector3f& scale) const
 	{
 		return ComputeAABB(Matrix4f::Transform(translation, rotation), scale);
 	}
 
-	Boxf Collider3D::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
+	Boxf BulletCollider3D::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
 	{
 		btTransform transform = ToBullet(offsetMatrix);
 
@@ -41,7 +41,7 @@ namespace Nz
 		return Boxf(scale * FromBullet(min), scale * FromBullet(max));
 	}
 
-	void Collider3D::ComputeInertia(float mass, Vector3f* inertia) const
+	void BulletCollider3D::ComputeInertia(float mass, Vector3f* inertia) const
 	{
 		NazaraAssert(inertia, "invalid inertia pointer");
 
@@ -51,7 +51,7 @@ namespace Nz
 		*inertia = FromBullet(inertiaVec);
 	}
 
-	std::shared_ptr<StaticMesh> Collider3D::GenerateDebugMesh() const
+	std::shared_ptr<StaticMesh> BulletCollider3D::GenerateDebugMesh() const
 	{
 		std::vector<Vector3f> colliderVertices;
 		std::vector<UInt16> colliderIndices;
@@ -67,7 +67,7 @@ namespace Nz
 		return colliderSubMesh;
 	}
 
-	std::shared_ptr<Collider3D> Collider3D::Build(const PrimitiveList& list)
+	std::shared_ptr<BulletCollider3D> BulletCollider3D::Build(const PrimitiveList& list)
 	{
 		std::size_t primitiveCount = list.GetSize();
 		if (primitiveCount > 1)
@@ -89,7 +89,7 @@ namespace Nz
 			return std::make_shared<NullCollider3D>();
 	}
 	
-	std::shared_ptr<Collider3D> Collider3D::CreateGeomFromPrimitive(const Primitive& primitive)
+	std::shared_ptr<BulletCollider3D> BulletCollider3D::CreateGeomFromPrimitive(const Primitive& primitive)
 	{
 		switch (primitive.type)
 		{
@@ -108,7 +108,7 @@ namespace Nz
 		}
 
 		NazaraError("Primitive type not handled (0x" + NumberToString(UnderlyingCast(primitive.type), 16) + ')');
-		return std::shared_ptr<Collider3D>();
+		return std::shared_ptr<BulletCollider3D>();
 	}
 
 	/********************************** BoxCollider3D **********************************/

src/Nazara/BulletPhysics3D/BulletConstraint3D.cpp

@@ -0,0 +1,123 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/BulletPhysics3D/BulletConstraint3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletHelper.hpp>
+#include <BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h>
+#include <BulletDynamics/Dynamics/btDynamicsWorld.h>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
+
+namespace Nz
+{
+	BulletConstraint3D::BulletConstraint3D(std::unique_ptr<btTypedConstraint> constraint, bool disableCollisions) :
+	m_constraint(std::move(constraint)),
+	m_bodyCollisionEnabled(!disableCollisions)
+	{
+		btDynamicsWorld* world = GetWorld().GetDynamicsWorld();
+		world->addConstraint(m_constraint.get(), disableCollisions);
+	}
+
+	BulletConstraint3D::BulletConstraint3D(BulletConstraint3D&& constraint) noexcept :
+	m_constraint(std::move(constraint.m_constraint)),
+	m_bodyCollisionEnabled(constraint.m_bodyCollisionEnabled)
+	{
+		if (m_constraint)
+			m_constraint->setUserConstraintPtr(this);
+	}
+
+	BulletConstraint3D::~BulletConstraint3D()
+	{
+		if (m_constraint)
+		{
+			btDynamicsWorld* world = GetWorld().GetDynamicsWorld();
+			world->removeConstraint(m_constraint.get());
+		}
+	}
+
+	BulletRigidBody3D& BulletConstraint3D::GetBodyA()
+	{
+		return *static_cast<BulletRigidBody3D*>(m_constraint->getRigidBodyA().getUserPointer());
+	}
+
+	const BulletRigidBody3D& BulletConstraint3D::GetBodyA() const
+	{
+		return *static_cast<BulletRigidBody3D*>(m_constraint->getRigidBodyA().getUserPointer());
+	}
+
+	BulletRigidBody3D& BulletConstraint3D::GetBodyB()
+	{
+		NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
+		return *static_cast<BulletRigidBody3D*>(m_constraint->getRigidBodyB().getUserPointer());
+	}
+
+	const BulletRigidBody3D& BulletConstraint3D::GetBodyB() const
+	{
+		NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
+		return *static_cast<BulletRigidBody3D*>(m_constraint->getRigidBodyB().getUserPointer());
+	}
+
+	BulletPhysWorld3D& BulletConstraint3D::GetWorld()
+	{
+		return *GetBodyA().GetWorld();
+	}
+
+	const BulletPhysWorld3D& BulletConstraint3D::GetWorld() const
+	{
+		return *GetBodyA().GetWorld();
+	}
+
+	bool BulletConstraint3D::IsSingleBody() const
+	{
+		return &m_constraint->getRigidBodyB() == &btTypedConstraint::getFixedBody();
+	}
+
+	BulletConstraint3D& BulletConstraint3D::operator=(BulletConstraint3D&& constraint) noexcept
+	{
+		m_constraint.reset();
+
+		m_constraint = std::move(constraint.m_constraint);
+		m_bodyCollisionEnabled = constraint.m_bodyCollisionEnabled;
+
+		if (m_constraint)
+			m_constraint->setUserConstraintPtr(this);
+
+		return *this;
+	}
+
+
+	BulletPivotConstraint3D::BulletPivotConstraint3D(BulletRigidBody3D& first, const Vector3f& pivot) :
+	BulletConstraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), ToBullet(first.ToLocal(pivot))))
+	{
+	}
+
+	BulletPivotConstraint3D::BulletPivotConstraint3D(BulletRigidBody3D& first, BulletRigidBody3D& second, const Vector3f& pivot, bool disableCollisions) :
+	BulletConstraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), *second.GetRigidBody(), ToBullet(first.ToLocal(pivot)), ToBullet(second.ToLocal(pivot))), disableCollisions)
+	{
+	}
+
+	BulletPivotConstraint3D::BulletPivotConstraint3D(BulletRigidBody3D& first, BulletRigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor, bool disableCollisions) :
+	BulletConstraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), *second.GetRigidBody(), ToBullet(firstAnchor), ToBullet(secondAnchor)), disableCollisions)
+	{
+	}
+
+	Vector3f BulletPivotConstraint3D::GetFirstAnchor() const
+	{
+		return FromBullet(GetConstraint<btPoint2PointConstraint>()->getPivotInA());
+	}
+
+	Vector3f BulletPivotConstraint3D::GetSecondAnchor() const
+	{
+		return FromBullet(GetConstraint<btPoint2PointConstraint>()->getPivotInB());
+	}
+
+	void BulletPivotConstraint3D::SetFirstAnchor(const Vector3f& firstAnchor)
+	{
+		GetConstraint<btPoint2PointConstraint>()->setPivotA(ToBullet(firstAnchor));
+	}
+
+	void BulletPivotConstraint3D::SetSecondAnchor(const Vector3f& secondAnchor)
+	{
+		GetConstraint<btPoint2PointConstraint>()->setPivotB(ToBullet(secondAnchor));
+	}
+}

src/Nazara/BulletPhysics3D/BulletHelper.hpp

@@ -1,17 +1,17 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
 
-#ifndef NAZARA_PHYSICS3D_BULLETHELPER_HPP
+#ifndef NAZARA_BULLETPHYSICS3D_BULLETHELPER_HPP
-#define NAZARA_PHYSICS3D_BULLETHELPER_HPP
+#define NAZARA_BULLETPHYSICS3D_BULLETHELPER_HPP
 
 #include <Nazara/Prerequisites.hpp>
+#include <Nazara/BulletPhysics3D/Config.hpp>
 #include <Nazara/Math/Matrix4.hpp>
 #include <Nazara/Math/Quaternion.hpp>
 #include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Physics3D/Config.hpp>
 #include <LinearMath/btQuaternion.h>
 #include <LinearMath/btTransform.h>
 #include <LinearMath/btVector3.h>
@@ -27,6 +27,6 @@ namespace Nz
 	inline btVector3 ToBullet(const Vector3f& vec);
 }
 
-#include <Nazara/Physics3D/BulletHelper.inl>
+#include <Nazara/BulletPhysics3D/BulletHelper.inl>
 
-#endif // NAZARA_PHYSICS3D_BULLETHELPER_HPP
+#endif // NAZARA_BULLETPHYSICS3D_BULLETHELPER_HPP

src/Nazara/BulletPhysics3D/BulletHelper.inl

@@ -1,8 +1,8 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics3D/Debug.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
 
 namespace Nz
 {
@@ -57,4 +57,4 @@ namespace Nz
 	}
 }
 
-#include <Nazara/Physics3D/DebugOff.hpp>
+#include <Nazara/BulletPhysics3D/DebugOff.hpp>

src/Nazara/BulletPhysics3D/BulletPhysWorld3D.cpp

@@ -1,9 +1,9 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics3D/PhysWorld3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletPhysWorld3D.hpp>
-#include <Nazara/Physics3D/BulletHelper.hpp>
+#include <Nazara/BulletPhysics3D/BulletHelper.hpp>
 #include <Nazara/Utils/MemoryPool.hpp>
 #include <Nazara/Utils/StackVector.hpp>
 #include <BulletCollision/BroadphaseCollision/btDbvtBroadphase.h>
@@ -12,11 +12,11 @@
 #include <BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h>
 #include <BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h>
 #include <cassert>
-#include <Nazara/Physics3D/Debug.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
 
 namespace Nz
 {
-	struct PhysWorld3D::BulletWorld
+	struct BulletPhysWorld3D::BulletWorld
 	{
 		btDefaultCollisionConfiguration collisionConfiguration;
 		btCollisionDispatcher dispatcher;
@@ -39,7 +39,7 @@ namespace Nz
 		BulletWorld& operator=(BulletWorld&&) = delete;
 	};
 
-	PhysWorld3D::PhysWorld3D() :
+	BulletPhysWorld3D::BulletPhysWorld3D() :
 	m_maxStepCount(50),
 	m_gravity(Vector3f::Zero()),
 	m_stepSize(Time::TickDuration(120)),
@@ -48,29 +48,29 @@ namespace Nz
 		m_world = std::make_unique<BulletWorld>();
 	}
 
-	PhysWorld3D::~PhysWorld3D() = default;
+	BulletPhysWorld3D::~BulletPhysWorld3D() = default;
 
-	btDynamicsWorld* PhysWorld3D::GetDynamicsWorld()
+	btDynamicsWorld* BulletPhysWorld3D::GetDynamicsWorld()
 	{
 		return &m_world->dynamicWorld;
 	}
 
-	Vector3f PhysWorld3D::GetGravity() const
+	Vector3f BulletPhysWorld3D::GetGravity() const
 	{
 		return FromBullet(m_world->dynamicWorld.getGravity());
 	}
 
-	std::size_t PhysWorld3D::GetMaxStepCount() const
+	std::size_t BulletPhysWorld3D::GetMaxStepCount() const
 	{
 		return m_maxStepCount;
 	}
 
-	Time PhysWorld3D::GetStepSize() const
+	Time BulletPhysWorld3D::GetStepSize() const
 	{
 		return m_stepSize;
 	}
 
-	bool PhysWorld3D::RaycastQueryFirst(const Vector3f& from, const Vector3f& to, RaycastHit* hitInfo)
+	bool BulletPhysWorld3D::RaycastQueryFirst(const Vector3f& from, const Vector3f& to, RaycastHit* hitInfo)
 	{
 		btCollisionWorld::ClosestRayResultCallback callback(ToBullet(from), ToBullet(to));
 		m_world->dynamicWorld.rayTest(ToBullet(from), ToBullet(to), callback);
@@ -85,28 +85,28 @@ namespace Nz
 			hitInfo->hitPosition = FromBullet(callback.m_hitPointWorld);
 
 			if (const btRigidBody* body = btRigidBody::upcast(callback.m_collisionObject))
-				hitInfo->hitBody = static_cast<RigidBody3D*>(body->getUserPointer());
+				hitInfo->hitBody = static_cast<BulletRigidBody3D*>(body->getUserPointer());
 		}
 
 		return true;
 	}
 
-	void PhysWorld3D::SetGravity(const Vector3f& gravity)
+	void BulletPhysWorld3D::SetGravity(const Vector3f& gravity)
 	{
 		m_world->dynamicWorld.setGravity(ToBullet(gravity));
 	}
 
-	void PhysWorld3D::SetMaxStepCount(std::size_t maxStepCount)
+	void BulletPhysWorld3D::SetMaxStepCount(std::size_t maxStepCount)
 	{
 		m_maxStepCount = maxStepCount;
 	}
 
-	void PhysWorld3D::SetStepSize(Time stepSize)
+	void BulletPhysWorld3D::SetStepSize(Time stepSize)
 	{
 		m_stepSize = stepSize;
 	}
 
-	void PhysWorld3D::Step(Time timestep)
+	void BulletPhysWorld3D::Step(Time timestep)
 	{
 		m_timestepAccumulator += timestep;
 
@@ -121,7 +121,7 @@ namespace Nz
 		}
 	}
 
-	btRigidBody* PhysWorld3D::AddRigidBody(std::size_t& rigidBodyIndex, FunctionRef<void(btRigidBody* body)> constructor)
+	btRigidBody* BulletPhysWorld3D::AddRigidBody(std::size_t& rigidBodyIndex, FunctionRef<void(btRigidBody* body)> constructor)
 	{
 		btRigidBody* rigidBody = m_world->rigidBodyPool.Allocate(m_world->rigidBodyPool.DeferConstruct, rigidBodyIndex);
 		constructor(rigidBody);
@@ -148,7 +148,7 @@ namespace Nz
 		return rigidBody;
 	}
 
-	void PhysWorld3D::RemoveRigidBody(btRigidBody* rigidBody, std::size_t rigidBodyIndex)
+	void BulletPhysWorld3D::RemoveRigidBody(btRigidBody* rigidBody, std::size_t rigidBodyIndex)
 	{
 		// TODO: Improve deletion (since rigid bodies are sorted)
 		m_world->dynamicWorld.removeRigidBody(rigidBody); //< this does a linear search

src/Nazara/BulletPhysics3D/BulletPhysics3D.cpp

@@ -0,0 +1,21 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/BulletPhysics3D/BulletPhysics3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletCollider3D.hpp>
+#include <Nazara/BulletPhysics3D/Config.hpp>
+#include <Nazara/Core/Core.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/Log.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
+
+namespace Nz
+{
+	BulletPhysics3D::BulletPhysics3D(Config /*config*/) :
+	ModuleBase("BulletPhysics3D", this)
+	{
+	}
+
+	BulletPhysics3D* BulletPhysics3D::s_instance;
+}

src/Nazara/BulletPhysics3D/BulletRigidBody3D.cpp

@@ -1,26 +1,26 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics3D/RigidBody3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletRigidBody3D.hpp>
-#include <Nazara/Physics3D/BulletHelper.hpp>
+#include <Nazara/BulletPhysics3D/BulletHelper.hpp>
-#include <Nazara/Physics3D/PhysWorld3D.hpp>
+#include <Nazara/BulletPhysics3D/BulletPhysWorld3D.hpp>
 #include <Nazara/Utils/MemoryHelper.hpp>
 #include <BulletDynamics/Dynamics/btDynamicsWorld.h>
 #include <BulletDynamics/Dynamics/btRigidBody.h>
 #include <algorithm>
 #include <array>
 #include <cmath>
-#include <Nazara/Physics3D/Debug.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
 
 namespace Nz
 {
-	RigidBody3D::RigidBody3D(PhysWorld3D* world, const Matrix4f& mat) :
+	BulletRigidBody3D::BulletRigidBody3D(BulletPhysWorld3D* world, const Matrix4f& mat) :
-	RigidBody3D(world, nullptr, mat)
+	BulletRigidBody3D(world, nullptr, mat)
 	{
 	}
 
-	RigidBody3D::RigidBody3D(PhysWorld3D* world, std::shared_ptr<Collider3D> geom, const Matrix4f& mat) :
+	BulletRigidBody3D::BulletRigidBody3D(BulletPhysWorld3D* world, std::shared_ptr<BulletCollider3D> geom, const Matrix4f& mat) :
 	m_geom(std::move(geom)),
 	m_world(world)
 	{
@@ -42,7 +42,7 @@ namespace Nz
 		m_body->setUserPointer(this);
 	}
 
-	RigidBody3D::RigidBody3D(RigidBody3D&& object) noexcept :
+	BulletRigidBody3D::BulletRigidBody3D(BulletRigidBody3D&& object) noexcept :
 	m_geom(std::move(object.m_geom)),
 	m_bodyPoolIndex(object.m_bodyPoolIndex),
 	m_body(object.m_body),
@@ -54,12 +54,12 @@ namespace Nz
 		object.m_body = nullptr;
 	}
 
-	RigidBody3D::~RigidBody3D()
+	BulletRigidBody3D::~BulletRigidBody3D()
 	{
 		Destroy();
 	}
 
-	void RigidBody3D::AddForce(const Vector3f& force, CoordSys coordSys)
+	void BulletRigidBody3D::AddForce(const Vector3f& force, CoordSys coordSys)
 	{
 		switch (coordSys)
 		{
@@ -75,7 +75,7 @@ namespace Nz
 		}
 	}
 
-	void RigidBody3D::AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys)
+	void BulletRigidBody3D::AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys)
 	{
 		switch (coordSys)
 		{
@@ -92,7 +92,7 @@ namespace Nz
 		}
 	}
 
-	void RigidBody3D::AddTorque(const Vector3f& torque, CoordSys coordSys)
+	void BulletRigidBody3D::AddTorque(const Vector3f& torque, CoordSys coordSys)
 	{
 		switch (coordSys)
 		{
@@ -109,7 +109,7 @@ namespace Nz
 		}
 	}
 
-	void RigidBody3D::EnableSleeping(bool enable)
+	void BulletRigidBody3D::EnableSleeping(bool enable)
 	{
 		if (enable)
 		{
@@ -123,13 +123,13 @@ namespace Nz
 		}
 	}
 
-	void RigidBody3D::FallAsleep()
+	void BulletRigidBody3D::FallAsleep()
 	{
 		if (m_body->getActivationState() != DISABLE_DEACTIVATION)
 			m_body->setActivationState(ISLAND_SLEEPING);
 	}
 
-	Boxf RigidBody3D::GetAABB() const
+	Boxf BulletRigidBody3D::GetAABB() const
 	{
 		btVector3 min, max;
 		m_body->getAabb(min, max);
@@ -137,77 +137,77 @@ namespace Nz
 		return Boxf(FromBullet(min), FromBullet(max));
 	}
 
-	float RigidBody3D::GetAngularDamping() const
+	float BulletRigidBody3D::GetAngularDamping() const
 	{
 		return m_body->getAngularDamping();
 	}
 
-	Vector3f RigidBody3D::GetAngularVelocity() const
+	Vector3f BulletRigidBody3D::GetAngularVelocity() const
 	{
 		return FromBullet(m_body->getAngularVelocity());
 	}
 
-	float RigidBody3D::GetLinearDamping() const
+	float BulletRigidBody3D::GetLinearDamping() const
 	{
 		return m_body->getLinearDamping();
 	}
 
-	Vector3f RigidBody3D::GetLinearVelocity() const
+	Vector3f BulletRigidBody3D::GetLinearVelocity() const
 	{
 		return FromBullet(m_body->getLinearVelocity());
 	}
 
-	float RigidBody3D::GetMass() const
+	float BulletRigidBody3D::GetMass() const
 	{
 		return m_body->getMass();
 	}
 
-	Vector3f RigidBody3D::GetMassCenter(CoordSys coordSys) const
+	Vector3f BulletRigidBody3D::GetMassCenter(CoordSys coordSys) const
 	{
 		return FromBullet(m_body->getCenterOfMassPosition());
 	}
 
-	Matrix4f RigidBody3D::GetMatrix() const
+	Matrix4f BulletRigidBody3D::GetMatrix() const
 	{
 		return FromBullet(m_body->getWorldTransform());
 	}
 
-	Vector3f RigidBody3D::GetPosition() const
+	Vector3f BulletRigidBody3D::GetPosition() const
 	{
 		return FromBullet(m_body->getWorldTransform().getOrigin());
 	}
 
-	Quaternionf RigidBody3D::GetRotation() const
+	Quaternionf BulletRigidBody3D::GetRotation() const
 	{
 		return FromBullet(m_body->getWorldTransform().getRotation());
 	}
 
-	bool RigidBody3D::IsSimulationEnabled() const
+	bool BulletRigidBody3D::IsSimulationEnabled() const
 	{
 		return m_body->isActive();
 	}
 
-	bool RigidBody3D::IsSleeping() const
+	bool BulletRigidBody3D::IsSleeping() const
 	{
 		return m_body->getActivationState() == ISLAND_SLEEPING;
 	}
 
-	bool RigidBody3D::IsSleepingEnabled() const
+	bool BulletRigidBody3D::IsSleepingEnabled() const
 	{
 		return m_body->getActivationState() != DISABLE_DEACTIVATION;
 	}
 
-	void RigidBody3D::SetAngularDamping(float angularDamping)
+	void BulletRigidBody3D::SetAngularDamping(float angularDamping)
 	{
 		m_body->setDamping(m_body->getLinearDamping(), angularDamping);
 	}
 
-	void RigidBody3D::SetAngularVelocity(const Vector3f& angularVelocity)
+	void BulletRigidBody3D::SetAngularVelocity(const Vector3f& angularVelocity)
 	{
 		m_body->setAngularVelocity(ToBullet(angularVelocity));
 	}
 
-	void RigidBody3D::SetGeom(std::shared_ptr<Collider3D> geom, bool recomputeInertia)
+	void BulletRigidBody3D::SetGeom(std::shared_ptr<BulletCollider3D> geom, bool recomputeInertia)
 	{
 		if (m_geom != geom)
 		{
@@ -229,17 +229,17 @@ namespace Nz
 		}
 	}
 
-	void RigidBody3D::SetLinearDamping(float damping)
+	void BulletRigidBody3D::SetLinearDamping(float damping)
 	{
 		m_body->setDamping(damping, m_body->getAngularDamping());
 	}
 
-	void RigidBody3D::SetLinearVelocity(const Vector3f& velocity)
+	void BulletRigidBody3D::SetLinearVelocity(const Vector3f& velocity)
 	{
 		m_body->setLinearVelocity(ToBullet(velocity));
 	}
 
-	void RigidBody3D::SetMass(float mass)
+	void BulletRigidBody3D::SetMass(float mass)
 	{
 		NazaraAssert(mass >= 0.f, "Mass must be positive and finite");
 		NazaraAssert(std::isfinite(mass), "Mass must be positive and finite");
@@ -250,7 +250,7 @@ namespace Nz
 		m_body->setMassProps(mass, ToBullet(inertia));
 	}
 
-	void RigidBody3D::SetMassCenter(const Vector3f& center)
+	void BulletRigidBody3D::SetMassCenter(const Vector3f& center)
 	{
 		btTransform centerTransform;
 		centerTransform.setIdentity();
@@ -259,7 +259,7 @@ namespace Nz
 		m_body->setCenterOfMassTransform(centerTransform);
 	}
 
-	void RigidBody3D::SetPosition(const Vector3f& position)
+	void BulletRigidBody3D::SetPosition(const Vector3f& position)
 	{
 		btTransform worldTransform = m_body->getWorldTransform();
 		worldTransform.setOrigin(ToBullet(position));
@@ -267,7 +267,7 @@ namespace Nz
 		m_body->setWorldTransform(worldTransform);
 	}
 
-	void RigidBody3D::SetRotation(const Quaternionf& rotation)
+	void BulletRigidBody3D::SetRotation(const Quaternionf& rotation)
 	{
 		btTransform worldTransform = m_body->getWorldTransform();
 		worldTransform.setRotation(ToBullet(rotation));
@@ -275,33 +275,33 @@ namespace Nz
 		m_body->setWorldTransform(worldTransform);
 	}
 
-	Quaternionf RigidBody3D::ToLocal(const Quaternionf& worldRotation)
+	Quaternionf BulletRigidBody3D::ToLocal(const Quaternionf& worldRotation)
 	{
 		return GetRotation().Conjugate() * worldRotation;
 	}
 
-	Vector3f RigidBody3D::ToLocal(const Vector3f& worldPosition)
+	Vector3f BulletRigidBody3D::ToLocal(const Vector3f& worldPosition)
 	{
 		btTransform worldTransform = m_body->getWorldTransform();
 		return GetMatrix().InverseTransform() * worldPosition;
 	}
 
-	Quaternionf RigidBody3D::ToWorld(const Quaternionf& localRotation)
+	Quaternionf BulletRigidBody3D::ToWorld(const Quaternionf& localRotation)
 	{
 		return GetRotation() * localRotation;
 	}
 
-	Vector3f RigidBody3D::ToWorld(const Vector3f& localPosition)
+	Vector3f BulletRigidBody3D::ToWorld(const Vector3f& localPosition)
 	{
 		return GetMatrix() * localPosition;
 	}
 
-	void RigidBody3D::WakeUp()
+	void BulletRigidBody3D::WakeUp()
 	{
 		m_body->activate();
 	}
 
-	RigidBody3D& RigidBody3D::operator=(RigidBody3D&& object) noexcept
+	BulletRigidBody3D& BulletRigidBody3D::operator=(BulletRigidBody3D&& object) noexcept
 	{
 		Destroy();
 
@@ -318,7 +318,7 @@ namespace Nz
 		return *this;
 	}
 
-	void RigidBody3D::Destroy()
+	void BulletRigidBody3D::Destroy()
 	{
 		if (m_body)
 		{

src/Nazara/BulletPhysics3D/Components/BulletRigidBody3DComponent.cpp

@@ -0,0 +1,10 @@
+// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/BulletPhysics3D/Components/BulletRigidBody3DComponent.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
+
+namespace Nz
+{
+}

src/Nazara/BulletPhysics3D/Systems/BulletPhysics3DSystem.cpp

@@ -1,32 +1,32 @@
 // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
+// This file is part of the "Nazara Engine - BulletPhysics3D module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Physics3D/Systems/Physics3DSystem.hpp>
+#include <Nazara/BulletPhysics3D/Systems/BulletPhysics3DSystem.hpp>
 #include <Nazara/Utility/Components/NodeComponent.hpp>
-#include <Nazara/Physics3D/Debug.hpp>
+#include <Nazara/BulletPhysics3D/Debug.hpp>
 
 namespace Nz
 {
-	Physics3DSystem::Physics3DSystem(entt::registry& registry) :
+	BulletPhysics3DSystem::BulletPhysics3DSystem(entt::registry& registry) :
 	m_registry(registry),
-	m_physicsConstructObserver(m_registry, entt::collector.group<RigidBody3DComponent, NodeComponent>())
+	m_physicsConstructObserver(m_registry, entt::collector.group<BulletRigidBody3DComponent, NodeComponent>())
 	{
-		m_constructConnection = registry.on_construct<RigidBody3DComponent>().connect<&Physics3DSystem::OnConstruct>(this);
+		m_constructConnection = registry.on_construct<BulletRigidBody3DComponent>().connect<&BulletPhysics3DSystem::OnConstruct>(this);
-		m_destructConnection = registry.on_destroy<RigidBody3DComponent>().connect<&Physics3DSystem::OnDestruct>(this);
+		m_destructConnection = registry.on_destroy<BulletRigidBody3DComponent>().connect<&BulletPhysics3DSystem::OnDestruct>(this);
 	}
 
-	Physics3DSystem::~Physics3DSystem()
+	BulletPhysics3DSystem::~BulletPhysics3DSystem()
 	{
 		m_physicsConstructObserver.disconnect();
 
 		// Ensure every RigidBody3D is destroyed before world is
-		auto rigidBodyView = m_registry.view<RigidBody3DComponent>();
+		auto rigidBodyView = m_registry.view<BulletRigidBody3DComponent>();
 		for (auto [entity, rigidBodyComponent] : rigidBodyView.each())
 			rigidBodyComponent.Destroy();
 	}
 
-	bool Physics3DSystem::RaycastQueryFirst(const Vector3f& from, const Vector3f& to, RaycastHit* hitInfo)
+	bool BulletPhysics3DSystem::RaycastQueryFirst(const Vector3f& from, const Vector3f& to, RaycastHit* hitInfo)
 	{
 		if (!m_physWorld.RaycastQueryFirst(from, to, hitInfo))
 			return false;
@@ -41,12 +41,12 @@ namespace Nz
 		return true;
 	}
 
-	void Physics3DSystem::Update(Time elapsedTime)
+	void BulletPhysics3DSystem::Update(Time elapsedTime)
 	{
 		// Move newly-created physics entities to their node position/rotation
 		m_physicsConstructObserver.each([&](entt::entity entity)
 		{
-			RigidBody3DComponent& entityPhysics = m_registry.get<RigidBody3DComponent>(entity);
+			BulletRigidBody3DComponent& entityPhysics = m_registry.get<BulletRigidBody3DComponent>(entity);
 			NodeComponent& entityNode = m_registry.get<NodeComponent>(entity);
 
 			entityPhysics.SetPosition(entityNode.GetPosition(CoordSys::Global));
@@ -58,7 +58,7 @@ namespace Nz
 
 		// Replicate rigid body position to their node components
 		// TODO: Only replicate active entities
-		auto view = m_registry.view<NodeComponent, const RigidBody3DComponent>();
+		auto view = m_registry.view<NodeComponent, const BulletRigidBody3DComponent>();
 		for (auto [entity, nodeComponent, rigidBodyComponent] : view.each())
 		{
 			if (rigidBodyComponent.IsSleeping())
@@ -69,10 +69,10 @@ namespace Nz
 		}
 	}
 
-	void Physics3DSystem::OnConstruct(entt::registry& registry, entt::entity entity)
+	void BulletPhysics3DSystem::OnConstruct(entt::registry& registry, entt::entity entity)
 	{
 		// Register rigid body owning entity
-		RigidBody3DComponent& rigidBody = registry.get<RigidBody3DComponent>(entity);
+		BulletRigidBody3DComponent& rigidBody = registry.get<BulletRigidBody3DComponent>(entity);
 		std::size_t uniqueIndex = rigidBody.GetUniqueIndex();
 		if (uniqueIndex >= m_physicsEntities.size())
 			m_physicsEntities.resize(uniqueIndex + 1);
@@ -80,10 +80,10 @@ namespace Nz
 		m_physicsEntities[uniqueIndex] = entity;
 	}
 
-	void Physics3DSystem::OnDestruct(entt::registry& registry, entt::entity entity)
+	void BulletPhysics3DSystem::OnDestruct(entt::registry& registry, entt::entity entity)
 	{
 		// Unregister owning entity
-		RigidBody3DComponent& rigidBody = registry.get<RigidBody3DComponent>(entity);
+		BulletRigidBody3DComponent& rigidBody = registry.get<BulletRigidBody3DComponent>(entity);
 		std::size_t uniqueIndex = rigidBody.GetUniqueIndex();
 		assert(uniqueIndex <= m_physicsEntities.size());
 

src/Nazara/Physics3D/Components/RigidBody3DComponent.cpp

@@ -1,10 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Physics3D/Components/RigidBody3DComponent.hpp>
-#include <Nazara/Physics3D/Debug.hpp>
-
-namespace Nz
-{
-}

src/Nazara/Physics3D/Constraint3D.cpp

@@ -1,123 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Physics3D/Constraint3D.hpp>
-#include <Nazara/Physics3D/BulletHelper.hpp>
-#include <BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h>
-#include <BulletDynamics/Dynamics/btDynamicsWorld.h>
-#include <Nazara/Physics3D/Debug.hpp>
-
-namespace Nz
-{
-	Constraint3D::Constraint3D(std::unique_ptr<btTypedConstraint> constraint, bool disableCollisions) :
-	m_constraint(std::move(constraint)),
-	m_bodyCollisionEnabled(!disableCollisions)
-	{
-		btDynamicsWorld* world = GetWorld().GetDynamicsWorld();
-		world->addConstraint(m_constraint.get(), disableCollisions);
-	}
-
-	Constraint3D::Constraint3D(Constraint3D&& constraint) noexcept :
-	m_constraint(std::move(constraint.m_constraint)),
-	m_bodyCollisionEnabled(constraint.m_bodyCollisionEnabled)
-	{
-		if (m_constraint)
-			m_constraint->setUserConstraintPtr(this);
-	}
-
-	Constraint3D::~Constraint3D()
-	{
-		if (m_constraint)
-		{
-			btDynamicsWorld* world = GetWorld().GetDynamicsWorld();
-			world->removeConstraint(m_constraint.get());
-		}
-	}
-
-	RigidBody3D& Constraint3D::GetBodyA()
-	{
-		return *static_cast<RigidBody3D*>(m_constraint->getRigidBodyA().getUserPointer());
-	}
-
-	const RigidBody3D& Constraint3D::GetBodyA() const
-	{
-		return *static_cast<RigidBody3D*>(m_constraint->getRigidBodyA().getUserPointer());
-	}
-
-	RigidBody3D& Constraint3D::GetBodyB()
-	{
-		NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
-		return *static_cast<RigidBody3D*>(m_constraint->getRigidBodyB().getUserPointer());
-	}
-
-	const RigidBody3D& Constraint3D::GetBodyB() const
-	{
-		NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
-		return *static_cast<RigidBody3D*>(m_constraint->getRigidBodyB().getUserPointer());
-	}
-
-	PhysWorld3D& Constraint3D::GetWorld()
-	{
-		return *GetBodyA().GetWorld();
-	}
-
-	const PhysWorld3D& Constraint3D::GetWorld() const
-	{
-		return *GetBodyA().GetWorld();
-	}
-
-	bool Constraint3D::IsSingleBody() const
-	{
-		return &m_constraint->getRigidBodyB() == &btTypedConstraint::getFixedBody();
-	}
-
-	Constraint3D& Constraint3D::operator=(Constraint3D&& constraint) noexcept
-	{
-		m_constraint.reset();
-
-		m_constraint = std::move(constraint.m_constraint);
-		m_bodyCollisionEnabled = constraint.m_bodyCollisionEnabled;
-
-		if (m_constraint)
-			m_constraint->setUserConstraintPtr(this);
-
-		return *this;
-	}
-
-
-	PivotConstraint3D::PivotConstraint3D(RigidBody3D& first, const Vector3f& pivot) :
-	Constraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), ToBullet(first.ToLocal(pivot))))
-	{
-	}
-
-	PivotConstraint3D::PivotConstraint3D(RigidBody3D& first, RigidBody3D& second, const Vector3f& pivot, bool disableCollisions) :
-	Constraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), *second.GetRigidBody(), ToBullet(first.ToLocal(pivot)), ToBullet(second.ToLocal(pivot))), disableCollisions)
-	{
-	}
-
-	PivotConstraint3D::PivotConstraint3D(RigidBody3D& first, RigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor, bool disableCollisions) :
-	Constraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), *second.GetRigidBody(), ToBullet(firstAnchor), ToBullet(secondAnchor)), disableCollisions)
-	{
-	}
-
-	Vector3f PivotConstraint3D::GetFirstAnchor() const
-	{
-		return FromBullet(GetConstraint<btPoint2PointConstraint>()->getPivotInA());
-	}
-
-	Vector3f PivotConstraint3D::GetSecondAnchor() const
-	{
-		return FromBullet(GetConstraint<btPoint2PointConstraint>()->getPivotInB());
-	}
-
-	void PivotConstraint3D::SetFirstAnchor(const Vector3f& firstAnchor)
-	{
-		GetConstraint<btPoint2PointConstraint>()->setPivotA(ToBullet(firstAnchor));
-	}
-
-	void PivotConstraint3D::SetSecondAnchor(const Vector3f& secondAnchor)
-	{
-		GetConstraint<btPoint2PointConstraint>()->setPivotB(ToBullet(secondAnchor));
-	}
-}

src/Nazara/Physics3D/Physics3D.cpp

@@ -1,21 +0,0 @@
-// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
-// This file is part of the "Nazara Engine - Physics3D module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Physics3D/Physics3D.hpp>
-#include <Nazara/Core/Core.hpp>
-#include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/Log.hpp>
-#include <Nazara/Physics3D/Collider3D.hpp>
-#include <Nazara/Physics3D/Config.hpp>
-#include <Nazara/Physics3D/Debug.hpp>
-
-namespace Nz
-{
-	Physics3D::Physics3D(Config /*config*/) :
-	ModuleBase("Physics3D", this)
-	{
-	}
-
-	Physics3D* Physics3D::s_instance;
-}

tests/UnitTests/Engine/Modules.hpp

@@ -3,5 +3,5 @@
 #include <Nazara/Math.hpp>
 #include <Nazara/Network.hpp>
 #include <Nazara/Physics2D.hpp>
-#include <Nazara/Physics3D.hpp>
+#include <Nazara/BulletPhysics3D.hpp>
 #include <Nazara/Utility.hpp>

xmake.lua

@@ -122,7 +122,7 @@ local modules = {
 		Deps = {"NazaraUtility"},
 		Packages = { "chipmunk2d", "entt" }
 	},
-	Physics3D = {
+	BulletPhysics3D = {
 		Deps = {"NazaraUtility"},
 		Packages = { "bullet3", "entt", "ordered_map" }
 	},