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

Rename Physics2D to ChipmunkPhysics2D

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

@@ -26,23 +26,23 @@
#pragma once
#ifndef NAZARA_GLOBAL_PHYSICS2D_HPP
#define NAZARA_GLOBAL_PHYSICS2D_HPP
#ifndef NAZARA_GLOBAL_CHIPMUNKPHYSICS2D_HPP
#define NAZARA_GLOBAL_CHIPMUNKPHYSICS2D_HPP
#include <Nazara/Physics2D/Arbiter2D.hpp>
#include <Nazara/Physics2D/Collider2D.hpp>
#include <Nazara/Physics2D/Config.hpp>
#include <Nazara/Physics2D/Constraint2D.hpp>
#include <Nazara/Physics2D/Enums.hpp>
#include <Nazara/Physics2D/Physics2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <Nazara/ChipmunkPhysics2D/Enums.hpp>
#ifdef NAZARA_ENTT
#include <Nazara/Physics2D/Components.hpp>
#include <Nazara/Physics2D/Systems.hpp>
#include <Nazara/ChipmunkPhysics2D/Components.hpp>
#include <Nazara/ChipmunkPhysics2D/Systems.hpp>
#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
#ifndef NAZARA_PHYSICS2D_ARBITER2D_HPP
#define NAZARA_PHYSICS2D_ARBITER2D_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_ARBITER2D_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_ARBITER2D_HPP
#include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Physics2D/Config.hpp>
#include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <NazaraUtils/MovablePtr.hpp>
struct cpArbiter;
namespace Nz
{
class RigidBody2D;
class ChipmunkRigidBody2D;
class NAZARA_PHYSICS2D_API Arbiter2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkArbiter2D
{
public:
inline Arbiter2D(cpArbiter* arbiter);
Arbiter2D(const Arbiter2D&) = delete;
Arbiter2D(Arbiter2D&&) = default;
~Arbiter2D() = default;
inline ChipmunkArbiter2D(cpArbiter* arbiter);
ChipmunkArbiter2D(const ChipmunkArbiter2D&) = delete;
ChipmunkArbiter2D(ChipmunkArbiter2D&&) = default;
~ChipmunkArbiter2D() = default;
float ComputeTotalKinematicEnergy() const;
Nz::Vector2f ComputeTotalImpulse() const;
std::pair<RigidBody2D*, RigidBody2D*> GetBodies() const;
std::pair<ChipmunkRigidBody2D*, ChipmunkRigidBody2D*> GetBodies() const;
std::size_t GetContactCount() const;
float GetContactDepth(std::size_t i) const;
@@ -48,14 +48,14 @@ namespace Nz
void SetFriction(float friction);
void SetSurfaceVelocity(const Vector2f& surfaceVelocity);
Arbiter2D& operator=(const Arbiter2D&) = delete;
Arbiter2D& operator=(Arbiter2D&&) = default;
ChipmunkArbiter2D& operator=(const ChipmunkArbiter2D&) = delete;
ChipmunkArbiter2D& operator=(ChipmunkArbiter2D&&) = default;
private:
MovablePtr<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
#include <memory>
#include <Nazara/Physics2D/Debug.hpp>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz
{
inline Arbiter2D::Arbiter2D(cpArbiter* arbiter) :
inline ChipmunkArbiter2D::ChipmunkArbiter2D(cpArbiter* 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
#ifndef NAZARA_PHYSICS2D_COLLIDER2D_HPP
#define NAZARA_PHYSICS2D_COLLIDER2D_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_COLLIDER2D_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_COLLIDER2D_HPP
#include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/ObjectLibrary.hpp>
#include <Nazara/Math/Rect.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Physics2D/Config.hpp>
#include <Nazara/Physics2D/Enums.hpp>
#include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <Nazara/ChipmunkPhysics2D/Enums.hpp>
#include <NazaraUtils/Signal.hpp>
#include <NazaraUtils/SparsePtr.hpp>
#include <vector>
@@ -22,18 +22,18 @@ struct cpShape;
namespace Nz
{
class RigidBody2D;
class ChipmunkRigidBody2D;
class NAZARA_PHYSICS2D_API Collider2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCollider2D
{
friend RigidBody2D;
friend class CompoundCollider2D; //< See CompoundCollider2D::CreateShapes
friend ChipmunkRigidBody2D;
friend class ChipmunkCompoundCollider2D; //< See CompoundCollider2D::CreateShapes
public:
inline Collider2D();
Collider2D(const Collider2D&) = delete;
Collider2D(Collider2D&&) = delete;
virtual ~Collider2D();
inline ChipmunkCollider2D();
ChipmunkCollider2D(const ChipmunkCollider2D&) = delete;
ChipmunkCollider2D(ChipmunkCollider2D&&) = delete;
virtual ~ChipmunkCollider2D();
virtual Vector2f ComputeCenterOfMass() const = 0;
virtual float ComputeMomentOfInertia(float mass) const = 0;
@@ -48,7 +48,7 @@ namespace Nz
inline float GetFriction() const;
inline Vector2f GetSurfaceVelocity() const;
virtual ColliderType2D GetType() const = 0;
virtual ChipmunkColliderType2D GetType() const = 0;
inline bool IsTrigger() const;
@@ -61,11 +61,11 @@ namespace Nz
inline void SetSurfaceVelocity(const Vector2f& surfaceVelocity);
inline void SetTrigger(bool trigger);
Collider2D& operator=(const Collider2D&) = delete;
Collider2D& operator=(Collider2D&&) = delete;
ChipmunkCollider2D& operator=(const ChipmunkCollider2D&) = delete;
ChipmunkCollider2D& operator=(ChipmunkCollider2D&&) = delete;
// Signals:
NazaraSignal(OnColliderRelease, const Collider2D* /*collider*/);
NazaraSignal(OnColliderRelease, const ChipmunkCollider2D* /*collider*/);
protected:
virtual std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const = 0;
@@ -83,11 +83,11 @@ namespace Nz
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:
BoxCollider2D(const Vector2f& size, float radius = 0.f);
BoxCollider2D(const Rectf& rect, float radius = 0.f);
ChipmunkBoxCollider2D(const Vector2f& size, float radius = 0.f);
ChipmunkBoxCollider2D(const Rectf& rect, float radius = 0.f);
Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override;
@@ -95,7 +95,7 @@ namespace Nz
inline float GetRadius() const;
inline const Rectf& GetRect() const;
inline Vector2f GetSize() const;
ColliderType2D GetType() const override;
ChipmunkColliderType2D GetType() const override;
private:
std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
@@ -104,17 +104,17 @@ namespace Nz
float m_radius;
};
class NAZARA_PHYSICS2D_API CircleCollider2D : public Collider2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCircleCollider2D : public ChipmunkCollider2D
{
public:
CircleCollider2D(float radius, const Vector2f& offset = Vector2f::Zero());
ChipmunkCircleCollider2D(float radius, const Vector2f& offset = Vector2f::Zero());
Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override;
inline const Vector2f& GetOffset() const;
inline float GetRadius() const;
ColliderType2D GetType() const override;
ChipmunkColliderType2D GetType() const override;
private:
std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
@@ -123,18 +123,18 @@ namespace Nz
float m_radius;
};
class NAZARA_PHYSICS2D_API CompoundCollider2D : public Collider2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkCompoundCollider2D : public ChipmunkCollider2D
{
public:
CompoundCollider2D(std::vector<std::shared_ptr<Collider2D>> geoms);
ChipmunkCompoundCollider2D(std::vector<std::shared_ptr<ChipmunkCollider2D>> geoms);
Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override;
inline bool DoesOverrideCollisionProperties() const;
inline const std::vector<std::shared_ptr<Collider2D>>& GetGeoms() const;
ColliderType2D GetType() const override;
inline const std::vector<std::shared_ptr<ChipmunkCollider2D>>& GetGeoms() const;
ChipmunkColliderType2D GetType() const override;
inline void OverridesCollisionProperties(bool shouldOverride);
@@ -142,19 +142,19 @@ namespace Nz
std::size_t CreateShapes(cpBody* body, std::vector<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;
};
class NAZARA_PHYSICS2D_API ConvexCollider2D : public Collider2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkConvexCollider2D : public ChipmunkCollider2D
{
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;
float ComputeMomentOfInertia(float mass) const override;
ColliderType2D GetType() const override;
ChipmunkColliderType2D GetType() const override;
inline const std::vector<Vector2d>& GetVertices() const;
private:
@@ -164,25 +164,25 @@ namespace Nz
float m_radius;
};
class NAZARA_PHYSICS2D_API NullCollider2D : public Collider2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkNullCollider2D : public ChipmunkCollider2D
{
public:
NullCollider2D() = default;
ChipmunkNullCollider2D() = default;
Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override;
ColliderType2D GetType() const override;
ChipmunkColliderType2D GetType() const override;
private:
std::size_t CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const override;
};
class NAZARA_PHYSICS2D_API SegmentCollider2D : public Collider2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkSegmentCollider2D : public ChipmunkCollider2D
{
public:
inline SegmentCollider2D(const Vector2f& first, const Vector2f& second, float thickness = 1.f);
inline SegmentCollider2D(const Vector2f& first, const Vector2f& firstNeighbor, const Vector2f& second, const Vector2f& secondNeighbor, float thickness = 1.f);
inline ChipmunkSegmentCollider2D(const Vector2f& first, const Vector2f& second, float thickness = 1.f);
inline ChipmunkSegmentCollider2D(const Vector2f& first, const Vector2f& firstNeighbor, const Vector2f& second, const Vector2f& secondNeighbor, float thickness = 1.f);
Nz::Vector2f ComputeCenterOfMass() const override;
float ComputeMomentOfInertia(float mass) const override;
@@ -193,7 +193,7 @@ namespace Nz
inline const Vector2f& GetSecondPoint() const;
inline const Vector2f& GetSecondPointNeighbor() const;
inline float GetThickness() const;
ColliderType2D GetType() const override;
ChipmunkColliderType2D GetType() const override;
private:
std::size_t CreateShapes(cpBody* body, std::vector<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
#include <memory>
#include <Nazara/Physics2D/Debug.hpp>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
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
#ifndef NAZARA_PHYSICS2D_PHYSWORLD2D_HPP
#define NAZARA_PHYSICS2D_PHYSWORLD2D_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_PHYSWORLD2D_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_PHYSWORLD2D_HPP
#include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/Color.hpp>
#include <Nazara/Core/Time.hpp>
#include <Nazara/Math/Angle.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Physics2D/Config.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp>
#include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <NazaraUtils/FunctionRef.hpp>
#include <NazaraUtils/Signal.hpp>
#include <functional>
@@ -25,23 +25,23 @@ struct cpSpace;
namespace Nz
{
class Arbiter2D;
class ChipmunkArbiter2D;
class NAZARA_PHYSICS2D_API PhysWorld2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPhysWorld2D
{
friend RigidBody2D;
friend ChipmunkRigidBody2D;
using ContactEndCallback = std::function<void(PhysWorld2D& world, Arbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)>;
using ContactPreSolveCallback = std::function<bool(PhysWorld2D& world, Arbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)>;
using ContactPostSolveCallback = std::function<void(PhysWorld2D& world, Arbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)>;
using ContactStartCallback = std::function<bool(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(ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)>;
using ContactPostSolveCallback = std::function<void(ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& 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 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 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 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:
struct Callback;
@@ -49,10 +49,10 @@ namespace Nz
struct NearestQueryResult;
struct RaycastHit;
PhysWorld2D();
PhysWorld2D(const PhysWorld2D&) = delete;
PhysWorld2D(PhysWorld2D&&) = delete; ///TODO
~PhysWorld2D();
ChipmunkPhysWorld2D();
ChipmunkPhysWorld2D(const ChipmunkPhysWorld2D&) = delete;
ChipmunkPhysWorld2D(ChipmunkPhysWorld2D&&) = delete; ///TODO
~ChipmunkPhysWorld2D();
void DebugDraw(const DebugDrawOptions& options, bool drawShapes = true, bool drawConstraints = true, bool drawCollisions = true);
@@ -63,15 +63,15 @@ namespace Nz
std::size_t GetMaxStepCount() const;
Time GetStepSize() const;
bool NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RigidBody2D** nearestBody = nullptr);
bool NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, ChipmunkRigidBody2D** nearestBody = nullptr);
bool NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, NearestQueryResult* result);
void RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<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 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, std::vector<RigidBody2D*>* bodies);
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<ChipmunkRigidBody2D*>* bodies);
void RegisterCallbacks(unsigned int collisionId, Callback callbacks);
void RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, Callback callbacks);
@@ -87,8 +87,8 @@ namespace Nz
void UseSpatialHash(float cellSize, std::size_t entityCount);
PhysWorld2D& operator=(const PhysWorld2D&) = delete;
PhysWorld2D& operator=(PhysWorld2D&&) = delete; ///TODO
ChipmunkPhysWorld2D& operator=(const ChipmunkPhysWorld2D&) = delete;
ChipmunkPhysWorld2D& operator=(ChipmunkPhysWorld2D&&) = delete; ///TODO
struct Callback
{
@@ -117,7 +117,7 @@ namespace Nz
struct NearestQueryResult
{
RigidBody2D* nearestBody;
ChipmunkRigidBody2D* nearestBody;
Vector2f closestPoint;
Vector2f fraction;
float distance;
@@ -125,29 +125,29 @@ namespace Nz
struct RaycastHit
{
RigidBody2D* nearestBody;
ChipmunkRigidBody2D* nearestBody;
Vector2f hitPos;
Vector2f hitNormal;
float fraction;
};
NazaraSignal(OnPhysWorld2DPreStep, const PhysWorld2D* /*physWorld*/, float /*invStepCount*/);
NazaraSignal(OnPhysWorld2DPostStep, const PhysWorld2D* /*physWorld*/, float /*invStepCount*/);
NazaraSignal(OnPhysWorld2DPreStep, const ChipmunkPhysWorld2D* /*physWorld*/, float /*invStepCount*/);
NazaraSignal(OnPhysWorld2DPostStep, const ChipmunkPhysWorld2D* /*physWorld*/, float /*invStepCount*/);
private:
void InitCallbacks(cpCollisionHandler* handler, Callback callbacks);
using PostStep = std::function<void(RigidBody2D* body)>;
using PostStep = std::function<void(ChipmunkRigidBody2D* body)>;
void OnRigidBodyMoved(RigidBody2D* oldPointer, RigidBody2D* newPointer);
void OnRigidBodyRelease(RigidBody2D* rigidBody);
void OnRigidBodyMoved(ChipmunkRigidBody2D* oldPointer, ChipmunkRigidBody2D* newPointer);
void OnRigidBodyRelease(ChipmunkRigidBody2D* rigidBody);
void RegisterPostStep(RigidBody2D* rigidBody, PostStep&& func);
void RegisterPostStep(ChipmunkRigidBody2D* rigidBody, PostStep&& func);
struct PostStepContainer
{
NazaraSlot(RigidBody2D, OnRigidBody2DMove, onMovedSlot);
NazaraSlot(RigidBody2D, OnRigidBody2DRelease, onReleaseSlot);
NazaraSlot(ChipmunkRigidBody2D, OnRigidBody2DMove, onMovedSlot);
NazaraSlot(ChipmunkRigidBody2D, OnRigidBody2DRelease, onReleaseSlot);
std::vector<PostStep> funcs;
};
@@ -156,11 +156,11 @@ namespace Nz
std::size_t m_maxStepCount;
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;
Time m_stepSize;
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
#ifndef NAZARA_PHYSICS2D_HPP
#define NAZARA_PHYSICS2D_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_HPP
#include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/Core.hpp>
#include <Nazara/Physics2D/Config.hpp>
#include <Nazara/ChipmunkPhysics2D/Config.hpp>
namespace Nz
{
class NAZARA_PHYSICS2D_API Physics2D : public ModuleBase<Physics2D>
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkPhysics2D : public ModuleBase<ChipmunkPhysics2D>
{
friend ModuleBase;
@@ -22,12 +22,12 @@ namespace Nz
struct Config {};
Physics2D(Config /*config*/);
~Physics2D() = default;
ChipmunkPhysics2D(Config /*config*/);
~ChipmunkPhysics2D() = default;
private:
static Physics2D* s_instance;
static ChipmunkPhysics2D* s_instance;
};
}
#endif // NAZARA_PHYSICS2D_HPP
#endif // NAZARA_CHIPMUNKPHYSICS2D_HPP

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

@@ -4,15 +4,15 @@
#pragma once
#ifndef NAZARA_PHYSICS2D_RIGIDBODY2D_HPP
#define NAZARA_PHYSICS2D_RIGIDBODY2D_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_RIGIDBODY2D_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_RIGIDBODY2D_HPP
#include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Core/Enums.hpp>
#include <Nazara/Math/Angle.hpp>
#include <Nazara/Math/Rect.hpp>
#include <Nazara/Physics2D/Collider2D.hpp>
#include <Nazara/Physics2D/Config.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp>
#include <Nazara/ChipmunkPhysics2D/Config.hpp>
#include <NazaraUtils/Signal.hpp>
#include <functional>
#include <limits>
@@ -21,19 +21,19 @@ struct cpBody;
namespace Nz
{
class Arbiter2D;
class PhysWorld2D;
class ChipmunkArbiter2D;
class ChipmunkPhysWorld2D;
class NAZARA_PHYSICS2D_API RigidBody2D
class NAZARA_CHIPMUNKPHYSICS2D_API ChipmunkRigidBody2D
{
public:
using VelocityFunc = std::function<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);
RigidBody2D(PhysWorld2D* world, float mass, std::shared_ptr<Collider2D> geom);
RigidBody2D(const RigidBody2D& object);
RigidBody2D(RigidBody2D&& object) noexcept;
~RigidBody2D();
ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass);
ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass, std::shared_ptr<ChipmunkCollider2D> geom);
ChipmunkRigidBody2D(const ChipmunkRigidBody2D& object);
ChipmunkRigidBody2D(ChipmunkRigidBody2D&& object) noexcept;
~ChipmunkRigidBody2D();
void AddForce(const Vector2f& force, CoordSys coordSys = CoordSys::Global);
void AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys = CoordSys::Global);
@@ -45,7 +45,7 @@ namespace Nz
void EnableSimulation(bool simulation);
void ForEachArbiter(std::function<void(Arbiter2D& /*arbiter*/)> callback);
void ForEachArbiter(std::function<void(ChipmunkArbiter2D& /*arbiter*/)> callback);
void ForceSleep();
Rectf GetAABB() const;
@@ -55,7 +55,7 @@ namespace Nz
inline Vector2f GetCenterOfGravity(CoordSys coordSys = CoordSys::Local) const;
float GetElasticity(std::size_t shapeIndex = 0) const;
float GetFriction(std::size_t shapeIndex = 0) const;
const std::shared_ptr<Collider2D>& GetGeom() const;
const std::shared_ptr<ChipmunkCollider2D>& GetGeom() const;
cpBody* GetHandle() const;
float GetMass() const;
Vector2f GetMassCenter(CoordSys coordSys = CoordSys::Local) const;
@@ -69,7 +69,7 @@ namespace Nz
void* GetUserdata() const;
Vector2f GetVelocity() const;
const VelocityFunc& GetVelocityFunction() const;
PhysWorld2D* GetWorld() const;
ChipmunkPhysWorld2D* GetWorld() const;
bool IsKinematic() const;
bool IsSimulationEnabled() const;
@@ -84,7 +84,7 @@ namespace Nz
void SetElasticity(std::size_t shapeIndex, float elasticity);
void SetFriction(float friction);
void SetFriction(std::size_t shapeIndex, float friction);
void SetGeom(std::shared_ptr<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 SetMassCenter(const Vector2f& center, CoordSys coordSys = CoordSys::Local);
void SetMomentOfInertia(float moment);
@@ -104,11 +104,11 @@ namespace Nz
void Wakeup();
RigidBody2D& operator=(const RigidBody2D& object);
RigidBody2D& operator=(RigidBody2D&& object);
ChipmunkRigidBody2D& operator=(const ChipmunkRigidBody2D& object);
ChipmunkRigidBody2D& operator=(ChipmunkRigidBody2D&& object);
NazaraSignal(OnRigidBody2DMove, RigidBody2D* /*oldPointer*/, RigidBody2D* /*newPointer*/);
NazaraSignal(OnRigidBody2DRelease, RigidBody2D* /*rigidBody*/);
NazaraSignal(OnRigidBody2DMove, ChipmunkRigidBody2D* /*oldPointer*/, ChipmunkRigidBody2D* /*newPointer*/);
NazaraSignal(OnRigidBody2DRelease, ChipmunkRigidBody2D* /*rigidBody*/);
static constexpr std::size_t InvalidShapeIndex = std::numeric_limits<std::size_t>::max();
@@ -126,10 +126,10 @@ namespace Nz
Vector2f m_positionOffset;
VelocityFunc m_velocityFunc;
std::vector<cpShape*> m_shapes;
std::shared_ptr<Collider2D> m_geom;
std::shared_ptr<ChipmunkCollider2D> m_geom;
cpBody* m_handle;
void* m_userData;
PhysWorld2D* m_world;
ChipmunkPhysWorld2D* m_world;
bool m_isRegistered;
bool m_isSimulationEnabled;
bool m_isStatic;
@@ -138,6 +138,6 @@ namespace Nz
};
}
#include <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
#ifndef NAZARA_PHYSICS2D_COMPONENTS_HPP
#define NAZARA_PHYSICS2D_COMPONENTS_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_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"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/Debug.hpp>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
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
#ifndef NAZARA_PHYSICS2D_CONFIG_HPP
#define NAZARA_PHYSICS2D_CONFIG_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_CONFIG_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_CONFIG_HPP
/// Chaque modification d'un paramètre du module nécessite une recompilation de celui-ci
// Active les tests de sécurité basés sur le code (Conseillé pour le développement)
#define NAZARA_PHYSICS2D_SAFE 1
#define NAZARA_CHIPMUNKPHYSICS2D_SAFE 1
/// Vérification des valeurs et types de certaines constantes
#include <Nazara/Physics2D/ConfigCheck.hpp>
#include <Nazara/ChipmunkPhysics2D/ConfigCheck.hpp>
#if defined(NAZARA_STATIC)
#define NAZARA_PHYSICS2D_API
#define NAZARA_CHIPMUNKPHYSICS2D_API
#else
#ifdef NAZARA_PHYSICS2D_BUILD
#define NAZARA_PHYSICS2D_API NAZARA_EXPORT
#ifdef NAZARA_CHIPMUNKPHYSICS2D_BUILD
#define NAZARA_CHIPMUNKPHYSICS2D_API NAZARA_EXPORT
#else
#define NAZARA_PHYSICS2D_API NAZARA_IMPORT
#define NAZARA_CHIPMUNKPHYSICS2D_API NAZARA_IMPORT
#endif
#endif
#endif // NAZARA_PHYSICS2D_CONFIG_HPP
#endif // NAZARA_CHIPMUNKPHYSICS2D_CONFIG_HPP

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

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

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
#ifndef NAZARA_PHYSICS2D_ENUMS_HPP
#define NAZARA_PHYSICS2D_ENUMS_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP
namespace Nz
{
enum class ColliderType2D
enum class ChipmunkColliderType2D
{
Box,
Compound,
@@ -22,4 +22,4 @@ namespace Nz
};
}
#endif // NAZARA_PHYSICS2D_ENUMS_HPP
#endif // NAZARA_CHIPMUNKPHYSICS2D_ENUMS_HPP

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

@@ -26,9 +26,9 @@
#pragma once
#ifndef NAZARA_PHYSICS2D_SYSTEMS_HPP
#define NAZARA_PHYSICS2D_SYSTEMS_HPP
#ifndef NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_SYSTEMS_HPP
#include <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>