sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename Physics2D to ChipmunkPhysics2D

This commit is contained in:
SirLynix 2023-04-10 13:49:36 +02:00 committed by Jérôme Leclercq
parent b1255ad2ad
commit 26b23ccce6
54 changed files with 1620 additions and 1620 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
examples/Physics2DDemo/main.cpp
View File

@ -2,7 +2,7 @@
#include <Nazara/Platform.hpp> #include <Nazara/Platform.hpp>
#include <Nazara/Graphics.hpp> #include <Nazara/Graphics.hpp>
#include <Nazara/Math/PidController.hpp> #include <Nazara/Math/PidController.hpp>
#include <Nazara/Physics2D.hpp> #include <Nazara/ChipmunkPhysics2D.hpp>
#include <Nazara/Renderer.hpp> #include <Nazara/Renderer.hpp>
#include <Nazara/Utility.hpp> #include <Nazara/Utility.hpp>
#include <Nazara/Widgets.hpp> #include <Nazara/Widgets.hpp>
@ -21,14 +21,14 @@ int main()
if (!std::filesystem::is_directory(resourceDir) && std::filesystem::is_directory("../.." / resourceDir)) if (!std::filesystem::is_directory(resourceDir) && std::filesystem::is_directory("../.." / resourceDir))
resourceDir = "../.." / resourceDir; resourceDir = "../.." / resourceDir;
Nz::Application<Nz::Graphics, Nz::Physics2D> app; Nz::Application<Nz::Graphics, Nz::ChipmunkPhysics2D> app;
auto& windowing = app.AddComponent<Nz::AppWindowingComponent>(); auto& windowing = app.AddComponent<Nz::AppWindowingComponent>();
auto& ecs = app.AddComponent<Nz::AppEntitySystemComponent>(); auto& ecs = app.AddComponent<Nz::AppEntitySystemComponent>();
auto& world = ecs.AddWorld<Nz::EnttWorld>(); auto& world = ecs.AddWorld<Nz::EnttWorld>();
Nz::Physics2DSystem& physSytem = world.AddSystem<Nz::Physics2DSystem>(); Nz::ChipmunkPhysics2DSystem& physSytem = world.AddSystem<Nz::ChipmunkPhysics2DSystem>();
Nz::RenderSystem& renderSystem = world.AddSystem<Nz::RenderSystem>(); Nz::RenderSystem& renderSystem = world.AddSystem<Nz::RenderSystem>();
std::string windowTitle = "Physics 2D"; std::string windowTitle = "Physics 2D";
@ -72,7 +72,7 @@ int main()
spriteEntity.emplace<Nz::NodeComponent>().SetPosition(windowSize.x * 0.5f + x * 48.f - 15.f * 48.f, windowSize.y / 2 + y * 48.f); spriteEntity.emplace<Nz::NodeComponent>().SetPosition(windowSize.x * 0.5f + x * 48.f - 15.f * 48.f, windowSize.y / 2 + y * 48.f);
spriteEntity.emplace<Nz::GraphicsComponent>().AttachRenderable(sprite, 1); spriteEntity.emplace<Nz::GraphicsComponent>().AttachRenderable(sprite, 1);
auto& rigidBody = spriteEntity.emplace<Nz::RigidBody2DComponent>(physSytem.CreateRigidBody(50.f, std::make_shared<Nz::BoxCollider2D>(Nz::Vector2f(32.f, 32.f)))); auto& rigidBody = spriteEntity.emplace<Nz::ChipmunkRigidBody2DComponent>(physSytem.CreateRigidBody(50.f, std::make_shared<Nz::ChipmunkBoxCollider2D>(Nz::Vector2f(32.f, 32.f))));
rigidBody.SetFriction(0.9f); rigidBody.SetFriction(0.9f);
//rigidBody.SetElasticity(0.99f); //rigidBody.SetElasticity(0.99f);
} }
@ -101,7 +101,7 @@ int main()
groundEntity.emplace<Nz::NodeComponent>().SetPosition(windowSize.x * 0.5f, -windowSize.y * 0.2f); groundEntity.emplace<Nz::NodeComponent>().SetPosition(windowSize.x * 0.5f, -windowSize.y * 0.2f);
groundEntity.emplace<Nz::GraphicsComponent>().AttachRenderable(tilemap, 1); groundEntity.emplace<Nz::GraphicsComponent>().AttachRenderable(tilemap, 1);
auto& rigidBody = groundEntity.emplace<Nz::RigidBody2DComponent>(physSytem.CreateRigidBody(0.f, std::make_shared<Nz::BoxCollider2D>(tilemap->GetSize()))); auto& rigidBody = groundEntity.emplace<Nz::ChipmunkRigidBody2DComponent>(physSytem.CreateRigidBody(0.f, std::make_shared<Nz::ChipmunkBoxCollider2D>(tilemap->GetSize())));
rigidBody.SetFriction(0.9f); rigidBody.SetFriction(0.9f);
} }

2
examples/Physics2DDemo/xmake.lua
View File

@ -1,5 +1,5 @@
target("Physics2DDemo") target("Physics2DDemo")
add_deps("NazaraGraphics", "NazaraPhysics2D") add_deps("NazaraGraphics", "NazaraChipmunkPhysics2D")
add_packages("entt") add_packages("entt")
add_files("main.cpp") add_files("main.cpp")
add_defines("NAZARA_ENTT") add_defines("NAZARA_ENTT")

2
examples/Showcase/xmake.lua
View File

@ -5,7 +5,7 @@ end
target("Showcase") target("Showcase")
set_group("Examples") set_group("Examples")
set_kind("binary") 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 if has_config("embed_plugins") then
add_deps("PluginAssimp") add_deps("PluginAssimp")
else else

4
examples/Tut00/main.cpp
View File

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

2
examples/Tut00/xmake.lua
View File

@ -1,3 +1,3 @@
target("Tut00_EmptyProject") 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") add_files("main.cpp")

20
include/Nazara/BulletPhysics3D/BulletCollider3D.hpp
View File

