diff --git a/examples/Physics2DDemo/main.cpp b/examples/Physics2DDemo/main.cpp index 7c0d1c58f..d52fe274c 100644 --- a/examples/Physics2DDemo/main.cpp +++ b/examples/Physics2DDemo/main.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -21,14 +21,14 @@ int main() if (!std::filesystem::is_directory(resourceDir) && std::filesystem::is_directory("../.." / resourceDir)) resourceDir = "../.." / resourceDir; - Nz::Application app; + Nz::Application app; auto& windowing = app.AddComponent(); auto& ecs = app.AddComponent(); auto& world = ecs.AddWorld(); - Nz::Physics2DSystem& physSytem = world.AddSystem(); + Nz::ChipmunkPhysics2DSystem& physSytem = world.AddSystem(); Nz::RenderSystem& renderSystem = world.AddSystem(); std::string windowTitle = "Physics 2D"; @@ -72,7 +72,7 @@ int main() spriteEntity.emplace().SetPosition(windowSize.x * 0.5f + x * 48.f - 15.f * 48.f, windowSize.y / 2 + y * 48.f); spriteEntity.emplace().AttachRenderable(sprite, 1); - auto& rigidBody = spriteEntity.emplace(physSytem.CreateRigidBody(50.f, std::make_shared(Nz::Vector2f(32.f, 32.f)))); + auto& rigidBody = spriteEntity.emplace(physSytem.CreateRigidBody(50.f, std::make_shared(Nz::Vector2f(32.f, 32.f)))); rigidBody.SetFriction(0.9f); //rigidBody.SetElasticity(0.99f); } @@ -101,7 +101,7 @@ int main() groundEntity.emplace().SetPosition(windowSize.x * 0.5f, -windowSize.y * 0.2f); groundEntity.emplace().AttachRenderable(tilemap, 1); - auto& rigidBody = groundEntity.emplace(physSytem.CreateRigidBody(0.f, std::make_shared(tilemap->GetSize()))); + auto& rigidBody = groundEntity.emplace(physSytem.CreateRigidBody(0.f, std::make_shared(tilemap->GetSize()))); rigidBody.SetFriction(0.9f); } diff --git a/examples/Physics2DDemo/xmake.lua b/examples/Physics2DDemo/xmake.lua index 9fd5ccd4a..bf4c5dcca 100644 --- a/examples/Physics2DDemo/xmake.lua +++ b/examples/Physics2DDemo/xmake.lua @@ -1,5 +1,5 @@ target("Physics2DDemo") - add_deps("NazaraGraphics", "NazaraPhysics2D") + add_deps("NazaraGraphics", "NazaraChipmunkPhysics2D") add_packages("entt") add_files("main.cpp") add_defines("NAZARA_ENTT") diff --git a/examples/Showcase/xmake.lua b/examples/Showcase/xmake.lua index 2bdda971f..545b821f3 100644 --- a/examples/Showcase/xmake.lua +++ b/examples/Showcase/xmake.lua @@ -5,7 +5,7 @@ end target("Showcase") set_group("Examples") set_kind("binary") - add_deps("NazaraAudio", "NazaraGraphics", "NazaraPhysics2D", "NazaraBulletPhysics3D", "NazaraJoltPhysics3D", "NazaraWidgets") + add_deps("NazaraAudio", "NazaraGraphics", "NazaraChipmunkPhysics2D", "NazaraBulletPhysics3D", "NazaraJoltPhysics3D", "NazaraWidgets") if has_config("embed_plugins") then add_deps("PluginAssimp") else diff --git a/examples/Tut00/main.cpp b/examples/Tut00/main.cpp index ed1817fbf..9c0d835a5 100644 --- a/examples/Tut00/main.cpp +++ b/examples/Tut00/main.cpp @@ -2,8 +2,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -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 app; + Nz::Application app; return EXIT_SUCCESS; } diff --git a/examples/Tut00/xmake.lua b/examples/Tut00/xmake.lua index 7d4d4f16c..db9171dc9 100644 --- a/examples/Tut00/xmake.lua +++ b/examples/Tut00/xmake.lua @@ -1,3 +1,3 @@ target("Tut00_EmptyProject") - add_deps("NazaraAudio", "NazaraGraphics", "NazaraNetwork", "NazaraPhysics2D", "NazaraBulletPhysics3D", "NazaraRenderer", "NazaraUtility") + add_deps("NazaraAudio", "NazaraGraphics", "NazaraNetwork", "NazaraChipmunkPhysics2D", "NazaraBulletPhysics3D", "NazaraRenderer", "NazaraUtility") add_files("main.cpp") diff --git a/include/Nazara/BulletPhysics3D/BulletCollider3D.hpp b/include/Nazara/BulletPhysics3D/BulletCollider3D.hpp index 070ff7456..207385dce 100644 --- a/include/Nazara/BulletPhysics3D/BulletCollider3D.hpp +++ b/include/Nazara/BulletPhysics3D/BulletCollider3D.hpp @@ -53,7 +53,7 @@ namespace Nz virtual std::shared_ptr GenerateDebugMesh() const; virtual btCollisionShape* GetShape() const = 0; - virtual ColliderType3D GetType() const = 0; + virtual BulletColliderType3D GetType() const = 0; BulletCollider3D& operator=(const BulletCollider3D&) = delete; BulletCollider3D& operator=(BulletCollider3D&&) = delete; @@ -74,7 +74,7 @@ namespace Nz Vector3f GetLengths() const; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; private: std::unique_ptr m_shape; @@ -92,7 +92,7 @@ namespace Nz float GetLength() const; float GetRadius() const; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; private: std::unique_ptr m_shape; @@ -112,7 +112,7 @@ namespace Nz const std::vector& GetGeoms() const; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; struct ChildCollider { @@ -136,7 +136,7 @@ namespace Nz float GetLength() const; float GetRadius() const; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; private: std::unique_ptr m_shape; @@ -153,7 +153,7 @@ namespace Nz void BuildDebugMesh(std::vector& vertices, std::vector& indices, const Matrix4f& offsetMatrix) const override; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; private: std::unique_ptr m_shape; @@ -170,7 +170,7 @@ namespace Nz float GetLength() const; float GetRadius() const; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; private: std::unique_ptr m_shape; @@ -190,7 +190,7 @@ namespace Nz void ComputeInertia(float mass, Vector3f* inertia) const override; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; private: std::unique_ptr m_shape; @@ -206,7 +206,7 @@ namespace Nz float GetRadius() const; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; private: std::unique_ptr m_shape; @@ -226,7 +226,7 @@ namespace Nz float GetDistance() const; const Vector3f& GetNormal() const; btCollisionShape* GetShape() const override; - ColliderType3D GetType() const override; + BulletColliderType3D GetType() const override; private: std::unique_ptr m_shape; diff --git a/include/Nazara/BulletPhysics3D/Enums.hpp b/include/Nazara/BulletPhysics3D/Enums.hpp index f864f61a9..6f48dd243 100644 --- a/include/Nazara/BulletPhysics3D/Enums.hpp +++ b/include/Nazara/BulletPhysics3D/Enums.hpp @@ -9,7 +9,7 @@ namespace Nz { - enum class ColliderType3D + enum class BulletColliderType3D { Box, Capsule, diff --git a/include/Nazara/Physics2D.hpp b/include/Nazara/ChipmunkPhysics2D.hpp similarity index 64% rename from include/Nazara/Physics2D.hpp rename to include/Nazara/ChipmunkPhysics2D.hpp index e71661663..3ce6a2eb0 100644 --- a/include/Nazara/Physics2D.hpp +++ b/include/Nazara/ChipmunkPhysics2D.hpp @@ -26,23 +26,23 @@ #pragma once -#ifndef NAZARA_GLOBAL_PHYSICS2D_HPP -#define NAZARA_GLOBAL_PHYSICS2D_HPP +#ifndef NAZARA_GLOBAL_CHIPMUNKPHYSICS2D_HPP +#define NAZARA_GLOBAL_CHIPMUNKPHYSICS2D_HPP -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include #ifdef NAZARA_ENTT -#include -#include +#include +#include #endif -#endif // NAZARA_GLOBAL_PHYSICS2D_HPP +#endif // NAZARA_GLOBAL_CHIPMUNKPHYSICS2D_HPP diff --git a/include/Nazara/Physics2D/Arbiter2D.hpp b/include/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp similarity index 59% rename from include/Nazara/Physics2D/Arbiter2D.hpp rename to include/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp index 05e4ee6ee..67a83d6e2 100644 --- a/include/Nazara/Physics2D/Arbiter2D.hpp +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp @@ -4,32 +4,32 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_ARBITER2D_HPP -#define NAZARA_PHYSICS2D_ARBITER2D_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_ARBITER2D_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_ARBITER2D_HPP #include #include -#include +#include #include struct cpArbiter; namespace Nz { - class RigidBody2D; + class ChipmunkRigidBody2D; - class NAZARA_PHYSICS2D_API Arbiter2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkArbiter2D { public: - inline Arbiter2D(cpArbiter* arbiter); - Arbiter2D(const Arbiter2D&) = delete; - Arbiter2D(Arbiter2D&&) = default; - ~Arbiter2D() = default; + inline ChipmunkArbiter2D(cpArbiter* arbiter); + ChipmunkArbiter2D(const ChipmunkArbiter2D&) = delete; + ChipmunkArbiter2D(ChipmunkArbiter2D&&) = default; + ~ChipmunkArbiter2D() = default; float ComputeTotalKinematicEnergy() const; Nz::Vector2f ComputeTotalImpulse() const; - std::pair GetBodies() const; + std::pair GetBodies() const; std::size_t GetContactCount() const; float GetContactDepth(std::size_t i) const; @@ -48,14 +48,14 @@ namespace Nz void SetFriction(float friction); void SetSurfaceVelocity(const Vector2f& surfaceVelocity); - Arbiter2D& operator=(const Arbiter2D&) = delete; - Arbiter2D& operator=(Arbiter2D&&) = default; + ChipmunkArbiter2D& operator=(const ChipmunkArbiter2D&) = delete; + ChipmunkArbiter2D& operator=(ChipmunkArbiter2D&&) = default; private: MovablePtr m_arbiter; }; } -#include +#include -#endif // NAZARA_PHYSICS2D_ARBITER2D_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_ARBITER2D_HPP diff --git a/include/Nazara/Physics2D/Arbiter2D.inl b/include/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.inl similarity index 62% rename from include/Nazara/Physics2D/Arbiter2D.inl rename to include/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.inl index 93f4aae01..7bc204027 100644 --- a/include/Nazara/Physics2D/Arbiter2D.inl +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.inl @@ -3,14 +3,14 @@ // For conditions of distribution and use, see copyright notice in Config.hpp #include -#include +#include namespace Nz { - inline Arbiter2D::Arbiter2D(cpArbiter* arbiter) : + inline ChipmunkArbiter2D::ChipmunkArbiter2D(cpArbiter* arbiter) : m_arbiter(arbiter) { } } -#include +#include diff --git a/include/Nazara/Physics2D/Collider2D.hpp b/include/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp similarity index 62% rename from include/Nazara/Physics2D/Collider2D.hpp rename to include/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp index c1bea3f87..c9d34f5ce 100644 --- a/include/Nazara/Physics2D/Collider2D.hpp +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp @@ -4,15 +4,15 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_COLLIDER2D_HPP -#define NAZARA_PHYSICS2D_COLLIDER2D_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_COLLIDER2D_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_COLLIDER2D_HPP #include #include #include #include -#include -#include +#include +#include #include #include #include @@ -22,18 +22,18 @@ struct cpShape; namespace Nz { - class RigidBody2D; + class ChipmunkRigidBody2D; - class NAZARA_PHYSICS2D_API Collider2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCollider2D { - friend RigidBody2D; - friend class CompoundCollider2D; //< See CompoundCollider2D::CreateShapes + friend ChipmunkRigidBody2D; + friend class ChipmunkCompoundCollider2D; //< See CompoundCollider2D::CreateShapes public: - inline Collider2D(); - Collider2D(const Collider2D&) = delete; - Collider2D(Collider2D&&) = delete; - virtual ~Collider2D(); + inline ChipmunkCollider2D(); + ChipmunkCollider2D(const ChipmunkCollider2D&) = delete; + ChipmunkCollider2D(ChipmunkCollider2D&&) = delete; + virtual ~ChipmunkCollider2D(); virtual Vector2f ComputeCenterOfMass() const = 0; virtual float ComputeMomentOfInertia(float mass) const = 0; @@ -48,7 +48,7 @@ namespace Nz inline float GetFriction() const; inline Vector2f GetSurfaceVelocity() const; - virtual ColliderType2D GetType() const = 0; + virtual ChipmunkColliderType2D GetType() const = 0; inline bool IsTrigger() const; @@ -61,11 +61,11 @@ namespace Nz inline void SetSurfaceVelocity(const Vector2f& surfaceVelocity); inline void SetTrigger(bool trigger); - Collider2D& operator=(const Collider2D&) = delete; - Collider2D& operator=(Collider2D&&) = delete; + ChipmunkCollider2D& operator=(const ChipmunkCollider2D&) = delete; + ChipmunkCollider2D& operator=(ChipmunkCollider2D&&) = delete; // Signals: - NazaraSignal(OnColliderRelease, const Collider2D* /*collider*/); + NazaraSignal(OnColliderRelease, const ChipmunkCollider2D* /*collider*/); protected: virtual std::size_t CreateShapes(cpBody* body, std::vector* shapes) const = 0; @@ -83,11 +83,11 @@ namespace Nz virtual std::size_t GenerateShapes(cpBody* body, std::vector* shapes) const; }; - class NAZARA_PHYSICS2D_API BoxCollider2D : public Collider2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkBoxCollider2D : public ChipmunkCollider2D { public: - BoxCollider2D(const Vector2f& size, float radius = 0.f); - BoxCollider2D(const Rectf& rect, float radius = 0.f); + ChipmunkBoxCollider2D(const Vector2f& size, float radius = 0.f); + ChipmunkBoxCollider2D(const Rectf& rect, float radius = 0.f); Nz::Vector2f ComputeCenterOfMass() const override; float ComputeMomentOfInertia(float mass) const override; @@ -95,7 +95,7 @@ namespace Nz inline float GetRadius() const; inline const Rectf& GetRect() const; inline Vector2f GetSize() const; - ColliderType2D GetType() const override; + ChipmunkColliderType2D GetType() const override; private: std::size_t CreateShapes(cpBody* body, std::vector* shapes) const override; @@ -104,17 +104,17 @@ namespace Nz float m_radius; }; - class NAZARA_PHYSICS2D_API CircleCollider2D : public Collider2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCircleCollider2D : public ChipmunkCollider2D { public: - CircleCollider2D(float radius, const Vector2f& offset = Vector2f::Zero()); + ChipmunkCircleCollider2D(float radius, const Vector2f& offset = Vector2f::Zero()); Nz::Vector2f ComputeCenterOfMass() const override; float ComputeMomentOfInertia(float mass) const override; inline const Vector2f& GetOffset() const; inline float GetRadius() const; - ColliderType2D GetType() const override; + ChipmunkColliderType2D GetType() const override; private: std::size_t CreateShapes(cpBody* body, std::vector* shapes) const override; @@ -123,18 +123,18 @@ namespace Nz float m_radius; }; - class NAZARA_PHYSICS2D_API CompoundCollider2D : public Collider2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCompoundCollider2D : public ChipmunkCollider2D { public: - CompoundCollider2D(std::vector> geoms); + ChipmunkCompoundCollider2D(std::vector> geoms); Nz::Vector2f ComputeCenterOfMass() const override; float ComputeMomentOfInertia(float mass) const override; inline bool DoesOverrideCollisionProperties() const; - inline const std::vector>& GetGeoms() const; - ColliderType2D GetType() const override; + inline const std::vector>& GetGeoms() const; + ChipmunkColliderType2D GetType() const override; inline void OverridesCollisionProperties(bool shouldOverride); @@ -142,19 +142,19 @@ namespace Nz std::size_t CreateShapes(cpBody* body, std::vector* shapes) const override; std::size_t GenerateShapes(cpBody* body, std::vector* shapes) const override; - std::vector> m_geoms; + std::vector> m_geoms; bool m_doesOverrideCollisionProperties; }; - class NAZARA_PHYSICS2D_API ConvexCollider2D : public Collider2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkConvexCollider2D : public ChipmunkCollider2D { public: - ConvexCollider2D(SparsePtr vertices, std::size_t vertexCount, float radius = 0.f); + ChipmunkConvexCollider2D(SparsePtr vertices, std::size_t vertexCount, float radius = 0.f); Nz::Vector2f ComputeCenterOfMass() const override; float ComputeMomentOfInertia(float mass) const override; - ColliderType2D GetType() const override; + ChipmunkColliderType2D GetType() const override; inline const std::vector& GetVertices() const; private: @@ -164,25 +164,25 @@ namespace Nz float m_radius; }; - class NAZARA_PHYSICS2D_API NullCollider2D : public Collider2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkNullCollider2D : public ChipmunkCollider2D { public: - NullCollider2D() = default; + ChipmunkNullCollider2D() = default; Nz::Vector2f ComputeCenterOfMass() const override; float ComputeMomentOfInertia(float mass) const override; - ColliderType2D GetType() const override; + ChipmunkColliderType2D GetType() const override; private: std::size_t CreateShapes(cpBody* body, std::vector* shapes) const override; }; - class NAZARA_PHYSICS2D_API SegmentCollider2D : public Collider2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkSegmentCollider2D : public ChipmunkCollider2D { public: - inline SegmentCollider2D(const Vector2f& first, const Vector2f& second, float thickness = 1.f); - inline SegmentCollider2D(const Vector2f& first, const Vector2f& firstNeighbor, const Vector2f& second, const Vector2f& secondNeighbor, float thickness = 1.f); + inline ChipmunkSegmentCollider2D(const Vector2f& first, const Vector2f& second, float thickness = 1.f); + inline ChipmunkSegmentCollider2D(const Vector2f& first, const Vector2f& firstNeighbor, const Vector2f& second, const Vector2f& secondNeighbor, float thickness = 1.f); Nz::Vector2f ComputeCenterOfMass() const override; float ComputeMomentOfInertia(float mass) const override; @@ -193,7 +193,7 @@ namespace Nz inline const Vector2f& GetSecondPoint() const; inline const Vector2f& GetSecondPointNeighbor() const; inline float GetThickness() const; - ColliderType2D GetType() const override; + ChipmunkColliderType2D GetType() const override; private: std::size_t CreateShapes(cpBody* body, std::vector* shapes) const override; @@ -206,6 +206,6 @@ namespace Nz }; } -#include +#include -#endif // NAZARA_PHYSICS2D_COLLIDER2D_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_COLLIDER2D_HPP diff --git a/include/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.inl b/include/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.inl new file mode 100644 index 000000000..4db87a45f --- /dev/null +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.inl @@ -0,0 +1,196 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include + +namespace Nz +{ + inline ChipmunkCollider2D::ChipmunkCollider2D() : + m_categoryMask(0xFFFFFFFF), + m_collisionGroup(0), + m_collisionMask(0xFFFFFFFF), + m_surfaceVelocity(Vector2f::Zero()), + m_trigger(false), + m_elasticity(0.f), + m_friction(0.f), + m_collisionId(0) + { + } + + inline UInt32 ChipmunkCollider2D::GetCategoryMask() const + { + return m_categoryMask; + } + + inline UInt32 ChipmunkCollider2D::GetCollisionGroup() const + { + return m_collisionGroup; + } + + inline unsigned int ChipmunkCollider2D::GetCollisionId() const + { + return m_collisionId; + } + + inline UInt32 ChipmunkCollider2D::GetCollisionMask() const + { + return m_collisionMask; + } + + inline float ChipmunkCollider2D::GetElasticity() const + { + return m_elasticity; + } + + inline float ChipmunkCollider2D::GetFriction() const + { + return m_friction; + } + + inline Vector2f ChipmunkCollider2D::GetSurfaceVelocity() const + { + return m_surfaceVelocity; + } + + inline bool ChipmunkCollider2D::IsTrigger() const + { + return m_trigger; + } + + inline void ChipmunkCollider2D::SetCategoryMask(UInt32 categoryMask) + { + m_categoryMask = categoryMask; + } + + inline void ChipmunkCollider2D::SetCollisionGroup(UInt32 groupId) + { + m_collisionGroup = groupId; + } + + inline void ChipmunkCollider2D::SetCollisionId(unsigned int typeId) + { + m_collisionId = typeId; + } + + inline void ChipmunkCollider2D::SetCollisionMask(UInt32 mask) + { + m_collisionMask = mask; + } + + inline void ChipmunkCollider2D::SetElasticity(float elasticity) + { + m_elasticity = elasticity; + } + + inline void ChipmunkCollider2D::SetFriction(float friction) + { + m_friction = friction; + } + + inline void ChipmunkCollider2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity) + { + m_surfaceVelocity = surfaceVelocity; + } + + inline void ChipmunkCollider2D::SetTrigger(bool trigger) + { + m_trigger = trigger; + } + + inline float ChipmunkBoxCollider2D::GetRadius() const + { + return m_radius; + } + + inline const Rectf& ChipmunkBoxCollider2D::GetRect() const + { + return m_rect; + } + + inline Vector2f ChipmunkBoxCollider2D::GetSize() const + { + return m_rect.GetLengths(); + } + + + inline const Vector2f& ChipmunkCircleCollider2D::GetOffset() const + { + return m_offset; + } + + inline float ChipmunkCircleCollider2D::GetRadius() const + { + return m_radius; + } + + + inline bool Nz::ChipmunkCompoundCollider2D::DoesOverrideCollisionProperties() const + { + return m_doesOverrideCollisionProperties; + } + + inline const std::vector>& ChipmunkCompoundCollider2D::GetGeoms() const + { + return m_geoms; + } + + inline void Nz::ChipmunkCompoundCollider2D::OverridesCollisionProperties(bool shouldOverride) + { + m_doesOverrideCollisionProperties = shouldOverride; + } + + + inline const std::vector& ChipmunkConvexCollider2D::GetVertices() const + { + return m_vertices; + } + + + ChipmunkSegmentCollider2D::ChipmunkSegmentCollider2D(const Vector2f& first, const Vector2f& second, float thickness) : + ChipmunkSegmentCollider2D(first, first, second, second, thickness) + { + } + + inline ChipmunkSegmentCollider2D::ChipmunkSegmentCollider2D(const Vector2f& first, const Vector2f& firstNeighbor, const Vector2f& second, const Vector2f& secondNeighbor, float thickness) : + m_first(first), + m_firstNeighbor(firstNeighbor), + m_second(second), + m_secondNeighbor(secondNeighbor), + m_thickness(thickness) + { + } + + inline const Vector2f& ChipmunkSegmentCollider2D::GetFirstPoint() const + { + return m_first; + } + + inline const Vector2f& ChipmunkSegmentCollider2D::GetFirstPointNeighbor() const + { + return m_firstNeighbor; + } + + inline float ChipmunkSegmentCollider2D::GetLength() const + { + return m_first.Distance(m_second); + } + + inline const Vector2f& ChipmunkSegmentCollider2D::GetSecondPoint() const + { + return m_second; + } + + inline const Vector2f& ChipmunkSegmentCollider2D::GetSecondPointNeighbor() const + { + return m_secondNeighbor; + } + + inline float ChipmunkSegmentCollider2D::GetThickness() const + { + return m_thickness; + } +} + +#include diff --git a/include/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.hpp b/include/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.hpp new file mode 100644 index 000000000..3c3b14408 --- /dev/null +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.hpp @@ -0,0 +1,233 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_CHIPMUNKPHYSICS2D_CONSTRAINT2D_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_CONSTRAINT2D_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct cpConstraint; + +namespace Nz +{ + class ChipmunkConstraint2D; + + using ChipmunkConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkConstraint2D : public HandledObject + { + public: + ChipmunkConstraint2D(const ChipmunkConstraint2D&) = delete; + ChipmunkConstraint2D(ChipmunkConstraint2D&& rhs); + virtual ~ChipmunkConstraint2D(); + + void EnableBodyCollision(bool enable); + + ChipmunkRigidBody2D& GetBodyA(); + const ChipmunkRigidBody2D& GetBodyA() const; + ChipmunkRigidBody2D& GetBodyB(); + const ChipmunkRigidBody2D& GetBodyB() const; + float GetErrorBias() const; + float GetLastImpulse() const; + float GetMaxBias() const; + float GetMaxForce() const; + ChipmunkPhysWorld2D& GetWorld(); + const ChipmunkPhysWorld2D& GetWorld() const; + + bool IsBodyCollisionEnabled() const; + + void SetErrorBias(float bias); + void SetMaxBias(float bias); + void SetMaxForce(float force); + + ChipmunkConstraint2D& operator=(const ChipmunkConstraint2D&) = delete; + ChipmunkConstraint2D& operator=(ChipmunkConstraint2D&& rhs); + + protected: + ChipmunkConstraint2D(ChipmunkPhysWorld2D* world, cpConstraint* constraint); + + MovablePtr m_constraint; + }; + + class ChipmunkDampedSpringConstraint2D; + + using ChipmunkDampedSpringConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkDampedSpringConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkDampedSpringConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float restLength, float stiffness, float damping); + ~ChipmunkDampedSpringConstraint2D() = default; + + float GetDamping() const; + Vector2f GetFirstAnchor() const; + float GetRestLength() const; + Vector2f GetSecondAnchor() const; + float GetStiffness() const; + + void SetDamping(float newDamping); + void SetFirstAnchor(const Vector2f& firstAnchor); + void SetRestLength(float newLength); + void SetSecondAnchor(const Vector2f& firstAnchor); + void SetStiffness(float newStiffness); + }; + + class ChipmunkDampedRotarySpringConstraint2D; + + using ChipmunkDampedRotarySpringConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkDampedRotarySpringConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkDampedRotarySpringConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const RadianAnglef& restAngle, float stiffness, float damping); + ~ChipmunkDampedRotarySpringConstraint2D() = default; + + float GetDamping() const; + RadianAnglef GetRestAngle() const; + float GetStiffness() const; + + void SetDamping(float newDamping); + void SetRestAngle(const RadianAnglef& newAngle); + void SetStiffness(float newStiffness); + }; + + class ChipmunkGearConstraint2D; + + using ChipmunkGearConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkGearConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkGearConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, float phase, float ratio); + ~ChipmunkGearConstraint2D() = default; + + float GetPhase() const; + float GetRatio() const; + + void SetPhase(float phase); + void SetRatio(float ratio); + }; + + class ChipmunkMotorConstraint2D; + + using ChipmunkMotorConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkMotorConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkMotorConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, float rate); + ~ChipmunkMotorConstraint2D() = default; + + float GetRate() const; + void SetRate(float rate); + }; + + class ChipmunkPinConstraint2D; + + using ChipmunkPinConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPinConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkPinConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor); + ~ChipmunkPinConstraint2D() = default; + + float GetDistance() const; + Vector2f GetFirstAnchor() const; + Vector2f GetSecondAnchor() const; + + void SetDistance(float newDistance); + void SetFirstAnchor(const Vector2f& firstAnchor); + void SetSecondAnchor(const Vector2f& firstAnchor); + }; + + class ChipmunkPivotConstraint2D; + + using ChipmunkPivotConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPivotConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkPivotConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& anchor); + ChipmunkPivotConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor); + ~ChipmunkPivotConstraint2D() = default; + + Vector2f GetFirstAnchor() const; + Vector2f GetSecondAnchor() const; + + void SetFirstAnchor(const Vector2f& firstAnchor); + void SetSecondAnchor(const Vector2f& firstAnchor); + }; + + class ChipmunkRatchetConstraint2D; + + using ChipmunkRatchetConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkRatchetConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkRatchetConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, float phase, float ratchet); + ~ChipmunkRatchetConstraint2D() = default; + + RadianAnglef GetAngle() const; + float GetPhase() const; + float GetRatchet() const; + + void SetAngle(const RadianAnglef& angle); + void SetPhase(float phase); + void SetRatchet(float ratchet); + }; + + class ChipmunkRotaryLimitConstraint2D; + + using ChipmunkRotaryLimitConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkRotaryLimitConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkRotaryLimitConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const RadianAnglef& minAngle, const RadianAnglef& maxAngle); + ~ChipmunkRotaryLimitConstraint2D() = default; + + RadianAnglef GetMaxAngle() const; + RadianAnglef GetMinAngle() const; + + void SetMaxAngle(const RadianAnglef& maxAngle); + void SetMinAngle(const RadianAnglef& minAngle); + }; + + class ChipmunkSlideConstraint2D; + + using ChipmunkSlideConstraint2DHandle = ObjectHandle; + + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkSlideConstraint2D : public ChipmunkConstraint2D + { + public: + ChipmunkSlideConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float min, float max); + ~ChipmunkSlideConstraint2D() = default; + + Vector2f GetFirstAnchor() const; + float GetMaxDistance() const; + float GetMinDistance() const; + Vector2f GetSecondAnchor() const; + + void SetFirstAnchor(const Vector2f& firstAnchor); + void SetMaxDistance(float newMaxDistance); + void SetMinDistance(float newMinDistance); + void SetSecondAnchor(const Vector2f& firstAnchor); + }; +} + +#include + +#endif // NAZARA_CHIPMUNKPHYSICS2D_CONSTRAINT2D_HPP diff --git a/include/Nazara/Physics2D/Constraint2D.inl b/include/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.inl similarity index 72% rename from include/Nazara/Physics2D/Constraint2D.inl rename to include/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.inl index 251b096a4..53dbf8b0a 100644 --- a/include/Nazara/Physics2D/Constraint2D.inl +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.inl @@ -3,10 +3,10 @@ // For conditions of distribution and use, see copyright notice in Config.hpp #include -#include +#include namespace Nz { } -#include +#include diff --git a/include/Nazara/Physics2D/PhysWorld2D.hpp b/include/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp similarity index 65% rename from include/Nazara/Physics2D/PhysWorld2D.hpp rename to include/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp index a3c1da4a2..49fccffae 100644 --- a/include/Nazara/Physics2D/PhysWorld2D.hpp +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp @@ -4,16 +4,16 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_PHYSWORLD2D_HPP -#define NAZARA_PHYSICS2D_PHYSWORLD2D_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_PHYSWORLD2D_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_PHYSWORLD2D_HPP #include #include #include #include #include -#include -#include +#include +#include #include #include #include @@ -25,23 +25,23 @@ struct cpSpace; namespace Nz { - class Arbiter2D; + class ChipmunkArbiter2D; - class NAZARA_PHYSICS2D_API PhysWorld2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPhysWorld2D { - friend RigidBody2D; + friend ChipmunkRigidBody2D; - using ContactEndCallback = std::function; - using ContactPreSolveCallback = std::function; - using ContactPostSolveCallback = std::function; - using ContactStartCallback = std::function; + using ContactEndCallback = std::function; + using ContactPreSolveCallback = std::function; + using ContactPostSolveCallback = std::function; + using ContactStartCallback = std::function; using DebugDrawCircleCallback = std::function; using DebugDrawDotCallback = std::function; using DebugDrawPolygonCallback = std::function; using DebugDrawSegmentCallback = std::function; using DebugDrawTickSegmentCallback = std::function; - using DebugDrawGetColorCallback = std::function; + using DebugDrawGetColorCallback = std::function; public: struct Callback; @@ -49,10 +49,10 @@ namespace Nz struct NearestQueryResult; struct RaycastHit; - PhysWorld2D(); - PhysWorld2D(const PhysWorld2D&) = delete; - PhysWorld2D(PhysWorld2D&&) = delete; ///TODO - ~PhysWorld2D(); + ChipmunkPhysWorld2D(); + ChipmunkPhysWorld2D(const ChipmunkPhysWorld2D&) = delete; + ChipmunkPhysWorld2D(ChipmunkPhysWorld2D&&) = delete; ///TODO + ~ChipmunkPhysWorld2D(); void DebugDraw(const DebugDrawOptions& options, bool drawShapes = true, bool drawConstraints = true, bool drawCollisions = true); @@ -63,15 +63,15 @@ namespace Nz std::size_t GetMaxStepCount() const; Time GetStepSize() const; - bool NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RigidBody2D** nearestBody = nullptr); + bool NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, ChipmunkRigidBody2D** nearestBody = nullptr); bool NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, NearestQueryResult* result); void RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef& callback); bool RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector* hitInfos); bool RaycastQueryFirst(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RaycastHit* hitInfo = nullptr); - void RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef& callback); - void RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector* bodies); + void RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef& callback); + void RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector* bodies); void RegisterCallbacks(unsigned int collisionId, Callback callbacks); void RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, Callback callbacks); @@ -87,8 +87,8 @@ namespace Nz void UseSpatialHash(float cellSize, std::size_t entityCount); - PhysWorld2D& operator=(const PhysWorld2D&) = delete; - PhysWorld2D& operator=(PhysWorld2D&&) = delete; ///TODO + ChipmunkPhysWorld2D& operator=(const ChipmunkPhysWorld2D&) = delete; + ChipmunkPhysWorld2D& operator=(ChipmunkPhysWorld2D&&) = delete; ///TODO struct Callback { @@ -117,7 +117,7 @@ namespace Nz struct NearestQueryResult { - RigidBody2D* nearestBody; + ChipmunkRigidBody2D* nearestBody; Vector2f closestPoint; Vector2f fraction; float distance; @@ -125,29 +125,29 @@ namespace Nz struct RaycastHit { - RigidBody2D* nearestBody; + ChipmunkRigidBody2D* nearestBody; Vector2f hitPos; Vector2f hitNormal; float fraction; }; - NazaraSignal(OnPhysWorld2DPreStep, const PhysWorld2D* /*physWorld*/, float /*invStepCount*/); - NazaraSignal(OnPhysWorld2DPostStep, const PhysWorld2D* /*physWorld*/, float /*invStepCount*/); + NazaraSignal(OnPhysWorld2DPreStep, const ChipmunkPhysWorld2D* /*physWorld*/, float /*invStepCount*/); + NazaraSignal(OnPhysWorld2DPostStep, const ChipmunkPhysWorld2D* /*physWorld*/, float /*invStepCount*/); private: void InitCallbacks(cpCollisionHandler* handler, Callback callbacks); - using PostStep = std::function; + using PostStep = std::function; - void OnRigidBodyMoved(RigidBody2D* oldPointer, RigidBody2D* newPointer); - void OnRigidBodyRelease(RigidBody2D* rigidBody); + void OnRigidBodyMoved(ChipmunkRigidBody2D* oldPointer, ChipmunkRigidBody2D* newPointer); + void OnRigidBodyRelease(ChipmunkRigidBody2D* rigidBody); - void RegisterPostStep(RigidBody2D* rigidBody, PostStep&& func); + void RegisterPostStep(ChipmunkRigidBody2D* rigidBody, PostStep&& func); struct PostStepContainer { - NazaraSlot(RigidBody2D, OnRigidBody2DMove, onMovedSlot); - NazaraSlot(RigidBody2D, OnRigidBody2DRelease, onReleaseSlot); + NazaraSlot(ChipmunkRigidBody2D, OnRigidBody2DMove, onMovedSlot); + NazaraSlot(ChipmunkRigidBody2D, OnRigidBody2DRelease, onReleaseSlot); std::vector funcs; }; @@ -156,11 +156,11 @@ namespace Nz std::size_t m_maxStepCount; std::unordered_map> m_callbacks; - std::unordered_map m_rigidPostSteps; + std::unordered_map m_rigidPostSteps; cpSpace* m_handle; Time m_stepSize; Time m_timestepAccumulator; }; } -#endif // NAZARA_PHYSICS2D_PHYSWORLD2D_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_PHYSWORLD2D_HPP diff --git a/include/Nazara/Physics2D/Physics2D.hpp b/include/Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp similarity index 53% rename from include/Nazara/Physics2D/Physics2D.hpp rename to include/Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp index 28474a9a6..77217930a 100644 --- a/include/Nazara/Physics2D/Physics2D.hpp +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp @@ -4,16 +4,16 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_HPP -#define NAZARA_PHYSICS2D_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_HPP #include #include -#include +#include namespace Nz { - class NAZARA_PHYSICS2D_API Physics2D : public ModuleBase + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPhysics2D : public ModuleBase { friend ModuleBase; @@ -22,12 +22,12 @@ namespace Nz struct Config {}; - Physics2D(Config /*config*/); - ~Physics2D() = default; + ChipmunkPhysics2D(Config /*config*/); + ~ChipmunkPhysics2D() = default; private: - static Physics2D* s_instance; + static ChipmunkPhysics2D* s_instance; }; } -#endif // NAZARA_PHYSICS2D_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_HPP diff --git a/include/Nazara/Physics2D/RigidBody2D.hpp b/include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp similarity index 71% rename from include/Nazara/Physics2D/RigidBody2D.hpp rename to include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp index e55edc88a..1acbdd1cd 100644 --- a/include/Nazara/Physics2D/RigidBody2D.hpp +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp @@ -4,15 +4,15 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_RIGIDBODY2D_HPP -#define NAZARA_PHYSICS2D_RIGIDBODY2D_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_RIGIDBODY2D_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_RIGIDBODY2D_HPP #include #include #include #include -#include -#include +#include +#include #include #include #include @@ -21,19 +21,19 @@ struct cpBody; namespace Nz { - class Arbiter2D; - class PhysWorld2D; + class ChipmunkArbiter2D; + class ChipmunkPhysWorld2D; - class NAZARA_PHYSICS2D_API RigidBody2D + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkRigidBody2D { public: - using VelocityFunc = std::function; + using VelocityFunc = std::function; - RigidBody2D(PhysWorld2D* world, float mass); - RigidBody2D(PhysWorld2D* world, float mass, std::shared_ptr geom); - RigidBody2D(const RigidBody2D& object); - RigidBody2D(RigidBody2D&& object) noexcept; - ~RigidBody2D(); + ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass); + ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass, std::shared_ptr geom); + ChipmunkRigidBody2D(const ChipmunkRigidBody2D& object); + ChipmunkRigidBody2D(ChipmunkRigidBody2D&& object) noexcept; + ~ChipmunkRigidBody2D(); void AddForce(const Vector2f& force, CoordSys coordSys = CoordSys::Global); void AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys = CoordSys::Global); @@ -45,7 +45,7 @@ namespace Nz void EnableSimulation(bool simulation); - void ForEachArbiter(std::function callback); + void ForEachArbiter(std::function callback); void ForceSleep(); Rectf GetAABB() const; @@ -55,7 +55,7 @@ namespace Nz inline Vector2f GetCenterOfGravity(CoordSys coordSys = CoordSys::Local) const; float GetElasticity(std::size_t shapeIndex = 0) const; float GetFriction(std::size_t shapeIndex = 0) const; - const std::shared_ptr& GetGeom() const; + const std::shared_ptr& GetGeom() const; cpBody* GetHandle() const; float GetMass() const; Vector2f GetMassCenter(CoordSys coordSys = CoordSys::Local) const; @@ -69,7 +69,7 @@ namespace Nz void* GetUserdata() const; Vector2f GetVelocity() const; const VelocityFunc& GetVelocityFunction() const; - PhysWorld2D* GetWorld() const; + ChipmunkPhysWorld2D* GetWorld() const; bool IsKinematic() const; bool IsSimulationEnabled() const; @@ -84,7 +84,7 @@ namespace Nz void SetElasticity(std::size_t shapeIndex, float elasticity); void SetFriction(float friction); void SetFriction(std::size_t shapeIndex, float friction); - void SetGeom(std::shared_ptr geom, bool recomputeMoment = true, bool recomputeMassCenter = true); + void SetGeom(std::shared_ptr geom, bool recomputeMoment = true, bool recomputeMassCenter = true); void SetMass(float mass, bool recomputeMoment = true); void SetMassCenter(const Vector2f& center, CoordSys coordSys = CoordSys::Local); void SetMomentOfInertia(float moment); @@ -104,11 +104,11 @@ namespace Nz void Wakeup(); - RigidBody2D& operator=(const RigidBody2D& object); - RigidBody2D& operator=(RigidBody2D&& object); + ChipmunkRigidBody2D& operator=(const ChipmunkRigidBody2D& object); + ChipmunkRigidBody2D& operator=(ChipmunkRigidBody2D&& object); - NazaraSignal(OnRigidBody2DMove, RigidBody2D* /*oldPointer*/, RigidBody2D* /*newPointer*/); - NazaraSignal(OnRigidBody2DRelease, RigidBody2D* /*rigidBody*/); + NazaraSignal(OnRigidBody2DMove, ChipmunkRigidBody2D* /*oldPointer*/, ChipmunkRigidBody2D* /*newPointer*/); + NazaraSignal(OnRigidBody2DRelease, ChipmunkRigidBody2D* /*rigidBody*/); static constexpr std::size_t InvalidShapeIndex = std::numeric_limits::max(); @@ -126,10 +126,10 @@ namespace Nz Vector2f m_positionOffset; VelocityFunc m_velocityFunc; std::vector m_shapes; - std::shared_ptr m_geom; + std::shared_ptr m_geom; cpBody* m_handle; void* m_userData; - PhysWorld2D* m_world; + ChipmunkPhysWorld2D* m_world; bool m_isRegistered; bool m_isSimulationEnabled; bool m_isStatic; @@ -138,6 +138,6 @@ namespace Nz }; } -#include +#include -#endif // NAZARA_PHYSICS2D_RIGIDBODY2D_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_RIGIDBODY2D_HPP diff --git a/include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.inl b/include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.inl new file mode 100644 index 000000000..0a2940eb5 --- /dev/null +++ b/include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.inl @@ -0,0 +1,35 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include + +namespace Nz +{ + inline float ChipmunkRigidBody2D::GetAngularDamping() const + { + return GetMomentOfInertia(); + } + + inline Vector2f ChipmunkRigidBody2D::GetCenterOfGravity(CoordSys coordSys) const + { + return GetMassCenter(coordSys); + } + + inline const Vector2f& ChipmunkRigidBody2D::GetPositionOffset() const + { + return m_positionOffset; + } + + inline std::size_t ChipmunkRigidBody2D::GetShapeCount() const + { + return m_shapes.size(); + } + + inline void ChipmunkRigidBody2D::SetAngularDamping(float angularDamping) + { + SetMomentOfInertia(angularDamping); + } +} + +#include diff --git a/include/Nazara/Physics2D/Components.hpp b/include/Nazara/ChipmunkPhysics2D/Components.hpp similarity index 84% rename from include/Nazara/Physics2D/Components.hpp rename to include/Nazara/ChipmunkPhysics2D/Components.hpp index 961ae131e..1a81da8b4 100644 --- a/include/Nazara/Physics2D/Components.hpp +++ b/include/Nazara/ChipmunkPhysics2D/Components.hpp @@ -26,9 +26,9 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_COMPONENTS_HPP -#define NAZARA_PHYSICS2D_COMPONENTS_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_HPP -#include +#include -#endif // NAZARA_PHYSICS2D_COMPONENTS_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_HPP diff --git a/include/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.hpp b/include/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.hpp new file mode 100644 index 000000000..4583d4870 --- /dev/null +++ b/include/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.hpp @@ -0,0 +1,32 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_RIGIDBODY2DCOMPONENT_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_RIGIDBODY2DCOMPONENT_HPP + +#include +#include + +namespace Nz +{ + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkRigidBody2DComponent : public ChipmunkRigidBody2D + { + friend class ChipmunkPhysics2DSystem; + + public: + using ChipmunkRigidBody2D::ChipmunkRigidBody2D; + ChipmunkRigidBody2DComponent(const ChipmunkRigidBody2DComponent&) = default; + ChipmunkRigidBody2DComponent(ChipmunkRigidBody2DComponent&&) noexcept = default; + ~ChipmunkRigidBody2DComponent() = default; + + ChipmunkRigidBody2DComponent& operator=(const ChipmunkRigidBody2DComponent&) = default; + ChipmunkRigidBody2DComponent& operator=(ChipmunkRigidBody2DComponent&&) noexcept = default; + }; +} + +#include + +#endif // NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_RIGIDBODY2DCOMPONENT_HPP diff --git a/include/Nazara/Physics2D/Components/RigidBody2DComponent.inl b/include/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.inl similarity index 70% rename from include/Nazara/Physics2D/Components/RigidBody2DComponent.inl rename to include/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.inl index efa5a35b9..3a801cbe6 100644 --- a/include/Nazara/Physics2D/Components/RigidBody2DComponent.inl +++ b/include/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.inl @@ -2,10 +2,10 @@ // This file is part of the "Nazara Engine - Physics2D module" // For conditions of distribution and use, see copyright notice in Config.hpp -#include +#include namespace Nz { } -#include +#include diff --git a/include/Nazara/Physics2D/Config.hpp b/include/Nazara/ChipmunkPhysics2D/Config.hpp similarity index 78% rename from include/Nazara/Physics2D/Config.hpp rename to include/Nazara/ChipmunkPhysics2D/Config.hpp index 1d988436b..6b937e9cb 100644 --- a/include/Nazara/Physics2D/Config.hpp +++ b/include/Nazara/ChipmunkPhysics2D/Config.hpp @@ -24,25 +24,25 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_CONFIG_HPP -#define NAZARA_PHYSICS2D_CONFIG_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_CONFIG_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_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_PHYSICS2D_SAFE 1 +#define NAZARA_CHIPMUNKPHYSICS2D_SAFE 1 /// Vérification des valeurs et types de certaines constantes -#include +#include #if defined(NAZARA_STATIC) - #define NAZARA_PHYSICS2D_API + #define NAZARA_CHIPMUNKPHYSICS2D_API #else - #ifdef NAZARA_PHYSICS2D_BUILD - #define NAZARA_PHYSICS2D_API NAZARA_EXPORT + #ifdef NAZARA_CHIPMUNKPHYSICS2D_BUILD + #define NAZARA_CHIPMUNKPHYSICS2D_API NAZARA_EXPORT #else - #define NAZARA_PHYSICS2D_API NAZARA_IMPORT + #define NAZARA_CHIPMUNKPHYSICS2D_API NAZARA_IMPORT #endif #endif -#endif // NAZARA_PHYSICS2D_CONFIG_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_CONFIG_HPP diff --git a/include/Nazara/Physics2D/ConfigCheck.hpp b/include/Nazara/ChipmunkPhysics2D/ConfigCheck.hpp similarity index 77% rename from include/Nazara/Physics2D/ConfigCheck.hpp rename to include/Nazara/ChipmunkPhysics2D/ConfigCheck.hpp index a2736a2d4..d540a68a4 100644 --- a/include/Nazara/Physics2D/ConfigCheck.hpp +++ b/include/Nazara/ChipmunkPhysics2D/ConfigCheck.hpp @@ -4,8 +4,8 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_CONFIGCHECK_HPP -#define NAZARA_PHYSICS2D_CONFIGCHECK_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_CONFIGCHECK_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_CONFIGCHECK_HPP /// This file is used to check the constant values defined in Config.hpp @@ -16,4 +16,4 @@ #undef NazaraCheckTypeAndVal -#endif // NAZARA_PHYSICS2D_CONFIGCHECK_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_CONFIGCHECK_HPP diff --git a/include/Nazara/Physics2D/Debug.hpp b/include/Nazara/ChipmunkPhysics2D/Debug.hpp similarity index 100% rename from include/Nazara/Physics2D/Debug.hpp rename to include/Nazara/ChipmunkPhysics2D/Debug.hpp diff --git a/include/Nazara/Physics2D/DebugOff.hpp b/include/Nazara/ChipmunkPhysics2D/DebugOff.hpp similarity index 100% rename from include/Nazara/Physics2D/DebugOff.hpp rename to include/Nazara/ChipmunkPhysics2D/DebugOff.hpp diff --git a/include/Nazara/Physics2D/Enums.hpp b/include/Nazara/ChipmunkPhysics2D/Enums.hpp similarity index 66% rename from include/Nazara/Physics2D/Enums.hpp rename to include/Nazara/ChipmunkPhysics2D/Enums.hpp index e980cf9f2..2ff913e17 100644 --- a/include/Nazara/Physics2D/Enums.hpp +++ b/include/Nazara/ChipmunkPhysics2D/Enums.hpp @@ -4,12 +4,12 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_ENUMS_HPP -#define NAZARA_PHYSICS2D_ENUMS_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP namespace Nz { - enum class ColliderType2D + enum class ChipmunkColliderType2D { Box, Compound, @@ -22,4 +22,4 @@ namespace Nz }; } -#endif // NAZARA_PHYSICS2D_ENUMS_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP diff --git a/include/Nazara/Physics2D/Systems.hpp b/include/Nazara/ChipmunkPhysics2D/Systems.hpp similarity index 85% rename from include/Nazara/Physics2D/Systems.hpp rename to include/Nazara/ChipmunkPhysics2D/Systems.hpp index 06875bbb9..db68b048f 100644 --- a/include/Nazara/Physics2D/Systems.hpp +++ b/include/Nazara/ChipmunkPhysics2D/Systems.hpp @@ -26,9 +26,9 @@ #pragma once -#ifndef NAZARA_PHYSICS2D_SYSTEMS_HPP -#define NAZARA_PHYSICS2D_SYSTEMS_HPP +#ifndef NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_HPP -#include +#include -#endif // NAZARA_PHYSICS2D_SYSTEMS_HPP +#endif // NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_HPP diff --git a/include/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.hpp b/include/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.hpp new file mode 100644 index 000000000..778091145 --- /dev/null +++ b/include/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.hpp @@ -0,0 +1,50 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_PHYSICS2DSYSTEM_HPP +#define NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_PHYSICS2DSYSTEM_HPP + +#include +#include +#include +#include +#include +#include + +namespace Nz +{ + class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPhysics2DSystem + { + public: + static constexpr Int64 ExecutionOrder = 0; + using Components = TypeList; + + ChipmunkPhysics2DSystem(entt::registry& registry); + ChipmunkPhysics2DSystem(const ChipmunkPhysics2DSystem&) = delete; + ChipmunkPhysics2DSystem(ChipmunkPhysics2DSystem&&) = delete; + ~ChipmunkPhysics2DSystem(); + + template ChipmunkRigidBody2DComponent CreateRigidBody(Args&&... args); + + inline ChipmunkPhysWorld2D& GetPhysWorld(); + inline const ChipmunkPhysWorld2D& GetPhysWorld() const; + + void Update(Time elapsedTime); + + ChipmunkPhysics2DSystem& operator=(const ChipmunkPhysics2DSystem&) = delete; + ChipmunkPhysics2DSystem& operator=(ChipmunkPhysics2DSystem&&) = delete; + + private: + entt::registry& m_registry; + entt::observer m_physicsConstructObserver; + entt::scoped_connection m_constructConnection; + ChipmunkPhysWorld2D m_physWorld; + }; +} + +#include + +#endif // NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_PHYSICS2DSYSTEM_HPP diff --git a/include/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.inl b/include/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.inl new file mode 100644 index 000000000..abc3a437d --- /dev/null +++ b/include/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.inl @@ -0,0 +1,26 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include + +namespace Nz +{ + template + ChipmunkRigidBody2DComponent ChipmunkPhysics2DSystem::CreateRigidBody(Args&&... args) + { + return ChipmunkRigidBody2DComponent(&m_physWorld, std::forward(args)...); + } + + inline ChipmunkPhysWorld2D& ChipmunkPhysics2DSystem::GetPhysWorld() + { + return m_physWorld; + } + + inline const ChipmunkPhysWorld2D& ChipmunkPhysics2DSystem::GetPhysWorld() const + { + return m_physWorld; + } +} + +#include diff --git a/include/Nazara/Physics2D/Collider2D.inl b/include/Nazara/Physics2D/Collider2D.inl deleted file mode 100644 index 9aabe46f5..000000000 --- a/include/Nazara/Physics2D/Collider2D.inl +++ /dev/null @@ -1,196 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include - -namespace Nz -{ - inline Collider2D::Collider2D() : - m_categoryMask(0xFFFFFFFF), - m_collisionGroup(0), - m_collisionMask(0xFFFFFFFF), - m_surfaceVelocity(Vector2f::Zero()), - m_trigger(false), - m_elasticity(0.f), - m_friction(0.f), - m_collisionId(0) - { - } - - inline UInt32 Collider2D::GetCategoryMask() const - { - return m_categoryMask; - } - - inline UInt32 Collider2D::GetCollisionGroup() const - { - return m_collisionGroup; - } - - inline unsigned int Collider2D::GetCollisionId() const - { - return m_collisionId; - } - - inline UInt32 Collider2D::GetCollisionMask() const - { - return m_collisionMask; - } - - inline float Collider2D::GetElasticity() const - { - return m_elasticity; - } - - inline float Collider2D::GetFriction() const - { - return m_friction; - } - - inline Vector2f Collider2D::GetSurfaceVelocity() const - { - return m_surfaceVelocity; - } - - inline bool Collider2D::IsTrigger() const - { - return m_trigger; - } - - inline void Collider2D::SetCategoryMask(UInt32 categoryMask) - { - m_categoryMask = categoryMask; - } - - inline void Collider2D::SetCollisionGroup(UInt32 groupId) - { - m_collisionGroup = groupId; - } - - inline void Collider2D::SetCollisionId(unsigned int typeId) - { - m_collisionId = typeId; - } - - inline void Collider2D::SetCollisionMask(UInt32 mask) - { - m_collisionMask = mask; - } - - inline void Collider2D::SetElasticity(float elasticity) - { - m_elasticity = elasticity; - } - - inline void Collider2D::SetFriction(float friction) - { - m_friction = friction; - } - - inline void Collider2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity) - { - m_surfaceVelocity = surfaceVelocity; - } - - inline void Collider2D::SetTrigger(bool trigger) - { - m_trigger = trigger; - } - - inline float BoxCollider2D::GetRadius() const - { - return m_radius; - } - - inline const Rectf& BoxCollider2D::GetRect() const - { - return m_rect; - } - - inline Vector2f BoxCollider2D::GetSize() const - { - return m_rect.GetLengths(); - } - - - inline const Vector2f& CircleCollider2D::GetOffset() const - { - return m_offset; - } - - inline float CircleCollider2D::GetRadius() const - { - return m_radius; - } - - - inline bool Nz::CompoundCollider2D::DoesOverrideCollisionProperties() const - { - return m_doesOverrideCollisionProperties; - } - - inline const std::vector>& CompoundCollider2D::GetGeoms() const - { - return m_geoms; - } - - inline void Nz::CompoundCollider2D::OverridesCollisionProperties(bool shouldOverride) - { - m_doesOverrideCollisionProperties = shouldOverride; - } - - - inline const std::vector& ConvexCollider2D::GetVertices() const - { - return m_vertices; - } - - - SegmentCollider2D::SegmentCollider2D(const Vector2f& first, const Vector2f& second, float thickness) : - SegmentCollider2D(first, first, second, second, thickness) - { - } - - inline SegmentCollider2D::SegmentCollider2D(const Vector2f& first, const Vector2f& firstNeighbor, const Vector2f& second, const Vector2f& secondNeighbor, float thickness) : - m_first(first), - m_firstNeighbor(firstNeighbor), - m_second(second), - m_secondNeighbor(secondNeighbor), - m_thickness(thickness) - { - } - - inline const Vector2f& SegmentCollider2D::GetFirstPoint() const - { - return m_first; - } - - inline const Vector2f& SegmentCollider2D::GetFirstPointNeighbor() const - { - return m_firstNeighbor; - } - - inline float SegmentCollider2D::GetLength() const - { - return m_first.Distance(m_second); - } - - inline const Vector2f& SegmentCollider2D::GetSecondPoint() const - { - return m_second; - } - - inline const Vector2f& SegmentCollider2D::GetSecondPointNeighbor() const - { - return m_secondNeighbor; - } - - inline float SegmentCollider2D::GetThickness() const - { - return m_thickness; - } -} - -#include diff --git a/include/Nazara/Physics2D/Components/RigidBody2DComponent.hpp b/include/Nazara/Physics2D/Components/RigidBody2DComponent.hpp deleted file mode 100644 index 5c0ebb74c..000000000 --- a/include/Nazara/Physics2D/Components/RigidBody2DComponent.hpp +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef NAZARA_PHYSICS2D_COMPONENTS_RIGIDBODY2DCOMPONENT_HPP -#define NAZARA_PHYSICS2D_COMPONENTS_RIGIDBODY2DCOMPONENT_HPP - -#include -#include - -namespace Nz -{ - class NAZARA_PHYSICS2D_API RigidBody2DComponent : public RigidBody2D - { - friend class Physics2DSystem; - - public: - using RigidBody2D::RigidBody2D; - RigidBody2DComponent(const RigidBody2DComponent&) = default; - RigidBody2DComponent(RigidBody2DComponent&&) noexcept = default; - ~RigidBody2DComponent() = default; - - RigidBody2DComponent& operator=(const RigidBody2DComponent&) = default; - RigidBody2DComponent& operator=(RigidBody2DComponent&&) noexcept = default; - }; -} - -#include - -#endif // NAZARA_PHYSICS2D_COMPONENTS_RIGIDBODY2DCOMPONENT_HPP diff --git a/include/Nazara/Physics2D/Constraint2D.hpp b/include/Nazara/Physics2D/Constraint2D.hpp deleted file mode 100644 index ad593d045..000000000 --- a/include/Nazara/Physics2D/Constraint2D.hpp +++ /dev/null @@ -1,233 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef NAZARA_PHYSICS2D_CONSTRAINT2D_HPP -#define NAZARA_PHYSICS2D_CONSTRAINT2D_HPP - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -struct cpConstraint; - -namespace Nz -{ - class Constraint2D; - - using Constraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API Constraint2D : public HandledObject - { - public: - Constraint2D(const Constraint2D&) = delete; - Constraint2D(Constraint2D&& rhs); - virtual ~Constraint2D(); - - void EnableBodyCollision(bool enable); - - RigidBody2D& GetBodyA(); - const RigidBody2D& GetBodyA() const; - RigidBody2D& GetBodyB(); - const RigidBody2D& GetBodyB() const; - float GetErrorBias() const; - float GetLastImpulse() const; - float GetMaxBias() const; - float GetMaxForce() const; - PhysWorld2D& GetWorld(); - const PhysWorld2D& GetWorld() const; - - bool IsBodyCollisionEnabled() const; - - void SetErrorBias(float bias); - void SetMaxBias(float bias); - void SetMaxForce(float force); - - Constraint2D& operator=(const Constraint2D&) = delete; - Constraint2D& operator=(Constraint2D&& rhs); - - protected: - Constraint2D(PhysWorld2D* world, cpConstraint* constraint); - - MovablePtr m_constraint; - }; - - class DampedSpringConstraint2D; - - using DampedSpringConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API DampedSpringConstraint2D : public Constraint2D - { - public: - DampedSpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float restLength, float stiffness, float damping); - ~DampedSpringConstraint2D() = default; - - float GetDamping() const; - Vector2f GetFirstAnchor() const; - float GetRestLength() const; - Vector2f GetSecondAnchor() const; - float GetStiffness() const; - - void SetDamping(float newDamping); - void SetFirstAnchor(const Vector2f& firstAnchor); - void SetRestLength(float newLength); - void SetSecondAnchor(const Vector2f& firstAnchor); - void SetStiffness(float newStiffness); - }; - - class DampedRotarySpringConstraint2D; - - using DampedRotarySpringConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API DampedRotarySpringConstraint2D : public Constraint2D - { - public: - DampedRotarySpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& restAngle, float stiffness, float damping); - ~DampedRotarySpringConstraint2D() = default; - - float GetDamping() const; - RadianAnglef GetRestAngle() const; - float GetStiffness() const; - - void SetDamping(float newDamping); - void SetRestAngle(const RadianAnglef& newAngle); - void SetStiffness(float newStiffness); - }; - - class GearConstraint2D; - - using GearConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API GearConstraint2D : public Constraint2D - { - public: - GearConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratio); - ~GearConstraint2D() = default; - - float GetPhase() const; - float GetRatio() const; - - void SetPhase(float phase); - void SetRatio(float ratio); - }; - - class MotorConstraint2D; - - using MotorConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API MotorConstraint2D : public Constraint2D - { - public: - MotorConstraint2D(RigidBody2D& first, RigidBody2D& second, float rate); - ~MotorConstraint2D() = default; - - float GetRate() const; - void SetRate(float rate); - }; - - class PinConstraint2D; - - using PinConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API PinConstraint2D : public Constraint2D - { - public: - PinConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor); - ~PinConstraint2D() = default; - - float GetDistance() const; - Vector2f GetFirstAnchor() const; - Vector2f GetSecondAnchor() const; - - void SetDistance(float newDistance); - void SetFirstAnchor(const Vector2f& firstAnchor); - void SetSecondAnchor(const Vector2f& firstAnchor); - }; - - class PivotConstraint2D; - - using PivotConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API PivotConstraint2D : public Constraint2D - { - public: - PivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& anchor); - PivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor); - ~PivotConstraint2D() = default; - - Vector2f GetFirstAnchor() const; - Vector2f GetSecondAnchor() const; - - void SetFirstAnchor(const Vector2f& firstAnchor); - void SetSecondAnchor(const Vector2f& firstAnchor); - }; - - class RatchetConstraint2D; - - using RatchetConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API RatchetConstraint2D : public Constraint2D - { - public: - RatchetConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratchet); - ~RatchetConstraint2D() = default; - - RadianAnglef GetAngle() const; - float GetPhase() const; - float GetRatchet() const; - - void SetAngle(const RadianAnglef& angle); - void SetPhase(float phase); - void SetRatchet(float ratchet); - }; - - class RotaryLimitConstraint2D; - - using RotaryLimitConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API RotaryLimitConstraint2D : public Constraint2D - { - public: - RotaryLimitConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& minAngle, const RadianAnglef& maxAngle); - ~RotaryLimitConstraint2D() = default; - - RadianAnglef GetMaxAngle() const; - RadianAnglef GetMinAngle() const; - - void SetMaxAngle(const RadianAnglef& maxAngle); - void SetMinAngle(const RadianAnglef& minAngle); - }; - - class SlideConstraint2D; - - using SlideConstraint2DHandle = ObjectHandle; - - class NAZARA_PHYSICS2D_API SlideConstraint2D : public Constraint2D - { - public: - SlideConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float min, float max); - ~SlideConstraint2D() = default; - - Vector2f GetFirstAnchor() const; - float GetMaxDistance() const; - float GetMinDistance() const; - Vector2f GetSecondAnchor() const; - - void SetFirstAnchor(const Vector2f& firstAnchor); - void SetMaxDistance(float newMaxDistance); - void SetMinDistance(float newMinDistance); - void SetSecondAnchor(const Vector2f& firstAnchor); - }; -} - -#include - -#endif // NAZARA_PHYSICS2D_CONSTRAINT2D_HPP diff --git a/include/Nazara/Physics2D/RigidBody2D.inl b/include/Nazara/Physics2D/RigidBody2D.inl deleted file mode 100644 index ac4b22bc5..000000000 --- a/include/Nazara/Physics2D/RigidBody2D.inl +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include - -namespace Nz -{ - inline float RigidBody2D::GetAngularDamping() const - { - return GetMomentOfInertia(); - } - - inline Vector2f RigidBody2D::GetCenterOfGravity(CoordSys coordSys) const - { - return GetMassCenter(coordSys); - } - - inline const Vector2f& RigidBody2D::GetPositionOffset() const - { - return m_positionOffset; - } - - inline std::size_t RigidBody2D::GetShapeCount() const - { - return m_shapes.size(); - } - - inline void RigidBody2D::SetAngularDamping(float angularDamping) - { - SetMomentOfInertia(angularDamping); - } -} - -#include diff --git a/include/Nazara/Physics2D/Systems/Physics2DSystem.hpp b/include/Nazara/Physics2D/Systems/Physics2DSystem.hpp deleted file mode 100644 index e9ef5ec46..000000000 --- a/include/Nazara/Physics2D/Systems/Physics2DSystem.hpp +++ /dev/null @@ -1,50 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef NAZARA_PHYSICS2D_SYSTEMS_PHYSICS2DSYSTEM_HPP -#define NAZARA_PHYSICS2D_SYSTEMS_PHYSICS2DSYSTEM_HPP - -#include -#include -#include -#include -#include -#include - -namespace Nz -{ - class NAZARA_PHYSICS2D_API Physics2DSystem - { - public: - static constexpr Int64 ExecutionOrder = 0; - using Components = TypeList; - - Physics2DSystem(entt::registry& registry); - Physics2DSystem(const Physics2DSystem&) = delete; - Physics2DSystem(Physics2DSystem&&) = delete; - ~Physics2DSystem(); - - template RigidBody2DComponent CreateRigidBody(Args&&... args); - - inline PhysWorld2D& GetPhysWorld(); - inline const PhysWorld2D& GetPhysWorld() const; - - void Update(Time elapsedTime); - - Physics2DSystem& operator=(const Physics2DSystem&) = delete; - Physics2DSystem& operator=(Physics2DSystem&&) = delete; - - private: - entt::registry& m_registry; - entt::observer m_physicsConstructObserver; - entt::scoped_connection m_constructConnection; - PhysWorld2D m_physWorld; - }; -} - -#include - -#endif // NAZARA_PHYSICS2D_SYSTEMS_PHYSICS2DSYSTEM_HPP diff --git a/include/Nazara/Physics2D/Systems/Physics2DSystem.inl b/include/Nazara/Physics2D/Systems/Physics2DSystem.inl deleted file mode 100644 index 1dfb2be55..000000000 --- a/include/Nazara/Physics2D/Systems/Physics2DSystem.inl +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include - -namespace Nz -{ - template - RigidBody2DComponent Physics2DSystem::CreateRigidBody(Args&&... args) - { - return RigidBody2DComponent(&m_physWorld, std::forward(args)...); - } - - inline PhysWorld2D& Physics2DSystem::GetPhysWorld() - { - return m_physWorld; - } - - inline const PhysWorld2D& Physics2DSystem::GetPhysWorld() const - { - return m_physWorld; - } -} - -#include diff --git a/src/Nazara/BulletPhysics3D/BulletCollider3D.cpp b/src/Nazara/BulletPhysics3D/BulletCollider3D.cpp index 9952b2e7f..616b5232d 100644 --- a/src/Nazara/BulletPhysics3D/BulletCollider3D.cpp +++ b/src/Nazara/BulletPhysics3D/BulletCollider3D.cpp @@ -174,9 +174,9 @@ namespace Nz return m_lengths; } - ColliderType3D BulletBoxCollider3D::GetType() const + BulletColliderType3D BulletBoxCollider3D::GetType() const { - return ColliderType3D::Box; + return BulletColliderType3D::Box; } /******************************** CapsuleCollider3D ********************************/ @@ -209,9 +209,9 @@ namespace Nz return m_shape.get(); } - ColliderType3D BulletCapsuleCollider3D::GetType() const + BulletColliderType3D BulletCapsuleCollider3D::GetType() const { - return ColliderType3D::Capsule; + return BulletColliderType3D::Capsule; } /******************************* CompoundCollider3D ********************************/ @@ -245,9 +245,9 @@ namespace Nz return m_shape.get(); } - ColliderType3D BulletCompoundCollider3D::GetType() const + BulletColliderType3D BulletCompoundCollider3D::GetType() const { - return ColliderType3D::Compound; + return BulletColliderType3D::Compound; } /********************************* ConeCollider3D **********************************/ @@ -280,9 +280,9 @@ namespace Nz return m_shape.get(); } - ColliderType3D BulletConeCollider3D::GetType() const + BulletColliderType3D BulletConeCollider3D::GetType() const { - return ColliderType3D::Cone; + return BulletColliderType3D::Cone; } /****************************** ConvexCollider3D *******************************/ @@ -330,9 +330,9 @@ namespace Nz return m_shape.get(); } - ColliderType3D BulletConvexCollider3D::GetType() const + BulletColliderType3D BulletConvexCollider3D::GetType() const { - return ColliderType3D::ConvexHull; + return BulletColliderType3D::ConvexHull; } /******************************* CylinderCollider3D ********************************/ @@ -366,9 +366,9 @@ namespace Nz return m_shape.get(); } - ColliderType3D BulletCylinderCollider3D::GetType() const + BulletColliderType3D BulletCylinderCollider3D::GetType() const { - return ColliderType3D::Cylinder; + return BulletColliderType3D::Cylinder; } /********************************* NullCollider3D **********************************/ @@ -394,9 +394,9 @@ namespace Nz return m_shape.get(); } - ColliderType3D BulletNullCollider3D::GetType() const + BulletColliderType3D BulletNullCollider3D::GetType() const { - return ColliderType3D::Null; + return BulletColliderType3D::Null; } /******************************** SphereCollider3D *********************************/ @@ -423,9 +423,9 @@ namespace Nz return m_shape.get(); } - ColliderType3D BulletSphereCollider3D::GetType() const + BulletColliderType3D BulletSphereCollider3D::GetType() const { - return ColliderType3D::Sphere; + return BulletColliderType3D::Sphere; } /******************************** StaticPlaneCollider3D *********************************/ @@ -463,8 +463,8 @@ namespace Nz return m_shape.get(); } - ColliderType3D BulletStaticPlaneCollider3D::GetType() const + BulletColliderType3D BulletStaticPlaneCollider3D::GetType() const { - return ColliderType3D::StaticPlane; + return BulletColliderType3D::StaticPlane; } } diff --git a/src/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.cpp b/src/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.cpp new file mode 100644 index 000000000..f386f5936 --- /dev/null +++ b/src/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.cpp @@ -0,0 +1,102 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include + +namespace Nz +{ + float ChipmunkArbiter2D::ComputeTotalKinematicEnergy() const + { + return float(cpArbiterTotalKE(m_arbiter)); + } + + Vector2f ChipmunkArbiter2D::ComputeTotalImpulse() const + { + cpVect impulse = cpArbiterTotalImpulse(m_arbiter); + return Vector2f(Vector2(impulse.x, impulse.y)); + } + + std::pair ChipmunkArbiter2D::GetBodies() const + { + std::pair bodies; + cpBody* firstBody; + cpBody* secondBody; + cpArbiterGetBodies(m_arbiter, &firstBody, &secondBody); + + bodies.first = static_cast(cpBodyGetUserData(firstBody)); + bodies.second = static_cast(cpBodyGetUserData(secondBody)); + + return bodies; + } + + std::size_t ChipmunkArbiter2D::GetContactCount() const + { + return cpArbiterGetCount(m_arbiter); + } + + float ChipmunkArbiter2D::GetContactDepth(std::size_t i) const + { + return float(cpArbiterGetDepth(m_arbiter, int(i))); + } + + Vector2f ChipmunkArbiter2D::GetContactPointA(std::size_t i) const + { + cpVect point = cpArbiterGetPointA(m_arbiter, int(i)); + return Vector2f(Vector2(point.x, point.y)); + } + + Vector2f ChipmunkArbiter2D::GetContactPointB(std::size_t i) const + { + cpVect point = cpArbiterGetPointB(m_arbiter, int(i)); + return Vector2f(Vector2(point.x, point.y)); + } + + float ChipmunkArbiter2D::GetElasticity() const + { + return float(cpArbiterGetRestitution(m_arbiter)); + } + float ChipmunkArbiter2D::GetFriction() const + { + return float(cpArbiterGetFriction(m_arbiter)); + } + + Vector2f ChipmunkArbiter2D::GetNormal() const + { + cpVect normal = cpArbiterGetNormal(m_arbiter); + return Vector2f(Vector2(normal.x, normal.y)); + } + + Vector2f ChipmunkArbiter2D::GetSurfaceVelocity() const + { + cpVect velocity = cpArbiterGetNormal(m_arbiter); + return Vector2f(Vector2(velocity.x, velocity.y)); + } + + bool ChipmunkArbiter2D::IsFirstContact() const + { + return cpArbiterIsFirstContact(m_arbiter) == cpTrue; + } + + bool ChipmunkArbiter2D::IsRemoval() const + { + return cpArbiterIsRemoval(m_arbiter) == cpTrue; + } + + void ChipmunkArbiter2D::SetElasticity(float elasticity) + { + cpArbiterSetRestitution(m_arbiter, elasticity); + } + + void ChipmunkArbiter2D::SetFriction(float friction) + { + cpArbiterSetFriction(m_arbiter, friction); + } + + void ChipmunkArbiter2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity) + { + cpArbiterSetSurfaceVelocity(m_arbiter, cpv(surfaceVelocity.x, surfaceVelocity.y)); + } +} diff --git a/src/Nazara/Physics2D/Collider2D.cpp b/src/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.cpp similarity index 73% rename from src/Nazara/Physics2D/Collider2D.cpp rename to src/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.cpp index 161b50dc5..f465618b5 100644 --- a/src/Nazara/Physics2D/Collider2D.cpp +++ b/src/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.cpp @@ -2,16 +2,16 @@ // This file is part of the "Nazara Engine - Physics2D module" // For conditions of distribution and use, see copyright notice in Config.hpp -#include +#include #include -#include -#include +#include +#include #include #include #include #include #include -#include +#include namespace Nz { @@ -25,9 +25,9 @@ namespace Nz } } - Collider2D::~Collider2D() = default; + ChipmunkCollider2D::~ChipmunkCollider2D() = default; - void Collider2D::ForEachPolygon(const std::function& callback) const + void ChipmunkCollider2D::ForEachPolygon(const std::function& callback) const { // Currently, the only way to get only the polygons of a shape is to create a temporary cpSpace containing only this shape // A better way to do this would be to reimplement this function in every subclass type in the very same way chipmunk does @@ -133,7 +133,7 @@ namespace Nz cpSpaceDebugDraw(space, &drawOptions); } - std::size_t Collider2D::GenerateShapes(cpBody* body, std::vector* shapes) const + std::size_t ChipmunkCollider2D::GenerateShapes(cpBody* body, std::vector* shapes) const { std::size_t shapeCount = CreateShapes(body, shapes); @@ -155,33 +155,33 @@ namespace Nz /******************************** BoxCollider2D *********************************/ - BoxCollider2D::BoxCollider2D(const Vector2f& size, float radius) : - BoxCollider2D(Rectf(-size.x / 2.f, -size.y / 2.f, size.x, size.y), radius) + ChipmunkBoxCollider2D::ChipmunkBoxCollider2D(const Vector2f& size, float radius) : + ChipmunkBoxCollider2D(Rectf(-size.x / 2.f, -size.y / 2.f, size.x, size.y), radius) { } - BoxCollider2D::BoxCollider2D(const Rectf& rect, float radius) : + ChipmunkBoxCollider2D::ChipmunkBoxCollider2D(const Rectf& rect, float radius) : m_rect(rect), m_radius(radius) { } - Vector2f BoxCollider2D::ComputeCenterOfMass() const + Vector2f ChipmunkBoxCollider2D::ComputeCenterOfMass() const { return m_rect.GetCenter(); } - float BoxCollider2D::ComputeMomentOfInertia(float mass) const + float ChipmunkBoxCollider2D::ComputeMomentOfInertia(float mass) const { return SafeCast(cpMomentForBox2(mass, cpBBNew(m_rect.x, m_rect.y, m_rect.x + m_rect.width, m_rect.y + m_rect.height))); } - ColliderType2D BoxCollider2D::GetType() const + ChipmunkColliderType2D ChipmunkBoxCollider2D::GetType() const { - return ColliderType2D::Box; + return ChipmunkColliderType2D::Box; } - std::size_t BoxCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const + std::size_t ChipmunkBoxCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const { shapes->push_back(cpBoxShapeNew2(body, cpBBNew(m_rect.x, m_rect.y, m_rect.x + m_rect.width, m_rect.y + m_rect.height), m_radius)); return 1; @@ -189,28 +189,28 @@ namespace Nz /******************************** CircleCollider2D *********************************/ - CircleCollider2D::CircleCollider2D(float radius, const Vector2f& offset) : + ChipmunkCircleCollider2D::ChipmunkCircleCollider2D(float radius, const Vector2f& offset) : m_offset(offset), m_radius(radius) { } - Vector2f CircleCollider2D::ComputeCenterOfMass() const + Vector2f ChipmunkCircleCollider2D::ComputeCenterOfMass() const { return m_offset; } - float CircleCollider2D::ComputeMomentOfInertia(float mass) const + float ChipmunkCircleCollider2D::ComputeMomentOfInertia(float mass) const { return SafeCast(cpMomentForCircle(mass, 0.f, m_radius, cpv(m_offset.x, m_offset.y))); } - ColliderType2D CircleCollider2D::GetType() const + ChipmunkColliderType2D ChipmunkCircleCollider2D::GetType() const { - return ColliderType2D::Circle; + return ChipmunkColliderType2D::Circle; } - std::size_t CircleCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const + std::size_t ChipmunkCircleCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const { shapes->push_back(cpCircleShapeNew(body, m_radius, cpv(m_offset.x, m_offset.y))); return 1; @@ -218,13 +218,13 @@ namespace Nz /******************************** CompoundCollider2D *********************************/ - CompoundCollider2D::CompoundCollider2D(std::vector> geoms) : + ChipmunkCompoundCollider2D::ChipmunkCompoundCollider2D(std::vector> geoms) : m_geoms(std::move(geoms)), m_doesOverrideCollisionProperties(true) { } - Vector2f CompoundCollider2D::ComputeCenterOfMass() const + Vector2f ChipmunkCompoundCollider2D::ComputeCenterOfMass() const { Vector2f centerOfMass = Vector2f::Zero(); for (const auto& geom : m_geoms) @@ -233,7 +233,7 @@ namespace Nz return centerOfMass / float(m_geoms.size()); } - float CompoundCollider2D::ComputeMomentOfInertia(float mass) const + float ChipmunkCompoundCollider2D::ComputeMomentOfInertia(float mass) const { ///TODO: Correctly compute moment using parallel axis theorem: /// https://chipmunk-physics.net/forum/viewtopic.php?t=1056 @@ -244,12 +244,12 @@ namespace Nz return momentOfInertia; } - ColliderType2D CompoundCollider2D::GetType() const + ChipmunkColliderType2D ChipmunkCompoundCollider2D::GetType() const { - return ColliderType2D::Compound; + return ChipmunkColliderType2D::Compound; } - std::size_t CompoundCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const + std::size_t ChipmunkCompoundCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const { // Since C++ does not allow protected call from other objects, we have to be a friend of Collider2D, yay @@ -260,11 +260,11 @@ namespace Nz return shapeCount; } - std::size_t CompoundCollider2D::GenerateShapes(cpBody* body, std::vector* shapes) const + std::size_t ChipmunkCompoundCollider2D::GenerateShapes(cpBody* body, std::vector* shapes) const { // This is our parent's default behavior if (m_doesOverrideCollisionProperties) - return Collider2D::GenerateShapes(body, shapes); + return ChipmunkCollider2D::GenerateShapes(body, shapes); else { std::size_t shapeCount = 0; @@ -277,7 +277,7 @@ namespace Nz /******************************** ConvexCollider2D *********************************/ - ConvexCollider2D::ConvexCollider2D(SparsePtr vertices, std::size_t vertexCount, float radius) : + ChipmunkConvexCollider2D::ChipmunkConvexCollider2D(SparsePtr vertices, std::size_t vertexCount, float radius) : m_radius(radius) { m_vertices.resize(vertexCount); @@ -285,7 +285,7 @@ namespace Nz m_vertices[i].Set(*vertices++); } - Vector2f ConvexCollider2D::ComputeCenterOfMass() const + Vector2f ChipmunkConvexCollider2D::ComputeCenterOfMass() const { static_assert(sizeof(cpVect) == sizeof(Vector2d), "Chipmunk vector is not equivalent to Vector2d"); @@ -294,19 +294,19 @@ namespace Nz return Vector2f(float(center.x), float(center.y)); } - float ConvexCollider2D::ComputeMomentOfInertia(float mass) const + float ChipmunkConvexCollider2D::ComputeMomentOfInertia(float mass) const { static_assert(sizeof(cpVect) == sizeof(Vector2d), "Chipmunk vector is not equivalent to Vector2d"); return SafeCast(cpMomentForPoly(mass, int(m_vertices.size()), reinterpret_cast(m_vertices.data()), cpv(0.0, 0.0), m_radius)); } - ColliderType2D ConvexCollider2D::GetType() const + ChipmunkColliderType2D ChipmunkConvexCollider2D::GetType() const { - return ColliderType2D::Convex; + return ChipmunkColliderType2D::Convex; } - std::size_t ConvexCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const + std::size_t ChipmunkConvexCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const { shapes->push_back(cpPolyShapeNew(body, int(m_vertices.size()), reinterpret_cast(m_vertices.data()), cpTransformIdentity, m_radius)); return 1; @@ -314,44 +314,44 @@ namespace Nz /********************************* NullCollider2D **********************************/ - ColliderType2D NullCollider2D::GetType() const + ChipmunkColliderType2D ChipmunkNullCollider2D::GetType() const { - return ColliderType2D::Null; + return ChipmunkColliderType2D::Null; } - Vector2f NullCollider2D::ComputeCenterOfMass() const + Vector2f ChipmunkNullCollider2D::ComputeCenterOfMass() const { return Vector2f::Zero(); } - float NullCollider2D::ComputeMomentOfInertia(float mass) const + float ChipmunkNullCollider2D::ComputeMomentOfInertia(float mass) const { return (mass > 0.f) ? 1.f : 0.f; //< Null inertia is only possible for static/kinematic objects } - std::size_t NullCollider2D::CreateShapes(cpBody* /*body*/, std::vector* /*shapes*/) const + std::size_t ChipmunkNullCollider2D::CreateShapes(cpBody* /*body*/, std::vector* /*shapes*/) const { return 0; } /******************************** SegmentCollider2D *********************************/ - Vector2f SegmentCollider2D::ComputeCenterOfMass() const + Vector2f ChipmunkSegmentCollider2D::ComputeCenterOfMass() const { return (m_first + m_second) / 2.f; } - float SegmentCollider2D::ComputeMomentOfInertia(float mass) const + float ChipmunkSegmentCollider2D::ComputeMomentOfInertia(float mass) const { return SafeCast(cpMomentForSegment(mass, cpv(m_first.x, m_first.y), cpv(m_second.x, m_second.y), m_thickness)); } - ColliderType2D SegmentCollider2D::GetType() const + ChipmunkColliderType2D ChipmunkSegmentCollider2D::GetType() const { - return ColliderType2D::Segment; + return ChipmunkColliderType2D::Segment; } - std::size_t SegmentCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const + std::size_t ChipmunkSegmentCollider2D::CreateShapes(cpBody* body, std::vector* shapes) const { cpShape* segment = cpSegmentShapeNew(body, cpv(m_first.x, m_first.y), cpv(m_second.x, m_second.y), m_thickness); cpSegmentShapeSetNeighbors(segment, cpv(m_firstNeighbor.x, m_firstNeighbor.y), cpv(m_secondNeighbor.x, m_secondNeighbor.y)); diff --git a/src/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.cpp b/src/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.cpp new file mode 100644 index 000000000..e476ca950 --- /dev/null +++ b/src/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.cpp @@ -0,0 +1,428 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include + +namespace Nz +{ + ChipmunkConstraint2D::ChipmunkConstraint2D(ChipmunkPhysWorld2D* world, cpConstraint* constraint) : + m_constraint(constraint) + { + cpConstraintSetUserData(m_constraint, this); + cpSpaceAddConstraint(world->GetHandle(), m_constraint); + } + + ChipmunkConstraint2D::ChipmunkConstraint2D(ChipmunkConstraint2D&& rhs) : + m_constraint(std::move(rhs.m_constraint)) + { + cpConstraintSetUserData(m_constraint, this); + } + + ChipmunkConstraint2D::~ChipmunkConstraint2D() + { + cpSpaceRemoveConstraint(cpConstraintGetSpace(m_constraint), m_constraint); + } + + void ChipmunkConstraint2D::EnableBodyCollision(bool enable) + { + cpConstraintSetCollideBodies(m_constraint, (enable) ? cpTrue : cpFalse); + } + + ChipmunkRigidBody2D& ChipmunkConstraint2D::GetBodyA() + { + return *static_cast(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint))); + } + + const ChipmunkRigidBody2D& ChipmunkConstraint2D::GetBodyA() const + { + return *static_cast(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint))); + } + + ChipmunkRigidBody2D& ChipmunkConstraint2D::GetBodyB() + { + return *static_cast(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint))); + } + + const ChipmunkRigidBody2D& ChipmunkConstraint2D::GetBodyB() const + { + return *static_cast(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint))); + } + + float ChipmunkConstraint2D::GetErrorBias() const + { + return float(cpConstraintGetErrorBias(m_constraint)); + } + + float ChipmunkConstraint2D::GetLastImpulse() const + { + return float(cpConstraintGetImpulse(m_constraint)); + } + + float ChipmunkConstraint2D::GetMaxBias() const + { + return float(cpConstraintGetMaxBias(m_constraint)); + } + + float ChipmunkConstraint2D::GetMaxForce() const + { + return float(cpConstraintGetMaxForce(m_constraint)); + } + + ChipmunkPhysWorld2D& ChipmunkConstraint2D::GetWorld() + { + return *static_cast(cpSpaceGetUserData(cpConstraintGetSpace(m_constraint))); + } + + const ChipmunkPhysWorld2D& ChipmunkConstraint2D::GetWorld() const + { + return *static_cast(cpSpaceGetUserData(cpConstraintGetSpace(m_constraint))); + } + + bool ChipmunkConstraint2D::IsBodyCollisionEnabled() const + { + return cpConstraintGetCollideBodies(m_constraint) == cpTrue; + } + + void ChipmunkConstraint2D::SetErrorBias(float bias) + { + cpConstraintSetErrorBias(m_constraint, bias); + } + + void ChipmunkConstraint2D::SetMaxBias(float bias) + { + cpConstraintSetMaxBias(m_constraint, bias); + } + + void ChipmunkConstraint2D::SetMaxForce(float force) + { + cpConstraintSetMaxForce(m_constraint, force); + } + + ChipmunkConstraint2D& ChipmunkConstraint2D::operator=(ChipmunkConstraint2D && rhs) + { + m_constraint = std::move(rhs.m_constraint); + cpConstraintSetUserData(m_constraint, this); + + return *this; + } + + + ChipmunkDampedSpringConstraint2D::ChipmunkDampedSpringConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float restLength, float stiffness, float damping) : + ChipmunkConstraint2D(first.GetWorld(), cpDampedSpringNew(first.GetHandle(), second.GetHandle(), cpv(firstAnchor.x, firstAnchor.y), cpv(secondAnchor.x, secondAnchor.y), restLength, stiffness, damping)) + { + } + + float ChipmunkDampedSpringConstraint2D::GetDamping() const + { + return float(cpDampedSpringGetDamping(m_constraint)); + } + + Vector2f ChipmunkDampedSpringConstraint2D::GetFirstAnchor() const + { + cpVect anchor = cpDampedSpringGetAnchorA(m_constraint); + return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); + } + + float ChipmunkDampedSpringConstraint2D::GetRestLength() const + { + return float(cpDampedSpringGetRestLength(m_constraint)); + } + + Vector2f ChipmunkDampedSpringConstraint2D::GetSecondAnchor() const + { + cpVect anchor = cpDampedSpringGetAnchorB(m_constraint); + return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); + } + + float ChipmunkDampedSpringConstraint2D::GetStiffness() const + { + return float(cpDampedSpringGetStiffness(m_constraint)); + } + + void ChipmunkDampedSpringConstraint2D::SetDamping(float newDamping) + { + cpDampedSpringSetDamping(m_constraint, newDamping); + } + + void ChipmunkDampedSpringConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor) + { + cpDampedSpringSetAnchorA(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); + } + + void ChipmunkDampedSpringConstraint2D::SetRestLength(float newLength) + { + cpDampedSpringSetRestLength(m_constraint, newLength); + } + + void ChipmunkDampedSpringConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor) + { + cpDampedSpringSetAnchorB(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); + } + + void ChipmunkDampedSpringConstraint2D::SetStiffness(float newStiffness) + { + cpDampedSpringSetStiffness(m_constraint, newStiffness); + } + + + ChipmunkDampedRotarySpringConstraint2D::ChipmunkDampedRotarySpringConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const RadianAnglef& restAngle, float stiffness, float damping) : + ChipmunkConstraint2D(first.GetWorld(), cpDampedRotarySpringNew(first.GetHandle(), second.GetHandle(), restAngle.value, stiffness, damping)) + { + } + + float ChipmunkDampedRotarySpringConstraint2D::GetDamping() const + { + return float(cpDampedRotarySpringGetDamping(m_constraint)); + } + + RadianAnglef ChipmunkDampedRotarySpringConstraint2D::GetRestAngle() const + { + return float(cpDampedRotarySpringGetRestAngle(m_constraint)); + } + + float ChipmunkDampedRotarySpringConstraint2D::GetStiffness() const + { + return float(cpDampedRotarySpringGetStiffness(m_constraint)); + } + + void ChipmunkDampedRotarySpringConstraint2D::SetDamping(float newDamping) + { + cpDampedSpringSetDamping(m_constraint, newDamping); + } + + void ChipmunkDampedRotarySpringConstraint2D::SetRestAngle(const RadianAnglef& newAngle) + { + cpDampedRotarySpringSetRestAngle(m_constraint, newAngle.value); + } + + void ChipmunkDampedRotarySpringConstraint2D::SetStiffness(float newStiffness) + { + cpDampedRotarySpringSetStiffness(m_constraint, newStiffness); + } + + + ChipmunkGearConstraint2D::ChipmunkGearConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, float phase, float ratio) : + ChipmunkConstraint2D(first.GetWorld(), cpGearJointNew(first.GetHandle(), second.GetHandle(), phase, ratio)) + { + } + + float ChipmunkGearConstraint2D::GetPhase() const + { + return float(cpGearJointGetPhase(m_constraint)); + } + + float ChipmunkGearConstraint2D::GetRatio() const + { + return float(cpGearJointGetRatio(m_constraint)); + } + + void ChipmunkGearConstraint2D::SetPhase(float phase) + { + cpGearJointSetPhase(m_constraint, phase); + } + + void ChipmunkGearConstraint2D::SetRatio(float ratio) + { + cpGearJointSetRatio(m_constraint, ratio); + } + + + ChipmunkMotorConstraint2D::ChipmunkMotorConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, float rate) : + ChipmunkConstraint2D(first.GetWorld(), cpSimpleMotorNew(first.GetHandle(), second.GetHandle(), rate)) + { + } + + float ChipmunkMotorConstraint2D::GetRate() const + { + return float(cpSimpleMotorGetRate(m_constraint)); + } + + void ChipmunkMotorConstraint2D::SetRate(float rate) + { + cpSimpleMotorSetRate(m_constraint, rate); + } + + + ChipmunkPinConstraint2D::ChipmunkPinConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor) : + ChipmunkConstraint2D(first.GetWorld(), cpPinJointNew(first.GetHandle(), second.GetHandle(), cpv(firstAnchor.x, firstAnchor.y), cpv(secondAnchor.x, secondAnchor.y))) + { + } + + float ChipmunkPinConstraint2D::GetDistance() const + { + return float(cpPinJointGetDist(m_constraint)); + } + + Vector2f ChipmunkPinConstraint2D::GetFirstAnchor() const + { + cpVect anchor = cpPinJointGetAnchorA(m_constraint); + return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); + } + + Vector2f ChipmunkPinConstraint2D::GetSecondAnchor() const + { + cpVect anchor = cpPinJointGetAnchorB(m_constraint); + return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); + } + + void ChipmunkPinConstraint2D::SetDistance(float newDistance) + { + cpPinJointSetDist(m_constraint, newDistance); + } + + void ChipmunkPinConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor) + { + cpPinJointSetAnchorA(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); + } + + void ChipmunkPinConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor) + { + cpPinJointSetAnchorB(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); + } + + + ChipmunkPivotConstraint2D::ChipmunkPivotConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& anchor) : + ChipmunkConstraint2D(first.GetWorld(), cpPivotJointNew(first.GetHandle(), second.GetHandle(), cpv(anchor.x, anchor.y))) + { + } + + ChipmunkPivotConstraint2D::ChipmunkPivotConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor) : + ChipmunkConstraint2D(first.GetWorld(), cpPivotJointNew2(first.GetHandle(), second.GetHandle(), cpv(firstAnchor.x, firstAnchor.y), cpv(secondAnchor.x, secondAnchor.y))) + { + } + + Vector2f ChipmunkPivotConstraint2D::GetFirstAnchor() const + { + cpVect anchor = cpPivotJointGetAnchorA(m_constraint); + return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); + } + + Vector2f ChipmunkPivotConstraint2D::GetSecondAnchor() const + { + cpVect anchor = cpPivotJointGetAnchorB(m_constraint); + return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); + } + + void ChipmunkPivotConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor) + { + cpPivotJointSetAnchorA(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); + } + + void ChipmunkPivotConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor) + { + cpPivotJointSetAnchorB(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); + } + + + ChipmunkRatchetConstraint2D::ChipmunkRatchetConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, float phase, float ratchet) : + ChipmunkConstraint2D(first.GetWorld(), cpRatchetJointNew(first.GetHandle(), second.GetHandle(), phase, ratchet)) + { + } + + RadianAnglef ChipmunkRatchetConstraint2D::GetAngle() const + { + return float(cpRatchetJointGetAngle(m_constraint)); + } + + float ChipmunkRatchetConstraint2D::GetPhase() const + { + return float(cpRatchetJointGetPhase(m_constraint)); + } + + float ChipmunkRatchetConstraint2D::GetRatchet() const + { + return float(cpRatchetJointGetRatchet(m_constraint)); + } + + void ChipmunkRatchetConstraint2D::SetAngle(const RadianAnglef& angle) + { + cpRatchetJointSetAngle(m_constraint, angle.value); + } + + void ChipmunkRatchetConstraint2D::SetPhase(float phase) + { + cpRatchetJointSetPhase(m_constraint, phase); + } + + void ChipmunkRatchetConstraint2D::SetRatchet(float ratchet) + { + cpRatchetJointSetRatchet(m_constraint, ratchet); + } + + + ChipmunkRotaryLimitConstraint2D::ChipmunkRotaryLimitConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const RadianAnglef& minAngle, const RadianAnglef& maxAngle) : + ChipmunkConstraint2D(first.GetWorld(), cpRotaryLimitJointNew(first.GetHandle(), second.GetHandle(), minAngle.value, maxAngle.value)) + { + } + + RadianAnglef ChipmunkRotaryLimitConstraint2D::GetMaxAngle() const + { + return float(cpRotaryLimitJointGetMax(m_constraint)); + } + + RadianAnglef ChipmunkRotaryLimitConstraint2D::GetMinAngle() const + { + return float(cpRotaryLimitJointGetMax(m_constraint)); + } + + void ChipmunkRotaryLimitConstraint2D::SetMaxAngle(const RadianAnglef& maxAngle) + { + cpRotaryLimitJointSetMax(m_constraint, maxAngle.value); + } + + void ChipmunkRotaryLimitConstraint2D::SetMinAngle(const RadianAnglef& minAngle) + { + cpRotaryLimitJointSetMin(m_constraint, minAngle.value); + } + + + ChipmunkSlideConstraint2D::ChipmunkSlideConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float min, float max) : + ChipmunkConstraint2D(first.GetWorld(), cpSlideJointNew(first.GetHandle(), second.GetHandle(), cpv(firstAnchor.x, firstAnchor.y), cpv(secondAnchor.x, secondAnchor.y), min, max)) + { + } + + Vector2f ChipmunkSlideConstraint2D::GetFirstAnchor() const + { + cpVect anchor = cpSlideJointGetAnchorA(m_constraint); + return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); + } + + float ChipmunkSlideConstraint2D::GetMaxDistance() const + { + return float(cpSlideJointGetMax(m_constraint)); + } + + float ChipmunkSlideConstraint2D::GetMinDistance() const + { + return float(cpSlideJointGetMin(m_constraint)); + } + + Vector2f ChipmunkSlideConstraint2D::GetSecondAnchor() const + { + cpVect anchor = cpSlideJointGetAnchorB(m_constraint); + return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); + } + + void ChipmunkSlideConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor) + { + cpSlideJointSetAnchorA(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); + } + + void ChipmunkSlideConstraint2D::SetMaxDistance(float newMaxDistance) + { + cpSlideJointSetMax(m_constraint, newMaxDistance); + } + + void ChipmunkSlideConstraint2D::SetMinDistance(float newMinDistance) + { + cpSlideJointSetMin(m_constraint, newMinDistance); + } + + void ChipmunkSlideConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor) + { + cpSlideJointSetAnchorB(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); + } +} diff --git a/src/Nazara/Physics2D/PhysWorld2D.cpp b/src/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.cpp similarity index 69% rename from src/Nazara/Physics2D/PhysWorld2D.cpp rename to src/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.cpp index 19b89661d..47e4428a7 100644 --- a/src/Nazara/Physics2D/PhysWorld2D.cpp +++ b/src/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.cpp @@ -2,11 +2,11 @@ // This file is part of the "Nazara Engine - Physics2D module" // For conditions of distribution and use, see copyright notice in Config.hpp -#include -#include +#include +#include #include #include -#include +#include namespace Nz { @@ -24,21 +24,21 @@ namespace Nz void CpCircleCallback(cpVect pos, cpFloat angle, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata) { - auto drawOptions = static_cast(userdata); + auto drawOptions = static_cast(userdata); if (drawOptions->circleCallback) drawOptions->circleCallback(Vector2f(float(pos.x), float(pos.y)), RadianAnglef(float(angle)), float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata); } void CpDotCallback(cpFloat size, cpVect pos, cpSpaceDebugColor color, cpDataPointer userdata) { - auto drawOptions = static_cast(userdata); + auto drawOptions = static_cast(userdata); if (drawOptions->dotCallback) drawOptions->dotCallback(Vector2f(float(pos.x), float(pos.y)), float(size), CpDebugColorToColor(color), drawOptions->userdata); } void CpPolygonCallback(int vertexCount, const cpVect* vertices, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata) { - auto drawOptions = static_cast(userdata); + auto drawOptions = static_cast(userdata); if (drawOptions->polygonCallback) { //TODO: constexpr if to prevent copy/cast if sizeof(cpVect) == sizeof(Vector2f) @@ -53,24 +53,24 @@ namespace Nz void CpSegmentCallback(cpVect a, cpVect b, cpSpaceDebugColor color, cpDataPointer userdata) { - auto drawOptions = static_cast(userdata); + auto drawOptions = static_cast(userdata); if (drawOptions->segmentCallback) drawOptions->segmentCallback(Vector2f(float(a.x), float(a.y)), Vector2f(float(b.x), float(b.y)), CpDebugColorToColor(color), drawOptions->userdata); } void CpThickSegmentCallback(cpVect a, cpVect b, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata) { - auto drawOptions = static_cast(userdata); + auto drawOptions = static_cast(userdata); if (drawOptions->thickSegmentCallback) drawOptions->thickSegmentCallback(Vector2f(float(a.x), float(a.y)), Vector2f(float(b.x), float(b.y)), float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata); } cpSpaceDebugColor CpShapeColorCallback(cpShape* shape, cpDataPointer userdata) { - auto drawOptions = static_cast(userdata); + auto drawOptions = static_cast(userdata); if (drawOptions->colorCallback) { - RigidBody2D& rigidBody = *static_cast(cpShapeGetUserData(shape)); + ChipmunkRigidBody2D& rigidBody = *static_cast(cpShapeGetUserData(shape)); return ColorToCpDebugColor(drawOptions->colorCallback(rigidBody, rigidBody.GetShapeIndex(shape), drawOptions->userdata)); } else @@ -78,7 +78,7 @@ namespace Nz } } - PhysWorld2D::PhysWorld2D() : + ChipmunkPhysWorld2D::ChipmunkPhysWorld2D() : m_maxStepCount(50), m_stepSize(Time::TickDuration(200)), m_timestepAccumulator(Time::Zero()) @@ -87,12 +87,12 @@ namespace Nz cpSpaceSetUserData(m_handle, this); } - PhysWorld2D::~PhysWorld2D() + ChipmunkPhysWorld2D::~ChipmunkPhysWorld2D() { cpSpaceFree(m_handle); } - void PhysWorld2D::DebugDraw(const DebugDrawOptions& options, bool drawShapes, bool drawConstraints, bool drawCollisions) + void ChipmunkPhysWorld2D::DebugDraw(const DebugDrawOptions& options, bool drawShapes, bool drawConstraints, bool drawCollisions) { auto ColorToCpDebugColor = [](Color c) -> cpSpaceDebugColor { @@ -128,45 +128,45 @@ namespace Nz cpSpaceDebugDraw(m_handle, &drawOptions); } - float PhysWorld2D::GetDamping() const + float ChipmunkPhysWorld2D::GetDamping() const { return float(cpSpaceGetDamping(m_handle)); } - Vector2f PhysWorld2D::GetGravity() const + Vector2f ChipmunkPhysWorld2D::GetGravity() const { cpVect gravity = cpSpaceGetGravity(m_handle); return Vector2f(Vector2(gravity.x, gravity.y)); } - cpSpace* PhysWorld2D::GetHandle() const + cpSpace* ChipmunkPhysWorld2D::GetHandle() const { return m_handle; } - std::size_t PhysWorld2D::GetIterationCount() const + std::size_t ChipmunkPhysWorld2D::GetIterationCount() const { return cpSpaceGetIterations(m_handle); } - std::size_t PhysWorld2D::GetMaxStepCount() const + std::size_t ChipmunkPhysWorld2D::GetMaxStepCount() const { return m_maxStepCount; } - Time PhysWorld2D::GetStepSize() const + Time ChipmunkPhysWorld2D::GetStepSize() const { return m_stepSize; } - bool PhysWorld2D::NearestBodyQuery(const Vector2f & from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RigidBody2D** nearestBody) + bool ChipmunkPhysWorld2D::NearestBodyQuery(const Vector2f & from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, ChipmunkRigidBody2D** nearestBody) { cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask); if (cpShape* shape = cpSpacePointQueryNearest(m_handle, {from.x, from.y}, maxDistance, filter, nullptr)) { if (nearestBody) - *nearestBody = static_cast(cpShapeGetUserData(shape)); + *nearestBody = static_cast(cpShapeGetUserData(shape)); return true; } @@ -174,7 +174,7 @@ namespace Nz return false; } - bool PhysWorld2D::NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, NearestQueryResult* result) + bool ChipmunkPhysWorld2D::NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, NearestQueryResult* result) { cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask); @@ -187,7 +187,7 @@ namespace Nz result->closestPoint.Set(Vector2(queryInfo.point.x, queryInfo.point.y)); result->distance = float(queryInfo.distance); result->fraction.Set(Vector2(queryInfo.gradient.x, queryInfo.gradient.y)); - result->nearestBody = static_cast(cpShapeGetUserData(queryInfo.shape)); + result->nearestBody = static_cast(cpShapeGetUserData(queryInfo.shape)); return true; } @@ -203,7 +203,7 @@ namespace Nz } } - void PhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef& callback) + void ChipmunkPhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef& callback) { using CallbackType = std::remove_reference_t; @@ -215,7 +215,7 @@ namespace Nz hitInfo.fraction = float(alpha); hitInfo.hitNormal.Set(Vector2(normal.x, normal.y)); hitInfo.hitPos.Set(Vector2(point.x, point.y)); - hitInfo.nearestBody = static_cast(cpShapeGetUserData(shape)); + hitInfo.nearestBody = static_cast(cpShapeGetUserData(shape)); callback(hitInfo); }; @@ -224,7 +224,7 @@ namespace Nz cpSpaceSegmentQuery(m_handle, { from.x, from.y }, { to.x, to.y }, radius, filter, cpCallback, const_cast(static_cast(&callback))); } - bool PhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector* hitInfos) + bool ChipmunkPhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector* hitInfos) { using ResultType = decltype(hitInfos); @@ -236,7 +236,7 @@ namespace Nz hitInfo.fraction = float(alpha); hitInfo.hitNormal.Set(Vector2(normal.x, normal.y)); hitInfo.hitPos.Set(Vector2(point.x, point.y)); - hitInfo.nearestBody = static_cast(cpShapeGetUserData(shape)); + hitInfo.nearestBody = static_cast(cpShapeGetUserData(shape)); results->emplace_back(std::move(hitInfo)); }; @@ -249,7 +249,7 @@ namespace Nz return hitInfos->size() != previousSize; } - bool PhysWorld2D::RaycastQueryFirst(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RaycastHit* hitInfo) + bool ChipmunkPhysWorld2D::RaycastQueryFirst(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RaycastHit* hitInfo) { cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask); @@ -262,7 +262,7 @@ namespace Nz hitInfo->fraction = float(queryInfo.alpha); hitInfo->hitNormal.Set(Vector2(queryInfo.normal.x, queryInfo.normal.y)); hitInfo->hitPos.Set(Vector2(queryInfo.point.x, queryInfo.point.y)); - hitInfo->nearestBody = static_cast(cpShapeGetUserData(queryInfo.shape)); + hitInfo->nearestBody = static_cast(cpShapeGetUserData(queryInfo.shape)); return true; } @@ -278,65 +278,65 @@ namespace Nz } } - void PhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef& callback) + void ChipmunkPhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef& callback) { using CallbackType = std::remove_reference_t; auto cpCallback = [](cpShape* shape, void* data) { CallbackType& callback = *static_cast(data); - callback(static_cast(cpShapeGetUserData(shape))); + callback(static_cast(cpShapeGetUserData(shape))); }; cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask); cpSpaceBBQuery(m_handle, cpBBNew(boundingBox.x, boundingBox.y, boundingBox.x + boundingBox.width, boundingBox.y + boundingBox.height), filter, cpCallback, const_cast(static_cast(&callback))); } - void PhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector* bodies) + void ChipmunkPhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector* bodies) { using ResultType = decltype(bodies); auto callback = [] (cpShape* shape, void* data) { ResultType results = static_cast(data); - results->push_back(static_cast(cpShapeGetUserData(shape))); + results->push_back(static_cast(cpShapeGetUserData(shape))); }; cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask); cpSpaceBBQuery(m_handle, cpBBNew(boundingBox.x, boundingBox.y, boundingBox.x + boundingBox.width, boundingBox.y + boundingBox.height), filter, callback, bodies); } - void PhysWorld2D::RegisterCallbacks(unsigned int collisionId, Callback callbacks) + void ChipmunkPhysWorld2D::RegisterCallbacks(unsigned int collisionId, Callback callbacks) { InitCallbacks(cpSpaceAddWildcardHandler(m_handle, collisionId), std::move(callbacks)); } - void PhysWorld2D::RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, Callback callbacks) + void ChipmunkPhysWorld2D::RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, Callback callbacks) { InitCallbacks(cpSpaceAddCollisionHandler(m_handle, collisionIdA, collisionIdB), std::move(callbacks)); } - void PhysWorld2D::SetDamping(float dampingValue) + void ChipmunkPhysWorld2D::SetDamping(float dampingValue) { cpSpaceSetDamping(m_handle, dampingValue); } - void PhysWorld2D::SetGravity(const Vector2f& gravity) + void ChipmunkPhysWorld2D::SetGravity(const Vector2f& gravity) { cpSpaceSetGravity(m_handle, cpv(gravity.x, gravity.y)); } - void PhysWorld2D::SetIterationCount(std::size_t iterationCount) + void ChipmunkPhysWorld2D::SetIterationCount(std::size_t iterationCount) { cpSpaceSetIterations(m_handle, SafeCast(iterationCount)); } - void PhysWorld2D::SetMaxStepCount(std::size_t maxStepCount) + void ChipmunkPhysWorld2D::SetMaxStepCount(std::size_t maxStepCount) { m_maxStepCount = maxStepCount; } - void PhysWorld2D::SetSleepTime(Time sleepTime) + void ChipmunkPhysWorld2D::SetSleepTime(Time sleepTime) { if (sleepTime > Time::Zero()) cpSpaceSetSleepTimeThreshold(m_handle, sleepTime.AsSeconds()); @@ -344,12 +344,12 @@ namespace Nz cpSpaceSetSleepTimeThreshold(m_handle, std::numeric_limits::infinity()); } - void PhysWorld2D::SetStepSize(Time stepSize) + void ChipmunkPhysWorld2D::SetStepSize(Time stepSize) { m_stepSize = stepSize; } - void PhysWorld2D::Step(Time timestep) + void ChipmunkPhysWorld2D::Step(Time timestep) { m_timestepAccumulator += timestep; @@ -379,12 +379,12 @@ namespace Nz } } - void PhysWorld2D::UseSpatialHash(float cellSize, std::size_t entityCount) + void ChipmunkPhysWorld2D::UseSpatialHash(float cellSize, std::size_t entityCount) { cpSpaceUseSpatialHash(m_handle, cpFloat(cellSize), int(entityCount)); } - void PhysWorld2D::InitCallbacks(cpCollisionHandler* handler, Callback callbacks) + void ChipmunkPhysWorld2D::InitCallbacks(cpCollisionHandler* handler, Callback callbacks) { auto it = m_callbacks.find(handler); if (it == m_callbacks.end()) @@ -403,11 +403,11 @@ namespace Nz cpBody* secondBody; cpArbiterGetBodies(arb, &firstBody, &secondBody); - PhysWorld2D* world = static_cast(cpSpaceGetUserData(space)); - RigidBody2D* firstRigidBody = static_cast(cpBodyGetUserData(firstBody)); - RigidBody2D* secondRigidBody = static_cast(cpBodyGetUserData(secondBody)); + ChipmunkPhysWorld2D* world = static_cast(cpSpaceGetUserData(space)); + ChipmunkRigidBody2D* firstRigidBody = static_cast(cpBodyGetUserData(firstBody)); + ChipmunkRigidBody2D* secondRigidBody = static_cast(cpBodyGetUserData(secondBody)); - Arbiter2D arbiter(arb); + ChipmunkArbiter2D arbiter(arb); const Callback* customCallbacks = static_cast(data); if (customCallbacks->startCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata)) @@ -432,11 +432,11 @@ namespace Nz cpBody* secondBody; cpArbiterGetBodies(arb, &firstBody, &secondBody); - PhysWorld2D* world = static_cast(cpSpaceGetUserData(space)); - RigidBody2D* firstRigidBody = static_cast(cpBodyGetUserData(firstBody)); - RigidBody2D* secondRigidBody = static_cast(cpBodyGetUserData(secondBody)); + ChipmunkPhysWorld2D* world = static_cast(cpSpaceGetUserData(space)); + ChipmunkRigidBody2D* firstRigidBody = static_cast(cpBodyGetUserData(firstBody)); + ChipmunkRigidBody2D* secondRigidBody = static_cast(cpBodyGetUserData(secondBody)); - Arbiter2D arbiter(arb); + ChipmunkArbiter2D arbiter(arb); const Callback* customCallbacks = static_cast(data); customCallbacks->endCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata); @@ -457,11 +457,11 @@ namespace Nz cpBody* secondBody; cpArbiterGetBodies(arb, &firstBody, &secondBody); - PhysWorld2D* world = static_cast(cpSpaceGetUserData(space)); - RigidBody2D* firstRigidBody = static_cast(cpBodyGetUserData(firstBody)); - RigidBody2D* secondRigidBody = static_cast(cpBodyGetUserData(secondBody)); + ChipmunkPhysWorld2D* world = static_cast(cpSpaceGetUserData(space)); + ChipmunkRigidBody2D* firstRigidBody = static_cast(cpBodyGetUserData(firstBody)); + ChipmunkRigidBody2D* secondRigidBody = static_cast(cpBodyGetUserData(secondBody)); - Arbiter2D arbiter(arb); + ChipmunkArbiter2D arbiter(arb); const Callback* customCallbacks = static_cast(data); if (customCallbacks->preSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata)) @@ -486,11 +486,11 @@ namespace Nz cpBody* secondBody; cpArbiterGetBodies(arb, &firstBody, &secondBody); - PhysWorld2D* world = static_cast(cpSpaceGetUserData(space)); - RigidBody2D* firstRigidBody = static_cast(cpBodyGetUserData(firstBody)); - RigidBody2D* secondRigidBody = static_cast(cpBodyGetUserData(secondBody)); + ChipmunkPhysWorld2D* world = static_cast(cpSpaceGetUserData(space)); + ChipmunkRigidBody2D* firstRigidBody = static_cast(cpBodyGetUserData(firstBody)); + ChipmunkRigidBody2D* secondRigidBody = static_cast(cpBodyGetUserData(secondBody)); - Arbiter2D arbiter(arb); + ChipmunkArbiter2D arbiter(arb); const Callback* customCallbacks = static_cast(data); customCallbacks->postSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata); @@ -504,7 +504,7 @@ namespace Nz } } - void PhysWorld2D::OnRigidBodyMoved(RigidBody2D* oldPointer, RigidBody2D* newPointer) + void ChipmunkPhysWorld2D::OnRigidBodyMoved(ChipmunkRigidBody2D* oldPointer, ChipmunkRigidBody2D* newPointer) { auto it = m_rigidPostSteps.find(oldPointer); if (it == m_rigidPostSteps.end()) @@ -514,12 +514,12 @@ namespace Nz m_rigidPostSteps.erase(oldPointer); } - void PhysWorld2D::OnRigidBodyRelease(RigidBody2D* rigidBody) + void ChipmunkPhysWorld2D::OnRigidBodyRelease(ChipmunkRigidBody2D* rigidBody) { m_rigidPostSteps.erase(rigidBody); } - void PhysWorld2D::RegisterPostStep(RigidBody2D* rigidBody, PostStep&& func) + void ChipmunkPhysWorld2D::RegisterPostStep(ChipmunkRigidBody2D* rigidBody, PostStep&& func) { // If space isn't locked, no need to wait if (!cpSpaceIsLocked(m_handle)) @@ -532,8 +532,8 @@ namespace Nz if (it == m_rigidPostSteps.end()) { PostStepContainer postStep; - postStep.onMovedSlot.Connect(rigidBody->OnRigidBody2DMove, this, &PhysWorld2D::OnRigidBodyMoved); - postStep.onReleaseSlot.Connect(rigidBody->OnRigidBody2DRelease, this, &PhysWorld2D::OnRigidBodyRelease); + postStep.onMovedSlot.Connect(rigidBody->OnRigidBody2DMove, this, &ChipmunkPhysWorld2D::OnRigidBodyMoved); + postStep.onReleaseSlot.Connect(rigidBody->OnRigidBody2DRelease, this, &ChipmunkPhysWorld2D::OnRigidBodyRelease); it = m_rigidPostSteps.insert(std::make_pair(rigidBody, std::move(postStep))).first; } diff --git a/src/Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.cpp b/src/Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.cpp new file mode 100644 index 000000000..d61420f7f --- /dev/null +++ b/src/Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.cpp @@ -0,0 +1,16 @@ +// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) +// This file is part of the "Nazara Engine - Physics2D module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include + +namespace Nz +{ + ChipmunkPhysics2D::ChipmunkPhysics2D(Config /*config*/) : + ModuleBase("ChipmunkPhysics2D", this) + { + } + + ChipmunkPhysics2D* ChipmunkPhysics2D::s_instance = nullptr; +} diff --git a/src/Nazara/Physics2D/RigidBody2D.cpp b/src/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.cpp similarity index 70% rename from src/Nazara/Physics2D/RigidBody2D.cpp rename to src/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.cpp index b0c5d5d7d..463ee1fb7 100644 --- a/src/Nazara/Physics2D/RigidBody2D.cpp +++ b/src/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.cpp @@ -2,23 +2,23 @@ // This file is part of the "Nazara Engine - Physics2D module" // For conditions of distribution and use, see copyright notice in Config.hpp -#include -#include -#include +#include +#include +#include #include #include #include #include -#include +#include namespace Nz { - RigidBody2D::RigidBody2D(PhysWorld2D* world, float mass) : - RigidBody2D(world, mass, nullptr) + ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass) : + ChipmunkRigidBody2D(world, mass, nullptr) { } - RigidBody2D::RigidBody2D(PhysWorld2D* world, float mass, std::shared_ptr geom) : + ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass, std::shared_ptr geom) : m_positionOffset(Vector2f::Zero()), m_geom(), m_userData(nullptr), @@ -35,7 +35,7 @@ namespace Nz SetGeom(std::move(geom)); } - RigidBody2D::RigidBody2D(const RigidBody2D& object) : + ChipmunkRigidBody2D::ChipmunkRigidBody2D(const ChipmunkRigidBody2D& object) : m_positionOffset(object.m_positionOffset), m_geom(object.m_geom), m_userData(object.m_userData), @@ -61,7 +61,7 @@ namespace Nz } } - RigidBody2D::RigidBody2D(RigidBody2D&& object) noexcept : + ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkRigidBody2D&& object) noexcept : OnRigidBody2DMove(std::move(object.OnRigidBody2DMove)), OnRigidBody2DRelease(std::move(object.OnRigidBody2DRelease)), m_positionOffset(std::move(object.m_positionOffset)), @@ -85,19 +85,19 @@ namespace Nz OnRigidBody2DMove(&object, this); } - RigidBody2D::~RigidBody2D() + ChipmunkRigidBody2D::~ChipmunkRigidBody2D() { OnRigidBody2DRelease(this); Destroy(); } - void RigidBody2D::AddForce(const Vector2f& force, CoordSys coordSys) + void ChipmunkRigidBody2D::AddForce(const Vector2f& force, CoordSys coordSys) { return AddForce(force, GetMassCenter(coordSys), coordSys); } - void RigidBody2D::AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys) + void ChipmunkRigidBody2D::AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys) { switch (coordSys) { @@ -111,12 +111,12 @@ namespace Nz } } - void RigidBody2D::AddImpulse(const Vector2f& impulse, CoordSys coordSys) + void ChipmunkRigidBody2D::AddImpulse(const Vector2f& impulse, CoordSys coordSys) { return AddImpulse(impulse, GetMassCenter(coordSys), coordSys); } - void RigidBody2D::AddImpulse(const Vector2f& impulse, const Vector2f& point, CoordSys coordSys) + void ChipmunkRigidBody2D::AddImpulse(const Vector2f& impulse, const Vector2f& point, CoordSys coordSys) { switch (coordSys) { @@ -130,12 +130,12 @@ namespace Nz } } - void RigidBody2D::AddTorque(const RadianAnglef& torque) + void ChipmunkRigidBody2D::AddTorque(const RadianAnglef& torque) { cpBodySetTorque(m_handle, cpBodyGetTorque(m_handle) + torque.value); } - bool RigidBody2D::ClosestPointQuery(const Vector2f& position, Vector2f* closestPoint, float* closestDistance) const + bool ChipmunkRigidBody2D::ClosestPointQuery(const Vector2f& position, Vector2f* closestPoint, float* closestDistance) const { cpVect pos = cpv(cpFloat(position.x), cpFloat(position.y)); @@ -166,7 +166,7 @@ namespace Nz return true; } - void RigidBody2D::EnableSimulation(bool simulation) + void ChipmunkRigidBody2D::EnableSimulation(bool simulation) { if (m_isSimulationEnabled != simulation) { @@ -179,7 +179,7 @@ namespace Nz } } - void RigidBody2D::ForEachArbiter(std::function callback) + void ChipmunkRigidBody2D::ForEachArbiter(std::function callback) { using CallbackType = decltype(callback); @@ -187,23 +187,23 @@ namespace Nz { CallbackType& cb = *static_cast(data); - Arbiter2D nzArbiter(arbiter); + ChipmunkArbiter2D nzArbiter(arbiter); cb(nzArbiter); }; cpBodyEachArbiter(m_handle, RealCallback, &callback); } - void RigidBody2D::ForceSleep() + void ChipmunkRigidBody2D::ForceSleep() { - m_world->RegisterPostStep(this, [](RigidBody2D* body) + m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { if (cpBodyGetType(body->GetHandle()) == CP_BODY_TYPE_DYNAMIC) cpBodySleep(body->GetHandle()); }); } - Rectf RigidBody2D::GetAABB() const + Rectf ChipmunkRigidBody2D::GetAABB() const { if (m_shapes.empty()) return Rectf::Zero(); @@ -216,39 +216,39 @@ namespace Nz return Rectf(Rect(bb.l, bb.b, bb.r - bb.l, bb.t - bb.b)); } - RadianAnglef RigidBody2D::GetAngularVelocity() const + RadianAnglef ChipmunkRigidBody2D::GetAngularVelocity() const { return float(cpBodyGetAngularVelocity(m_handle)); } - float RigidBody2D::GetElasticity(std::size_t shapeIndex) const + float ChipmunkRigidBody2D::GetElasticity(std::size_t shapeIndex) const { assert(shapeIndex < m_shapes.size()); return float(cpShapeGetElasticity(m_shapes[shapeIndex])); } - float RigidBody2D::GetFriction(std::size_t shapeIndex) const + float ChipmunkRigidBody2D::GetFriction(std::size_t shapeIndex) const { assert(shapeIndex < m_shapes.size()); return float(cpShapeGetFriction(m_shapes[shapeIndex])); } - const std::shared_ptr& RigidBody2D::GetGeom() const + const std::shared_ptr& ChipmunkRigidBody2D::GetGeom() const { return m_geom; } - cpBody* RigidBody2D::GetHandle() const + cpBody* ChipmunkRigidBody2D::GetHandle() const { return m_handle; } - float RigidBody2D::GetMass() const + float ChipmunkRigidBody2D::GetMass() const { return m_mass; } - Vector2f RigidBody2D::GetMassCenter(CoordSys coordSys) const + Vector2f ChipmunkRigidBody2D::GetMassCenter(CoordSys coordSys) const { cpVect massCenter = cpBodyGetCenterOfGravity(m_handle); @@ -265,23 +265,23 @@ namespace Nz return Vector2f(static_cast(massCenter.x), static_cast(massCenter.y)); } - float RigidBody2D::GetMomentOfInertia() const + float ChipmunkRigidBody2D::GetMomentOfInertia() const { return float(cpBodyGetMoment(m_handle)); } - Vector2f RigidBody2D::GetPosition() const + Vector2f ChipmunkRigidBody2D::GetPosition() const { cpVect pos = cpBodyLocalToWorld(m_handle, cpv(-m_positionOffset.x, -m_positionOffset.y)); return Vector2f(static_cast(pos.x), static_cast(pos.y)); } - RadianAnglef RigidBody2D::GetRotation() const + RadianAnglef ChipmunkRigidBody2D::GetRotation() const { return float(cpBodyGetAngle(m_handle)); } - std::size_t RigidBody2D::GetShapeIndex(cpShape* shape) const + std::size_t ChipmunkRigidBody2D::GetShapeIndex(cpShape* shape) const { auto it = std::find(m_shapes.begin(), m_shapes.end(), shape); if (it == m_shapes.end()) @@ -290,91 +290,91 @@ namespace Nz return std::distance(m_shapes.begin(), it); } - Vector2f RigidBody2D::GetSurfaceVelocity(std::size_t shapeIndex) const + Vector2f ChipmunkRigidBody2D::GetSurfaceVelocity(std::size_t shapeIndex) const { assert(shapeIndex < m_shapes.size()); cpVect vel = cpShapeGetSurfaceVelocity(m_shapes[shapeIndex]); return Vector2f(static_cast(vel.x), static_cast(vel.y)); } - void* RigidBody2D::GetUserdata() const + void* ChipmunkRigidBody2D::GetUserdata() const { return m_userData; } - Vector2f RigidBody2D::GetVelocity() const + Vector2f ChipmunkRigidBody2D::GetVelocity() const { cpVect vel = cpBodyGetVelocity(m_handle); return Vector2f(static_cast(vel.x), static_cast(vel.y)); } - const RigidBody2D::VelocityFunc& RigidBody2D::GetVelocityFunction() const + const ChipmunkRigidBody2D::VelocityFunc& ChipmunkRigidBody2D::GetVelocityFunction() const { return m_velocityFunc; } - PhysWorld2D* RigidBody2D::GetWorld() const + ChipmunkPhysWorld2D* ChipmunkRigidBody2D::GetWorld() const { return m_world; } - bool RigidBody2D::IsKinematic() const + bool ChipmunkRigidBody2D::IsKinematic() const { return m_mass <= 0.f; } - bool RigidBody2D::IsSimulationEnabled() const + bool ChipmunkRigidBody2D::IsSimulationEnabled() const { return m_isSimulationEnabled; } - bool RigidBody2D::IsSleeping() const + bool ChipmunkRigidBody2D::IsSleeping() const { return cpBodyIsSleeping(m_handle) != 0; } - bool RigidBody2D::IsStatic() const + bool ChipmunkRigidBody2D::IsStatic() const { return m_isStatic; } - void RigidBody2D::ResetVelocityFunction() + void ChipmunkRigidBody2D::ResetVelocityFunction() { m_handle->velocity_func = cpBodyUpdateVelocity; } - void RigidBody2D::SetAngularVelocity(const RadianAnglef& angularVelocity) + void ChipmunkRigidBody2D::SetAngularVelocity(const RadianAnglef& angularVelocity) { cpBodySetAngularVelocity(m_handle, angularVelocity.value); } - void RigidBody2D::SetElasticity(float friction) + void ChipmunkRigidBody2D::SetElasticity(float friction) { cpFloat frict(friction); for (cpShape* shape : m_shapes) cpShapeSetElasticity(shape, frict); } - void RigidBody2D::SetElasticity(std::size_t shapeIndex, float friction) + void ChipmunkRigidBody2D::SetElasticity(std::size_t shapeIndex, float friction) { assert(shapeIndex < m_shapes.size()); cpShapeSetElasticity(m_shapes[shapeIndex], cpFloat(friction)); } - void RigidBody2D::SetFriction(float friction) + void ChipmunkRigidBody2D::SetFriction(float friction) { cpFloat frict(friction); for (cpShape* shape : m_shapes) cpShapeSetFriction(shape, frict); } - void RigidBody2D::SetFriction(std::size_t shapeIndex, float friction) + void ChipmunkRigidBody2D::SetFriction(std::size_t shapeIndex, float friction) { assert(shapeIndex < m_shapes.size()); cpShapeSetFriction(m_shapes[shapeIndex], cpFloat(friction)); } - void RigidBody2D::SetGeom(std::shared_ptr geom, bool recomputeMoment, bool recomputeMassCenter) + void ChipmunkRigidBody2D::SetGeom(std::shared_ptr geom, bool recomputeMoment, bool recomputeMassCenter) { // We have no public way of getting rid of an existing geom without removing the whole body // So let's save some attributes of the body, destroy it and rebuild it @@ -395,7 +395,7 @@ namespace Nz if (geom) m_geom = std::move(geom); else - m_geom = std::make_shared(); + m_geom = std::make_shared(); m_geom->GenerateShapes(m_handle, &m_shapes); @@ -415,13 +415,13 @@ namespace Nz SetMassCenter(m_geom->ComputeCenterOfMass()); } - void RigidBody2D::SetMass(float mass, bool recomputeMoment) + void ChipmunkRigidBody2D::SetMass(float mass, bool recomputeMoment) { if (m_mass > 0.f) { if (mass > 0.f) { - m_world->RegisterPostStep(this, [mass, recomputeMoment](RigidBody2D* body) + m_world->RegisterPostStep(this, [mass, recomputeMoment](ChipmunkRigidBody2D* body) { cpBodySetMass(body->GetHandle(), mass); @@ -430,11 +430,11 @@ namespace Nz }); } else - m_world->RegisterPostStep(this, [](RigidBody2D* body) { cpBodySetType(body->GetHandle(), (body->IsStatic()) ? CP_BODY_TYPE_STATIC : CP_BODY_TYPE_KINEMATIC); } ); + m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { cpBodySetType(body->GetHandle(), (body->IsStatic()) ? CP_BODY_TYPE_STATIC : CP_BODY_TYPE_KINEMATIC); } ); } else if (mass > 0.f) { - m_world->RegisterPostStep(this, [mass, recomputeMoment](RigidBody2D* body) + m_world->RegisterPostStep(this, [mass, recomputeMoment](ChipmunkRigidBody2D* body) { if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_DYNAMIC) { @@ -450,7 +450,7 @@ namespace Nz m_mass = mass; } - void RigidBody2D::SetMassCenter(const Vector2f& center, CoordSys coordSys) + void ChipmunkRigidBody2D::SetMassCenter(const Vector2f& center, CoordSys coordSys) { cpVect massCenter = cpv(center.x, center.y); @@ -467,64 +467,64 @@ namespace Nz cpBodySetCenterOfGravity(m_handle, massCenter); } - void RigidBody2D::SetMomentOfInertia(float moment) + void ChipmunkRigidBody2D::SetMomentOfInertia(float moment) { // Even though Chipmunk allows us to change this anytime, we need to do it in a post-step to prevent other post-steps to override this - m_world->RegisterPostStep(this, [moment] (RigidBody2D* body) + m_world->RegisterPostStep(this, [moment] (ChipmunkRigidBody2D* body) { cpBodySetMoment(body->GetHandle(), moment); }); } - void RigidBody2D::SetPosition(const Vector2f& position) + void ChipmunkRigidBody2D::SetPosition(const Vector2f& position) { // Use cpTransformVect to rotate/scale the position offset cpBodySetPosition(m_handle, cpvadd(cpv(position.x, position.y), cpTransformVect(m_handle->transform, cpv(m_positionOffset.x, m_positionOffset.y)))); if (m_isStatic) { - m_world->RegisterPostStep(this, [](RigidBody2D* body) + m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle()); }); } } - void RigidBody2D::SetPositionOffset(const Vector2f& offset) + void ChipmunkRigidBody2D::SetPositionOffset(const Vector2f& offset) { Vector2f position = GetPosition(); m_positionOffset = offset; SetPosition(position); } - void RigidBody2D::SetRotation(const RadianAnglef& rotation) + void ChipmunkRigidBody2D::SetRotation(const RadianAnglef& rotation) { cpBodySetAngle(m_handle, rotation.value); if (m_isStatic) { - m_world->RegisterPostStep(this, [](RigidBody2D* body) + m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle()); }); } } - void RigidBody2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity) + void ChipmunkRigidBody2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity) { Vector2 velocity(surfaceVelocity.x, surfaceVelocity.y); for (cpShape* shape : m_shapes) cpShapeSetSurfaceVelocity(shape, cpv(velocity.x, velocity.y)); } - void RigidBody2D::SetSurfaceVelocity(std::size_t shapeIndex, const Vector2f& surfaceVelocity) + void ChipmunkRigidBody2D::SetSurfaceVelocity(std::size_t shapeIndex, const Vector2f& surfaceVelocity) { assert(shapeIndex < m_shapes.size()); cpShapeSetSurfaceVelocity(m_shapes[shapeIndex], cpv(cpFloat(surfaceVelocity.x), cpFloat(surfaceVelocity.y))); } - void RigidBody2D::SetStatic(bool setStaticBody) + void ChipmunkRigidBody2D::SetStatic(bool setStaticBody) { m_isStatic = setStaticBody; - m_world->RegisterPostStep(this, [](RigidBody2D* body) + m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { if (body->IsStatic()) { @@ -538,17 +538,17 @@ namespace Nz }); } - void RigidBody2D::SetUserdata(void* ud) + void ChipmunkRigidBody2D::SetUserdata(void* ud) { m_userData = ud; } - void RigidBody2D::SetVelocity(const Vector2f& velocity) + void ChipmunkRigidBody2D::SetVelocity(const Vector2f& velocity) { cpBodySetVelocity(m_handle, cpv(velocity.x, velocity.y)); } - void RigidBody2D::SetVelocityFunction(VelocityFunc velocityFunc) + void ChipmunkRigidBody2D::SetVelocityFunction(VelocityFunc velocityFunc) { m_velocityFunc = std::move(velocityFunc); @@ -556,7 +556,7 @@ namespace Nz { m_handle->velocity_func = [](cpBody* body, cpVect gravity, cpFloat damping, cpFloat dt) { - RigidBody2D* rigidBody = static_cast(cpBodyGetUserData(body)); + ChipmunkRigidBody2D* rigidBody = static_cast(cpBodyGetUserData(body)); const auto& callback = rigidBody->GetVelocityFunction(); assert(callback); @@ -567,28 +567,28 @@ namespace Nz m_handle->velocity_func = cpBodyUpdateVelocity; } - void RigidBody2D::TeleportTo(const Vector2f& position, const RadianAnglef& rotation) + void ChipmunkRigidBody2D::TeleportTo(const Vector2f& position, const RadianAnglef& rotation) { // Use cpTransformVect to rotate/scale the position offset cpBodySetPosition(m_handle, cpvadd(cpv(position.x, position.y), cpTransformVect(m_handle->transform, cpv(m_positionOffset.x, m_positionOffset.y)))); cpBodySetAngle(m_handle, rotation.value); if (m_isStatic) { - m_world->RegisterPostStep(this, [](RigidBody2D* body) + m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle()); }); } } - void RigidBody2D::UpdateVelocity(const Vector2f & gravity, float damping, float deltaTime) + void ChipmunkRigidBody2D::UpdateVelocity(const Vector2f & gravity, float damping, float deltaTime) { cpBodyUpdateVelocity(m_handle, cpv(gravity.x, gravity.y), damping, deltaTime); } - void RigidBody2D::Wakeup() + void ChipmunkRigidBody2D::Wakeup() { - m_world->RegisterPostStep(this, [](RigidBody2D* body) + m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_STATIC) cpBodyActivate(body->GetHandle()); @@ -597,13 +597,13 @@ namespace Nz }); } - RigidBody2D& RigidBody2D::operator=(const RigidBody2D& object) + ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(const ChipmunkRigidBody2D& object) { - RigidBody2D physObj(object); + ChipmunkRigidBody2D physObj(object); return operator=(std::move(physObj)); } - RigidBody2D& RigidBody2D::operator=(RigidBody2D&& object) + ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(ChipmunkRigidBody2D&& object) { Destroy(); @@ -637,7 +637,7 @@ namespace Nz return *this; } - void RigidBody2D::Destroy() + void ChipmunkRigidBody2D::Destroy() { UnregisterFromSpace(); @@ -653,7 +653,7 @@ namespace Nz m_shapes.clear(); } - cpBody* RigidBody2D::Create(float mass, float moment) + cpBody* ChipmunkRigidBody2D::Create(float mass, float moment) { cpBody* handle; if (IsKinematic()) @@ -671,7 +671,7 @@ namespace Nz return handle; } - void RigidBody2D::RegisterToSpace() + void ChipmunkRigidBody2D::RegisterToSpace() { if (!m_isRegistered) { @@ -686,7 +686,7 @@ namespace Nz } } - void RigidBody2D::UnregisterFromSpace() + void ChipmunkRigidBody2D::UnregisterFromSpace() { if (m_isRegistered) { @@ -701,7 +701,7 @@ namespace Nz } } - void RigidBody2D::CopyBodyData(cpBody* from, cpBody* to) + void ChipmunkRigidBody2D::CopyBodyData(cpBody* from, cpBody* to) { cpBodySetCenterOfGravity(to, cpBodyGetCenterOfGravity(from)); @@ -717,7 +717,7 @@ namespace Nz to->velocity_func = from->velocity_func; } - void RigidBody2D::CopyShapeData(cpShape* from, cpShape* to) + void ChipmunkRigidBody2D::CopyShapeData(cpShape* from, cpShape* to) { cpShapeSetElasticity(to, cpShapeGetElasticity(from)); cpShapeSetFriction(to, cpShapeGetFriction(from)); diff --git a/src/Nazara/Physics2D/Components/RigidBody2DComponent.cpp b/src/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.cpp similarity index 64% rename from src/Nazara/Physics2D/Components/RigidBody2DComponent.cpp rename to src/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.cpp index 0692a20f3..a98c71076 100644 --- a/src/Nazara/Physics2D/Components/RigidBody2DComponent.cpp +++ b/src/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.cpp @@ -2,8 +2,8 @@ // This file is part of the "Nazara Engine - Physics2D module" // For conditions of distribution and use, see copyright notice in Config.hpp -#include -#include +#include +#include namespace Nz { diff --git a/src/Nazara/Physics2D/Systems/Physics2DSystem.cpp b/src/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.cpp similarity index 68% rename from src/Nazara/Physics2D/Systems/Physics2DSystem.cpp rename to src/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.cpp index 12d002c50..da570b5ff 100644 --- a/src/Nazara/Physics2D/Systems/Physics2DSystem.cpp +++ b/src/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.cpp @@ -2,9 +2,9 @@ // This file is part of the "Nazara Engine - Physics2D module" // For conditions of distribution and use, see copyright notice in Config.hpp -#include +#include #include -#include +#include namespace Nz { @@ -19,28 +19,28 @@ namespace Nz } } - Physics2DSystem::Physics2DSystem(entt::registry& registry) : + ChipmunkPhysics2DSystem::ChipmunkPhysics2DSystem(entt::registry& registry) : m_registry(registry), - m_physicsConstructObserver(m_registry, entt::collector.group()) + m_physicsConstructObserver(m_registry, entt::collector.group()) { } - Physics2DSystem::~Physics2DSystem() + ChipmunkPhysics2DSystem::~ChipmunkPhysics2DSystem() { m_physicsConstructObserver.disconnect(); // Ensure every body is destroyed before world is - auto rigidBodyView = m_registry.view(); + auto rigidBodyView = m_registry.view(); for (auto [entity, rigidBodyComponent] : rigidBodyView.each()) rigidBodyComponent.Destroy(); } - void Physics2DSystem::Update(Time elapsedTime) + void ChipmunkPhysics2DSystem::Update(Time elapsedTime) { // Move newly-created physics entities to their node position/rotation m_physicsConstructObserver.each([&](entt::entity entity) { - RigidBody2DComponent& entityPhysics = m_registry.get(entity); + ChipmunkRigidBody2DComponent& entityPhysics = m_registry.get(entity); NodeComponent& entityNode = m_registry.get(entity); entityPhysics.TeleportTo(Vector2f(entityNode.GetPosition()), AngleFromQuaternion(entityNode.GetRotation())); @@ -49,7 +49,7 @@ namespace Nz m_physWorld.Step(elapsedTime); // Replicate rigid body position to their node components - auto view = m_registry.view(); + auto view = m_registry.view(); for (auto [entity, nodeComponent, rigidBodyComponent] : view.each()) { if (rigidBodyComponent.IsSleeping()) diff --git a/src/Nazara/Physics2D/Arbiter2D.cpp b/src/Nazara/Physics2D/Arbiter2D.cpp deleted file mode 100644 index c2c21ea3f..000000000 --- a/src/Nazara/Physics2D/Arbiter2D.cpp +++ /dev/null @@ -1,102 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include -#include - -namespace Nz -{ - float Nz::Arbiter2D::ComputeTotalKinematicEnergy() const - { - return float(cpArbiterTotalKE(m_arbiter)); - } - - Nz::Vector2f Arbiter2D::ComputeTotalImpulse() const - { - cpVect impulse = cpArbiterTotalImpulse(m_arbiter); - return Nz::Vector2f(Nz::Vector2(impulse.x, impulse.y)); - } - - std::pair Arbiter2D::GetBodies() const - { - std::pair bodies; - cpBody* firstBody; - cpBody* secondBody; - cpArbiterGetBodies(m_arbiter, &firstBody, &secondBody); - - bodies.first = static_cast(cpBodyGetUserData(firstBody)); - bodies.second = static_cast(cpBodyGetUserData(secondBody)); - - return bodies; - } - - std::size_t Arbiter2D::GetContactCount() const - { - return cpArbiterGetCount(m_arbiter); - } - - float Arbiter2D::GetContactDepth(std::size_t i) const - { - return float(cpArbiterGetDepth(m_arbiter, int(i))); - } - - Nz::Vector2f Arbiter2D::GetContactPointA(std::size_t i) const - { - cpVect point = cpArbiterGetPointA(m_arbiter, int(i)); - return Nz::Vector2f(Nz::Vector2(point.x, point.y)); - } - - Nz::Vector2f Arbiter2D::GetContactPointB(std::size_t i) const - { - cpVect point = cpArbiterGetPointB(m_arbiter, int(i)); - return Nz::Vector2f(Nz::Vector2(point.x, point.y)); - } - - float Arbiter2D::GetElasticity() const - { - return float(cpArbiterGetRestitution(m_arbiter)); - } - float Arbiter2D::GetFriction() const - { - return float(cpArbiterGetFriction(m_arbiter)); - } - - Nz::Vector2f Arbiter2D::GetNormal() const - { - cpVect normal = cpArbiterGetNormal(m_arbiter); - return Nz::Vector2f(Nz::Vector2(normal.x, normal.y)); - } - - Nz::Vector2f Arbiter2D::GetSurfaceVelocity() const - { - cpVect velocity = cpArbiterGetNormal(m_arbiter); - return Nz::Vector2f(Nz::Vector2(velocity.x, velocity.y)); - } - - bool Arbiter2D::IsFirstContact() const - { - return cpArbiterIsFirstContact(m_arbiter) == cpTrue; - } - - bool Arbiter2D::IsRemoval() const - { - return cpArbiterIsRemoval(m_arbiter) == cpTrue; - } - - void Arbiter2D::SetElasticity(float elasticity) - { - cpArbiterSetRestitution(m_arbiter, elasticity); - } - - void Arbiter2D::SetFriction(float friction) - { - cpArbiterSetFriction(m_arbiter, friction); - } - - void Arbiter2D::SetSurfaceVelocity(const Nz::Vector2f& surfaceVelocity) - { - cpArbiterSetSurfaceVelocity(m_arbiter, cpv(surfaceVelocity.x, surfaceVelocity.y)); - } -} diff --git a/src/Nazara/Physics2D/Constraint2D.cpp b/src/Nazara/Physics2D/Constraint2D.cpp deleted file mode 100644 index 1d5b73ef1..000000000 --- a/src/Nazara/Physics2D/Constraint2D.cpp +++ /dev/null @@ -1,428 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include -#include - -namespace Nz -{ - Constraint2D::Constraint2D(PhysWorld2D* world, cpConstraint* constraint) : - m_constraint(constraint) - { - cpConstraintSetUserData(m_constraint, this); - cpSpaceAddConstraint(world->GetHandle(), m_constraint); - } - - Constraint2D::Constraint2D(Constraint2D&& rhs) : - m_constraint(std::move(rhs.m_constraint)) - { - cpConstraintSetUserData(m_constraint, this); - } - - Constraint2D::~Constraint2D() - { - cpSpaceRemoveConstraint(cpConstraintGetSpace(m_constraint), m_constraint); - } - - void Constraint2D::EnableBodyCollision(bool enable) - { - cpConstraintSetCollideBodies(m_constraint, (enable) ? cpTrue : cpFalse); - } - - RigidBody2D& Constraint2D::GetBodyA() - { - return *static_cast(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint))); - } - - const RigidBody2D& Constraint2D::GetBodyA() const - { - return *static_cast(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint))); - } - - RigidBody2D& Constraint2D::GetBodyB() - { - return *static_cast(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint))); - } - - const RigidBody2D& Constraint2D::GetBodyB() const - { - return *static_cast(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint))); - } - - float Constraint2D::GetErrorBias() const - { - return float(cpConstraintGetErrorBias(m_constraint)); - } - - float Constraint2D::GetLastImpulse() const - { - return float(cpConstraintGetImpulse(m_constraint)); - } - - float Constraint2D::GetMaxBias() const - { - return float(cpConstraintGetMaxBias(m_constraint)); - } - - float Constraint2D::GetMaxForce() const - { - return float(cpConstraintGetMaxForce(m_constraint)); - } - - PhysWorld2D& Constraint2D::GetWorld() - { - return *static_cast(cpSpaceGetUserData(cpConstraintGetSpace(m_constraint))); - } - - const PhysWorld2D& Constraint2D::GetWorld() const - { - return *static_cast(cpSpaceGetUserData(cpConstraintGetSpace(m_constraint))); - } - - bool Constraint2D::IsBodyCollisionEnabled() const - { - return cpConstraintGetCollideBodies(m_constraint) == cpTrue; - } - - void Constraint2D::SetErrorBias(float bias) - { - cpConstraintSetErrorBias(m_constraint, bias); - } - - void Constraint2D::SetMaxBias(float bias) - { - cpConstraintSetMaxBias(m_constraint, bias); - } - - void Constraint2D::SetMaxForce(float force) - { - cpConstraintSetMaxForce(m_constraint, force); - } - - Constraint2D& Constraint2D::operator=(Constraint2D && rhs) - { - m_constraint = std::move(rhs.m_constraint); - cpConstraintSetUserData(m_constraint, this); - - return *this; - } - - - DampedSpringConstraint2D::DampedSpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float restLength, float stiffness, float damping) : - Constraint2D(first.GetWorld(), cpDampedSpringNew(first.GetHandle(), second.GetHandle(), cpv(firstAnchor.x, firstAnchor.y), cpv(secondAnchor.x, secondAnchor.y), restLength, stiffness, damping)) - { - } - - float DampedSpringConstraint2D::GetDamping() const - { - return float(cpDampedSpringGetDamping(m_constraint)); - } - - Vector2f DampedSpringConstraint2D::GetFirstAnchor() const - { - cpVect anchor = cpDampedSpringGetAnchorA(m_constraint); - return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); - } - - float DampedSpringConstraint2D::GetRestLength() const - { - return float(cpDampedSpringGetRestLength(m_constraint)); - } - - Vector2f DampedSpringConstraint2D::GetSecondAnchor() const - { - cpVect anchor = cpDampedSpringGetAnchorB(m_constraint); - return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); - } - - float DampedSpringConstraint2D::GetStiffness() const - { - return float(cpDampedSpringGetStiffness(m_constraint)); - } - - void DampedSpringConstraint2D::SetDamping(float newDamping) - { - cpDampedSpringSetDamping(m_constraint, newDamping); - } - - void DampedSpringConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor) - { - cpDampedSpringSetAnchorA(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); - } - - void DampedSpringConstraint2D::SetRestLength(float newLength) - { - cpDampedSpringSetRestLength(m_constraint, newLength); - } - - void DampedSpringConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor) - { - cpDampedSpringSetAnchorB(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); - } - - void DampedSpringConstraint2D::SetStiffness(float newStiffness) - { - cpDampedSpringSetStiffness(m_constraint, newStiffness); - } - - - DampedRotarySpringConstraint2D::DampedRotarySpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& restAngle, float stiffness, float damping) : - Constraint2D(first.GetWorld(), cpDampedRotarySpringNew(first.GetHandle(), second.GetHandle(), restAngle.value, stiffness, damping)) - { - } - - float DampedRotarySpringConstraint2D::GetDamping() const - { - return float(cpDampedRotarySpringGetDamping(m_constraint)); - } - - RadianAnglef DampedRotarySpringConstraint2D::GetRestAngle() const - { - return float(cpDampedRotarySpringGetRestAngle(m_constraint)); - } - - float DampedRotarySpringConstraint2D::GetStiffness() const - { - return float(cpDampedRotarySpringGetStiffness(m_constraint)); - } - - void DampedRotarySpringConstraint2D::SetDamping(float newDamping) - { - cpDampedSpringSetDamping(m_constraint, newDamping); - } - - void DampedRotarySpringConstraint2D::SetRestAngle(const RadianAnglef& newAngle) - { - cpDampedRotarySpringSetRestAngle(m_constraint, newAngle.value); - } - - void DampedRotarySpringConstraint2D::SetStiffness(float newStiffness) - { - cpDampedRotarySpringSetStiffness(m_constraint, newStiffness); - } - - - GearConstraint2D::GearConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratio) : - Constraint2D(first.GetWorld(), cpGearJointNew(first.GetHandle(), second.GetHandle(), phase, ratio)) - { - } - - float GearConstraint2D::GetPhase() const - { - return float(cpGearJointGetPhase(m_constraint)); - } - - float GearConstraint2D::GetRatio() const - { - return float(cpGearJointGetRatio(m_constraint)); - } - - void GearConstraint2D::SetPhase(float phase) - { - cpGearJointSetPhase(m_constraint, phase); - } - - void GearConstraint2D::SetRatio(float ratio) - { - cpGearJointSetRatio(m_constraint, ratio); - } - - - MotorConstraint2D::MotorConstraint2D(RigidBody2D& first, RigidBody2D& second, float rate) : - Constraint2D(first.GetWorld(), cpSimpleMotorNew(first.GetHandle(), second.GetHandle(), rate)) - { - } - - float MotorConstraint2D::GetRate() const - { - return float(cpSimpleMotorGetRate(m_constraint)); - } - - void MotorConstraint2D::SetRate(float rate) - { - cpSimpleMotorSetRate(m_constraint, rate); - } - - - PinConstraint2D::PinConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor) : - Constraint2D(first.GetWorld(), cpPinJointNew(first.GetHandle(), second.GetHandle(), cpv(firstAnchor.x, firstAnchor.y), cpv(secondAnchor.x, secondAnchor.y))) - { - } - - float PinConstraint2D::GetDistance() const - { - return float(cpPinJointGetDist(m_constraint)); - } - - Vector2f PinConstraint2D::GetFirstAnchor() const - { - cpVect anchor = cpPinJointGetAnchorA(m_constraint); - return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); - } - - Vector2f PinConstraint2D::GetSecondAnchor() const - { - cpVect anchor = cpPinJointGetAnchorB(m_constraint); - return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); - } - - void PinConstraint2D::SetDistance(float newDistance) - { - cpPinJointSetDist(m_constraint, newDistance); - } - - void PinConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor) - { - cpPinJointSetAnchorA(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); - } - - void PinConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor) - { - cpPinJointSetAnchorB(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); - } - - - PivotConstraint2D::PivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& anchor) : - Constraint2D(first.GetWorld(), cpPivotJointNew(first.GetHandle(), second.GetHandle(), cpv(anchor.x, anchor.y))) - { - } - - PivotConstraint2D::PivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor) : - Constraint2D(first.GetWorld(), cpPivotJointNew2(first.GetHandle(), second.GetHandle(), cpv(firstAnchor.x, firstAnchor.y), cpv(secondAnchor.x, secondAnchor.y))) - { - } - - Vector2f PivotConstraint2D::GetFirstAnchor() const - { - cpVect anchor = cpPivotJointGetAnchorA(m_constraint); - return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); - } - - Vector2f PivotConstraint2D::GetSecondAnchor() const - { - cpVect anchor = cpPivotJointGetAnchorB(m_constraint); - return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); - } - - void PivotConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor) - { - cpPivotJointSetAnchorA(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); - } - - void PivotConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor) - { - cpPivotJointSetAnchorB(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); - } - - - RatchetConstraint2D::RatchetConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratchet) : - Constraint2D(first.GetWorld(), cpRatchetJointNew(first.GetHandle(), second.GetHandle(), phase, ratchet)) - { - } - - RadianAnglef RatchetConstraint2D::GetAngle() const - { - return float(cpRatchetJointGetAngle(m_constraint)); - } - - float RatchetConstraint2D::GetPhase() const - { - return float(cpRatchetJointGetPhase(m_constraint)); - } - - float RatchetConstraint2D::GetRatchet() const - { - return float(cpRatchetJointGetRatchet(m_constraint)); - } - - void RatchetConstraint2D::SetAngle(const RadianAnglef& angle) - { - cpRatchetJointSetAngle(m_constraint, angle.value); - } - - void RatchetConstraint2D::SetPhase(float phase) - { - cpRatchetJointSetPhase(m_constraint, phase); - } - - void RatchetConstraint2D::SetRatchet(float ratchet) - { - cpRatchetJointSetRatchet(m_constraint, ratchet); - } - - - RotaryLimitConstraint2D::RotaryLimitConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& minAngle, const RadianAnglef& maxAngle) : - Constraint2D(first.GetWorld(), cpRotaryLimitJointNew(first.GetHandle(), second.GetHandle(), minAngle.value, maxAngle.value)) - { - } - - RadianAnglef RotaryLimitConstraint2D::GetMaxAngle() const - { - return float(cpRotaryLimitJointGetMax(m_constraint)); - } - - RadianAnglef RotaryLimitConstraint2D::GetMinAngle() const - { - return float(cpRotaryLimitJointGetMax(m_constraint)); - } - - void RotaryLimitConstraint2D::SetMaxAngle(const RadianAnglef& maxAngle) - { - cpRotaryLimitJointSetMax(m_constraint, maxAngle.value); - } - - void RotaryLimitConstraint2D::SetMinAngle(const RadianAnglef& minAngle) - { - cpRotaryLimitJointSetMin(m_constraint, minAngle.value); - } - - - SlideConstraint2D::SlideConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float min, float max) : - Constraint2D(first.GetWorld(), cpSlideJointNew(first.GetHandle(), second.GetHandle(), cpv(firstAnchor.x, firstAnchor.y), cpv(secondAnchor.x, secondAnchor.y), min, max)) - { - } - - Vector2f SlideConstraint2D::GetFirstAnchor() const - { - cpVect anchor = cpSlideJointGetAnchorA(m_constraint); - return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); - } - - float SlideConstraint2D::GetMaxDistance() const - { - return float(cpSlideJointGetMax(m_constraint)); - } - - float SlideConstraint2D::GetMinDistance() const - { - return float(cpSlideJointGetMin(m_constraint)); - } - - Vector2f SlideConstraint2D::GetSecondAnchor() const - { - cpVect anchor = cpSlideJointGetAnchorB(m_constraint); - return Vector2f(static_cast(anchor.x), static_cast(anchor.y)); - } - - void SlideConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor) - { - cpSlideJointSetAnchorA(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); - } - - void SlideConstraint2D::SetMaxDistance(float newMaxDistance) - { - cpSlideJointSetMax(m_constraint, newMaxDistance); - } - - void SlideConstraint2D::SetMinDistance(float newMinDistance) - { - cpSlideJointSetMin(m_constraint, newMinDistance); - } - - void SlideConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor) - { - cpSlideJointSetAnchorB(m_constraint, cpv(firstAnchor.x, firstAnchor.y)); - } -} diff --git a/src/Nazara/Physics2D/Physics2D.cpp b/src/Nazara/Physics2D/Physics2D.cpp deleted file mode 100644 index a45a032b1..000000000 --- a/src/Nazara/Physics2D/Physics2D.cpp +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) -// This file is part of the "Nazara Engine - Physics2D module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include - -namespace Nz -{ - Physics2D::Physics2D(Config /*config*/) : - ModuleBase("Physics2D", this) - { - } - - Physics2D* Physics2D::s_instance = nullptr; -} diff --git a/tests/UnitTests/Engine/Modules.hpp b/tests/UnitTests/Engine/Modules.hpp index 8baef12c5..89bf4a86a 100644 --- a/tests/UnitTests/Engine/Modules.hpp +++ b/tests/UnitTests/Engine/Modules.hpp @@ -2,6 +2,6 @@ #include #include #include -#include +#include #include #include diff --git a/tests/UnitTests/Engine/Physics2D/Collider2DTest.cpp b/tests/UnitTests/Engine/Physics2D/Collider2DTest.cpp index 5bed2d431..f9eeb6213 100644 --- a/tests/UnitTests/Engine/Physics2D/Collider2DTest.cpp +++ b/tests/UnitTests/Engine/Physics2D/Collider2DTest.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -9,13 +9,13 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]") WHEN("We construct a box with Rect") { Nz::Rectf aabb(5.f, 3.f, 10.f, 6.f); - Nz::BoxCollider2D box(aabb); + Nz::ChipmunkBoxCollider2D box(aabb); THEN("We expect those to be true") { CHECK(box.GetRect() == aabb); CHECK(box.GetSize() == aabb.GetLengths()); - CHECK(box.GetType() == Nz::ColliderType2D::Box); + CHECK(box.GetType() == Nz::ChipmunkColliderType2D::Box); } } @@ -23,13 +23,13 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]") { Nz::Vector2f vec(5.f, 3.f); Nz::Rectf aabb(-2.5f, -1.5f, 5.f, 3.f); - Nz::BoxCollider2D box(vec); + Nz::ChipmunkBoxCollider2D box(vec); THEN("We expect those to be true") { CHECK(box.GetRect() == aabb); CHECK(box.GetSize() == vec); - CHECK(box.GetType() == Nz::ColliderType2D::Box); + CHECK(box.GetType() == Nz::ChipmunkColliderType2D::Box); } } @@ -37,30 +37,30 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]") { Nz::Vector2f position(5.f, 3.f); float radius = 7.f; - Nz::CircleCollider2D circle(radius, position); + Nz::ChipmunkCircleCollider2D circle(radius, position); THEN("We expect those to be true") { CHECK(circle.GetRadius() == Catch::Approx(radius)); - CHECK(circle.GetType() == Nz::ColliderType2D::Circle); + CHECK(circle.GetType() == Nz::ChipmunkColliderType2D::Circle); } } WHEN("We construct a compound") { Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f); - std::shared_ptr box1 = std::make_shared(aabb); + std::shared_ptr box1 = std::make_shared(aabb); aabb.Translate(Nz::Vector2f::Unit()); - std::shared_ptr box2 = std::make_shared(aabb); + std::shared_ptr box2 = std::make_shared(aabb); - std::vector> colliders; + std::vector> colliders; colliders.push_back(box1); colliders.push_back(box2); - Nz::CompoundCollider2D compound(colliders); + Nz::ChipmunkCompoundCollider2D compound(colliders); THEN("We expect those to be true") { - CHECK(compound.GetType() == Nz::ColliderType2D::Compound); + CHECK(compound.GetType() == Nz::ChipmunkColliderType2D::Compound); } } @@ -72,21 +72,21 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]") vertices.push_back(Nz::Vector2f(1.f, 1.f)); vertices.push_back(Nz::Vector2f(1.f, 0.f)); - Nz::ConvexCollider2D convex(Nz::SparsePtr(vertices.data()), vertices.size()); + Nz::ChipmunkConvexCollider2D convex(Nz::SparsePtr(vertices.data()), vertices.size()); THEN("We expect those to be true") { - CHECK(convex.GetType() == Nz::ColliderType2D::Convex); + CHECK(convex.GetType() == Nz::ChipmunkColliderType2D::Convex); } } WHEN("We construct a null") { - Nz::NullCollider2D null; + Nz::ChipmunkNullCollider2D null; THEN("We expect those to be true") { - CHECK(null.GetType() == Nz::ColliderType2D::Null); + CHECK(null.GetType() == Nz::ChipmunkColliderType2D::Null); } } @@ -94,21 +94,21 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]") { Nz::Vector2f firstPoint(2.f, 1.f); Nz::Vector2f secondPoint(-4.f, -3.f); - Nz::SegmentCollider2D segment(firstPoint, secondPoint); + Nz::ChipmunkSegmentCollider2D segment(firstPoint, secondPoint); THEN("We expect those to be true") { CHECK(segment.GetFirstPoint() == firstPoint); CHECK(segment.GetLength() == Catch::Approx(firstPoint.Distance(secondPoint))); CHECK(segment.GetSecondPoint() == secondPoint); - CHECK(segment.GetType() == Nz::ColliderType2D::Segment); + CHECK(segment.GetType() == Nz::ChipmunkColliderType2D::Segment); } } WHEN("We verify general purpose methods") { Nz::Rectf aabb(5.f, 3.f, 10.f, 6.f); - Nz::BoxCollider2D box(aabb); + Nz::ChipmunkBoxCollider2D box(aabb); Nz::UInt32 categoryMask = 1; Nz::UInt32 groupId = 2; diff --git a/tests/UnitTests/Engine/Physics2D/PhysWorld2DTest.cpp b/tests/UnitTests/Engine/Physics2D/PhysWorld2DTest.cpp index e38fa24c7..45c404501 100644 --- a/tests/UnitTests/Engine/Physics2D/PhysWorld2DTest.cpp +++ b/tests/UnitTests/Engine/Physics2D/PhysWorld2DTest.cpp @@ -1,8 +1,8 @@ -#include +#include #include #include -Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world, const Nz::Vector2f& position, bool isMoving = true, const Nz::Vector2f& lengths = Nz::Vector2f::Unit()); +Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world, const Nz::Vector2f& position, bool isMoving = true, const Nz::Vector2f& lengths = Nz::Vector2f::Unit()); Nz::UInt32 collisionGroup = 1; Nz::UInt32 categoryMask = 2; @@ -12,9 +12,9 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]") { GIVEN("A physic world and a bunch of entities on a grid") { - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; - std::vector bodies; + std::vector bodies; const int numberOfBodiesPerLign = 3; for (int i = 0; i != numberOfBodiesPerLign; ++i) { @@ -28,7 +28,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]") WHEN("We ask for the nearest body") { - Nz::PhysWorld2D::NearestQueryResult result; + Nz::ChipmunkPhysWorld2D::NearestQueryResult result; REQUIRE(world.NearestBodyQuery(-Nz::Vector2f::UnitY() * 1.f, 2.f, collisionGroup, categoryMask, collisionMask, &result)); THEN("It should be the one on the origin") @@ -54,7 +54,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]") { Nz::Vector2f origin = -Nz::Vector2f::UnitY() * 2.f; Nz::Vector2f end = (numberOfBodiesPerLign + 1) * 10.f * Nz::Vector2f::UnitY(); - Nz::PhysWorld2D::RaycastHit result; + Nz::ChipmunkPhysWorld2D::RaycastHit result; REQUIRE(world.RaycastQueryFirst(origin, end, 1.f, collisionGroup, categoryMask, collisionMask, &result)); THEN("It should be the one on the origin") @@ -70,7 +70,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]") { Nz::Vector2f origin = -Nz::Vector2f::UnitY() * 2.f; Nz::Vector2f end = (numberOfBodiesPerLign + 1) * 10.f * Nz::Vector2f::UnitY(); - std::vector results; + std::vector results; REQUIRE(world.RaycastQuery(origin, end, 1.f, collisionGroup, categoryMask, collisionMask, &results)); THEN("It should be the first lign") @@ -79,7 +79,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]") for (int i = 0; i != numberOfBodiesPerLign; ++i) { - const Nz::PhysWorld2D::RaycastHit& result = results[i]; + const Nz::ChipmunkPhysWorld2D::RaycastHit& result = results[i]; CHECK(result.nearestBody == &bodies[i]); CHECK(result.fraction == Catch::Approx(i / 4.f).margin(0.1f)); CHECK(result.hitPos == Nz::Vector2f(0.f, i * 10.f)); @@ -90,7 +90,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]") WHEN("We ask for a region") { - std::vector results; + std::vector results; world.RegionQuery(Nz::Rectf(-5.f, -5.f, 5.f, 5.f), collisionGroup, categoryMask, collisionMask, &results); THEN("It should be the one on the origin") @@ -109,53 +109,53 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]") int statusTriggerCollision = 0; - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; Nz::Rectf characterAABB(0.f, 0.f, 1.f, 1.f); - std::shared_ptr characterBox = std::make_shared(characterAABB); + std::shared_ptr characterBox = std::make_shared(characterAABB); characterBox->SetCollisionId(CHARACTER_COLLISION_ID); - Nz::RigidBody2D character(&world, 1.f, characterBox); + Nz::ChipmunkRigidBody2D character(&world, 1.f, characterBox); character.SetPosition(Nz::Vector2f::Zero()); Nz::Rectf wallAABB(0.f, 0.f, 1.f, 2.f); - std::shared_ptr wallBox = std::make_shared(wallAABB); + std::shared_ptr wallBox = std::make_shared(wallAABB); wallBox->SetCollisionId(WALL_COLLISION_ID); - Nz::RigidBody2D wall(&world, 0.f, wallBox); + Nz::ChipmunkRigidBody2D wall(&world, 0.f, wallBox); wall.SetPosition(Nz::Vector2f(5.f, 0.f)); Nz::Rectf triggerAABB(0.f, 0.f, 1.f, 1.f); - std::shared_ptr triggerBox = std::make_shared(triggerAABB); + std::shared_ptr triggerBox = std::make_shared(triggerAABB); triggerBox->SetTrigger(true); triggerBox->SetCollisionId(TRIGGER_COLLISION_ID); - Nz::RigidBody2D trigger(&world, 0.f, triggerBox); + Nz::ChipmunkRigidBody2D trigger(&world, 0.f, triggerBox); trigger.SetPosition(Nz::Vector2f(2.f, 0.f)); world.Step(Nz::Time::Zero()); - Nz::PhysWorld2D::Callback characterTriggerCallback; - characterTriggerCallback.startCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool { + Nz::ChipmunkPhysWorld2D::Callback characterTriggerCallback; + characterTriggerCallback.startCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool { statusTriggerCollision = statusTriggerCollision | 1 << 0; return true; }; - characterTriggerCallback.preSolveCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool { + characterTriggerCallback.preSolveCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool { statusTriggerCollision = statusTriggerCollision | 1 << 1; return true; }; - characterTriggerCallback.postSolveCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) { + characterTriggerCallback.postSolveCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) { statusTriggerCollision = statusTriggerCollision | 1 << 2; }; - characterTriggerCallback.endCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) { + characterTriggerCallback.endCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) { statusTriggerCollision = statusTriggerCollision | 1 << 3; }; world.RegisterCallbacks(CHARACTER_COLLISION_ID, TRIGGER_COLLISION_ID, characterTriggerCallback); int statusWallCollision = 0; - Nz::PhysWorld2D::Callback characterWallCallback; - characterWallCallback.startCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool { + Nz::ChipmunkPhysWorld2D::Callback characterWallCallback; + characterWallCallback.startCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool { statusWallCollision = statusWallCollision | 1 << 0; return true; }; - characterWallCallback.endCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) { + characterWallCallback.endCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) { statusWallCollision = statusWallCollision | 1 << 1; }; world.RegisterCallbacks(CHARACTER_COLLISION_ID, WALL_COLLISION_ID, characterWallCallback); @@ -193,14 +193,14 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]") } } -Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world, const Nz::Vector2f& position, bool isMoving, const Nz::Vector2f& lengths) +Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world, const Nz::Vector2f& position, bool isMoving, const Nz::Vector2f& lengths) { Nz::Rectf aabb(0.f, 0.f, lengths.x, lengths.y); - std::shared_ptr box = std::make_shared(aabb); + std::shared_ptr box = std::make_shared(aabb); box->SetCategoryMask(categoryMask); box->SetCollisionMask(collisionMask); float mass = isMoving ? 1.f : 0.f; - Nz::RigidBody2D rigidBody(&world, mass, box); + Nz::ChipmunkRigidBody2D rigidBody(&world, mass, box); rigidBody.SetPosition(position); return rigidBody; } diff --git a/tests/UnitTests/Engine/Physics2D/RigidBody2DTest.cpp b/tests/UnitTests/Engine/Physics2D/RigidBody2DTest.cpp index 22dfe41f6..d533c782b 100644 --- a/tests/UnitTests/Engine/Physics2D/RigidBody2DTest.cpp +++ b/tests/UnitTests/Engine/Physics2D/RigidBody2DTest.cpp @@ -1,26 +1,26 @@ -#include -#include +#include +#include #include #include #include #include -Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world); -void EQUALITY(const Nz::RigidBody2D& left, const Nz::RigidBody2D& right); +Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world); +void EQUALITY(const Nz::ChipmunkRigidBody2D& left, const Nz::ChipmunkRigidBody2D& right); void EQUALITY(const Nz::Rectf& left, const Nz::Rectf& right); SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") { GIVEN("A physic world and a rigid body") { - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; world.SetMaxStepCount(std::numeric_limits::max()); Nz::Vector2f positionAABB(3.f, 4.f); Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f); - std::shared_ptr box = std::make_shared(aabb); + std::shared_ptr box = std::make_shared(aabb); float mass = 1.f; - Nz::RigidBody2D body(&world, mass, box); + Nz::ChipmunkRigidBody2D body(&world, mass, box); float angularVelocity = 0.2f; body.SetAngularVelocity(angularVelocity); Nz::Vector2f massCenter(5.f, 7.f); @@ -39,7 +39,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") WHEN("We copy construct the body") { body.AddForce(Nz::Vector2f(3.f, 5.f)); - Nz::RigidBody2D copiedBody(body); + Nz::ChipmunkRigidBody2D copiedBody(body); EQUALITY(copiedBody, body); world.Step(Nz::Time::Second()); EQUALITY(copiedBody, body); @@ -47,22 +47,22 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") WHEN("We move construct the body") { - Nz::RigidBody2D copiedBody(body); - Nz::RigidBody2D movedBody(std::move(body)); + Nz::ChipmunkRigidBody2D copiedBody(body); + Nz::ChipmunkRigidBody2D movedBody(std::move(body)); EQUALITY(movedBody, copiedBody); } WHEN("We copy assign the body") { - Nz::RigidBody2D copiedBody(&world, 0.f); + Nz::ChipmunkRigidBody2D copiedBody(&world, 0.f); copiedBody = body; EQUALITY(copiedBody, body); } WHEN("We move assign the body") { - Nz::RigidBody2D copiedBody(body); - Nz::RigidBody2D movedBody(&world, 0.f); + Nz::ChipmunkRigidBody2D copiedBody(body); + Nz::ChipmunkRigidBody2D movedBody(&world, 0.f); movedBody = std::move(body); EQUALITY(movedBody, copiedBody); } @@ -70,7 +70,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") WHEN("We set a new geometry") { float radius = 5.f; - body.SetGeom(std::make_shared(radius)); + body.SetGeom(std::make_shared(radius)); world.Step(Nz::Time::Second()); @@ -85,14 +85,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") GIVEN("A physic world") { - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; world.SetMaxStepCount(std::numeric_limits::max()); Nz::Rectf aabb(3.f, 4.f, 1.f, 2.f); WHEN("We get a rigid body from a function") { - std::vector tmp; + std::vector tmp; tmp.push_back(CreateBody(world)); tmp.push_back(CreateBody(world)); @@ -108,14 +108,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") GIVEN("A physic world and a rigid body") { - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; world.SetMaxStepCount(std::numeric_limits::max()); Nz::Vector2f positionAABB(3.f, 4.f); Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f); - std::shared_ptr box = std::make_shared(aabb); + std::shared_ptr box = std::make_shared(aabb); float mass = 1.f; - Nz::RigidBody2D body(&world, mass); + Nz::ChipmunkRigidBody2D body(&world, mass); body.SetGeom(box, true, false); bool userData = false; @@ -211,14 +211,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") GIVEN("A physic world and a rigid body of circle") { - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; world.SetMaxStepCount(std::numeric_limits::max()); Nz::Vector2f position(3.f, 4.f); float radius = 5.f; - std::shared_ptr circle = std::make_shared(radius, position); + std::shared_ptr circle = std::make_shared(radius, position); float mass = 1.f; - Nz::RigidBody2D body(&world, mass); + Nz::ChipmunkRigidBody2D body(&world, mass); body.SetGeom(circle, true, false); world.Step(Nz::Time::Second()); @@ -235,21 +235,21 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") GIVEN("A physic world and a rigid body of compound") { - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; world.SetMaxStepCount(std::numeric_limits::max()); Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f); - std::shared_ptr box1 = std::make_shared(aabb); + std::shared_ptr box1 = std::make_shared(aabb); aabb.Translate(Nz::Vector2f::Unit()); - std::shared_ptr box2 = std::make_shared(aabb); + std::shared_ptr box2 = std::make_shared(aabb); - std::vector> colliders; + std::vector> colliders; colliders.push_back(box1); colliders.push_back(box2); - std::shared_ptr compound = std::make_shared(colliders); + std::shared_ptr compound = std::make_shared(colliders); float mass = 1.f; - Nz::RigidBody2D body(&world, mass); + Nz::ChipmunkRigidBody2D body(&world, mass); body.SetGeom(compound, true, false); world.Step(Nz::Time::Second()); @@ -266,7 +266,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") GIVEN("A physic world and a rigid body of circle") { - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; world.SetMaxStepCount(std::numeric_limits::max()); std::vector vertices; @@ -276,9 +276,9 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") vertices.emplace_back(1.f, 0.f); Nz::SparsePtr sparsePtr(vertices.data()); - std::shared_ptr convex = std::make_shared(sparsePtr, vertices.size()); + std::shared_ptr convex = std::make_shared(sparsePtr, vertices.size()); float mass = 1.f; - Nz::RigidBody2D body(&world, mass); + Nz::ChipmunkRigidBody2D body(&world, mass); body.SetGeom(convex, true, false); world.Step(Nz::Time::Second()); @@ -295,14 +295,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") GIVEN("A physic world and a rigid body of segment") { - Nz::PhysWorld2D world; + Nz::ChipmunkPhysWorld2D world; world.SetMaxStepCount(std::numeric_limits::max()); Nz::Vector2f positionA(3.f, 4.f); Nz::Vector2f positionB(1.f, -4.f); - std::shared_ptr segment = std::make_shared(positionA, positionB, 0.f); + std::shared_ptr segment = std::make_shared(positionA, positionB, 0.f); float mass = 1.f; - Nz::RigidBody2D body(&world, mass); + Nz::ChipmunkRigidBody2D body(&world, mass); body.SetGeom(segment, true, false); world.Step(Nz::Time::Second()); @@ -318,20 +318,20 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") } } -Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world) +Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world) { Nz::Vector2f positionAABB(3.f, 4.f); Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f); - std::shared_ptr box = std::make_shared(aabb); + std::shared_ptr box = std::make_shared(aabb); float mass = 1.f; - Nz::RigidBody2D body(&world, mass, box); + Nz::ChipmunkRigidBody2D body(&world, mass, box); body.SetPosition(Nz::Vector2f::Zero()); return body; } -void EQUALITY(const Nz::RigidBody2D& left, const Nz::RigidBody2D& right) +void EQUALITY(const Nz::ChipmunkRigidBody2D& left, const Nz::ChipmunkRigidBody2D& right) { CHECK(left.GetAABB() == right.GetAABB()); CHECK(left.GetAngularVelocity() == right.GetAngularVelocity()); diff --git a/tests/UnitTests/main.cpp b/tests/UnitTests/main.cpp index 961893300..2a9b06610 100644 --- a/tests/UnitTests/main.cpp +++ b/tests/UnitTests/main.cpp @@ -6,12 +6,12 @@ #include #include #include -#include +#include #include int main(int argc, char* argv[]) { - Nz::Modules nazaza; + Nz::Modules nazaza; return Catch::Session().run(argc, argv); } diff --git a/tests/UnitTests/xmake.lua b/tests/UnitTests/xmake.lua index ebf8f4d13..a60b66b41 100644 --- a/tests/UnitTests/xmake.lua +++ b/tests/UnitTests/xmake.lua @@ -5,7 +5,7 @@ if is_mode("asan") then add_defines("CATCH_CONFIG_NO_POSIX_SIGNALS") end -add_deps("NazaraAudio", "NazaraCore", "NazaraNetwork", "NazaraPhysics2D") +add_deps("NazaraAudio", "NazaraCore", "NazaraNetwork", "NazaraChipmunkPhysics2D") add_packages("catch2", "entt") add_headerfiles("Engine/**.hpp", { prefixdir = "private", install = false }) add_files("resources.cpp") diff --git a/xmake.lua b/xmake.lua index 30ba43b13..4d459d7da 100644 --- a/xmake.lua +++ b/xmake.lua @@ -74,6 +74,11 @@ local modules = { Deps = {"NazaraUtility"}, Packages = { "bullet3", "entt" } }, + ChipmunkPhysics2D = { + Option = "chipmunkphysics", + Deps = {"NazaraUtility"}, + Packages = { "chipmunk2d", "entt" } + }, Core = { Custom = function () add_headerfiles("include/(Nazara/*.hpp)") @@ -133,11 +138,6 @@ local modules = { end end }, - Physics2D = { - Option = "chipmunkphysics", - Deps = {"NazaraUtility"}, - Packages = { "chipmunk2d", "entt" } - }, Platform = { Option = "platform", Deps = {"NazaraUtility"}, @@ -232,7 +232,7 @@ end add_repositories("nazara-engine-repo https://github.com/NazaraEngine/xmake-repo") -add_requires("entt 3.11.1", "fmt", "frozen", "kiwisolver", "nazarautils") +add_requires("entt 3.11.1", "fmt", "frozen", "nazarautils") -- Module dependencies if has_config("audio") then