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

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

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

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"
// 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/Physics2D/PhysWorld2D.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <NazaraUtils/CallOnExit.hpp>
#include <NazaraUtils/StackArray.hpp>
#include <chipmunk/chipmunk.h>
#include <chipmunk/chipmunk_structs.h>
#include <array>
#include <Nazara/Physics2D/Debug.hpp>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
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
// A better way to do this would be to reimplement this function in every subclass type in the very same way chipmunk does
@@ -133,7 +133,7 @@ namespace Nz
cpSpaceDebugDraw(space, &drawOptions);
}
std::size_t Collider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
std::size_t ChipmunkCollider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{
std::size_t shapeCount = CreateShapes(body, shapes);
@@ -155,33 +155,33 @@ namespace Nz
/******************************** BoxCollider2D *********************************/
BoxCollider2D::BoxCollider2D(const Vector2f& size, float radius) :
BoxCollider2D(Rectf(-size.x / 2.f, -size.y / 2.f, size.x, size.y), radius)
ChipmunkBoxCollider2D::ChipmunkBoxCollider2D(const Vector2f& size, float radius) :
ChipmunkBoxCollider2D(Rectf(-size.x / 2.f, -size.y / 2.f, size.x, size.y), radius)
{
}
BoxCollider2D::BoxCollider2D(const Rectf& rect, float radius) :
ChipmunkBoxCollider2D::ChipmunkBoxCollider2D(const Rectf& rect, float radius) :
m_rect(rect),
m_radius(radius)
{
}
Vector2f BoxCollider2D::ComputeCenterOfMass() const
Vector2f ChipmunkBoxCollider2D::ComputeCenterOfMass() const
{
return m_rect.GetCenter();
}
float BoxCollider2D::ComputeMomentOfInertia(float mass) const
float ChipmunkBoxCollider2D::ComputeMomentOfInertia(float mass) const
{
return SafeCast<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));
return 1;
@@ -189,28 +189,28 @@ namespace Nz
/******************************** CircleCollider2D *********************************/
CircleCollider2D::CircleCollider2D(float radius, const Vector2f& offset) :
ChipmunkCircleCollider2D::ChipmunkCircleCollider2D(float radius, const Vector2f& offset) :
m_offset(offset),
m_radius(radius)
{
}
Vector2f CircleCollider2D::ComputeCenterOfMass() const
Vector2f ChipmunkCircleCollider2D::ComputeCenterOfMass() const
{
return m_offset;
}
float CircleCollider2D::ComputeMomentOfInertia(float mass) const
float ChipmunkCircleCollider2D::ComputeMomentOfInertia(float mass) const
{
return SafeCast<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)));
return 1;
@@ -218,13 +218,13 @@ namespace Nz
/******************************** 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_doesOverrideCollisionProperties(true)
{
}
Vector2f CompoundCollider2D::ComputeCenterOfMass() const
Vector2f ChipmunkCompoundCollider2D::ComputeCenterOfMass() const
{
Vector2f centerOfMass = Vector2f::Zero();
for (const auto& geom : m_geoms)
@@ -233,7 +233,7 @@ namespace Nz
return centerOfMass / float(m_geoms.size());
}
float CompoundCollider2D::ComputeMomentOfInertia(float mass) const
float ChipmunkCompoundCollider2D::ComputeMomentOfInertia(float mass) const
{
///TODO: Correctly compute moment using parallel axis theorem:
/// https://chipmunk-physics.net/forum/viewtopic.php?t=1056
@@ -244,12 +244,12 @@ namespace Nz
return momentOfInertia;
}
ColliderType2D CompoundCollider2D::GetType() const
ChipmunkColliderType2D ChipmunkCompoundCollider2D::GetType() const
{
return ColliderType2D::Compound;
return ChipmunkColliderType2D::Compound;
}
std::size_t CompoundCollider2D::CreateShapes(cpBody* body, std::vector<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
@@ -260,11 +260,11 @@ namespace Nz
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
if (m_doesOverrideCollisionProperties)
return Collider2D::GenerateShapes(body, shapes);
return ChipmunkCollider2D::GenerateShapes(body, shapes);
else
{
std::size_t shapeCount = 0;
@@ -277,7 +277,7 @@ namespace Nz
/******************************** ConvexCollider2D *********************************/
ConvexCollider2D::ConvexCollider2D(SparsePtr<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_vertices.resize(vertexCount);
@@ -285,7 +285,7 @@ namespace Nz
m_vertices[i].Set(*vertices++);
}
Vector2f ConvexCollider2D::ComputeCenterOfMass() const
Vector2f ChipmunkConvexCollider2D::ComputeCenterOfMass() const
{
static_assert(sizeof(cpVect) == sizeof(Vector2d), "Chipmunk vector is not equivalent to Vector2d");
@@ -294,19 +294,19 @@ namespace Nz
return Vector2f(float(center.x), float(center.y));
}
float ConvexCollider2D::ComputeMomentOfInertia(float mass) const
float ChipmunkConvexCollider2D::ComputeMomentOfInertia(float mass) const
{
static_assert(sizeof(cpVect) == sizeof(Vector2d), "Chipmunk vector is not equivalent to Vector2d");
return SafeCast<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));
return 1;
@@ -314,44 +314,44 @@ namespace Nz
/********************************* NullCollider2D **********************************/
ColliderType2D NullCollider2D::GetType() const
ChipmunkColliderType2D ChipmunkNullCollider2D::GetType() const
{
return ColliderType2D::Null;
return ChipmunkColliderType2D::Null;
}
Vector2f NullCollider2D::ComputeCenterOfMass() const
Vector2f ChipmunkNullCollider2D::ComputeCenterOfMass() const
{
return Vector2f::Zero();
}
float NullCollider2D::ComputeMomentOfInertia(float mass) const
float ChipmunkNullCollider2D::ComputeMomentOfInertia(float mass) const
{
return (mass > 0.f) ? 1.f : 0.f; //< Null inertia is only possible for static/kinematic objects
}
std::size_t NullCollider2D::CreateShapes(cpBody* /*body*/, std::vector<cpShape*>* /*shapes*/) const
std::size_t ChipmunkNullCollider2D::CreateShapes(cpBody* /*body*/, std::vector<cpShape*>* /*shapes*/) const
{
return 0;
}
/******************************** SegmentCollider2D *********************************/
Vector2f SegmentCollider2D::ComputeCenterOfMass() const
Vector2f ChipmunkSegmentCollider2D::ComputeCenterOfMass() const
{
return (m_first + m_second) / 2.f;
}
float SegmentCollider2D::ComputeMomentOfInertia(float mass) const
float ChipmunkSegmentCollider2D::ComputeMomentOfInertia(float mass) const
{
return SafeCast<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);
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"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <Nazara/Physics2D/Arbiter2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <NazaraUtils/StackArray.hpp>
#include <chipmunk/chipmunk.h>
#include <Nazara/Physics2D/Debug.hpp>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz
{
@@ -24,21 +24,21 @@ namespace Nz
void CpCircleCallback(cpVect pos, cpFloat angle, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata)
{
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->circleCallback)
drawOptions->circleCallback(Vector2f(float(pos.x), float(pos.y)), RadianAnglef(float(angle)), float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata);
}
void CpDotCallback(cpFloat size, cpVect pos, cpSpaceDebugColor color, cpDataPointer userdata)
{
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->dotCallback)
drawOptions->dotCallback(Vector2f(float(pos.x), float(pos.y)), float(size), CpDebugColorToColor(color), drawOptions->userdata);
}
void CpPolygonCallback(int vertexCount, const cpVect* vertices, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata)
{
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->polygonCallback)
{
//TODO: constexpr if to prevent copy/cast if sizeof(cpVect) == sizeof(Vector2f)
@@ -53,24 +53,24 @@ namespace Nz
void CpSegmentCallback(cpVect a, cpVect b, cpSpaceDebugColor color, cpDataPointer userdata)
{
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->segmentCallback)
drawOptions->segmentCallback(Vector2f(float(a.x), float(a.y)), Vector2f(float(b.x), float(b.y)), CpDebugColorToColor(color), drawOptions->userdata);
}
void CpThickSegmentCallback(cpVect a, cpVect b, cpFloat radius, cpSpaceDebugColor outlineColor, cpSpaceDebugColor fillColor, cpDataPointer userdata)
{
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->thickSegmentCallback)
drawOptions->thickSegmentCallback(Vector2f(float(a.x), float(a.y)), Vector2f(float(b.x), float(b.y)), float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata);
}
cpSpaceDebugColor CpShapeColorCallback(cpShape* shape, cpDataPointer userdata)
{
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
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));
}
else
@@ -78,7 +78,7 @@ namespace Nz
}
}
PhysWorld2D::PhysWorld2D() :
ChipmunkPhysWorld2D::ChipmunkPhysWorld2D() :
m_maxStepCount(50),
m_stepSize(Time::TickDuration(200)),
m_timestepAccumulator(Time::Zero())
@@ -87,12 +87,12 @@ namespace Nz
cpSpaceSetUserData(m_handle, this);
}
PhysWorld2D::~PhysWorld2D()
ChipmunkPhysWorld2D::~ChipmunkPhysWorld2D()
{
cpSpaceFree(m_handle);
}
void PhysWorld2D::DebugDraw(const DebugDrawOptions& options, bool drawShapes, bool drawConstraints, bool drawCollisions)
void ChipmunkPhysWorld2D::DebugDraw(const DebugDrawOptions& options, bool drawShapes, bool drawConstraints, bool drawCollisions)
{
auto ColorToCpDebugColor = [](Color c) -> cpSpaceDebugColor
{
@@ -128,45 +128,45 @@ namespace Nz
cpSpaceDebugDraw(m_handle, &drawOptions);
}
float PhysWorld2D::GetDamping() const
float ChipmunkPhysWorld2D::GetDamping() const
{
return float(cpSpaceGetDamping(m_handle));
}
Vector2f PhysWorld2D::GetGravity() const
Vector2f ChipmunkPhysWorld2D::GetGravity() const
{
cpVect gravity = cpSpaceGetGravity(m_handle);
return Vector2f(Vector2<cpFloat>(gravity.x, gravity.y));
}
cpSpace* PhysWorld2D::GetHandle() const
cpSpace* ChipmunkPhysWorld2D::GetHandle() const
{
return m_handle;
}
std::size_t PhysWorld2D::GetIterationCount() const
std::size_t ChipmunkPhysWorld2D::GetIterationCount() const
{
return cpSpaceGetIterations(m_handle);
}
std::size_t PhysWorld2D::GetMaxStepCount() const
std::size_t ChipmunkPhysWorld2D::GetMaxStepCount() const
{
return m_maxStepCount;
}
Time PhysWorld2D::GetStepSize() const
Time ChipmunkPhysWorld2D::GetStepSize() const
{
return m_stepSize;
}
bool PhysWorld2D::NearestBodyQuery(const Vector2f & from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RigidBody2D** nearestBody)
bool ChipmunkPhysWorld2D::NearestBodyQuery(const Vector2f & from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, ChipmunkRigidBody2D** nearestBody)
{
cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask);
if (cpShape* shape = cpSpacePointQueryNearest(m_handle, {from.x, from.y}, maxDistance, filter, nullptr))
{
if (nearestBody)
*nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(shape));
*nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
return true;
}
@@ -174,7 +174,7 @@ namespace Nz
return false;
}
bool PhysWorld2D::NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, NearestQueryResult* result)
bool ChipmunkPhysWorld2D::NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, NearestQueryResult* result)
{
cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask);
@@ -187,7 +187,7 @@ namespace Nz
result->closestPoint.Set(Vector2<cpFloat>(queryInfo.point.x, queryInfo.point.y));
result->distance = float(queryInfo.distance);
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;
}
@@ -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)>;
@@ -215,7 +215,7 @@ namespace Nz
hitInfo.fraction = float(alpha);
hitInfo.hitNormal.Set(Vector2<cpFloat>(normal.x, normal.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);
};
@@ -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)));
}
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);
@@ -236,7 +236,7 @@ namespace Nz
hitInfo.fraction = float(alpha);
hitInfo.hitNormal.Set(Vector2<cpFloat>(normal.x, normal.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));
};
@@ -249,7 +249,7 @@ namespace Nz
return hitInfos->size() != previousSize;
}
bool PhysWorld2D::RaycastQueryFirst(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RaycastHit* hitInfo)
bool ChipmunkPhysWorld2D::RaycastQueryFirst(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RaycastHit* hitInfo)
{
cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask);
@@ -262,7 +262,7 @@ namespace Nz
hitInfo->fraction = float(queryInfo.alpha);
hitInfo->hitNormal.Set(Vector2<cpFloat>(queryInfo.normal.x, queryInfo.normal.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;
}
@@ -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)>;
auto cpCallback = [](cpShape* shape, void* 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);
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);
auto callback = [] (cpShape* shape, void* 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);
cpSpaceBBQuery(m_handle, cpBBNew(boundingBox.x, boundingBox.y, boundingBox.x + boundingBox.width, boundingBox.y + boundingBox.height), filter, callback, bodies);
}
void PhysWorld2D::RegisterCallbacks(unsigned int collisionId, Callback callbacks)
void ChipmunkPhysWorld2D::RegisterCallbacks(unsigned int collisionId, Callback callbacks)
{
InitCallbacks(cpSpaceAddWildcardHandler(m_handle, collisionId), std::move(callbacks));
}
void PhysWorld2D::RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, Callback callbacks)
void ChipmunkPhysWorld2D::RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, Callback callbacks)
{
InitCallbacks(cpSpaceAddCollisionHandler(m_handle, collisionIdA, collisionIdB), std::move(callbacks));
}
void PhysWorld2D::SetDamping(float dampingValue)
void ChipmunkPhysWorld2D::SetDamping(float dampingValue)
{
cpSpaceSetDamping(m_handle, dampingValue);
}
void PhysWorld2D::SetGravity(const Vector2f& gravity)
void ChipmunkPhysWorld2D::SetGravity(const Vector2f& gravity)
{
cpSpaceSetGravity(m_handle, cpv(gravity.x, gravity.y));
}
void PhysWorld2D::SetIterationCount(std::size_t iterationCount)
void ChipmunkPhysWorld2D::SetIterationCount(std::size_t iterationCount)
{
cpSpaceSetIterations(m_handle, SafeCast<int>(iterationCount));
}
void PhysWorld2D::SetMaxStepCount(std::size_t maxStepCount)
void ChipmunkPhysWorld2D::SetMaxStepCount(std::size_t maxStepCount)
{
m_maxStepCount = maxStepCount;
}
void PhysWorld2D::SetSleepTime(Time sleepTime)
void ChipmunkPhysWorld2D::SetSleepTime(Time sleepTime)
{
if (sleepTime > Time::Zero())
cpSpaceSetSleepTimeThreshold(m_handle, sleepTime.AsSeconds<cpFloat>());
@@ -344,12 +344,12 @@ namespace Nz
cpSpaceSetSleepTimeThreshold(m_handle, std::numeric_limits<cpFloat>::infinity());
}
void PhysWorld2D::SetStepSize(Time stepSize)
void ChipmunkPhysWorld2D::SetStepSize(Time stepSize)
{
m_stepSize = stepSize;
}
void PhysWorld2D::Step(Time timestep)
void ChipmunkPhysWorld2D::Step(Time timestep)
{
m_timestepAccumulator += timestep;
@@ -379,12 +379,12 @@ namespace Nz
}
}
void PhysWorld2D::UseSpatialHash(float cellSize, std::size_t entityCount)
void ChipmunkPhysWorld2D::UseSpatialHash(float cellSize, std::size_t entityCount)
{
cpSpaceUseSpatialHash(m_handle, cpFloat(cellSize), int(entityCount));
}
void PhysWorld2D::InitCallbacks(cpCollisionHandler* handler, Callback callbacks)
void ChipmunkPhysWorld2D::InitCallbacks(cpCollisionHandler* handler, Callback callbacks)
{
auto it = m_callbacks.find(handler);
if (it == m_callbacks.end())
@@ -403,11 +403,11 @@ namespace Nz
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
Arbiter2D arbiter(arb);
ChipmunkArbiter2D arbiter(arb);
const Callback* customCallbacks = static_cast<const Callback*>(data);
if (customCallbacks->startCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata))
@@ -432,11 +432,11 @@ namespace Nz
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
Arbiter2D arbiter(arb);
ChipmunkArbiter2D arbiter(arb);
const Callback* customCallbacks = static_cast<const Callback*>(data);
customCallbacks->endCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata);
@@ -457,11 +457,11 @@ namespace Nz
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
Arbiter2D arbiter(arb);
ChipmunkArbiter2D arbiter(arb);
const Callback* customCallbacks = static_cast<const Callback*>(data);
if (customCallbacks->preSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata))
@@ -486,11 +486,11 @@ namespace Nz
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
Arbiter2D arbiter(arb);
ChipmunkArbiter2D arbiter(arb);
const Callback* customCallbacks = static_cast<const Callback*>(data);
customCallbacks->postSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata);
@@ -504,7 +504,7 @@ namespace Nz
}
}
void PhysWorld2D::OnRigidBodyMoved(RigidBody2D* oldPointer, RigidBody2D* newPointer)
void ChipmunkPhysWorld2D::OnRigidBodyMoved(ChipmunkRigidBody2D* oldPointer, ChipmunkRigidBody2D* newPointer)
{
auto it = m_rigidPostSteps.find(oldPointer);
if (it == m_rigidPostSteps.end())
@@ -514,12 +514,12 @@ namespace Nz
m_rigidPostSteps.erase(oldPointer);
}
void PhysWorld2D::OnRigidBodyRelease(RigidBody2D* rigidBody)
void ChipmunkPhysWorld2D::OnRigidBodyRelease(ChipmunkRigidBody2D* rigidBody)
{
m_rigidPostSteps.erase(rigidBody);
}
void PhysWorld2D::RegisterPostStep(RigidBody2D* rigidBody, PostStep&& func)
void ChipmunkPhysWorld2D::RegisterPostStep(ChipmunkRigidBody2D* rigidBody, PostStep&& func)
{
// If space isn't locked, no need to wait
if (!cpSpaceIsLocked(m_handle))
@@ -532,8 +532,8 @@ namespace Nz
if (it == m_rigidPostSteps.end())
{
PostStepContainer postStep;
postStep.onMovedSlot.Connect(rigidBody->OnRigidBody2DMove, this, &PhysWorld2D::OnRigidBodyMoved);
postStep.onReleaseSlot.Connect(rigidBody->OnRigidBody2DRelease, this, &PhysWorld2D::OnRigidBodyRelease);
postStep.onMovedSlot.Connect(rigidBody->OnRigidBody2DMove, this, &ChipmunkPhysWorld2D::OnRigidBodyMoved);
postStep.onReleaseSlot.Connect(rigidBody->OnRigidBody2DRelease, this, &ChipmunkPhysWorld2D::OnRigidBodyRelease);
it = m_rigidPostSteps.insert(std::make_pair(rigidBody, std::move(postStep))).first;
}

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"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics2D/RigidBody2D.hpp>
#include <Nazara/Physics2D/Arbiter2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <chipmunk/chipmunk.h>
#include <chipmunk/chipmunk_private.h>
#include <algorithm>
#include <cmath>
#include <Nazara/Physics2D/Debug.hpp>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz
{
RigidBody2D::RigidBody2D(PhysWorld2D* world, float mass) :
RigidBody2D(world, mass, nullptr)
ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass) :
ChipmunkRigidBody2D(world, mass, nullptr)
{
}
RigidBody2D::RigidBody2D(PhysWorld2D* world, float mass, std::shared_ptr<Collider2D> geom) :
ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkPhysWorld2D* world, float mass, std::shared_ptr<ChipmunkCollider2D> geom) :
m_positionOffset(Vector2f::Zero()),
m_geom(),
m_userData(nullptr),
@@ -35,7 +35,7 @@ namespace Nz
SetGeom(std::move(geom));
}
RigidBody2D::RigidBody2D(const RigidBody2D& object) :
ChipmunkRigidBody2D::ChipmunkRigidBody2D(const ChipmunkRigidBody2D& object) :
m_positionOffset(object.m_positionOffset),
m_geom(object.m_geom),
m_userData(object.m_userData),
@@ -61,7 +61,7 @@ namespace Nz
}
}
RigidBody2D::RigidBody2D(RigidBody2D&& object) noexcept :
ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkRigidBody2D&& object) noexcept :
OnRigidBody2DMove(std::move(object.OnRigidBody2DMove)),
OnRigidBody2DRelease(std::move(object.OnRigidBody2DRelease)),
m_positionOffset(std::move(object.m_positionOffset)),
@@ -85,19 +85,19 @@ namespace Nz
OnRigidBody2DMove(&object, this);
}
RigidBody2D::~RigidBody2D()
ChipmunkRigidBody2D::~ChipmunkRigidBody2D()
{
OnRigidBody2DRelease(this);
Destroy();
}
void RigidBody2D::AddForce(const Vector2f& force, CoordSys coordSys)
void ChipmunkRigidBody2D::AddForce(const Vector2f& force, CoordSys coordSys)
{
return AddForce(force, GetMassCenter(coordSys), coordSys);
}
void RigidBody2D::AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys)
void ChipmunkRigidBody2D::AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys)
{
switch (coordSys)
{
@@ -111,12 +111,12 @@ namespace Nz
}
}
void RigidBody2D::AddImpulse(const Vector2f& impulse, CoordSys coordSys)
void ChipmunkRigidBody2D::AddImpulse(const Vector2f& impulse, CoordSys coordSys)
{
return AddImpulse(impulse, GetMassCenter(coordSys), coordSys);
}
void RigidBody2D::AddImpulse(const Vector2f& impulse, const Vector2f& point, CoordSys coordSys)
void ChipmunkRigidBody2D::AddImpulse(const Vector2f& impulse, const Vector2f& point, CoordSys coordSys)
{
switch (coordSys)
{
@@ -130,12 +130,12 @@ namespace Nz
}
}
void RigidBody2D::AddTorque(const RadianAnglef& torque)
void ChipmunkRigidBody2D::AddTorque(const RadianAnglef& torque)
{
cpBodySetTorque(m_handle, cpBodyGetTorque(m_handle) + torque.value);
}
bool RigidBody2D::ClosestPointQuery(const Vector2f& position, Vector2f* closestPoint, float* closestDistance) const
bool ChipmunkRigidBody2D::ClosestPointQuery(const Vector2f& position, Vector2f* closestPoint, float* closestDistance) const
{
cpVect pos = cpv(cpFloat(position.x), cpFloat(position.y));
@@ -166,7 +166,7 @@ namespace Nz
return true;
}
void RigidBody2D::EnableSimulation(bool simulation)
void ChipmunkRigidBody2D::EnableSimulation(bool simulation)
{
if (m_isSimulationEnabled != simulation)
{
@@ -179,7 +179,7 @@ namespace Nz
}
}
void RigidBody2D::ForEachArbiter(std::function<void(Arbiter2D&)> callback)
void ChipmunkRigidBody2D::ForEachArbiter(std::function<void(ChipmunkArbiter2D&)> callback)
{
using CallbackType = decltype(callback);
@@ -187,23 +187,23 @@ namespace Nz
{
CallbackType& cb = *static_cast<CallbackType*>(data);
Arbiter2D nzArbiter(arbiter);
ChipmunkArbiter2D nzArbiter(arbiter);
cb(nzArbiter);
};
cpBodyEachArbiter(m_handle, RealCallback, &callback);
}
void RigidBody2D::ForceSleep()
void ChipmunkRigidBody2D::ForceSleep()
{
m_world->RegisterPostStep(this, [](RigidBody2D* body)
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) == CP_BODY_TYPE_DYNAMIC)
cpBodySleep(body->GetHandle());
});
}
Rectf RigidBody2D::GetAABB() const
Rectf ChipmunkRigidBody2D::GetAABB() const
{
if (m_shapes.empty())
return Rectf::Zero();
@@ -216,39 +216,39 @@ namespace Nz
return Rectf(Rect<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));
}
float RigidBody2D::GetElasticity(std::size_t shapeIndex) const
float ChipmunkRigidBody2D::GetElasticity(std::size_t shapeIndex) const
{
assert(shapeIndex < m_shapes.size());
return float(cpShapeGetElasticity(m_shapes[shapeIndex]));
}
float RigidBody2D::GetFriction(std::size_t shapeIndex) const
float ChipmunkRigidBody2D::GetFriction(std::size_t shapeIndex) const
{
assert(shapeIndex < m_shapes.size());
return float(cpShapeGetFriction(m_shapes[shapeIndex]));
}
const std::shared_ptr<Collider2D>& RigidBody2D::GetGeom() const
const std::shared_ptr<ChipmunkCollider2D>& ChipmunkRigidBody2D::GetGeom() const
{
return m_geom;
}
cpBody* RigidBody2D::GetHandle() const
cpBody* ChipmunkRigidBody2D::GetHandle() const
{
return m_handle;
}
float RigidBody2D::GetMass() const
float ChipmunkRigidBody2D::GetMass() const
{
return m_mass;
}
Vector2f RigidBody2D::GetMassCenter(CoordSys coordSys) const
Vector2f ChipmunkRigidBody2D::GetMassCenter(CoordSys coordSys) const
{
cpVect massCenter = cpBodyGetCenterOfGravity(m_handle);
@@ -265,23 +265,23 @@ namespace Nz
return Vector2f(static_cast<float>(massCenter.x), static_cast<float>(massCenter.y));
}
float RigidBody2D::GetMomentOfInertia() const
float ChipmunkRigidBody2D::GetMomentOfInertia() const
{
return float(cpBodyGetMoment(m_handle));
}
Vector2f RigidBody2D::GetPosition() const
Vector2f ChipmunkRigidBody2D::GetPosition() const
{
cpVect pos = cpBodyLocalToWorld(m_handle, cpv(-m_positionOffset.x, -m_positionOffset.y));
return Vector2f(static_cast<float>(pos.x), static_cast<float>(pos.y));
}
RadianAnglef RigidBody2D::GetRotation() const
RadianAnglef ChipmunkRigidBody2D::GetRotation() const
{
return float(cpBodyGetAngle(m_handle));
}
std::size_t RigidBody2D::GetShapeIndex(cpShape* shape) const
std::size_t ChipmunkRigidBody2D::GetShapeIndex(cpShape* shape) const
{
auto it = std::find(m_shapes.begin(), m_shapes.end(), shape);
if (it == m_shapes.end())
@@ -290,91 +290,91 @@ namespace Nz
return std::distance(m_shapes.begin(), it);
}
Vector2f RigidBody2D::GetSurfaceVelocity(std::size_t shapeIndex) const
Vector2f ChipmunkRigidBody2D::GetSurfaceVelocity(std::size_t shapeIndex) const
{
assert(shapeIndex < m_shapes.size());
cpVect vel = cpShapeGetSurfaceVelocity(m_shapes[shapeIndex]);
return Vector2f(static_cast<float>(vel.x), static_cast<float>(vel.y));
}
void* RigidBody2D::GetUserdata() const
void* ChipmunkRigidBody2D::GetUserdata() const
{
return m_userData;
}
Vector2f RigidBody2D::GetVelocity() const
Vector2f ChipmunkRigidBody2D::GetVelocity() const
{
cpVect vel = cpBodyGetVelocity(m_handle);
return Vector2f(static_cast<float>(vel.x), static_cast<float>(vel.y));
}
const RigidBody2D::VelocityFunc& RigidBody2D::GetVelocityFunction() const
const ChipmunkRigidBody2D::VelocityFunc& ChipmunkRigidBody2D::GetVelocityFunction() const
{
return m_velocityFunc;
}
PhysWorld2D* RigidBody2D::GetWorld() const
ChipmunkPhysWorld2D* ChipmunkRigidBody2D::GetWorld() const
{
return m_world;
}
bool RigidBody2D::IsKinematic() const
bool ChipmunkRigidBody2D::IsKinematic() const
{
return m_mass <= 0.f;
}
bool RigidBody2D::IsSimulationEnabled() const
bool ChipmunkRigidBody2D::IsSimulationEnabled() const
{
return m_isSimulationEnabled;
}
bool RigidBody2D::IsSleeping() const
bool ChipmunkRigidBody2D::IsSleeping() const
{
return cpBodyIsSleeping(m_handle) != 0;
}
bool RigidBody2D::IsStatic() const
bool ChipmunkRigidBody2D::IsStatic() const
{
return m_isStatic;
}
void RigidBody2D::ResetVelocityFunction()
void ChipmunkRigidBody2D::ResetVelocityFunction()
{
m_handle->velocity_func = cpBodyUpdateVelocity;
}
void RigidBody2D::SetAngularVelocity(const RadianAnglef& angularVelocity)
void ChipmunkRigidBody2D::SetAngularVelocity(const RadianAnglef& angularVelocity)
{
cpBodySetAngularVelocity(m_handle, angularVelocity.value);
}
void RigidBody2D::SetElasticity(float friction)
void ChipmunkRigidBody2D::SetElasticity(float friction)
{
cpFloat frict(friction);
for (cpShape* shape : m_shapes)
cpShapeSetElasticity(shape, frict);
}
void RigidBody2D::SetElasticity(std::size_t shapeIndex, float friction)
void ChipmunkRigidBody2D::SetElasticity(std::size_t shapeIndex, float friction)
{
assert(shapeIndex < m_shapes.size());
cpShapeSetElasticity(m_shapes[shapeIndex], cpFloat(friction));
}
void RigidBody2D::SetFriction(float friction)
void ChipmunkRigidBody2D::SetFriction(float friction)
{
cpFloat frict(friction);
for (cpShape* shape : m_shapes)
cpShapeSetFriction(shape, frict);
}
void RigidBody2D::SetFriction(std::size_t shapeIndex, float friction)
void ChipmunkRigidBody2D::SetFriction(std::size_t shapeIndex, float friction)
{
assert(shapeIndex < m_shapes.size());
cpShapeSetFriction(m_shapes[shapeIndex], cpFloat(friction));
}
void RigidBody2D::SetGeom(std::shared_ptr<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
// So let's save some attributes of the body, destroy it and rebuild it
@@ -395,7 +395,7 @@ namespace Nz
if (geom)
m_geom = std::move(geom);
else
m_geom = std::make_shared<NullCollider2D>();
m_geom = std::make_shared<ChipmunkNullCollider2D>();
m_geom->GenerateShapes(m_handle, &m_shapes);
@@ -415,13 +415,13 @@ namespace Nz
SetMassCenter(m_geom->ComputeCenterOfMass());
}
void RigidBody2D::SetMass(float mass, bool recomputeMoment)
void ChipmunkRigidBody2D::SetMass(float mass, bool recomputeMoment)
{
if (m_mass > 0.f)
{
if (mass > 0.f)
{
m_world->RegisterPostStep(this, [mass, recomputeMoment](RigidBody2D* body)
m_world->RegisterPostStep(this, [mass, recomputeMoment](ChipmunkRigidBody2D* body)
{
cpBodySetMass(body->GetHandle(), mass);
@@ -430,11 +430,11 @@ namespace Nz
});
}
else
m_world->RegisterPostStep(this, [](RigidBody2D* body) { cpBodySetType(body->GetHandle(), (body->IsStatic()) ? CP_BODY_TYPE_STATIC : CP_BODY_TYPE_KINEMATIC); } );
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { cpBodySetType(body->GetHandle(), (body->IsStatic()) ? CP_BODY_TYPE_STATIC : CP_BODY_TYPE_KINEMATIC); } );
}
else if (mass > 0.f)
{
m_world->RegisterPostStep(this, [mass, recomputeMoment](RigidBody2D* body)
m_world->RegisterPostStep(this, [mass, recomputeMoment](ChipmunkRigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_DYNAMIC)
{
@@ -450,7 +450,7 @@ namespace Nz
m_mass = mass;
}
void RigidBody2D::SetMassCenter(const Vector2f& center, CoordSys coordSys)
void ChipmunkRigidBody2D::SetMassCenter(const Vector2f& center, CoordSys coordSys)
{
cpVect massCenter = cpv(center.x, center.y);
@@ -467,64 +467,64 @@ namespace Nz
cpBodySetCenterOfGravity(m_handle, massCenter);
}
void RigidBody2D::SetMomentOfInertia(float moment)
void ChipmunkRigidBody2D::SetMomentOfInertia(float moment)
{
// Even though Chipmunk allows us to change this anytime, we need to do it in a post-step to prevent other post-steps to override this
m_world->RegisterPostStep(this, [moment] (RigidBody2D* body)
m_world->RegisterPostStep(this, [moment] (ChipmunkRigidBody2D* body)
{
cpBodySetMoment(body->GetHandle(), moment);
});
}
void RigidBody2D::SetPosition(const Vector2f& position)
void ChipmunkRigidBody2D::SetPosition(const Vector2f& position)
{
// Use cpTransformVect to rotate/scale the position offset
cpBodySetPosition(m_handle, cpvadd(cpv(position.x, position.y), cpTransformVect(m_handle->transform, cpv(m_positionOffset.x, m_positionOffset.y))));
if (m_isStatic)
{
m_world->RegisterPostStep(this, [](RigidBody2D* body)
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
}
}
void RigidBody2D::SetPositionOffset(const Vector2f& offset)
void ChipmunkRigidBody2D::SetPositionOffset(const Vector2f& offset)
{
Vector2f position = GetPosition();
m_positionOffset = offset;
SetPosition(position);
}
void RigidBody2D::SetRotation(const RadianAnglef& rotation)
void ChipmunkRigidBody2D::SetRotation(const RadianAnglef& rotation)
{
cpBodySetAngle(m_handle, rotation.value);
if (m_isStatic)
{
m_world->RegisterPostStep(this, [](RigidBody2D* body)
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
}
}
void RigidBody2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity)
void ChipmunkRigidBody2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity)
{
Vector2<cpFloat> velocity(surfaceVelocity.x, surfaceVelocity.y);
for (cpShape* shape : m_shapes)
cpShapeSetSurfaceVelocity(shape, cpv(velocity.x, velocity.y));
}
void RigidBody2D::SetSurfaceVelocity(std::size_t shapeIndex, const Vector2f& surfaceVelocity)
void ChipmunkRigidBody2D::SetSurfaceVelocity(std::size_t shapeIndex, const Vector2f& surfaceVelocity)
{
assert(shapeIndex < m_shapes.size());
cpShapeSetSurfaceVelocity(m_shapes[shapeIndex], cpv(cpFloat(surfaceVelocity.x), cpFloat(surfaceVelocity.y)));
}
void RigidBody2D::SetStatic(bool setStaticBody)
void ChipmunkRigidBody2D::SetStatic(bool setStaticBody)
{
m_isStatic = setStaticBody;
m_world->RegisterPostStep(this, [](RigidBody2D* body)
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{
if (body->IsStatic())
{
@@ -538,17 +538,17 @@ namespace Nz
});
}
void RigidBody2D::SetUserdata(void* ud)
void ChipmunkRigidBody2D::SetUserdata(void* ud)
{
m_userData = ud;
}
void RigidBody2D::SetVelocity(const Vector2f& velocity)
void ChipmunkRigidBody2D::SetVelocity(const Vector2f& velocity)
{
cpBodySetVelocity(m_handle, cpv(velocity.x, velocity.y));
}
void RigidBody2D::SetVelocityFunction(VelocityFunc velocityFunc)
void ChipmunkRigidBody2D::SetVelocityFunction(VelocityFunc velocityFunc)
{
m_velocityFunc = std::move(velocityFunc);
@@ -556,7 +556,7 @@ namespace Nz
{
m_handle->velocity_func = [](cpBody* body, cpVect gravity, cpFloat damping, cpFloat dt)
{
RigidBody2D* rigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(body));
ChipmunkRigidBody2D* rigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(body));
const auto& callback = rigidBody->GetVelocityFunction();
assert(callback);
@@ -567,28 +567,28 @@ namespace Nz
m_handle->velocity_func = cpBodyUpdateVelocity;
}
void RigidBody2D::TeleportTo(const Vector2f& position, const RadianAnglef& rotation)
void ChipmunkRigidBody2D::TeleportTo(const Vector2f& position, const RadianAnglef& rotation)
{
// Use cpTransformVect to rotate/scale the position offset
cpBodySetPosition(m_handle, cpvadd(cpv(position.x, position.y), cpTransformVect(m_handle->transform, cpv(m_positionOffset.x, m_positionOffset.y))));
cpBodySetAngle(m_handle, rotation.value);
if (m_isStatic)
{
m_world->RegisterPostStep(this, [](RigidBody2D* body)
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
}
}
void RigidBody2D::UpdateVelocity(const Vector2f & gravity, float damping, float deltaTime)
void ChipmunkRigidBody2D::UpdateVelocity(const Vector2f & gravity, float damping, float deltaTime)
{
cpBodyUpdateVelocity(m_handle, cpv(gravity.x, gravity.y), damping, deltaTime);
}
void RigidBody2D::Wakeup()
void ChipmunkRigidBody2D::Wakeup()
{
m_world->RegisterPostStep(this, [](RigidBody2D* body)
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_STATIC)
cpBodyActivate(body->GetHandle());
@@ -597,13 +597,13 @@ namespace Nz
});
}
RigidBody2D& RigidBody2D::operator=(const RigidBody2D& object)
ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(const ChipmunkRigidBody2D& object)
{
RigidBody2D physObj(object);
ChipmunkRigidBody2D physObj(object);
return operator=(std::move(physObj));
}
RigidBody2D& RigidBody2D::operator=(RigidBody2D&& object)
ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(ChipmunkRigidBody2D&& object)
{
Destroy();
@@ -637,7 +637,7 @@ namespace Nz
return *this;
}
void RigidBody2D::Destroy()
void ChipmunkRigidBody2D::Destroy()
{
UnregisterFromSpace();
@@ -653,7 +653,7 @@ namespace Nz
m_shapes.clear();
}
cpBody* RigidBody2D::Create(float mass, float moment)
cpBody* ChipmunkRigidBody2D::Create(float mass, float moment)
{
cpBody* handle;
if (IsKinematic())
@@ -671,7 +671,7 @@ namespace Nz
return handle;
}
void RigidBody2D::RegisterToSpace()
void ChipmunkRigidBody2D::RegisterToSpace()
{
if (!m_isRegistered)
{
@@ -686,7 +686,7 @@ namespace Nz
}
}
void RigidBody2D::UnregisterFromSpace()
void ChipmunkRigidBody2D::UnregisterFromSpace()
{
if (m_isRegistered)
{
@@ -701,7 +701,7 @@ namespace Nz
}
}
void RigidBody2D::CopyBodyData(cpBody* from, cpBody* to)
void ChipmunkRigidBody2D::CopyBodyData(cpBody* from, cpBody* to)
{
cpBodySetCenterOfGravity(to, cpBodyGetCenterOfGravity(from));
@@ -717,7 +717,7 @@ namespace Nz
to->velocity_func = from->velocity_func;
}
void RigidBody2D::CopyShapeData(cpShape* from, cpShape* to)
void ChipmunkRigidBody2D::CopyShapeData(cpShape* from, cpShape* to)
{
cpShapeSetElasticity(to, cpShapeGetElasticity(from));
cpShapeSetFriction(to, cpShapeGetFriction(from));

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