@ -53,7 +53,7 @@ namespace Nz
virtual std::shared_ptr<StaticMesh> GenerateDebugMesh() const; virtual std::shared_ptr<StaticMesh> GenerateDebugMesh() const;
virtual btCollisionShape* GetShape() const = 0; virtual btCollisionShape* GetShape() const = 0;
virtual ColliderType3D GetType() const = 0; virtual BulletColliderType3D GetType() const = 0;
BulletCollider3D& operator=(const BulletCollider3D&) = delete; BulletCollider3D& operator=(const BulletCollider3D&) = delete;
BulletCollider3D& operator=(BulletCollider3D&&) = delete; BulletCollider3D& operator=(BulletCollider3D&&) = delete;
@ -74,7 +74,7 @@ namespace Nz
Vector3f GetLengths() const; Vector3f GetLengths() const;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
private: private:
std::unique_ptr<btBoxShape> m_shape; std::unique_ptr<btBoxShape> m_shape;
@ -92,7 +92,7 @@ namespace Nz
float GetLength() const; float GetLength() const;
float GetRadius() const; float GetRadius() const;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
private: private:
std::unique_ptr<btCapsuleShape> m_shape; std::unique_ptr<btCapsuleShape> m_shape;
@ -112,7 +112,7 @@ namespace Nz
const std::vector<ChildCollider>& GetGeoms() const; const std::vector<ChildCollider>& GetGeoms() const;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
struct ChildCollider struct ChildCollider
{ {
@ -136,7 +136,7 @@ namespace Nz
float GetLength() const; float GetLength() const;
float GetRadius() const; float GetRadius() const;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
private: private:
std::unique_ptr<btConeShape> m_shape; std::unique_ptr<btConeShape> m_shape;
@ -153,7 +153,7 @@ namespace Nz
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override; void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
private: private:
std::unique_ptr<btConvexHullShape> m_shape; std::unique_ptr<btConvexHullShape> m_shape;
@ -170,7 +170,7 @@ namespace Nz
float GetLength() const; float GetLength() const;
float GetRadius() const; float GetRadius() const;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
private: private:
std::unique_ptr<btCylinderShape> m_shape; std::unique_ptr<btCylinderShape> m_shape;
@ -190,7 +190,7 @@ namespace Nz
void ComputeInertia(float mass, Vector3f* inertia) const override; void ComputeInertia(float mass, Vector3f* inertia) const override;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
private: private:
std::unique_ptr<btEmptyShape> m_shape; std::unique_ptr<btEmptyShape> m_shape;
@ -206,7 +206,7 @@ namespace Nz
float GetRadius() const; float GetRadius() const;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
private: private:
std::unique_ptr<btSphereShape> m_shape; std::unique_ptr<btSphereShape> m_shape;
@ -226,7 +226,7 @@ namespace Nz
float GetDistance() const; float GetDistance() const;
const Vector3f& GetNormal() const; const Vector3f& GetNormal() const;
btCollisionShape* GetShape() const override; btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override; BulletColliderType3D GetType() const override;
private: private:
std::unique_ptr<btStaticPlaneShape> m_shape; std::unique_ptr<btStaticPlaneShape> m_shape;

2
include/Nazara/BulletPhysics3D/Enums.hpp
View File

@ -9,7 +9,7 @@
namespace Nz namespace Nz
{ {
enum class ColliderType3D enum class BulletColliderType3D
{ {
Box, Box,
Capsule, Capsule,

26
include/Nazara/Physics2D.hpp → include/Nazara/ChipmunkPhysics2D.hpp
View File

@ -26,23 +26,23 @@
#pragma once #pragma once
#ifndef NAZARA_GLOBAL_PHYSICS2D_HPP #ifndef NAZARA_GLOBAL_CHIPMUNKPHYSICS2D_HPP
#define NAZARA_GLOBAL_PHYSICS2D_HPP #define NAZARA_GLOBAL_CHIPMUNKPHYSICS2D_HPP
#include <Nazara/Physics2D/Arbiter2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <Nazara/Physics2D/Collider2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp>
#include <Nazara/Physics2D/Config.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.hpp>
#include <Nazara/Physics2D/Constraint2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp>
#include <Nazara/Physics2D/Enums.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/Physics2D/Physics2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp> #include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp> #include <Nazara/ChipmunkPhysics2D/Enums.hpp>
#ifdef NAZARA_ENTT #ifdef NAZARA_ENTT
#include <Nazara/Physics2D/Components.hpp> #include <Nazara/ChipmunkPhysics2D/Components.hpp>
#include <Nazara/Physics2D/Systems.hpp> #include <Nazara/ChipmunkPhysics2D/Systems.hpp>
#endif #endif
#endif // NAZARA_GLOBAL_PHYSICS2D_HPP #endif // NAZARA_GLOBAL_CHIPMUNKPHYSICS2D_HPP

28
include/Nazara/Physics2D/Arbiter2D.hpp → include/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp
View File

@ -4,32 +4,32 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_ARBITER2D_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_ARBITER2D_HPP
#define NAZARA_PHYSICS2D_ARBITER2D_HPP #define NAZARA_CHIPMUNKPHYSICS2D_ARBITER2D_HPP
#include <NazaraUtils/Prerequisites.hpp> #include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Math/Vector2.hpp> #include <Nazara/Math/Vector2.hpp>
#include <Nazara/Physics2D/Config.hpp> #include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <NazaraUtils/MovablePtr.hpp> #include <NazaraUtils/MovablePtr.hpp>
struct cpArbiter; struct cpArbiter;
namespace Nz namespace Nz
{ {
class RigidBody2D; class ChipmunkRigidBody2D;
class NAZARA_PHYSICS2D_API Arbiter2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkArbiter2D
{ {
public: public:
inline Arbiter2D(cpArbiter* arbiter); inline ChipmunkArbiter2D(cpArbiter* arbiter);
Arbiter2D(const Arbiter2D&) = delete; ChipmunkArbiter2D(const ChipmunkArbiter2D&) = delete;
Arbiter2D(Arbiter2D&&) = default; ChipmunkArbiter2D(ChipmunkArbiter2D&&) = default;
~Arbiter2D() = default; ~ChipmunkArbiter2D() = default;
float ComputeTotalKinematicEnergy() const; float ComputeTotalKinematicEnergy() const;
Nz::Vector2f ComputeTotalImpulse() const; Nz::Vector2f ComputeTotalImpulse() const;
std::pair<RigidBody2D*, RigidBody2D*> GetBodies() const; std::pair<ChipmunkRigidBody2D*, ChipmunkRigidBody2D*> GetBodies() const;
std::size_t GetContactCount() const; std::size_t GetContactCount() const;
float GetContactDepth(std::size_t i) const; float GetContactDepth(std::size_t i) const;
@ -48,14 +48,14 @@ namespace Nz
void SetFriction(float friction); void SetFriction(float friction);
void SetSurfaceVelocity(const Vector2f& surfaceVelocity); void SetSurfaceVelocity(const Vector2f& surfaceVelocity);
Arbiter2D& operator=(const Arbiter2D&) = delete; ChipmunkArbiter2D& operator=(const ChipmunkArbiter2D&) = delete;
Arbiter2D& operator=(Arbiter2D&&) = default; ChipmunkArbiter2D& operator=(ChipmunkArbiter2D&&) = default;
private: private:
MovablePtr<cpArbiter> m_arbiter; MovablePtr<cpArbiter> m_arbiter;
}; };
} }
#include <Nazara/Physics2D/Arbiter2D.inl> #include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.inl>
#endif // NAZARA_PHYSICS2D_ARBITER2D_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_ARBITER2D_HPP

6
include/Nazara/Physics2D/Arbiter2D.inl → include/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.inl
View File

@ -3,14 +3,14 @@
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <memory> #include <memory>
#include <Nazara/Physics2D/Debug.hpp> #include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz namespace Nz
{ {
inline Arbiter2D::Arbiter2D(cpArbiter* arbiter) : inline ChipmunkArbiter2D::ChipmunkArbiter2D(cpArbiter* arbiter) :
m_arbiter(arbiter) m_arbiter(arbiter)
{ {
} }
} }
#include <Nazara/Physics2D/DebugOff.hpp> #include <Nazara/ChipmunkPhysics2D/DebugOff.hpp>

80
include/Nazara/Physics2D/Collider2D.hpp → include/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp
View File

@ -4,15 +4,15 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_COLLIDER2D_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_COLLIDER2D_HPP
#define NAZARA_PHYSICS2D_COLLIDER2D_HPP #define NAZARA_CHIPMUNKPHYSICS2D_COLLIDER2D_HPP
#include <NazaraUtils/Prerequisites.hpp> #include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/ObjectLibrary.hpp> #include <Nazara/Core/ObjectLibrary.hpp>
#include <Nazara/Math/Rect.hpp> #include <Nazara/Math/Rect.hpp>
#include <Nazara/Math/Vector2.hpp> #include <Nazara/Math/Vector2.hpp>
#include <Nazara/Physics2D/Config.hpp> #include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <Nazara/Physics2D/Enums.hpp> #include <Nazara/ChipmunkPhysics2D/Enums.hpp>
#include <NazaraUtils/Signal.hpp> #include <NazaraUtils/Signal.hpp>
#include <NazaraUtils/SparsePtr.hpp> #include <NazaraUtils/SparsePtr.hpp>
#include <vector> #include <vector>
@ -22,18 +22,18 @@ struct cpShape;
namespace Nz namespace Nz
{ {
class RigidBody2D; class ChipmunkRigidBody2D;
class NAZARA_PHYSICS2D_API Collider2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCollider2D
{ {
friend RigidBody2D; friend ChipmunkRigidBody2D;
friend class CompoundCollider2D; //< See CompoundCollider2D::CreateShapes friend class ChipmunkCompoundCollider2D; //< See CompoundCollider2D::CreateShapes
public: public:
inline Collider2D(); inline ChipmunkCollider2D();
Collider2D(const Collider2D&) = delete; ChipmunkCollider2D(const ChipmunkCollider2D&) = delete;
Collider2D(Collider2D&&) = delete; ChipmunkCollider2D(ChipmunkCollider2D&&) = delete;
virtual ~Collider2D(); virtual ~ChipmunkCollider2D();
virtual Vector2f ComputeCenterOfMass() const = 0; virtual Vector2f ComputeCenterOfMass() const = 0;
virtual float ComputeMomentOfInertia(float mass) const = 0; virtual float ComputeMomentOfInertia(float mass) const = 0;
@ -48,7 +48,7 @@ namespace Nz
inline float GetFriction() const; inline float GetFriction() const;
inline Vector2f GetSurfaceVelocity() const; inline Vector2f GetSurfaceVelocity() const;
virtual ColliderType2D GetType() const = 0; virtual ChipmunkColliderType2D GetType() const = 0;
inline bool IsTrigger() const; inline bool IsTrigger() const;
@ -61,11 +61,11 @@ namespace Nz
inline void SetSurfaceVelocity(const Vector2f& surfaceVelocity); inline void SetSurfaceVelocity(const Vector2f& surfaceVelocity);
inline void SetTrigger(bool trigger); inline void SetTrigger(bool trigger);
Collider2D& operator=(const Collider2D&) = delete; ChipmunkCollider2D& operator=(const ChipmunkCollider2D&) = delete;
Collider2D& operator=(Collider2D&&) = delete; ChipmunkCollider2D& operator=(ChipmunkCollider2D&&) = delete;
// Signals: // Signals:
NazaraSignal(OnColliderRelease, const Collider2D* /*collider*/); NazaraSignal(OnColliderRelease, const ChipmunkCollider2D* /*collider*/);
protected: protected:
virtual std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const = 0; virtual std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const = 0;
@ -83,11 +83,11 @@ namespace Nz
virtual std::size_t GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const; virtual std::size_t GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const;
}; };
class NAZARA_PHYSICS2D_API BoxCollider2D : public Collider2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkBoxCollider2D : public ChipmunkCollider2D
{ {
public: public:
BoxCollider2D(const Vector2f& size, float radius = 0.f); ChipmunkBoxCollider2D(const Vector2f& size, float radius = 0.f);
BoxCollider2D(const Rectf& rect, float radius = 0.f); ChipmunkBoxCollider2D(const Rectf& rect, float radius = 0.f);
Nz::Vector2f ComputeCenterOfMass() const override; Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override; float ComputeMomentOfInertia(float mass) const override;
@ -95,7 +95,7 @@ namespace Nz
inline float GetRadius() const; inline float GetRadius() const;
inline const Rectf& GetRect() const; inline const Rectf& GetRect() const;
inline Vector2f GetSize() const; inline Vector2f GetSize() const;
ColliderType2D GetType() const override; ChipmunkColliderType2D GetType() const override;
private: private:
std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override; std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
@ -104,17 +104,17 @@ namespace Nz
float m_radius; float m_radius;
}; };
class NAZARA_PHYSICS2D_API CircleCollider2D : public Collider2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCircleCollider2D : public ChipmunkCollider2D
{ {
public: public:
CircleCollider2D(float radius, const Vector2f& offset = Vector2f::Zero()); ChipmunkCircleCollider2D(float radius, const Vector2f& offset = Vector2f::Zero());
Nz::Vector2f ComputeCenterOfMass() const override; Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override; float ComputeMomentOfInertia(float mass) const override;
inline const Vector2f& GetOffset() const; inline const Vector2f& GetOffset() const;
inline float GetRadius() const; inline float GetRadius() const;
ColliderType2D GetType() const override; ChipmunkColliderType2D GetType() const override;
private: private:
std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override; std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
@ -123,18 +123,18 @@ namespace Nz
float m_radius; float m_radius;
}; };
class NAZARA_PHYSICS2D_API CompoundCollider2D : public Collider2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCompoundCollider2D : public ChipmunkCollider2D
{ {
public: public:
CompoundCollider2D(std::vector<std::shared_ptr<Collider2D>> geoms); ChipmunkCompoundCollider2D(std::vector<std::shared_ptr<ChipmunkCollider2D>> geoms);
Nz::Vector2f ComputeCenterOfMass() const override; Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override; float ComputeMomentOfInertia(float mass) const override;
inline bool DoesOverrideCollisionProperties() const; inline bool DoesOverrideCollisionProperties() const;
inline const std::vector<std::shared_ptr<Collider2D>>& GetGeoms() const; inline const std::vector<std::shared_ptr<ChipmunkCollider2D>>& GetGeoms() const;
ColliderType2D GetType() const override; ChipmunkColliderType2D GetType() const override;
inline void OverridesCollisionProperties(bool shouldOverride); inline void OverridesCollisionProperties(bool shouldOverride);
@ -142,19 +142,19 @@ namespace Nz
std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override; std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
std::size_t GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override; std::size_t GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
std::vector<std::shared_ptr<Collider2D>> m_geoms; std::vector<std::shared_ptr<ChipmunkCollider2D>> m_geoms;
bool m_doesOverrideCollisionProperties; bool m_doesOverrideCollisionProperties;
}; };
class NAZARA_PHYSICS2D_API ConvexCollider2D : public Collider2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkConvexCollider2D : public ChipmunkCollider2D
{ {
public: public:
ConvexCollider2D(SparsePtr<const Vector2f> vertices, std::size_t vertexCount, float radius = 0.f); ChipmunkConvexCollider2D(SparsePtr<const Vector2f> vertices, std::size_t vertexCount, float radius = 0.f);
Nz::Vector2f ComputeCenterOfMass() const override; Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override; float ComputeMomentOfInertia(float mass) const override;
ColliderType2D GetType() const override; ChipmunkColliderType2D GetType() const override;
inline const std::vector<Vector2d>& GetVertices() const; inline const std::vector<Vector2d>& GetVertices() const;
private: private:
@ -164,25 +164,25 @@ namespace Nz
float m_radius; float m_radius;
}; };
class NAZARA_PHYSICS2D_API NullCollider2D : public Collider2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkNullCollider2D : public ChipmunkCollider2D
{ {
public: public:
NullCollider2D() = default; ChipmunkNullCollider2D() = default;
Nz::Vector2f ComputeCenterOfMass() const override; Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override; float ComputeMomentOfInertia(float mass) const override;
ColliderType2D GetType() const override; ChipmunkColliderType2D GetType() const override;
private: private:
std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override; std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
}; };
class NAZARA_PHYSICS2D_API SegmentCollider2D : public Collider2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkSegmentCollider2D : public ChipmunkCollider2D
{ {
public: public:
inline SegmentCollider2D(const Vector2f& first, const Vector2f& second, float thickness = 1.f); inline ChipmunkSegmentCollider2D(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& firstNeighbor, const Vector2f& second, const Vector2f& secondNeighbor, float thickness = 1.f);
Nz::Vector2f ComputeCenterOfMass() const override; Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override; float ComputeMomentOfInertia(float mass) const override;
@ -193,7 +193,7 @@ namespace Nz
inline const Vector2f& GetSecondPoint() const; inline const Vector2f& GetSecondPoint() const;
inline const Vector2f& GetSecondPointNeighbor() const; inline const Vector2f& GetSecondPointNeighbor() const;
inline float GetThickness() const; inline float GetThickness() const;
ColliderType2D GetType() const override; ChipmunkColliderType2D GetType() const override;
private: private:
std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override; std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
@ -206,6 +206,6 @@ namespace Nz
}; };
} }
#include <Nazara/Physics2D/Collider2D.inl> #include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.inl>
#endif // NAZARA_PHYSICS2D_COLLIDER2D_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_COLLIDER2D_HPP

196
include/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.inl Normal file
View File

@ -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 <memory>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
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<std::shared_ptr<ChipmunkCollider2D>>& ChipmunkCompoundCollider2D::GetGeoms() const
{
return m_geoms;
}
inline void Nz::ChipmunkCompoundCollider2D::OverridesCollisionProperties(bool shouldOverride)
{
m_doesOverrideCollisionProperties = shouldOverride;
}
inline const std::vector<Vector2d>& 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 <Nazara/ChipmunkPhysics2D/DebugOff.hpp>

233
include/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.hpp Normal file
View File

@ -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 <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/HandledObject.hpp>
#include <Nazara/Core/ObjectHandle.hpp>
#include <Nazara/Math/Angle.hpp>
#include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <NazaraUtils/MovablePtr.hpp>
#include <vector>
struct cpConstraint;
namespace Nz
{
class ChipmunkConstraint2D;
using ChipmunkConstraint2DHandle = ObjectHandle<ChipmunkConstraint2D>;
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkConstraint2D : public HandledObject<ChipmunkConstraint2D>
{
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<cpConstraint> m_constraint;
};
class ChipmunkDampedSpringConstraint2D;
using ChipmunkDampedSpringConstraint2DHandle = ObjectHandle<ChipmunkDampedSpringConstraint2D>;
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<ChipmunkDampedRotarySpringConstraint2D>;
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<ChipmunkGearConstraint2D>;
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<ChipmunkMotorConstraint2D>;
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<ChipmunkPinConstraint2D>;
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<ChipmunkPivotConstraint2D>;
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<ChipmunkRatchetConstraint2D>;
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<ChipmunkRotaryLimitConstraint2D>;
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<ChipmunkSlideConstraint2D>;
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 <Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.inl>
#endif // NAZARA_CHIPMUNKPHYSICS2D_CONSTRAINT2D_HPP

4
include/Nazara/Physics2D/Constraint2D.inl → include/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.inl
View File

@ -3,10 +3,10 @@
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <memory> #include <memory>
#include <Nazara/Physics2D/Debug.hpp> #include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz namespace Nz
{ {
} }
#include <Nazara/Physics2D/DebugOff.hpp> #include <Nazara/ChipmunkPhysics2D/DebugOff.hpp>

66
include/Nazara/Physics2D/PhysWorld2D.hpp → include/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp
View File

@ -4,16 +4,16 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_PHYSWORLD2D_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_PHYSWORLD2D_HPP
#define NAZARA_PHYSICS2D_PHYSWORLD2D_HPP #define NAZARA_CHIPMUNKPHYSICS2D_PHYSWORLD2D_HPP
#include <NazaraUtils/Prerequisites.hpp> #include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/Color.hpp> #include <Nazara/Core/Color.hpp>
#include <Nazara/Core/Time.hpp> #include <Nazara/Core/Time.hpp>
#include <Nazara/Math/Angle.hpp> #include <Nazara/Math/Angle.hpp>
#include <Nazara/Math/Vector2.hpp> #include <Nazara/Math/Vector2.hpp>
#include <Nazara/Physics2D/Config.hpp> #include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <NazaraUtils/FunctionRef.hpp> #include <NazaraUtils/FunctionRef.hpp>
#include <NazaraUtils/Signal.hpp> #include <NazaraUtils/Signal.hpp>
#include <functional> #include <functional>
@ -25,23 +25,23 @@ struct cpSpace;
namespace Nz namespace Nz
{ {
class Arbiter2D; class ChipmunkArbiter2D;
class NAZARA_PHYSICS2D_API PhysWorld2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPhysWorld2D
{ {
friend RigidBody2D; friend ChipmunkRigidBody2D;
using ContactEndCallback = std::function<void(PhysWorld2D& world, Arbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)>; using ContactEndCallback = std::function<void(ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)>;
using ContactPreSolveCallback = std::function<bool(PhysWorld2D& world, Arbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)>; using ContactPreSolveCallback = std::function<bool(ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)>;
using ContactPostSolveCallback = std::function<void(PhysWorld2D& world, Arbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)>; using ContactPostSolveCallback = std::function<void(ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)>;
using ContactStartCallback = std::function<bool(PhysWorld2D& world, Arbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)>; using ContactStartCallback = std::function<bool(ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)>;
using DebugDrawCircleCallback = std::function<void(const Vector2f& origin, const RadianAnglef& rotation, float radius, const Color& outlineColor, const Color& fillColor, void* userdata)>; using DebugDrawCircleCallback = std::function<void(const Vector2f& origin, const RadianAnglef& rotation, float radius, const Color& outlineColor, const Color& fillColor, void* userdata)>;
using DebugDrawDotCallback = std::function<void(const Vector2f& origin, float radius, const Color& color, void* userdata)>; using DebugDrawDotCallback = std::function<void(const Vector2f& origin, float radius, const Color& color, void* userdata)>;
using DebugDrawPolygonCallback = std::function<void(const Vector2f* vertices, std::size_t vertexCount, float radius, const Color& outlineColor, const Color& fillColor, void* userdata)>; using DebugDrawPolygonCallback = std::function<void(const Vector2f* vertices, std::size_t vertexCount, float radius, const Color& outlineColor, const Color& fillColor, void* userdata)>;
using DebugDrawSegmentCallback = std::function<void(const Vector2f& first, const Vector2f& second, const Color& color, void* userdata)>; using DebugDrawSegmentCallback = std::function<void(const Vector2f& first, const Vector2f& second, const Color& color, void* userdata)>;
using DebugDrawTickSegmentCallback = std::function<void(const Vector2f& first, const Vector2f& second, float thickness, const Color& outlineColor, const Color& fillColor, void* userdata)>; using DebugDrawTickSegmentCallback = std::function<void(const Vector2f& first, const Vector2f& second, float thickness, const Color& outlineColor, const Color& fillColor, void* userdata)>;
using DebugDrawGetColorCallback = std::function<Color(RigidBody2D& body, std::size_t shapeIndex, void* userdata)>; using DebugDrawGetColorCallback = std::function<Color(ChipmunkRigidBody2D& body, std::size_t shapeIndex, void* userdata)>;
public: public:
struct Callback; struct Callback;
@ -49,10 +49,10 @@ namespace Nz
struct NearestQueryResult; struct NearestQueryResult;
struct RaycastHit; struct RaycastHit;
PhysWorld2D(); ChipmunkPhysWorld2D();
PhysWorld2D(const PhysWorld2D&) = delete; ChipmunkPhysWorld2D(const ChipmunkPhysWorld2D&) = delete;
PhysWorld2D(PhysWorld2D&&) = delete; ///TODO ChipmunkPhysWorld2D(ChipmunkPhysWorld2D&&) = delete; ///TODO
~PhysWorld2D(); ~ChipmunkPhysWorld2D();
void DebugDraw(const DebugDrawOptions& options, bool drawShapes = true, bool drawConstraints = true, bool drawCollisions = true); 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; std::size_t GetMaxStepCount() const;
Time GetStepSize() 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); 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<void(const RaycastHit&)>& callback); void RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<void(const RaycastHit&)>& callback);
bool RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RaycastHit>* hitInfos); bool RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RaycastHit>* hitInfos);
bool RaycastQueryFirst(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RaycastHit* hitInfo = nullptr); 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<void(RigidBody2D*)>& callback); void RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<void(ChipmunkRigidBody2D*)>& callback);
void RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RigidBody2D*>* bodies); void RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<ChipmunkRigidBody2D*>* bodies);
void RegisterCallbacks(unsigned int collisionId, Callback callbacks); void RegisterCallbacks(unsigned int collisionId, Callback callbacks);
void RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, 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); void UseSpatialHash(float cellSize, std::size_t entityCount);
PhysWorld2D& operator=(const PhysWorld2D&) = delete; ChipmunkPhysWorld2D& operator=(const ChipmunkPhysWorld2D&) = delete;
PhysWorld2D& operator=(PhysWorld2D&&) = delete; ///TODO ChipmunkPhysWorld2D& operator=(ChipmunkPhysWorld2D&&) = delete; ///TODO
struct Callback struct Callback
{ {
@ -117,7 +117,7 @@ namespace Nz
struct NearestQueryResult struct NearestQueryResult
{ {
RigidBody2D* nearestBody; ChipmunkRigidBody2D* nearestBody;
Vector2f closestPoint; Vector2f closestPoint;
Vector2f fraction; Vector2f fraction;
float distance; float distance;
@ -125,29 +125,29 @@ namespace Nz
struct RaycastHit struct RaycastHit
{ {
RigidBody2D* nearestBody; ChipmunkRigidBody2D* nearestBody;
Vector2f hitPos; Vector2f hitPos;
Vector2f hitNormal; Vector2f hitNormal;
float fraction; float fraction;
}; };
NazaraSignal(OnPhysWorld2DPreStep, const PhysWorld2D* /*physWorld*/, float /*invStepCount*/); NazaraSignal(OnPhysWorld2DPreStep, const ChipmunkPhysWorld2D* /*physWorld*/, float /*invStepCount*/);
NazaraSignal(OnPhysWorld2DPostStep, const PhysWorld2D* /*physWorld*/, float /*invStepCount*/); NazaraSignal(OnPhysWorld2DPostStep, const ChipmunkPhysWorld2D* /*physWorld*/, float /*invStepCount*/);
private: private:
void InitCallbacks(cpCollisionHandler* handler, Callback callbacks); void InitCallbacks(cpCollisionHandler* handler, Callback callbacks);
using PostStep = std::function<void(RigidBody2D* body)>; using PostStep = std::function<void(ChipmunkRigidBody2D* body)>;
void OnRigidBodyMoved(RigidBody2D* oldPointer, RigidBody2D* newPointer); void OnRigidBodyMoved(ChipmunkRigidBody2D* oldPointer, ChipmunkRigidBody2D* newPointer);
void OnRigidBodyRelease(RigidBody2D* rigidBody); void OnRigidBodyRelease(ChipmunkRigidBody2D* rigidBody);
void RegisterPostStep(RigidBody2D* rigidBody, PostStep&& func); void RegisterPostStep(ChipmunkRigidBody2D* rigidBody, PostStep&& func);
struct PostStepContainer struct PostStepContainer
{ {
NazaraSlot(RigidBody2D, OnRigidBody2DMove, onMovedSlot); NazaraSlot(ChipmunkRigidBody2D, OnRigidBody2DMove, onMovedSlot);
NazaraSlot(RigidBody2D, OnRigidBody2DRelease, onReleaseSlot); NazaraSlot(ChipmunkRigidBody2D, OnRigidBody2DRelease, onReleaseSlot);
std::vector<PostStep> funcs; std::vector<PostStep> funcs;
}; };
@ -156,11 +156,11 @@ namespace Nz
std::size_t m_maxStepCount; std::size_t m_maxStepCount;
std::unordered_map<cpCollisionHandler*, std::unique_ptr<Callback>> m_callbacks; std::unordered_map<cpCollisionHandler*, std::unique_ptr<Callback>> m_callbacks;
std::unordered_map<RigidBody2D*, PostStepContainer> m_rigidPostSteps; std::unordered_map<ChipmunkRigidBody2D*, PostStepContainer> m_rigidPostSteps;
cpSpace* m_handle; cpSpace* m_handle;
Time m_stepSize; Time m_stepSize;
Time m_timestepAccumulator; Time m_timestepAccumulator;
}; };
} }
#endif // NAZARA_PHYSICS2D_PHYSWORLD2D_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_PHYSWORLD2D_HPP

16
include/Nazara/Physics2D/Physics2D.hpp → include/Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp
View File

@ -4,16 +4,16 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_HPP
#define NAZARA_PHYSICS2D_HPP #define NAZARA_CHIPMUNKPHYSICS2D_HPP
#include <NazaraUtils/Prerequisites.hpp> #include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/Core.hpp> #include <Nazara/Core/Core.hpp>
#include <Nazara/Physics2D/Config.hpp> #include <Nazara/ChipmunkPhysics2D/Config.hpp>
namespace Nz namespace Nz
{ {
class NAZARA_PHYSICS2D_API Physics2D : public ModuleBase<Physics2D> class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPhysics2D : public ModuleBase<ChipmunkPhysics2D>
{ {
friend ModuleBase; friend ModuleBase;
@ -22,12 +22,12 @@ namespace Nz
struct Config {}; struct Config {};
Physics2D(Config /*config*/); ChipmunkPhysics2D(Config /*config*/);
~Physics2D() = default; ~ChipmunkPhysics2D() = default;
private: private:
static Physics2D* s_instance; static ChipmunkPhysics2D* s_instance;
}; };
} }
#endif // NAZARA_PHYSICS2D_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_HPP

50
include/Nazara/Physics2D/RigidBody2D.hpp → include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp
View File

@ -4,15 +4,15 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_RIGIDBODY2D_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_RIGIDBODY2D_HPP
#define NAZARA_PHYSICS2D_RIGIDBODY2D_HPP #define NAZARA_CHIPMUNKPHYSICS2D_RIGIDBODY2D_HPP
#include <NazaraUtils/Prerequisites.hpp> #include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/Enums.hpp> #include <Nazara/Core/Enums.hpp>
#include <Nazara/Math/Angle.hpp> #include <Nazara/Math/Angle.hpp>
#include <Nazara/Math/Rect.hpp> #include <Nazara/Math/Rect.hpp>
#include <Nazara/Physics2D/Collider2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp>
#include <Nazara/Physics2D/Config.hpp> #include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <NazaraUtils/Signal.hpp> #include <NazaraUtils/Signal.hpp>
#include <functional> #include <functional>
#include <limits> #include <limits>
@ -21,19 +21,19 @@ struct cpBody;
namespace Nz namespace Nz
{ {
class Arbiter2D; class ChipmunkArbiter2D;
class PhysWorld2D; class ChipmunkPhysWorld2D;
class NAZARA_PHYSICS2D_API RigidBody2D class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkRigidBody2D
{ {
public: public:
using VelocityFunc = std::function<void(RigidBody2D& body2D, const Vector2f& gravity, float damping, float deltaTime)>; using VelocityFunc = std::function<void(ChipmunkRigidBody2D& body2D, const Vector2f& gravity, float damping, float deltaTime)>;
RigidBody2D(PhysWorld2D* world, float mass); ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass);
RigidBody2D(PhysWorld2D* world, float mass, std::shared_ptr<Collider2D> geom); ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass, std::shared_ptr<ChipmunkCollider2D> geom);
RigidBody2D(const RigidBody2D& object); ChipmunkRigidBody2D(const ChipmunkRigidBody2D& object);
RigidBody2D(RigidBody2D&& object) noexcept; ChipmunkRigidBody2D(ChipmunkRigidBody2D&& object) noexcept;
~RigidBody2D(); ~ChipmunkRigidBody2D();
void AddForce(const Vector2f& force, CoordSys coordSys = CoordSys::Global); void AddForce(const Vector2f& force, CoordSys coordSys = CoordSys::Global);
void AddForce(const Vector2f& force, const Vector2f& point, 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 EnableSimulation(bool simulation);
void ForEachArbiter(std::function<void(Arbiter2D& /*arbiter*/)> callback); void ForEachArbiter(std::function<void(ChipmunkArbiter2D& /*arbiter*/)> callback);
void ForceSleep(); void ForceSleep();
Rectf GetAABB() const; Rectf GetAABB() const;
@ -55,7 +55,7 @@ namespace Nz
inline Vector2f GetCenterOfGravity(CoordSys coordSys = CoordSys::Local) const; inline Vector2f GetCenterOfGravity(CoordSys coordSys = CoordSys::Local) const;
float GetElasticity(std::size_t shapeIndex = 0) const; float GetElasticity(std::size_t shapeIndex = 0) const;
float GetFriction(std::size_t shapeIndex = 0) const; float GetFriction(std::size_t shapeIndex = 0) const;
const std::shared_ptr<Collider2D>& GetGeom() const; const std::shared_ptr<ChipmunkCollider2D>& GetGeom() const;
cpBody* GetHandle() const; cpBody* GetHandle() const;
float GetMass() const; float GetMass() const;
Vector2f GetMassCenter(CoordSys coordSys = CoordSys::Local) const; Vector2f GetMassCenter(CoordSys coordSys = CoordSys::Local) const;
@ -69,7 +69,7 @@ namespace Nz
void* GetUserdata() const; void* GetUserdata() const;
Vector2f GetVelocity() const; Vector2f GetVelocity() const;
const VelocityFunc& GetVelocityFunction() const; const VelocityFunc& GetVelocityFunction() const;
PhysWorld2D* GetWorld() const; ChipmunkPhysWorld2D* GetWorld() const;
bool IsKinematic() const; bool IsKinematic() const;
bool IsSimulationEnabled() const; bool IsSimulationEnabled() const;
@ -84,7 +84,7 @@ namespace Nz
void SetElasticity(std::size_t shapeIndex, float elasticity); void SetElasticity(std::size_t shapeIndex, float elasticity);
void SetFriction(float friction); void SetFriction(float friction);
void SetFriction(std::size_t shapeIndex, float friction); void SetFriction(std::size_t shapeIndex, float friction);
void SetGeom(std::shared_ptr<Collider2D> geom, bool recomputeMoment = true, bool recomputeMassCenter = true); void SetGeom(std::shared_ptr<ChipmunkCollider2D> geom, bool recomputeMoment = true, bool recomputeMassCenter = true);
void SetMass(float mass, bool recomputeMoment = true); void SetMass(float mass, bool recomputeMoment = true);
void SetMassCenter(const Vector2f& center, CoordSys coordSys = CoordSys::Local); void SetMassCenter(const Vector2f& center, CoordSys coordSys = CoordSys::Local);
void SetMomentOfInertia(float moment); void SetMomentOfInertia(float moment);
@ -104,11 +104,11 @@ namespace Nz
void Wakeup(); void Wakeup();
RigidBody2D& operator=(const RigidBody2D& object); ChipmunkRigidBody2D& operator=(const ChipmunkRigidBody2D& object);
RigidBody2D& operator=(RigidBody2D&& object); ChipmunkRigidBody2D& operator=(ChipmunkRigidBody2D&& object);
NazaraSignal(OnRigidBody2DMove, RigidBody2D* /*oldPointer*/, RigidBody2D* /*newPointer*/); NazaraSignal(OnRigidBody2DMove, ChipmunkRigidBody2D* /*oldPointer*/, ChipmunkRigidBody2D* /*newPointer*/);
NazaraSignal(OnRigidBody2DRelease, RigidBody2D* /*rigidBody*/); NazaraSignal(OnRigidBody2DRelease, ChipmunkRigidBody2D* /*rigidBody*/);
static constexpr std::size_t InvalidShapeIndex = std::numeric_limits<std::size_t>::max(); static constexpr std::size_t InvalidShapeIndex = std::numeric_limits<std::size_t>::max();
@ -126,10 +126,10 @@ namespace Nz
Vector2f m_positionOffset; Vector2f m_positionOffset;
VelocityFunc m_velocityFunc; VelocityFunc m_velocityFunc;
std::vector<cpShape*> m_shapes; std::vector<cpShape*> m_shapes;
std::shared_ptr<Collider2D> m_geom; std::shared_ptr<ChipmunkCollider2D> m_geom;
cpBody* m_handle; cpBody* m_handle;
void* m_userData; void* m_userData;
PhysWorld2D* m_world; ChipmunkPhysWorld2D* m_world;
bool m_isRegistered; bool m_isRegistered;
bool m_isSimulationEnabled; bool m_isSimulationEnabled;
bool m_isStatic; bool m_isStatic;
@ -138,6 +138,6 @@ namespace Nz
}; };
} }
#include <Nazara/Physics2D/RigidBody2D.inl> #include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.inl>
#endif // NAZARA_PHYSICS2D_RIGIDBODY2D_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_RIGIDBODY2D_HPP

35
include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.inl Normal file
View File

@ -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 <Nazara/ChipmunkPhysics2D/Debug.hpp>
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 <Nazara/ChipmunkPhysics2D/DebugOff.hpp>

8
include/Nazara/Physics2D/Components.hpp → include/Nazara/ChipmunkPhysics2D/Components.hpp
View File

@ -26,9 +26,9 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_COMPONENTS_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_HPP
#define NAZARA_PHYSICS2D_COMPONENTS_HPP #define NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_HPP
#include <Nazara/Physics2D/Components/RigidBody2DComponent.hpp> #include <Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.hpp>
#endif // NAZARA_PHYSICS2D_COMPONENTS_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_HPP

32
include/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.hpp Normal file
View File

@ -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 <NazaraUtils/Prerequisites.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
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 <Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.inl>
#endif // NAZARA_CHIPMUNKPHYSICS2D_COMPONENTS_RIGIDBODY2DCOMPONENT_HPP

4
include/Nazara/Physics2D/Components/RigidBody2DComponent.inl → include/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.inl
View File

@ -2,10 +2,10 @@
// This file is part of the "Nazara Engine - Physics2D module" // This file is part of the "Nazara Engine - Physics2D module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/Debug.hpp> #include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz namespace Nz
{ {
} }
#include <Nazara/Physics2D/DebugOff.hpp> #include <Nazara/ChipmunkPhysics2D/DebugOff.hpp>

18
include/Nazara/Physics2D/Config.hpp → include/Nazara/ChipmunkPhysics2D/Config.hpp
View File

@ -24,25 +24,25 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_CONFIG_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_CONFIG_HPP
#define NAZARA_PHYSICS2D_CONFIG_HPP #define NAZARA_CHIPMUNKPHYSICS2D_CONFIG_HPP
/// Chaque modification d'un paramètre du module nécessite une recompilation de celui-ci /// 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) // 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 /// Vérification des valeurs et types de certaines constantes
#include <Nazara/Physics2D/ConfigCheck.hpp> #include <Nazara/ChipmunkPhysics2D/ConfigCheck.hpp>
#if defined(NAZARA_STATIC) #if defined(NAZARA_STATIC)
#define NAZARA_PHYSICS2D_API #define NAZARA_CHIPMUNKPHYSICS2D_API
#else #else
#ifdef NAZARA_PHYSICS2D_BUILD #ifdef NAZARA_CHIPMUNKPHYSICS2D_BUILD
#define NAZARA_PHYSICS2D_API NAZARA_EXPORT #define NAZARA_CHIPMUNKPHYSICS2D_API NAZARA_EXPORT
#else #else
#define NAZARA_PHYSICS2D_API NAZARA_IMPORT #define NAZARA_CHIPMUNKPHYSICS2D_API NAZARA_IMPORT
#endif #endif
#endif #endif
#endif // NAZARA_PHYSICS2D_CONFIG_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_CONFIG_HPP

6
include/Nazara/Physics2D/ConfigCheck.hpp → include/Nazara/ChipmunkPhysics2D/ConfigCheck.hpp
View File

@ -4,8 +4,8 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_CONFIGCHECK_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_CONFIGCHECK_HPP
#define NAZARA_PHYSICS2D_CONFIGCHECK_HPP #define NAZARA_CHIPMUNKPHYSICS2D_CONFIGCHECK_HPP
/// This file is used to check the constant values defined in Config.hpp /// This file is used to check the constant values defined in Config.hpp
@ -16,4 +16,4 @@
#undef NazaraCheckTypeAndVal #undef NazaraCheckTypeAndVal
#endif // NAZARA_PHYSICS2D_CONFIGCHECK_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_CONFIGCHECK_HPP

0
include/Nazara/Physics2D/Debug.hpp → include/Nazara/ChipmunkPhysics2D/Debug.hpp
View File

0
include/Nazara/Physics2D/DebugOff.hpp → include/Nazara/ChipmunkPhysics2D/DebugOff.hpp
View File

8
include/Nazara/Physics2D/Enums.hpp → include/Nazara/ChipmunkPhysics2D/Enums.hpp
View File

@ -4,12 +4,12 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_ENUMS_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP
#define NAZARA_PHYSICS2D_ENUMS_HPP #define NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP
namespace Nz namespace Nz
{ {
enum class ColliderType2D enum class ChipmunkColliderType2D
{ {
Box, Box,
Compound, Compound,
@ -22,4 +22,4 @@ namespace Nz
}; };
} }
#endif // NAZARA_PHYSICS2D_ENUMS_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP

8
include/Nazara/Physics2D/Systems.hpp → include/Nazara/ChipmunkPhysics2D/Systems.hpp
View File

@ -26,9 +26,9 @@
#pragma once #pragma once
#ifndef NAZARA_PHYSICS2D_SYSTEMS_HPP #ifndef NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_HPP
#define NAZARA_PHYSICS2D_SYSTEMS_HPP #define NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_HPP
#include <Nazara/Physics2D/Systems/Physics2DSystem.hpp> #include <Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.hpp>
#endif // NAZARA_PHYSICS2D_SYSTEMS_HPP #endif // NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_HPP

50
include/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.hpp Normal file
View File

@ -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 <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/Time.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.hpp>
#include <NazaraUtils/TypeList.hpp>
#include <entt/entt.hpp>
namespace Nz
{
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPhysics2DSystem
{
public:
static constexpr Int64 ExecutionOrder = 0;
using Components = TypeList<ChipmunkRigidBody2DComponent, class NodeComponent>;
ChipmunkPhysics2DSystem(entt::registry& registry);
ChipmunkPhysics2DSystem(const ChipmunkPhysics2DSystem&) = delete;
ChipmunkPhysics2DSystem(ChipmunkPhysics2DSystem&&) = delete;
~ChipmunkPhysics2DSystem();
template<typename... Args> 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 <Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.inl>
#endif // NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_PHYSICS2DSYSTEM_HPP

26
include/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.inl Normal file
View File

@ -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 <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz
{
template<typename... Args>
ChipmunkRigidBody2DComponent ChipmunkPhysics2DSystem::CreateRigidBody(Args&&... args)
{
return ChipmunkRigidBody2DComponent(&m_physWorld, std::forward<Args>(args)...);
}
inline ChipmunkPhysWorld2D& ChipmunkPhysics2DSystem::GetPhysWorld()
{
return m_physWorld;
}
inline const ChipmunkPhysWorld2D& ChipmunkPhysics2DSystem::GetPhysWorld() const
{
return m_physWorld;
}
}
#include <Nazara/ChipmunkPhysics2D/DebugOff.hpp>

196
include/Nazara/Physics2D/Collider2D.inl
View File

@ -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 <memory>
#include <Nazara/Physics2D/Debug.hpp>
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<std::shared_ptr<Collider2D>>& CompoundCollider2D::GetGeoms() const
{
return m_geoms;
}
inline void Nz::CompoundCollider2D::OverridesCollisionProperties(bool shouldOverride)
{
m_doesOverrideCollisionProperties = shouldOverride;
}
inline const std::vector<Vector2d>& 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 <Nazara/Physics2D/DebugOff.hpp>

32
include/Nazara/Physics2D/Components/RigidBody2DComponent.hpp
View File

@ -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 <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp>
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 <Nazara/Physics2D/Components/RigidBody2DComponent.inl>
#endif // NAZARA_PHYSICS2D_COMPONENTS_RIGIDBODY2DCOMPONENT_HPP

233
include/Nazara/Physics2D/Constraint2D.hpp
View File

@ -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 <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/HandledObject.hpp>
#include <Nazara/Core/ObjectHandle.hpp>
#include <Nazara/Math/Angle.hpp>
#include <Nazara/Physics2D/Config.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp>
#include <NazaraUtils/MovablePtr.hpp>
#include <vector>
struct cpConstraint;
namespace Nz
{
class Constraint2D;
using Constraint2DHandle = ObjectHandle<Constraint2D>;
class NAZARA_PHYSICS2D_API Constraint2D : public HandledObject<Constraint2D>
{
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<cpConstraint> m_constraint;
};
class DampedSpringConstraint2D;
using DampedSpringConstraint2DHandle = ObjectHandle<DampedSpringConstraint2D>;
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<DampedRotarySpringConstraint2D>;
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<GearConstraint2D>;
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<MotorConstraint2D>;
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<PinConstraint2D>;
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<PivotConstraint2D>;
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<RatchetConstraint2D>;
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<RotaryLimitConstraint2D>;
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<SlideConstraint2D>;
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 <Nazara/Physics2D/Constraint2D.inl>
#endif // NAZARA_PHYSICS2D_CONSTRAINT2D_HPP

35
include/Nazara/Physics2D/RigidBody2D.inl
View File

@ -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 <Nazara/Physics2D/Debug.hpp>
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 <Nazara/Physics2D/DebugOff.hpp>

50
include/Nazara/Physics2D/Systems/Physics2DSystem.hpp
View File

@ -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 <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/Time.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <Nazara/Physics2D/Components/RigidBody2DComponent.hpp>
#include <NazaraUtils/TypeList.hpp>
#include <entt/entt.hpp>
namespace Nz
{
class NAZARA_PHYSICS2D_API Physics2DSystem
{
public:
static constexpr Int64 ExecutionOrder = 0;
using Components = TypeList<RigidBody2DComponent, class NodeComponent>;
Physics2DSystem(entt::registry& registry);
Physics2DSystem(const Physics2DSystem&) = delete;
Physics2DSystem(Physics2DSystem&&) = delete;
~Physics2DSystem();
template<typename... Args> 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 <Nazara/Physics2D/Systems/Physics2DSystem.inl>
#endif // NAZARA_PHYSICS2D_SYSTEMS_PHYSICS2DSYSTEM_HPP

26
include/Nazara/Physics2D/Systems/Physics2DSystem.inl
View File

@ -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 <Nazara/Physics2D/Debug.hpp>
namespace Nz
{
template<typename... Args>
RigidBody2DComponent Physics2DSystem::CreateRigidBody(Args&&... args)
{
return RigidBody2DComponent(&m_physWorld, std::forward<Args>(args)...);
}
inline PhysWorld2D& Physics2DSystem::GetPhysWorld()
{
return m_physWorld;
}
inline const PhysWorld2D& Physics2DSystem::GetPhysWorld() const
{
return m_physWorld;
}
}
#include <Nazara/Physics2D/DebugOff.hpp>

36
src/Nazara/BulletPhysics3D/BulletCollider3D.cpp
View File

@ -174,9 +174,9 @@ namespace Nz
return m_lengths; return m_lengths;
} }
ColliderType3D BulletBoxCollider3D::GetType() const BulletColliderType3D BulletBoxCollider3D::GetType() const
{ {
return ColliderType3D::Box; return BulletColliderType3D::Box;
} }
/******************************** CapsuleCollider3D ********************************/ /******************************** CapsuleCollider3D ********************************/
@ -209,9 +209,9 @@ namespace Nz
return m_shape.get(); return m_shape.get();
} }
ColliderType3D BulletCapsuleCollider3D::GetType() const BulletColliderType3D BulletCapsuleCollider3D::GetType() const
{ {
return ColliderType3D::Capsule; return BulletColliderType3D::Capsule;
} }
/******************************* CompoundCollider3D ********************************/ /******************************* CompoundCollider3D ********************************/
@ -245,9 +245,9 @@ namespace Nz
return m_shape.get(); return m_shape.get();
} }
ColliderType3D BulletCompoundCollider3D::GetType() const BulletColliderType3D BulletCompoundCollider3D::GetType() const
{ {
return ColliderType3D::Compound; return BulletColliderType3D::Compound;
} }
/********************************* ConeCollider3D **********************************/ /********************************* ConeCollider3D **********************************/
@ -280,9 +280,9 @@ namespace Nz
return m_shape.get(); return m_shape.get();
} }
ColliderType3D BulletConeCollider3D::GetType() const BulletColliderType3D BulletConeCollider3D::GetType() const
{ {
return ColliderType3D::Cone; return BulletColliderType3D::Cone;
} }
/****************************** ConvexCollider3D *******************************/ /****************************** ConvexCollider3D *******************************/
@ -330,9 +330,9 @@ namespace Nz
return m_shape.get(); return m_shape.get();
} }
ColliderType3D BulletConvexCollider3D::GetType() const BulletColliderType3D BulletConvexCollider3D::GetType() const
{ {
return ColliderType3D::ConvexHull; return BulletColliderType3D::ConvexHull;
} }
/******************************* CylinderCollider3D ********************************/ /******************************* CylinderCollider3D ********************************/
@ -366,9 +366,9 @@ namespace Nz
return m_shape.get(); return m_shape.get();
} }
ColliderType3D BulletCylinderCollider3D::GetType() const BulletColliderType3D BulletCylinderCollider3D::GetType() const
{ {
return ColliderType3D::Cylinder; return BulletColliderType3D::Cylinder;
} }
/********************************* NullCollider3D **********************************/ /********************************* NullCollider3D **********************************/
@ -394,9 +394,9 @@ namespace Nz
return m_shape.get(); return m_shape.get();
} }
ColliderType3D BulletNullCollider3D::GetType() const BulletColliderType3D BulletNullCollider3D::GetType() const
{ {
return ColliderType3D::Null; return BulletColliderType3D::Null;
} }
/******************************** SphereCollider3D *********************************/ /******************************** SphereCollider3D *********************************/
@ -423,9 +423,9 @@ namespace Nz
return m_shape.get(); return m_shape.get();
} }
ColliderType3D BulletSphereCollider3D::GetType() const BulletColliderType3D BulletSphereCollider3D::GetType() const
{ {
return ColliderType3D::Sphere; return BulletColliderType3D::Sphere;
} }
/******************************** StaticPlaneCollider3D *********************************/ /******************************** StaticPlaneCollider3D *********************************/
@ -463,8 +463,8 @@ namespace Nz
return m_shape.get(); return m_shape.get();
} }
ColliderType3D BulletStaticPlaneCollider3D::GetType() const BulletColliderType3D BulletStaticPlaneCollider3D::GetType() const
{ {
return ColliderType3D::StaticPlane; return BulletColliderType3D::StaticPlane;
} }
} }

102
src/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.cpp Normal file
View File

@ -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 <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <chipmunk/chipmunk.h>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz
{
float ChipmunkArbiter2D::ComputeTotalKinematicEnergy() const
{
return float(cpArbiterTotalKE(m_arbiter));
}
Vector2f ChipmunkArbiter2D::ComputeTotalImpulse() const
{
cpVect impulse = cpArbiterTotalImpulse(m_arbiter);
return Vector2f(Vector2<cpFloat>(impulse.x, impulse.y));
}
std::pair<ChipmunkRigidBody2D*, ChipmunkRigidBody2D*> ChipmunkArbiter2D::GetBodies() const
{
std::pair<ChipmunkRigidBody2D*, ChipmunkRigidBody2D*> bodies;
cpBody* firstBody;
cpBody* secondBody;
cpArbiterGetBodies(m_arbiter, &firstBody, &secondBody);
bodies.first = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
bodies.second = static_cast<ChipmunkRigidBody2D*>(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<cpFloat>(point.x, point.y));
}
Vector2f ChipmunkArbiter2D::GetContactPointB(std::size_t i) const
{
cpVect point = cpArbiterGetPointB(m_arbiter, int(i));
return Vector2f(Vector2<cpFloat>(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<cpFloat>(normal.x, normal.y));
}
Vector2f ChipmunkArbiter2D::GetSurfaceVelocity() const
{
cpVect velocity = cpArbiterGetNormal(m_arbiter);
return Vector2f(Vector2<cpFloat>(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));
}
}

90
src/Nazara/Physics2D/Collider2D.cpp → src/Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.cpp
View File

@ -2,16 +2,16 @@
// This file is part of the "Nazara Engine - Physics2D module" // This file is part of the "Nazara Engine - Physics2D module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/Collider2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp>
#include <Nazara/Math/Quaternion.hpp> #include <Nazara/Math/Quaternion.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <NazaraUtils/CallOnExit.hpp> #include <NazaraUtils/CallOnExit.hpp>
#include <NazaraUtils/StackArray.hpp> #include <NazaraUtils/StackArray.hpp>
#include <chipmunk/chipmunk.h> #include <chipmunk/chipmunk.h>
#include <chipmunk/chipmunk_structs.h> #include <chipmunk/chipmunk_structs.h>
#include <array> #include <array>
#include <Nazara/Physics2D/Debug.hpp> #include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz namespace Nz
{ {
@ -25,9 +25,9 @@ namespace Nz
} }
} }
Collider2D::~Collider2D() = default; ChipmunkCollider2D::~ChipmunkCollider2D() = default;
void Collider2D::ForEachPolygon(const std::function<void(const Vector2f* vertices, std::size_t vertexCount)>& callback) const void ChipmunkCollider2D::ForEachPolygon(const std::function<void(const Vector2f* vertices, std::size_t vertexCount)>& callback) const
{ {
// Currently, the only way to get only the polygons of a shape is to create a temporary cpSpace containing only this shape // 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 // 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); cpSpaceDebugDraw(space, &drawOptions);
} }
std::size_t Collider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const std::size_t ChipmunkCollider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{ {
std::size_t shapeCount = CreateShapes(body, shapes); std::size_t shapeCount = CreateShapes(body, shapes);
@ -155,33 +155,33 @@ namespace Nz
/******************************** BoxCollider2D *********************************/ /******************************** BoxCollider2D *********************************/
BoxCollider2D::BoxCollider2D(const Vector2f& size, float radius) : ChipmunkBoxCollider2D::ChipmunkBoxCollider2D(const Vector2f& size, float radius) :
BoxCollider2D(Rectf(-size.x / 2.f, -size.y / 2.f, size.x, size.y), 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_rect(rect),
m_radius(radius) m_radius(radius)
{ {
} }
Vector2f BoxCollider2D::ComputeCenterOfMass() const Vector2f ChipmunkBoxCollider2D::ComputeCenterOfMass() const
{ {
return m_rect.GetCenter(); return m_rect.GetCenter();
} }
float BoxCollider2D::ComputeMomentOfInertia(float mass) const float ChipmunkBoxCollider2D::ComputeMomentOfInertia(float mass) const
{ {
return SafeCast<float>(cpMomentForBox2(mass, cpBBNew(m_rect.x, m_rect.y, m_rect.x + m_rect.width, m_rect.y + m_rect.height))); return SafeCast<float>(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<cpShape*>* shapes) const std::size_t ChipmunkBoxCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* 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)); 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; return 1;
@ -189,28 +189,28 @@ namespace Nz
/******************************** CircleCollider2D *********************************/ /******************************** CircleCollider2D *********************************/
CircleCollider2D::CircleCollider2D(float radius, const Vector2f& offset) : ChipmunkCircleCollider2D::ChipmunkCircleCollider2D(float radius, const Vector2f& offset) :
m_offset(offset), m_offset(offset),
m_radius(radius) m_radius(radius)
{ {
} }
Vector2f CircleCollider2D::ComputeCenterOfMass() const Vector2f ChipmunkCircleCollider2D::ComputeCenterOfMass() const
{ {
return m_offset; return m_offset;
} }
float CircleCollider2D::ComputeMomentOfInertia(float mass) const float ChipmunkCircleCollider2D::ComputeMomentOfInertia(float mass) const
{ {
return SafeCast<float>(cpMomentForCircle(mass, 0.f, m_radius, cpv(m_offset.x, m_offset.y))); return SafeCast<float>(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<cpShape*>* shapes) const std::size_t ChipmunkCircleCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{ {
shapes->push_back(cpCircleShapeNew(body, m_radius, cpv(m_offset.x, m_offset.y))); shapes->push_back(cpCircleShapeNew(body, m_radius, cpv(m_offset.x, m_offset.y)));
return 1; return 1;
@ -218,13 +218,13 @@ namespace Nz
/******************************** CompoundCollider2D *********************************/ /******************************** CompoundCollider2D *********************************/
CompoundCollider2D::CompoundCollider2D(std::vector<std::shared_ptr<Collider2D>> geoms) : ChipmunkCompoundCollider2D::ChipmunkCompoundCollider2D(std::vector<std::shared_ptr<ChipmunkCollider2D>> geoms) :
m_geoms(std::move(geoms)), m_geoms(std::move(geoms)),
m_doesOverrideCollisionProperties(true) m_doesOverrideCollisionProperties(true)
{ {
} }
Vector2f CompoundCollider2D::ComputeCenterOfMass() const Vector2f ChipmunkCompoundCollider2D::ComputeCenterOfMass() const
{ {
Vector2f centerOfMass = Vector2f::Zero(); Vector2f centerOfMass = Vector2f::Zero();
for (const auto& geom : m_geoms) for (const auto& geom : m_geoms)
@ -233,7 +233,7 @@ namespace Nz
return centerOfMass / float(m_geoms.size()); 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: ///TODO: Correctly compute moment using parallel axis theorem:
/// https://chipmunk-physics.net/forum/viewtopic.php?t=1056 /// https://chipmunk-physics.net/forum/viewtopic.php?t=1056
@ -244,12 +244,12 @@ namespace Nz
return momentOfInertia; 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<cpShape*>* shapes) const std::size_t ChipmunkCompoundCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{ {
// Since C++ does not allow protected call from other objects, we have to be a friend of Collider2D, yay // 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; return shapeCount;
} }
std::size_t CompoundCollider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const std::size_t ChipmunkCompoundCollider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{ {
// This is our parent's default behavior // This is our parent's default behavior
if (m_doesOverrideCollisionProperties) if (m_doesOverrideCollisionProperties)
return Collider2D::GenerateShapes(body, shapes); return ChipmunkCollider2D::GenerateShapes(body, shapes);
else else
{ {
std::size_t shapeCount = 0; std::size_t shapeCount = 0;
@ -277,7 +277,7 @@ namespace Nz
/******************************** ConvexCollider2D *********************************/ /******************************** ConvexCollider2D *********************************/
ConvexCollider2D::ConvexCollider2D(SparsePtr<const Vector2f> vertices, std::size_t vertexCount, float radius) : ChipmunkConvexCollider2D::ChipmunkConvexCollider2D(SparsePtr<const Vector2f> vertices, std::size_t vertexCount, float radius) :
m_radius(radius) m_radius(radius)
{ {
m_vertices.resize(vertexCount); m_vertices.resize(vertexCount);
@ -285,7 +285,7 @@ namespace Nz
m_vertices[i].Set(*vertices++); 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"); 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)); 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"); static_assert(sizeof(cpVect) == sizeof(Vector2d), "Chipmunk vector is not equivalent to Vector2d");
return SafeCast<float>(cpMomentForPoly(mass, int(m_vertices.size()), reinterpret_cast<const cpVect*>(m_vertices.data()), cpv(0.0, 0.0), m_radius)); return SafeCast<float>(cpMomentForPoly(mass, int(m_vertices.size()), reinterpret_cast<const cpVect*>(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<cpShape*>* shapes) const std::size_t ChipmunkConvexCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{ {
shapes->push_back(cpPolyShapeNew(body, int(m_vertices.size()), reinterpret_cast<const cpVect*>(m_vertices.data()), cpTransformIdentity, m_radius)); shapes->push_back(cpPolyShapeNew(body, int(m_vertices.size()), reinterpret_cast<const cpVect*>(m_vertices.data()), cpTransformIdentity, m_radius));
return 1; return 1;
@ -314,44 +314,44 @@ namespace Nz
/********************************* NullCollider2D **********************************/ /********************************* 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(); 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 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<cpShape*>* /*shapes*/) const std::size_t ChipmunkNullCollider2D::CreateShapes(cpBody* /*body*/, std::vector<cpShape*>* /*shapes*/) const
{ {
return 0; return 0;
} }
/******************************** SegmentCollider2D *********************************/ /******************************** SegmentCollider2D *********************************/
Vector2f SegmentCollider2D::ComputeCenterOfMass() const Vector2f ChipmunkSegmentCollider2D::ComputeCenterOfMass() const
{ {
return (m_first + m_second) / 2.f; return (m_first + m_second) / 2.f;
} }
float SegmentCollider2D::ComputeMomentOfInertia(float mass) const float ChipmunkSegmentCollider2D::ComputeMomentOfInertia(float mass) const
{ {
return SafeCast<float>(cpMomentForSegment(mass, cpv(m_first.x, m_first.y), cpv(m_second.x, m_second.y), m_thickness)); return SafeCast<float>(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<cpShape*>* shapes) const std::size_t ChipmunkSegmentCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{ {
cpShape* segment = cpSegmentShapeNew(body, cpv(m_first.x, m_first.y), cpv(m_second.x, m_second.y), m_thickness); 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)); cpSegmentShapeSetNeighbors(segment, cpv(m_firstNeighbor.x, m_firstNeighbor.y), cpv(m_secondNeighbor.x, m_secondNeighbor.y));

428
src/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.cpp Normal file
View File

@ -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 <Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.hpp>
#include <chipmunk/chipmunk.h>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
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<ChipmunkRigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint)));
}
const ChipmunkRigidBody2D& ChipmunkConstraint2D::GetBodyA() const
{
return *static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint)));
}
ChipmunkRigidBody2D& ChipmunkConstraint2D::GetBodyB()
{
return *static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint)));
}
const ChipmunkRigidBody2D& ChipmunkConstraint2D::GetBodyB() const
{
return *static_cast<ChipmunkRigidBody2D*>(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<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(cpConstraintGetSpace(m_constraint)));
}
const ChipmunkPhysWorld2D& ChipmunkConstraint2D::GetWorld() const
{
return *static_cast<ChipmunkPhysWorld2D*>(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<float>(anchor.x), static_cast<float>(anchor.y));
}
float ChipmunkDampedSpringConstraint2D::GetRestLength() const
{
return float(cpDampedSpringGetRestLength(m_constraint));
}
Vector2f ChipmunkDampedSpringConstraint2D::GetSecondAnchor() const
{
cpVect anchor = cpDampedSpringGetAnchorB(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(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<float>(anchor.x), static_cast<float>(anchor.y));
}
Vector2f ChipmunkPinConstraint2D::GetSecondAnchor() const
{
cpVect anchor = cpPinJointGetAnchorB(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(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<float>(anchor.x), static_cast<float>(anchor.y));
}
Vector2f ChipmunkPivotConstraint2D::GetSecondAnchor() const
{
cpVect anchor = cpPivotJointGetAnchorB(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(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<float>(anchor.x), static_cast<float>(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<float>(anchor.x), static_cast<float>(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));
}
}

130
src/Nazara/Physics2D/PhysWorld2D.cpp → src/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.cpp
View File

@ -2,11 +2,11 @@
// This file is part of the "Nazara Engine - Physics2D module" // This file is part of the "Nazara Engine - Physics2D module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/PhysWorld2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/Physics2D/Arbiter2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <NazaraUtils/StackArray.hpp> #include <NazaraUtils/StackArray.hpp>
#include <chipmunk/chipmunk.h> #include <chipmunk/chipmunk.h>
#include <Nazara/Physics2D/Debug.hpp> #include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz namespace Nz
{ {
@ -24,21 +24,21 @@ namespace Nz
void CpCircleCallback(cpVect pos, cpFloat angle, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata) void CpCircleCallback(cpVect pos, cpFloat angle, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata)
{ {
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata); auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->circleCallback) if (drawOptions->circleCallback)
drawOptions->circleCallback(Vector2f(float(pos.x), float(pos.y)), RadianAnglef(float(angle)), float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata); 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) void CpDotCallback(cpFloat size, cpVect pos, cpSpaceDebugColor color, cpDataPointer userdata)
{ {
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata); auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->dotCallback) if (drawOptions->dotCallback)
drawOptions->dotCallback(Vector2f(float(pos.x), float(pos.y)), float(size), CpDebugColorToColor(color), drawOptions->userdata); 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) void CpPolygonCallback(int vertexCount, const cpVect* vertices, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata)
{ {
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata); auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->polygonCallback) if (drawOptions->polygonCallback)
{ {
//TODO: constexpr if to prevent copy/cast if sizeof(cpVect) == sizeof(Vector2f) //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) void CpSegmentCallback(cpVect a, cpVect b, cpSpaceDebugColor color, cpDataPointer userdata)
{ {
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata); auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->segmentCallback) if (drawOptions->segmentCallback)
drawOptions->segmentCallback(Vector2f(float(a.x), float(a.y)), Vector2f(float(b.x), float(b.y)), CpDebugColorToColor(color), drawOptions->userdata); 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) void CpThickSegmentCallback(cpVect a, cpVect b, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata)
{ {
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata); auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->thickSegmentCallback) 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); 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) cpSpaceDebugColor CpShapeColorCallback(cpShape* shape, cpDataPointer userdata)
{ {
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata); auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->colorCallback) if (drawOptions->colorCallback)
{ {
RigidBody2D& rigidBody = *static_cast<RigidBody2D*>(cpShapeGetUserData(shape)); ChipmunkRigidBody2D& rigidBody = *static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
return ColorToCpDebugColor(drawOptions->colorCallback(rigidBody, rigidBody.GetShapeIndex(shape), drawOptions->userdata)); return ColorToCpDebugColor(drawOptions->colorCallback(rigidBody, rigidBody.GetShapeIndex(shape), drawOptions->userdata));
} }
else else
@ -78,7 +78,7 @@ namespace Nz
} }
} }
PhysWorld2D::PhysWorld2D() : ChipmunkPhysWorld2D::ChipmunkPhysWorld2D() :
m_maxStepCount(50), m_maxStepCount(50),
m_stepSize(Time::TickDuration(200)), m_stepSize(Time::TickDuration(200)),
m_timestepAccumulator(Time::Zero()) m_timestepAccumulator(Time::Zero())
@ -87,12 +87,12 @@ namespace Nz
cpSpaceSetUserData(m_handle, this); cpSpaceSetUserData(m_handle, this);
} }
PhysWorld2D::~PhysWorld2D() ChipmunkPhysWorld2D::~ChipmunkPhysWorld2D()
{ {
cpSpaceFree(m_handle); 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 auto ColorToCpDebugColor = [](Color c) -> cpSpaceDebugColor
{ {
@ -128,45 +128,45 @@ namespace Nz
cpSpaceDebugDraw(m_handle, &drawOptions); cpSpaceDebugDraw(m_handle, &drawOptions);
} }
float PhysWorld2D::GetDamping() const float ChipmunkPhysWorld2D::GetDamping() const
{ {
return float(cpSpaceGetDamping(m_handle)); return float(cpSpaceGetDamping(m_handle));
} }
Vector2f PhysWorld2D::GetGravity() const Vector2f ChipmunkPhysWorld2D::GetGravity() const
{ {
cpVect gravity = cpSpaceGetGravity(m_handle); cpVect gravity = cpSpaceGetGravity(m_handle);
return Vector2f(Vector2<cpFloat>(gravity.x, gravity.y)); return Vector2f(Vector2<cpFloat>(gravity.x, gravity.y));
} }
cpSpace* PhysWorld2D::GetHandle() const cpSpace* ChipmunkPhysWorld2D::GetHandle() const
{ {
return m_handle; return m_handle;
} }
std::size_t PhysWorld2D::GetIterationCount() const std::size_t ChipmunkPhysWorld2D::GetIterationCount() const
{ {
return cpSpaceGetIterations(m_handle); return cpSpaceGetIterations(m_handle);
} }
std::size_t PhysWorld2D::GetMaxStepCount() const std::size_t ChipmunkPhysWorld2D::GetMaxStepCount() const
{ {
return m_maxStepCount; return m_maxStepCount;
} }
Time PhysWorld2D::GetStepSize() const Time ChipmunkPhysWorld2D::GetStepSize() const
{ {
return m_stepSize; 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); cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask);
if (cpShape* shape = cpSpacePointQueryNearest(m_handle, {from.x, from.y}, maxDistance, filter, nullptr)) if (cpShape* shape = cpSpacePointQueryNearest(m_handle, {from.x, from.y}, maxDistance, filter, nullptr))
{ {
if (nearestBody) if (nearestBody)
*nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(shape)); *nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
return true; return true;
} }
@ -174,7 +174,7 @@ namespace Nz
return false; 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); cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask);
@ -187,7 +187,7 @@ namespace Nz
result->closestPoint.Set(Vector2<cpFloat>(queryInfo.point.x, queryInfo.point.y)); result->closestPoint.Set(Vector2<cpFloat>(queryInfo.point.x, queryInfo.point.y));
result->distance = float(queryInfo.distance); result->distance = float(queryInfo.distance);
result->fraction.Set(Vector2<cpFloat>(queryInfo.gradient.x, queryInfo.gradient.y)); result->fraction.Set(Vector2<cpFloat>(queryInfo.gradient.x, queryInfo.gradient.y));
result->nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(queryInfo.shape)); result->nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(queryInfo.shape));
return true; 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<void(const RaycastHit&)>& callback) void ChipmunkPhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<void(const RaycastHit&)>& callback)
{ {
using CallbackType = std::remove_reference_t<decltype(callback)>; using CallbackType = std::remove_reference_t<decltype(callback)>;
@ -215,7 +215,7 @@ namespace Nz
hitInfo.fraction = float(alpha); hitInfo.fraction = float(alpha);
hitInfo.hitNormal.Set(Vector2<cpFloat>(normal.x, normal.y)); hitInfo.hitNormal.Set(Vector2<cpFloat>(normal.x, normal.y));
hitInfo.hitPos.Set(Vector2<cpFloat>(point.x, point.y)); hitInfo.hitPos.Set(Vector2<cpFloat>(point.x, point.y));
hitInfo.nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(shape)); hitInfo.nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
callback(hitInfo); callback(hitInfo);
}; };
@ -224,7 +224,7 @@ namespace Nz
cpSpaceSegmentQuery(m_handle, { from.x, from.y }, { to.x, to.y }, radius, filter, cpCallback, const_cast<void*>(static_cast<const void*>(&callback))); cpSpaceSegmentQuery(m_handle, { from.x, from.y }, { to.x, to.y }, radius, filter, cpCallback, const_cast<void*>(static_cast<const void*>(&callback)));
} }
bool PhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RaycastHit>* hitInfos) bool ChipmunkPhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RaycastHit>* hitInfos)
{ {
using ResultType = decltype(hitInfos); using ResultType = decltype(hitInfos);
@ -236,7 +236,7 @@ namespace Nz
hitInfo.fraction = float(alpha); hitInfo.fraction = float(alpha);
hitInfo.hitNormal.Set(Vector2<cpFloat>(normal.x, normal.y)); hitInfo.hitNormal.Set(Vector2<cpFloat>(normal.x, normal.y));
hitInfo.hitPos.Set(Vector2<cpFloat>(point.x, point.y)); hitInfo.hitPos.Set(Vector2<cpFloat>(point.x, point.y));
hitInfo.nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(shape)); hitInfo.nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
results->emplace_back(std::move(hitInfo)); results->emplace_back(std::move(hitInfo));
}; };
@ -249,7 +249,7 @@ namespace Nz
return hitInfos->size() != previousSize; 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); cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask);
@ -262,7 +262,7 @@ namespace Nz
hitInfo->fraction = float(queryInfo.alpha); hitInfo->fraction = float(queryInfo.alpha);
hitInfo->hitNormal.Set(Vector2<cpFloat>(queryInfo.normal.x, queryInfo.normal.y)); hitInfo->hitNormal.Set(Vector2<cpFloat>(queryInfo.normal.x, queryInfo.normal.y));
hitInfo->hitPos.Set(Vector2<cpFloat>(queryInfo.point.x, queryInfo.point.y)); hitInfo->hitPos.Set(Vector2<cpFloat>(queryInfo.point.x, queryInfo.point.y));
hitInfo->nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(queryInfo.shape)); hitInfo->nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(queryInfo.shape));
return true; return true;
} }
@ -278,65 +278,65 @@ namespace Nz
} }
} }
void PhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<void(RigidBody2D*)>& callback) void ChipmunkPhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<void(ChipmunkRigidBody2D*)>& callback)
{ {
using CallbackType = std::remove_reference_t<decltype(callback)>; using CallbackType = std::remove_reference_t<decltype(callback)>;
auto cpCallback = [](cpShape* shape, void* data) auto cpCallback = [](cpShape* shape, void* data)
{ {
CallbackType& callback = *static_cast<CallbackType*>(data); CallbackType& callback = *static_cast<CallbackType*>(data);
callback(static_cast<RigidBody2D*>(cpShapeGetUserData(shape))); callback(static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape)));
}; };
cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask); 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<void*>(static_cast<const void*>(&callback))); cpSpaceBBQuery(m_handle, cpBBNew(boundingBox.x, boundingBox.y, boundingBox.x + boundingBox.width, boundingBox.y + boundingBox.height), filter, cpCallback, const_cast<void*>(static_cast<const void*>(&callback)));
} }
void PhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RigidBody2D*>* bodies) void ChipmunkPhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<ChipmunkRigidBody2D*>* bodies)
{ {
using ResultType = decltype(bodies); using ResultType = decltype(bodies);
auto callback = [] (cpShape* shape, void* data) auto callback = [] (cpShape* shape, void* data)
{ {
ResultType results = static_cast<ResultType>(data); ResultType results = static_cast<ResultType>(data);
results->push_back(static_cast<RigidBody2D*>(cpShapeGetUserData(shape))); results->push_back(static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape)));
}; };
cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask); 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); 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)); 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)); InitCallbacks(cpSpaceAddCollisionHandler(m_handle, collisionIdA, collisionIdB), std::move(callbacks));
} }
void PhysWorld2D::SetDamping(float dampingValue) void ChipmunkPhysWorld2D::SetDamping(float dampingValue)
{ {
cpSpaceSetDamping(m_handle, 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)); 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<int>(iterationCount)); cpSpaceSetIterations(m_handle, SafeCast<int>(iterationCount));
} }
void PhysWorld2D::SetMaxStepCount(std::size_t maxStepCount) void ChipmunkPhysWorld2D::SetMaxStepCount(std::size_t maxStepCount)
{ {
m_maxStepCount = maxStepCount; m_maxStepCount = maxStepCount;
} }
void PhysWorld2D::SetSleepTime(Time sleepTime) void ChipmunkPhysWorld2D::SetSleepTime(Time sleepTime)
{ {
if (sleepTime > Time::Zero()) if (sleepTime > Time::Zero())
cpSpaceSetSleepTimeThreshold(m_handle, sleepTime.AsSeconds<cpFloat>()); cpSpaceSetSleepTimeThreshold(m_handle, sleepTime.AsSeconds<cpFloat>());
@ -344,12 +344,12 @@ namespace Nz
cpSpaceSetSleepTimeThreshold(m_handle, std::numeric_limits<cpFloat>::infinity()); cpSpaceSetSleepTimeThreshold(m_handle, std::numeric_limits<cpFloat>::infinity());
} }
void PhysWorld2D::SetStepSize(Time stepSize) void ChipmunkPhysWorld2D::SetStepSize(Time stepSize)
{ {
m_stepSize = stepSize; m_stepSize = stepSize;
} }
void PhysWorld2D::Step(Time timestep) void ChipmunkPhysWorld2D::Step(Time timestep)
{ {
m_timestepAccumulator += 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)); 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); auto it = m_callbacks.find(handler);
if (it == m_callbacks.end()) if (it == m_callbacks.end())
@ -403,11 +403,11 @@ namespace Nz
cpBody* secondBody; cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody); cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space)); ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody)); ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody)); ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
Arbiter2D arbiter(arb); ChipmunkArbiter2D arbiter(arb);
const Callback* customCallbacks = static_cast<const Callback*>(data); const Callback* customCallbacks = static_cast<const Callback*>(data);
if (customCallbacks->startCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata)) if (customCallbacks->startCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata))
@ -432,11 +432,11 @@ namespace Nz
cpBody* secondBody; cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody); cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space)); ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody)); ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody)); ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
Arbiter2D arbiter(arb); ChipmunkArbiter2D arbiter(arb);
const Callback* customCallbacks = static_cast<const Callback*>(data); const Callback* customCallbacks = static_cast<const Callback*>(data);
customCallbacks->endCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata); customCallbacks->endCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata);
@ -457,11 +457,11 @@ namespace Nz
cpBody* secondBody; cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody); cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space)); ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody)); ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody)); ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
Arbiter2D arbiter(arb); ChipmunkArbiter2D arbiter(arb);
const Callback* customCallbacks = static_cast<const Callback*>(data); const Callback* customCallbacks = static_cast<const Callback*>(data);
if (customCallbacks->preSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata)) if (customCallbacks->preSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata))
@ -486,11 +486,11 @@ namespace Nz
cpBody* secondBody; cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody); cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space)); ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody)); ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody)); ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
Arbiter2D arbiter(arb); ChipmunkArbiter2D arbiter(arb);
const Callback* customCallbacks = static_cast<const Callback*>(data); const Callback* customCallbacks = static_cast<const Callback*>(data);
customCallbacks->postSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata); 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); auto it = m_rigidPostSteps.find(oldPointer);
if (it == m_rigidPostSteps.end()) if (it == m_rigidPostSteps.end())
@ -514,12 +514,12 @@ namespace Nz
m_rigidPostSteps.erase(oldPointer); m_rigidPostSteps.erase(oldPointer);
} }
void PhysWorld2D::OnRigidBodyRelease(RigidBody2D* rigidBody) void ChipmunkPhysWorld2D::OnRigidBodyRelease(ChipmunkRigidBody2D* rigidBody)
{ {
m_rigidPostSteps.erase(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 space isn't locked, no need to wait
if (!cpSpaceIsLocked(m_handle)) if (!cpSpaceIsLocked(m_handle))
@ -532,8 +532,8 @@ namespace Nz
if (it == m_rigidPostSteps.end()) if (it == m_rigidPostSteps.end())
{ {
PostStepContainer postStep; PostStepContainer postStep;
postStep.onMovedSlot.Connect(rigidBody->OnRigidBody2DMove, this, &PhysWorld2D::OnRigidBodyMoved); postStep.onMovedSlot.Connect(rigidBody->OnRigidBody2DMove, this, &ChipmunkPhysWorld2D::OnRigidBodyMoved);
postStep.onReleaseSlot.Connect(rigidBody->OnRigidBody2DRelease, this, &PhysWorld2D::OnRigidBodyRelease); postStep.onReleaseSlot.Connect(rigidBody->OnRigidBody2DRelease, this, &ChipmunkPhysWorld2D::OnRigidBodyRelease);
it = m_rigidPostSteps.insert(std::make_pair(rigidBody, std::move(postStep))).first; it = m_rigidPostSteps.insert(std::make_pair(rigidBody, std::move(postStep))).first;
} }

16
src/Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.cpp Normal file
View File

@ -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 <Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz
{
ChipmunkPhysics2D::ChipmunkPhysics2D(Config /*config*/) :
ModuleBase("ChipmunkPhysics2D", this)
{
}
ChipmunkPhysics2D* ChipmunkPhysics2D::s_instance = nullptr;
}

168
src/Nazara/Physics2D/RigidBody2D.cpp → src/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.cpp
View File

@ -2,23 +2,23 @@
// This file is part of the "Nazara Engine - Physics2D module" // This file is part of the "Nazara Engine - Physics2D module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/RigidBody2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <Nazara/Physics2D/Arbiter2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <chipmunk/chipmunk.h> #include <chipmunk/chipmunk.h>
#include <chipmunk/chipmunk_private.h> #include <chipmunk/chipmunk_private.h>
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
#include <Nazara/Physics2D/Debug.hpp> #include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz namespace Nz
{ {
RigidBody2D::RigidBody2D(PhysWorld2D* world, float mass) : ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass) :
RigidBody2D(world, mass, nullptr) ChipmunkRigidBody2D(world, mass, nullptr)
{ {
} }
RigidBody2D::RigidBody2D(PhysWorld2D* world, float mass, std::shared_ptr<Collider2D> geom) : ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass, std::shared_ptr<ChipmunkCollider2D> geom) :
m_positionOffset(Vector2f::Zero()), m_positionOffset(Vector2f::Zero()),
m_geom(), m_geom(),
m_userData(nullptr), m_userData(nullptr),
@ -35,7 +35,7 @@ namespace Nz
SetGeom(std::move(geom)); SetGeom(std::move(geom));
} }
RigidBody2D::RigidBody2D(const RigidBody2D& object) : ChipmunkRigidBody2D::ChipmunkRigidBody2D(const ChipmunkRigidBody2D& object) :
m_positionOffset(object.m_positionOffset), m_positionOffset(object.m_positionOffset),
m_geom(object.m_geom), m_geom(object.m_geom),
m_userData(object.m_userData), 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)), OnRigidBody2DMove(std::move(object.OnRigidBody2DMove)),
OnRigidBody2DRelease(std::move(object.OnRigidBody2DRelease)), OnRigidBody2DRelease(std::move(object.OnRigidBody2DRelease)),
m_positionOffset(std::move(object.m_positionOffset)), m_positionOffset(std::move(object.m_positionOffset)),
@ -85,19 +85,19 @@ namespace Nz
OnRigidBody2DMove(&object, this); OnRigidBody2DMove(&object, this);
} }
RigidBody2D::~RigidBody2D() ChipmunkRigidBody2D::~ChipmunkRigidBody2D()
{ {
OnRigidBody2DRelease(this); OnRigidBody2DRelease(this);
Destroy(); Destroy();
} }
void RigidBody2D::AddForce(const Vector2f& force, CoordSys coordSys) void ChipmunkRigidBody2D::AddForce(const Vector2f& force, CoordSys coordSys)
{ {
return AddForce(force, GetMassCenter(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) 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); 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) 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); 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)); cpVect pos = cpv(cpFloat(position.x), cpFloat(position.y));
@ -166,7 +166,7 @@ namespace Nz
return true; return true;
} }
void RigidBody2D::EnableSimulation(bool simulation) void ChipmunkRigidBody2D::EnableSimulation(bool simulation)
{ {
if (m_isSimulationEnabled != simulation) if (m_isSimulationEnabled != simulation)
{ {
@ -179,7 +179,7 @@ namespace Nz
} }
} }
void RigidBody2D::ForEachArbiter(std::function<void(Arbiter2D&)> callback) void ChipmunkRigidBody2D::ForEachArbiter(std::function<void(ChipmunkArbiter2D&)> callback)
{ {
using CallbackType = decltype(callback); using CallbackType = decltype(callback);
@ -187,23 +187,23 @@ namespace Nz
{ {
CallbackType& cb = *static_cast<CallbackType*>(data); CallbackType& cb = *static_cast<CallbackType*>(data);
Arbiter2D nzArbiter(arbiter); ChipmunkArbiter2D nzArbiter(arbiter);
cb(nzArbiter); cb(nzArbiter);
}; };
cpBodyEachArbiter(m_handle, RealCallback, &callback); 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) if (cpBodyGetType(body->GetHandle()) == CP_BODY_TYPE_DYNAMIC)
cpBodySleep(body->GetHandle()); cpBodySleep(body->GetHandle());
}); });
} }
Rectf RigidBody2D::GetAABB() const Rectf ChipmunkRigidBody2D::GetAABB() const
{ {
if (m_shapes.empty()) if (m_shapes.empty())
return Rectf::Zero(); return Rectf::Zero();
@ -216,39 +216,39 @@ namespace Nz
return Rectf(Rect<cpFloat>(bb.l, bb.b, bb.r - bb.l, bb.t - bb.b)); return Rectf(Rect<cpFloat>(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)); 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()); assert(shapeIndex < m_shapes.size());
return float(cpShapeGetElasticity(m_shapes[shapeIndex])); 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()); assert(shapeIndex < m_shapes.size());
return float(cpShapeGetFriction(m_shapes[shapeIndex])); return float(cpShapeGetFriction(m_shapes[shapeIndex]));
} }
const std::shared_ptr<Collider2D>& RigidBody2D::GetGeom() const const std::shared_ptr<ChipmunkCollider2D>& ChipmunkRigidBody2D::GetGeom() const
{ {
return m_geom; return m_geom;
} }
cpBody* RigidBody2D::GetHandle() const cpBody* ChipmunkRigidBody2D::GetHandle() const
{ {
return m_handle; return m_handle;
} }
float RigidBody2D::GetMass() const float ChipmunkRigidBody2D::GetMass() const
{ {
return m_mass; return m_mass;
} }
Vector2f RigidBody2D::GetMassCenter(CoordSys coordSys) const Vector2f ChipmunkRigidBody2D::GetMassCenter(CoordSys coordSys) const
{ {
cpVect massCenter = cpBodyGetCenterOfGravity(m_handle); cpVect massCenter = cpBodyGetCenterOfGravity(m_handle);
@ -265,23 +265,23 @@ namespace Nz
return Vector2f(static_cast<float>(massCenter.x), static_cast<float>(massCenter.y)); return Vector2f(static_cast<float>(massCenter.x), static_cast<float>(massCenter.y));
} }
float RigidBody2D::GetMomentOfInertia() const float ChipmunkRigidBody2D::GetMomentOfInertia() const
{ {
return float(cpBodyGetMoment(m_handle)); 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)); cpVect pos = cpBodyLocalToWorld(m_handle, cpv(-m_positionOffset.x, -m_positionOffset.y));
return Vector2f(static_cast<float>(pos.x), static_cast<float>(pos.y)); return Vector2f(static_cast<float>(pos.x), static_cast<float>(pos.y));
} }
RadianAnglef RigidBody2D::GetRotation() const RadianAnglef ChipmunkRigidBody2D::GetRotation() const
{ {
return float(cpBodyGetAngle(m_handle)); 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); auto it = std::find(m_shapes.begin(), m_shapes.end(), shape);
if (it == m_shapes.end()) if (it == m_shapes.end())
@ -290,91 +290,91 @@ namespace Nz
return std::distance(m_shapes.begin(), it); 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()); assert(shapeIndex < m_shapes.size());
cpVect vel = cpShapeGetSurfaceVelocity(m_shapes[shapeIndex]); cpVect vel = cpShapeGetSurfaceVelocity(m_shapes[shapeIndex]);
return Vector2f(static_cast<float>(vel.x), static_cast<float>(vel.y)); return Vector2f(static_cast<float>(vel.x), static_cast<float>(vel.y));
} }
void* RigidBody2D::GetUserdata() const void* ChipmunkRigidBody2D::GetUserdata() const
{ {
return m_userData; return m_userData;
} }
Vector2f RigidBody2D::GetVelocity() const Vector2f ChipmunkRigidBody2D::GetVelocity() const
{ {
cpVect vel = cpBodyGetVelocity(m_handle); cpVect vel = cpBodyGetVelocity(m_handle);
return Vector2f(static_cast<float>(vel.x), static_cast<float>(vel.y)); return Vector2f(static_cast<float>(vel.x), static_cast<float>(vel.y));
} }
const RigidBody2D::VelocityFunc& RigidBody2D::GetVelocityFunction() const const ChipmunkRigidBody2D::VelocityFunc& ChipmunkRigidBody2D::GetVelocityFunction() const
{ {
return m_velocityFunc; return m_velocityFunc;
} }
PhysWorld2D* RigidBody2D::GetWorld() const ChipmunkPhysWorld2D* ChipmunkRigidBody2D::GetWorld() const
{ {
return m_world; return m_world;
} }
bool RigidBody2D::IsKinematic() const bool ChipmunkRigidBody2D::IsKinematic() const
{ {
return m_mass <= 0.f; return m_mass <= 0.f;
} }
bool RigidBody2D::IsSimulationEnabled() const bool ChipmunkRigidBody2D::IsSimulationEnabled() const
{ {
return m_isSimulationEnabled; return m_isSimulationEnabled;
} }
bool RigidBody2D::IsSleeping() const bool ChipmunkRigidBody2D::IsSleeping() const
{ {
return cpBodyIsSleeping(m_handle) != 0; return cpBodyIsSleeping(m_handle) != 0;
} }
bool RigidBody2D::IsStatic() const bool ChipmunkRigidBody2D::IsStatic() const
{ {
return m_isStatic; return m_isStatic;
} }
void RigidBody2D::ResetVelocityFunction() void ChipmunkRigidBody2D::ResetVelocityFunction()
{ {
m_handle->velocity_func = cpBodyUpdateVelocity; m_handle->velocity_func = cpBodyUpdateVelocity;
} }
void RigidBody2D::SetAngularVelocity(const RadianAnglef& angularVelocity) void ChipmunkRigidBody2D::SetAngularVelocity(const RadianAnglef& angularVelocity)
{ {
cpBodySetAngularVelocity(m_handle, angularVelocity.value); cpBodySetAngularVelocity(m_handle, angularVelocity.value);
} }
void RigidBody2D::SetElasticity(float friction) void ChipmunkRigidBody2D::SetElasticity(float friction)
{ {
cpFloat frict(friction); cpFloat frict(friction);
for (cpShape* shape : m_shapes) for (cpShape* shape : m_shapes)
cpShapeSetElasticity(shape, frict); 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()); assert(shapeIndex < m_shapes.size());
cpShapeSetElasticity(m_shapes[shapeIndex], cpFloat(friction)); cpShapeSetElasticity(m_shapes[shapeIndex], cpFloat(friction));
} }
void RigidBody2D::SetFriction(float friction) void ChipmunkRigidBody2D::SetFriction(float friction)
{ {
cpFloat frict(friction); cpFloat frict(friction);
for (cpShape* shape : m_shapes) for (cpShape* shape : m_shapes)
cpShapeSetFriction(shape, frict); 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()); assert(shapeIndex < m_shapes.size());
cpShapeSetFriction(m_shapes[shapeIndex], cpFloat(friction)); cpShapeSetFriction(m_shapes[shapeIndex], cpFloat(friction));
} }
void RigidBody2D::SetGeom(std::shared_ptr<Collider2D> geom, bool recomputeMoment, bool recomputeMassCenter) void ChipmunkRigidBody2D::SetGeom(std::shared_ptr<ChipmunkCollider2D> geom, bool recomputeMoment, bool recomputeMassCenter)
{ {
// We have no public way of getting rid of an existing geom without removing the whole body // 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 // So let's save some attributes of the body, destroy it and rebuild it
@ -395,7 +395,7 @@ namespace Nz
if (geom) if (geom)
m_geom = std::move(geom); m_geom = std::move(geom);
else else
m_geom = std::make_shared<NullCollider2D>(); m_geom = std::make_shared<ChipmunkNullCollider2D>();
m_geom->GenerateShapes(m_handle, &m_shapes); m_geom->GenerateShapes(m_handle, &m_shapes);
@ -415,13 +415,13 @@ namespace Nz
SetMassCenter(m_geom->ComputeCenterOfMass()); SetMassCenter(m_geom->ComputeCenterOfMass());
} }
void RigidBody2D::SetMass(float mass, bool recomputeMoment) void ChipmunkRigidBody2D::SetMass(float mass, bool recomputeMoment)
{ {
if (m_mass > 0.f) if (m_mass > 0.f)
{ {
if (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); cpBodySetMass(body->GetHandle(), mass);
@ -430,11 +430,11 @@ namespace Nz
}); });
} }
else 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) 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) if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_DYNAMIC)
{ {
@ -450,7 +450,7 @@ namespace Nz
m_mass = mass; 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); cpVect massCenter = cpv(center.x, center.y);
@ -467,64 +467,64 @@ namespace Nz
cpBodySetCenterOfGravity(m_handle, massCenter); 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 // 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); cpBodySetMoment(body->GetHandle(), moment);
}); });
} }
void RigidBody2D::SetPosition(const Vector2f& position) void ChipmunkRigidBody2D::SetPosition(const Vector2f& position)
{ {
// Use cpTransformVect to rotate/scale the position offset // 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)))); cpBodySetPosition(m_handle, cpvadd(cpv(position.x, position.y), cpTransformVect(m_handle->transform, cpv(m_positionOffset.x, m_positionOffset.y))));
if (m_isStatic) if (m_isStatic)
{ {
m_world->RegisterPostStep(this, [](RigidBody2D* body) m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{ {
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle()); cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
}); });
} }
} }
void RigidBody2D::SetPositionOffset(const Vector2f& offset) void ChipmunkRigidBody2D::SetPositionOffset(const Vector2f& offset)
{ {
Vector2f position = GetPosition(); Vector2f position = GetPosition();
m_positionOffset = offset; m_positionOffset = offset;
SetPosition(position); SetPosition(position);
} }
void RigidBody2D::SetRotation(const RadianAnglef& rotation) void ChipmunkRigidBody2D::SetRotation(const RadianAnglef& rotation)
{ {
cpBodySetAngle(m_handle, rotation.value); cpBodySetAngle(m_handle, rotation.value);
if (m_isStatic) if (m_isStatic)
{ {
m_world->RegisterPostStep(this, [](RigidBody2D* body) m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{ {
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle()); cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
}); });
} }
} }
void RigidBody2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity) void ChipmunkRigidBody2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity)
{ {
Vector2<cpFloat> velocity(surfaceVelocity.x, surfaceVelocity.y); Vector2<cpFloat> velocity(surfaceVelocity.x, surfaceVelocity.y);
for (cpShape* shape : m_shapes) for (cpShape* shape : m_shapes)
cpShapeSetSurfaceVelocity(shape, cpv(velocity.x, velocity.y)); 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()); assert(shapeIndex < m_shapes.size());
cpShapeSetSurfaceVelocity(m_shapes[shapeIndex], cpv(cpFloat(surfaceVelocity.x), cpFloat(surfaceVelocity.y))); 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_isStatic = setStaticBody;
m_world->RegisterPostStep(this, [](RigidBody2D* body) m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{ {
if (body->IsStatic()) if (body->IsStatic())
{ {
@ -538,17 +538,17 @@ namespace Nz
}); });
} }
void RigidBody2D::SetUserdata(void* ud) void ChipmunkRigidBody2D::SetUserdata(void* ud)
{ {
m_userData = ud; m_userData = ud;
} }
void RigidBody2D::SetVelocity(const Vector2f& velocity) void ChipmunkRigidBody2D::SetVelocity(const Vector2f& velocity)
{ {
cpBodySetVelocity(m_handle, cpv(velocity.x, velocity.y)); cpBodySetVelocity(m_handle, cpv(velocity.x, velocity.y));
} }
void RigidBody2D::SetVelocityFunction(VelocityFunc velocityFunc) void ChipmunkRigidBody2D::SetVelocityFunction(VelocityFunc velocityFunc)
{ {
m_velocityFunc = std::move(velocityFunc); m_velocityFunc = std::move(velocityFunc);
@ -556,7 +556,7 @@ namespace Nz
{ {
m_handle->velocity_func = [](cpBody* body, cpVect gravity, cpFloat damping, cpFloat dt) m_handle->velocity_func = [](cpBody* body, cpVect gravity, cpFloat damping, cpFloat dt)
{ {
RigidBody2D* rigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(body)); ChipmunkRigidBody2D* rigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(body));
const auto& callback = rigidBody->GetVelocityFunction(); const auto& callback = rigidBody->GetVelocityFunction();
assert(callback); assert(callback);
@ -567,28 +567,28 @@ namespace Nz
m_handle->velocity_func = cpBodyUpdateVelocity; 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 // 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)))); 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); cpBodySetAngle(m_handle, rotation.value);
if (m_isStatic) if (m_isStatic)
{ {
m_world->RegisterPostStep(this, [](RigidBody2D* body) m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{ {
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle()); 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); 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) if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_STATIC)
cpBodyActivate(body->GetHandle()); 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)); return operator=(std::move(physObj));
} }
RigidBody2D& RigidBody2D::operator=(RigidBody2D&& object) ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(ChipmunkRigidBody2D&& object)
{ {
Destroy(); Destroy();
@ -637,7 +637,7 @@ namespace Nz
return *this; return *this;
} }
void RigidBody2D::Destroy() void ChipmunkRigidBody2D::Destroy()
{ {
UnregisterFromSpace(); UnregisterFromSpace();
@ -653,7 +653,7 @@ namespace Nz
m_shapes.clear(); m_shapes.clear();
} }
cpBody* RigidBody2D::Create(float mass, float moment) cpBody* ChipmunkRigidBody2D::Create(float mass, float moment)
{ {
cpBody* handle; cpBody* handle;
if (IsKinematic()) if (IsKinematic())
@ -671,7 +671,7 @@ namespace Nz
return handle; return handle;
} }
void RigidBody2D::RegisterToSpace() void ChipmunkRigidBody2D::RegisterToSpace()
{ {
if (!m_isRegistered) if (!m_isRegistered)
{ {
@ -686,7 +686,7 @@ namespace Nz
} }
} }
void RigidBody2D::UnregisterFromSpace() void ChipmunkRigidBody2D::UnregisterFromSpace()
{ {
if (m_isRegistered) 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)); cpBodySetCenterOfGravity(to, cpBodyGetCenterOfGravity(from));
@ -717,7 +717,7 @@ namespace Nz
to->velocity_func = from->velocity_func; to->velocity_func = from->velocity_func;
} }
void RigidBody2D::CopyShapeData(cpShape* from, cpShape* to) void ChipmunkRigidBody2D::CopyShapeData(cpShape* from, cpShape* to)
{ {
cpShapeSetElasticity(to, cpShapeGetElasticity(from)); cpShapeSetElasticity(to, cpShapeGetElasticity(from));
cpShapeSetFriction(to, cpShapeGetFriction(from)); cpShapeSetFriction(to, cpShapeGetFriction(from));

4
src/Nazara/Physics2D/Components/RigidBody2DComponent.cpp → src/Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.cpp
View File

@ -2,8 +2,8 @@
// This file is part of the "Nazara Engine - Physics2D module" // This file is part of the "Nazara Engine - Physics2D module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/Components/RigidBody2DComponent.hpp> #include <Nazara/ChipmunkPhysics2D/Components/ChipmunkRigidBody2DComponent.hpp>
#include <Nazara/Physics2D/Debug.hpp> #include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz namespace Nz
{ {

18
src/Nazara/Physics2D/Systems/Physics2DSystem.cpp → src/Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.cpp
View File

@ -2,9 +2,9 @@
// This file is part of the "Nazara Engine - Physics2D module" // This file is part of the "Nazara Engine - Physics2D module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/Systems/Physics2DSystem.hpp> #include <Nazara/ChipmunkPhysics2D/Systems/ChipmunkPhysics2DSystem.hpp>
#include <Nazara/Utility/Components/NodeComponent.hpp> #include <Nazara/Utility/Components/NodeComponent.hpp>
#include <Nazara/Physics2D/Debug.hpp> #include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz namespace Nz
{ {
@ -19,28 +19,28 @@ namespace Nz
} }
} }
Physics2DSystem::Physics2DSystem(entt::registry& registry) : ChipmunkPhysics2DSystem::ChipmunkPhysics2DSystem(entt::registry& registry) :
m_registry(registry), m_registry(registry),
m_physicsConstructObserver(m_registry, entt::collector.group<RigidBody2DComponent, NodeComponent>()) m_physicsConstructObserver(m_registry, entt::collector.group<ChipmunkRigidBody2DComponent, NodeComponent>())
{ {
} }
Physics2DSystem::~Physics2DSystem() ChipmunkPhysics2DSystem::~ChipmunkPhysics2DSystem()
{ {
m_physicsConstructObserver.disconnect(); m_physicsConstructObserver.disconnect();
// Ensure every body is destroyed before world is // Ensure every body is destroyed before world is
auto rigidBodyView = m_registry.view<RigidBody2DComponent>(); auto rigidBodyView = m_registry.view<ChipmunkRigidBody2DComponent>();
for (auto [entity, rigidBodyComponent] : rigidBodyView.each()) for (auto [entity, rigidBodyComponent] : rigidBodyView.each())
rigidBodyComponent.Destroy(); rigidBodyComponent.Destroy();
} }
void Physics2DSystem::Update(Time elapsedTime) void ChipmunkPhysics2DSystem::Update(Time elapsedTime)
{ {
// Move newly-created physics entities to their node position/rotation // Move newly-created physics entities to their node position/rotation
m_physicsConstructObserver.each([&](entt::entity entity) m_physicsConstructObserver.each([&](entt::entity entity)
{ {
RigidBody2DComponent& entityPhysics = m_registry.get<RigidBody2DComponent>(entity); ChipmunkRigidBody2DComponent& entityPhysics = m_registry.get<ChipmunkRigidBody2DComponent>(entity);
NodeComponent& entityNode = m_registry.get<NodeComponent>(entity); NodeComponent& entityNode = m_registry.get<NodeComponent>(entity);
entityPhysics.TeleportTo(Vector2f(entityNode.GetPosition()), AngleFromQuaternion(entityNode.GetRotation())); entityPhysics.TeleportTo(Vector2f(entityNode.GetPosition()), AngleFromQuaternion(entityNode.GetRotation()));
@ -49,7 +49,7 @@ namespace Nz
m_physWorld.Step(elapsedTime); m_physWorld.Step(elapsedTime);
// Replicate rigid body position to their node components // Replicate rigid body position to their node components
auto view = m_registry.view<NodeComponent, const RigidBody2DComponent>(); auto view = m_registry.view<NodeComponent, const ChipmunkRigidBody2DComponent>();
for (auto [entity, nodeComponent, rigidBodyComponent] : view.each()) for (auto [entity, nodeComponent, rigidBodyComponent] : view.each())
{ {
if (rigidBodyComponent.IsSleeping()) if (rigidBodyComponent.IsSleeping())

102
src/Nazara/Physics2D/Arbiter2D.cpp
View File

@ -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 <Nazara/Physics2D/Arbiter2D.hpp>
#include <chipmunk/chipmunk.h>
#include <Nazara/Physics2D/Debug.hpp>
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<cpFloat>(impulse.x, impulse.y));
}
std::pair<RigidBody2D*, RigidBody2D*> Arbiter2D::GetBodies() const
{
std::pair<RigidBody2D*, RigidBody2D*> bodies;
cpBody* firstBody;
cpBody* secondBody;
cpArbiterGetBodies(m_arbiter, &firstBody, &secondBody);
bodies.first = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
bodies.second = static_cast<RigidBody2D*>(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<cpFloat>(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<cpFloat>(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<cpFloat>(normal.x, normal.y));
}
Nz::Vector2f Arbiter2D::GetSurfaceVelocity() const
{
cpVect velocity = cpArbiterGetNormal(m_arbiter);
return Nz::Vector2f(Nz::Vector2<cpFloat>(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));
}
}

428
src/Nazara/Physics2D/Constraint2D.cpp
View File

@ -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 <Nazara/Physics2D/Constraint2D.hpp>
#include <chipmunk/chipmunk.h>
#include <Nazara/Physics2D/Debug.hpp>
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<RigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint)));
}
const RigidBody2D& Constraint2D::GetBodyA() const
{
return *static_cast<RigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint)));
}
RigidBody2D& Constraint2D::GetBodyB()
{
return *static_cast<RigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint)));
}
const RigidBody2D& Constraint2D::GetBodyB() const
{
return *static_cast<RigidBody2D*>(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<PhysWorld2D*>(cpSpaceGetUserData(cpConstraintGetSpace(m_constraint)));
}
const PhysWorld2D& Constraint2D::GetWorld() const
{
return *static_cast<PhysWorld2D*>(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<float>(anchor.x), static_cast<float>(anchor.y));
}
float DampedSpringConstraint2D::GetRestLength() const
{
return float(cpDampedSpringGetRestLength(m_constraint));
}
Vector2f DampedSpringConstraint2D::GetSecondAnchor() const
{
cpVect anchor = cpDampedSpringGetAnchorB(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(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<float>(anchor.x), static_cast<float>(anchor.y));
}
Vector2f PinConstraint2D::GetSecondAnchor() const
{
cpVect anchor = cpPinJointGetAnchorB(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(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<float>(anchor.x), static_cast<float>(anchor.y));
}
Vector2f PivotConstraint2D::GetSecondAnchor() const
{
cpVect anchor = cpPivotJointGetAnchorB(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(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<float>(anchor.x), static_cast<float>(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<float>(anchor.x), static_cast<float>(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));
}
}

16
src/Nazara/Physics2D/Physics2D.cpp
View File

@ -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 <Nazara/Physics2D/Physics2D.hpp>
#include <Nazara/Physics2D/Debug.hpp>
namespace Nz
{
Physics2D::Physics2D(Config /*config*/) :
ModuleBase("Physics2D", this)
{
}
Physics2D* Physics2D::s_instance = nullptr;
}

2
tests/UnitTests/Engine/Modules.hpp
View File

@ -2,6 +2,6 @@
#include <Nazara/Core.hpp> #include <Nazara/Core.hpp>
#include <Nazara/Math.hpp> #include <Nazara/Math.hpp>
#include <Nazara/Network.hpp> #include <Nazara/Network.hpp>
#include <Nazara/Physics2D.hpp> #include <Nazara/ChipmunkPhysics2D.hpp>
#include <Nazara/BulletPhysics3D.hpp> #include <Nazara/BulletPhysics3D.hpp>
#include <Nazara/Utility.hpp> #include <Nazara/Utility.hpp>

38
tests/UnitTests/Engine/Physics2D/Collider2DTest.cpp
View File

@ -1,4 +1,4 @@
#include <Nazara/Physics2D/Collider2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp>
#include <catch2/catch_approx.hpp> #include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp> #include <catch2/catch_test_macros.hpp>
@ -9,13 +9,13 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]")
WHEN("We construct a box with Rect") WHEN("We construct a box with Rect")
{ {
Nz::Rectf aabb(5.f, 3.f, 10.f, 6.f); 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") THEN("We expect those to be true")
{ {
CHECK(box.GetRect() == aabb); CHECK(box.GetRect() == aabb);
CHECK(box.GetSize() == aabb.GetLengths()); 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::Vector2f vec(5.f, 3.f);
Nz::Rectf aabb(-2.5f, -1.5f, 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") THEN("We expect those to be true")
{ {
CHECK(box.GetRect() == aabb); CHECK(box.GetRect() == aabb);
CHECK(box.GetSize() == vec); 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); Nz::Vector2f position(5.f, 3.f);
float radius = 7.f; float radius = 7.f;
Nz::CircleCollider2D circle(radius, position); Nz::ChipmunkCircleCollider2D circle(radius, position);
THEN("We expect those to be true") THEN("We expect those to be true")
{ {
CHECK(circle.GetRadius() == Catch::Approx(radius)); CHECK(circle.GetRadius() == Catch::Approx(radius));
CHECK(circle.GetType() == Nz::ColliderType2D::Circle); CHECK(circle.GetType() == Nz::ChipmunkColliderType2D::Circle);
} }
} }
WHEN("We construct a compound") WHEN("We construct a compound")
{ {
Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f); Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::BoxCollider2D> box1 = std::make_shared<Nz::BoxCollider2D>(aabb); std::shared_ptr<Nz::ChipmunkBoxCollider2D> box1 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
aabb.Translate(Nz::Vector2f::Unit()); aabb.Translate(Nz::Vector2f::Unit());
std::shared_ptr<Nz::BoxCollider2D> box2 = std::make_shared<Nz::BoxCollider2D>(aabb); std::shared_ptr<Nz::ChipmunkBoxCollider2D> box2 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::vector<std::shared_ptr<Nz::Collider2D>> colliders; std::vector<std::shared_ptr<Nz::ChipmunkCollider2D>> colliders;
colliders.push_back(box1); colliders.push_back(box1);
colliders.push_back(box2); colliders.push_back(box2);
Nz::CompoundCollider2D compound(colliders); Nz::ChipmunkCompoundCollider2D compound(colliders);
THEN("We expect those to be true") 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, 1.f));
vertices.push_back(Nz::Vector2f(1.f, 0.f)); vertices.push_back(Nz::Vector2f(1.f, 0.f));
Nz::ConvexCollider2D convex(Nz::SparsePtr<const Nz::Vector2f>(vertices.data()), vertices.size()); Nz::ChipmunkConvexCollider2D convex(Nz::SparsePtr<const Nz::Vector2f>(vertices.data()), vertices.size());
THEN("We expect those to be true") THEN("We expect those to be true")
{ {
CHECK(convex.GetType() == Nz::ColliderType2D::Convex); CHECK(convex.GetType() == Nz::ChipmunkColliderType2D::Convex);
} }
} }
WHEN("We construct a null") WHEN("We construct a null")
{ {
Nz::NullCollider2D null; Nz::ChipmunkNullCollider2D null;
THEN("We expect those to be true") 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 firstPoint(2.f, 1.f);
Nz::Vector2f secondPoint(-4.f, -3.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") THEN("We expect those to be true")
{ {
CHECK(segment.GetFirstPoint() == firstPoint); CHECK(segment.GetFirstPoint() == firstPoint);
CHECK(segment.GetLength() == Catch::Approx(firstPoint.Distance(secondPoint))); CHECK(segment.GetLength() == Catch::Approx(firstPoint.Distance(secondPoint)));
CHECK(segment.GetSecondPoint() == secondPoint); CHECK(segment.GetSecondPoint() == secondPoint);
CHECK(segment.GetType() == Nz::ColliderType2D::Segment); CHECK(segment.GetType() == Nz::ChipmunkColliderType2D::Segment);
} }
} }
WHEN("We verify general purpose methods") WHEN("We verify general purpose methods")
{ {
Nz::Rectf aabb(5.f, 3.f, 10.f, 6.f); 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 categoryMask = 1;
Nz::UInt32 groupId = 2; Nz::UInt32 groupId = 2;

54
tests/UnitTests/Engine/Physics2D/PhysWorld2DTest.cpp
View File

@ -1,8 +1,8 @@
#include <Nazara/Physics2D/PhysWorld2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <catch2/catch_approx.hpp> #include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp> #include <catch2/catch_test_macros.hpp>
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 collisionGroup = 1;
Nz::UInt32 categoryMask = 2; Nz::UInt32 categoryMask = 2;
@ -12,9 +12,9 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
{ {
GIVEN("A physic world and a bunch of entities on a grid") GIVEN("A physic world and a bunch of entities on a grid")
{ {
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
std::vector<Nz::RigidBody2D> bodies; std::vector<Nz::ChipmunkRigidBody2D> bodies;
const int numberOfBodiesPerLign = 3; const int numberOfBodiesPerLign = 3;
for (int i = 0; i != numberOfBodiesPerLign; ++i) for (int i = 0; i != numberOfBodiesPerLign; ++i)
{ {
@ -28,7 +28,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
WHEN("We ask for the nearest body") 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)); REQUIRE(world.NearestBodyQuery(-Nz::Vector2f::UnitY() * 1.f, 2.f, collisionGroup, categoryMask, collisionMask, &result));
THEN("It should be the one on the origin") 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 origin = -Nz::Vector2f::UnitY() * 2.f;
Nz::Vector2f end = (numberOfBodiesPerLign + 1) * 10.f * Nz::Vector2f::UnitY(); 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)); REQUIRE(world.RaycastQueryFirst(origin, end, 1.f, collisionGroup, categoryMask, collisionMask, &result));
THEN("It should be the one on the origin") 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 origin = -Nz::Vector2f::UnitY() * 2.f;
Nz::Vector2f end = (numberOfBodiesPerLign + 1) * 10.f * Nz::Vector2f::UnitY(); Nz::Vector2f end = (numberOfBodiesPerLign + 1) * 10.f * Nz::Vector2f::UnitY();
std::vector<Nz::PhysWorld2D::RaycastHit> results; std::vector<Nz::ChipmunkPhysWorld2D::RaycastHit> results;
REQUIRE(world.RaycastQuery(origin, end, 1.f, collisionGroup, categoryMask, collisionMask, &results)); REQUIRE(world.RaycastQuery(origin, end, 1.f, collisionGroup, categoryMask, collisionMask, &results));
THEN("It should be the first lign") THEN("It should be the first lign")
@ -79,7 +79,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
for (int i = 0; i != numberOfBodiesPerLign; ++i) 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.nearestBody == &bodies[i]);
CHECK(result.fraction == Catch::Approx(i / 4.f).margin(0.1f)); CHECK(result.fraction == Catch::Approx(i / 4.f).margin(0.1f));
CHECK(result.hitPos == Nz::Vector2f(0.f, i * 10.f)); CHECK(result.hitPos == Nz::Vector2f(0.f, i * 10.f));
@ -90,7 +90,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
WHEN("We ask for a region") WHEN("We ask for a region")
{ {
std::vector<Nz::RigidBody2D*> results; std::vector<Nz::ChipmunkRigidBody2D*> results;
world.RegionQuery(Nz::Rectf(-5.f, -5.f, 5.f, 5.f), collisionGroup, categoryMask, collisionMask, &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") THEN("It should be the one on the origin")
@ -109,53 +109,53 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
int statusTriggerCollision = 0; int statusTriggerCollision = 0;
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
Nz::Rectf characterAABB(0.f, 0.f, 1.f, 1.f); Nz::Rectf characterAABB(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::Collider2D> characterBox = std::make_shared<Nz::BoxCollider2D>(characterAABB); std::shared_ptr<Nz::ChipmunkCollider2D> characterBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(characterAABB);
characterBox->SetCollisionId(CHARACTER_COLLISION_ID); characterBox->SetCollisionId(CHARACTER_COLLISION_ID);
Nz::RigidBody2D character(&world, 1.f, characterBox); Nz::ChipmunkRigidBody2D character(&world, 1.f, characterBox);
character.SetPosition(Nz::Vector2f::Zero()); character.SetPosition(Nz::Vector2f::Zero());
Nz::Rectf wallAABB(0.f, 0.f, 1.f, 2.f); Nz::Rectf wallAABB(0.f, 0.f, 1.f, 2.f);
std::shared_ptr<Nz::Collider2D> wallBox = std::make_shared<Nz::BoxCollider2D>(wallAABB); std::shared_ptr<Nz::ChipmunkCollider2D> wallBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(wallAABB);
wallBox->SetCollisionId(WALL_COLLISION_ID); 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)); wall.SetPosition(Nz::Vector2f(5.f, 0.f));
Nz::Rectf triggerAABB(0.f, 0.f, 1.f, 1.f); Nz::Rectf triggerAABB(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::Collider2D> triggerBox = std::make_shared<Nz::BoxCollider2D>(triggerAABB); std::shared_ptr<Nz::ChipmunkCollider2D> triggerBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(triggerAABB);
triggerBox->SetTrigger(true); triggerBox->SetTrigger(true);
triggerBox->SetCollisionId(TRIGGER_COLLISION_ID); 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)); trigger.SetPosition(Nz::Vector2f(2.f, 0.f));
world.Step(Nz::Time::Zero()); world.Step(Nz::Time::Zero());
Nz::PhysWorld2D::Callback characterTriggerCallback; Nz::ChipmunkPhysWorld2D::Callback characterTriggerCallback;
characterTriggerCallback.startCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool { characterTriggerCallback.startCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool {
statusTriggerCollision = statusTriggerCollision | 1 << 0; statusTriggerCollision = statusTriggerCollision | 1 << 0;
return true; 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; statusTriggerCollision = statusTriggerCollision | 1 << 1;
return true; 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; 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; statusTriggerCollision = statusTriggerCollision | 1 << 3;
}; };
world.RegisterCallbacks(CHARACTER_COLLISION_ID, TRIGGER_COLLISION_ID, characterTriggerCallback); world.RegisterCallbacks(CHARACTER_COLLISION_ID, TRIGGER_COLLISION_ID, characterTriggerCallback);
int statusWallCollision = 0; int statusWallCollision = 0;
Nz::PhysWorld2D::Callback characterWallCallback; Nz::ChipmunkPhysWorld2D::Callback characterWallCallback;
characterWallCallback.startCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool { characterWallCallback.startCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool {
statusWallCollision = statusWallCollision | 1 << 0; statusWallCollision = statusWallCollision | 1 << 0;
return true; 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; statusWallCollision = statusWallCollision | 1 << 1;
}; };
world.RegisterCallbacks(CHARACTER_COLLISION_ID, WALL_COLLISION_ID, characterWallCallback); 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); Nz::Rectf aabb(0.f, 0.f, lengths.x, lengths.y);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb); std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
box->SetCategoryMask(categoryMask); box->SetCategoryMask(categoryMask);
box->SetCollisionMask(collisionMask); box->SetCollisionMask(collisionMask);
float mass = isMoving ? 1.f : 0.f; float mass = isMoving ? 1.f : 0.f;
Nz::RigidBody2D rigidBody(&world, mass, box); Nz::ChipmunkRigidBody2D rigidBody(&world, mass, box);
rigidBody.SetPosition(position); rigidBody.SetPosition(position);
return rigidBody; return rigidBody;
} }

76
tests/UnitTests/Engine/Physics2D/RigidBody2DTest.cpp
View File

@ -1,26 +1,26 @@
#include <Nazara/Physics2D/RigidBody2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <catch2/catch_approx.hpp> #include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp> #include <catch2/catch_test_macros.hpp>
#include <iostream> #include <iostream>
#include <limits> #include <limits>
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world); Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world);
void EQUALITY(const Nz::RigidBody2D& left, const Nz::RigidBody2D& right); void EQUALITY(const Nz::ChipmunkRigidBody2D& left, const Nz::ChipmunkRigidBody2D& right);
void EQUALITY(const Nz::Rectf& left, const Nz::Rectf& right); void EQUALITY(const Nz::Rectf& left, const Nz::Rectf& right);
SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]") SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
{ {
GIVEN("A physic world and a rigid body") GIVEN("A physic world and a rigid body")
{ {
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max()); world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Vector2f positionAABB(3.f, 4.f); Nz::Vector2f positionAABB(3.f, 4.f);
Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f); Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb); std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
float mass = 1.f; float mass = 1.f;
Nz::RigidBody2D body(&world, mass, box); Nz::ChipmunkRigidBody2D body(&world, mass, box);
float angularVelocity = 0.2f; float angularVelocity = 0.2f;
body.SetAngularVelocity(angularVelocity); body.SetAngularVelocity(angularVelocity);
Nz::Vector2f massCenter(5.f, 7.f); Nz::Vector2f massCenter(5.f, 7.f);
@ -39,7 +39,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
WHEN("We copy construct the body") WHEN("We copy construct the body")
{ {
body.AddForce(Nz::Vector2f(3.f, 5.f)); body.AddForce(Nz::Vector2f(3.f, 5.f));
Nz::RigidBody2D copiedBody(body); Nz::ChipmunkRigidBody2D copiedBody(body);
EQUALITY(copiedBody, body); EQUALITY(copiedBody, body);
world.Step(Nz::Time::Second()); world.Step(Nz::Time::Second());
EQUALITY(copiedBody, body); EQUALITY(copiedBody, body);
@ -47,22 +47,22 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
WHEN("We move construct the body") WHEN("We move construct the body")
{ {
Nz::RigidBody2D copiedBody(body); Nz::ChipmunkRigidBody2D copiedBody(body);
Nz::RigidBody2D movedBody(std::move(body)); Nz::ChipmunkRigidBody2D movedBody(std::move(body));
EQUALITY(movedBody, copiedBody); EQUALITY(movedBody, copiedBody);
} }
WHEN("We copy assign the body") WHEN("We copy assign the body")
{ {
Nz::RigidBody2D copiedBody(&world, 0.f); Nz::ChipmunkRigidBody2D copiedBody(&world, 0.f);
copiedBody = body; copiedBody = body;
EQUALITY(copiedBody, body); EQUALITY(copiedBody, body);
} }
WHEN("We move assign the body") WHEN("We move assign the body")
{ {
Nz::RigidBody2D copiedBody(body); Nz::ChipmunkRigidBody2D copiedBody(body);
Nz::RigidBody2D movedBody(&world, 0.f); Nz::ChipmunkRigidBody2D movedBody(&world, 0.f);
movedBody = std::move(body); movedBody = std::move(body);
EQUALITY(movedBody, copiedBody); EQUALITY(movedBody, copiedBody);
} }
@ -70,7 +70,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
WHEN("We set a new geometry") WHEN("We set a new geometry")
{ {
float radius = 5.f; float radius = 5.f;
body.SetGeom(std::make_shared<Nz::CircleCollider2D>(radius)); body.SetGeom(std::make_shared<Nz::ChipmunkCircleCollider2D>(radius));
world.Step(Nz::Time::Second()); world.Step(Nz::Time::Second());
@ -85,14 +85,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world") GIVEN("A physic world")
{ {
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max()); world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Rectf aabb(3.f, 4.f, 1.f, 2.f); Nz::Rectf aabb(3.f, 4.f, 1.f, 2.f);
WHEN("We get a rigid body from a function") WHEN("We get a rigid body from a function")
{ {
std::vector<Nz::RigidBody2D> tmp; std::vector<Nz::ChipmunkRigidBody2D> tmp;
tmp.push_back(CreateBody(world)); tmp.push_back(CreateBody(world));
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") GIVEN("A physic world and a rigid body")
{ {
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max()); world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Vector2f positionAABB(3.f, 4.f); Nz::Vector2f positionAABB(3.f, 4.f);
Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f); Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb); std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
float mass = 1.f; float mass = 1.f;
Nz::RigidBody2D body(&world, mass); Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(box, true, false); body.SetGeom(box, true, false);
bool userData = false; bool userData = false;
@ -211,14 +211,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of circle") GIVEN("A physic world and a rigid body of circle")
{ {
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max()); world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Vector2f position(3.f, 4.f); Nz::Vector2f position(3.f, 4.f);
float radius = 5.f; float radius = 5.f;
std::shared_ptr<Nz::Collider2D> circle = std::make_shared<Nz::CircleCollider2D>(radius, position); std::shared_ptr<Nz::ChipmunkCollider2D> circle = std::make_shared<Nz::ChipmunkCircleCollider2D>(radius, position);
float mass = 1.f; float mass = 1.f;
Nz::RigidBody2D body(&world, mass); Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(circle, true, false); body.SetGeom(circle, true, false);
world.Step(Nz::Time::Second()); world.Step(Nz::Time::Second());
@ -235,21 +235,21 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of compound") GIVEN("A physic world and a rigid body of compound")
{ {
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max()); world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f); Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::BoxCollider2D> box1 = std::make_shared<Nz::BoxCollider2D>(aabb); std::shared_ptr<Nz::ChipmunkBoxCollider2D> box1 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
aabb.Translate(Nz::Vector2f::Unit()); aabb.Translate(Nz::Vector2f::Unit());
std::shared_ptr<Nz::BoxCollider2D> box2 = std::make_shared<Nz::BoxCollider2D>(aabb); std::shared_ptr<Nz::ChipmunkBoxCollider2D> box2 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::vector<std::shared_ptr<Nz::Collider2D>> colliders; std::vector<std::shared_ptr<Nz::ChipmunkCollider2D>> colliders;
colliders.push_back(box1); colliders.push_back(box1);
colliders.push_back(box2); colliders.push_back(box2);
std::shared_ptr<Nz::CompoundCollider2D> compound = std::make_shared<Nz::CompoundCollider2D>(colliders); std::shared_ptr<Nz::ChipmunkCompoundCollider2D> compound = std::make_shared<Nz::ChipmunkCompoundCollider2D>(colliders);
float mass = 1.f; float mass = 1.f;
Nz::RigidBody2D body(&world, mass); Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(compound, true, false); body.SetGeom(compound, true, false);
world.Step(Nz::Time::Second()); world.Step(Nz::Time::Second());
@ -266,7 +266,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of circle") GIVEN("A physic world and a rigid body of circle")
{ {
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max()); world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
std::vector<Nz::Vector2f> vertices; std::vector<Nz::Vector2f> vertices;
@ -276,9 +276,9 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
vertices.emplace_back(1.f, 0.f); vertices.emplace_back(1.f, 0.f);
Nz::SparsePtr<const Nz::Vector2f> sparsePtr(vertices.data()); Nz::SparsePtr<const Nz::Vector2f> sparsePtr(vertices.data());
std::shared_ptr<Nz::ConvexCollider2D> convex = std::make_shared<Nz::ConvexCollider2D>(sparsePtr, vertices.size()); std::shared_ptr<Nz::ChipmunkConvexCollider2D> convex = std::make_shared<Nz::ChipmunkConvexCollider2D>(sparsePtr, vertices.size());
float mass = 1.f; float mass = 1.f;
Nz::RigidBody2D body(&world, mass); Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(convex, true, false); body.SetGeom(convex, true, false);
world.Step(Nz::Time::Second()); world.Step(Nz::Time::Second());
@ -295,14 +295,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of segment") GIVEN("A physic world and a rigid body of segment")
{ {
Nz::PhysWorld2D world; Nz::ChipmunkPhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max()); world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Vector2f positionA(3.f, 4.f); Nz::Vector2f positionA(3.f, 4.f);
Nz::Vector2f positionB(1.f, -4.f); Nz::Vector2f positionB(1.f, -4.f);
std::shared_ptr<Nz::Collider2D> segment = std::make_shared<Nz::SegmentCollider2D>(positionA, positionB, 0.f); std::shared_ptr<Nz::ChipmunkCollider2D> segment = std::make_shared<Nz::ChipmunkSegmentCollider2D>(positionA, positionB, 0.f);
float mass = 1.f; float mass = 1.f;
Nz::RigidBody2D body(&world, mass); Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(segment, true, false); body.SetGeom(segment, true, false);
world.Step(Nz::Time::Second()); 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::Vector2f positionAABB(3.f, 4.f);
Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f); Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb); std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
float mass = 1.f; float mass = 1.f;
Nz::RigidBody2D body(&world, mass, box); Nz::ChipmunkRigidBody2D body(&world, mass, box);
body.SetPosition(Nz::Vector2f::Zero()); body.SetPosition(Nz::Vector2f::Zero());
return body; 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.GetAABB() == right.GetAABB());
CHECK(left.GetAngularVelocity() == right.GetAngularVelocity()); CHECK(left.GetAngularVelocity() == right.GetAngularVelocity());

4
tests/UnitTests/main.cpp
View File

@ -6,12 +6,12 @@
#include <Nazara/Core/AbstractLogger.hpp> #include <Nazara/Core/AbstractLogger.hpp>
#include <Nazara/Core/Modules.hpp> #include <Nazara/Core/Modules.hpp>
#include <Nazara/Network/Network.hpp> #include <Nazara/Network/Network.hpp>
#include <Nazara/Physics2D/Physics2D.hpp> #include <Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp>
#include <Nazara/Utility/Utility.hpp> #include <Nazara/Utility/Utility.hpp>
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
Nz::Modules<Nz::Audio, Nz::Network, Nz::Physics2D, Nz::Utility> nazaza; Nz::Modules<Nz::Audio, Nz::Network, Nz::ChipmunkPhysics2D, Nz::Utility> nazaza;
return Catch::Session().run(argc, argv); return Catch::Session().run(argc, argv);
} }

2
tests/UnitTests/xmake.lua
View File

@ -5,7 +5,7 @@ if is_mode("asan") then
add_defines("CATCH_CONFIG_NO_POSIX_SIGNALS") add_defines("CATCH_CONFIG_NO_POSIX_SIGNALS")
end end
add_deps("NazaraAudio", "NazaraCore", "NazaraNetwork", "NazaraPhysics2D") add_deps("NazaraAudio", "NazaraCore", "NazaraNetwork", "NazaraChipmunkPhysics2D")
add_packages("catch2", "entt") add_packages("catch2", "entt")
add_headerfiles("Engine/**.hpp", { prefixdir = "private", install = false }) add_headerfiles("Engine/**.hpp", { prefixdir = "private", install = false })
add_files("resources.cpp") add_files("resources.cpp")

12
xmake.lua
View File

@ -74,6 +74,11 @@ local modules = {
Deps = {"NazaraUtility"}, Deps = {"NazaraUtility"},
Packages = { "bullet3", "entt" } Packages = { "bullet3", "entt" }
}, },
ChipmunkPhysics2D = {
Option = "chipmunkphysics",
Deps = {"NazaraUtility"},
Packages = { "chipmunk2d", "entt" }
},
Core = { Core = {
Custom = function () Custom = function ()
add_headerfiles("include/(Nazara/*.hpp)") add_headerfiles("include/(Nazara/*.hpp)")
@ -133,11 +138,6 @@ local modules = {
end end
end end
}, },
Physics2D = {
Option = "chipmunkphysics",
Deps = {"NazaraUtility"},
Packages = { "chipmunk2d", "entt" }
},
Platform = { Platform = {
Option = "platform", Option = "platform",
Deps = {"NazaraUtility"}, Deps = {"NazaraUtility"},
@ -232,7 +232,7 @@ end
add_repositories("nazara-engine-repo https://github.com/NazaraEngine/xmake-repo") 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 -- Module dependencies
if has_config("audio") then if has_config("audio") then