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

Rename ChipmunkPhysics2D and JoltPhysics3D to Physics[2D|3D]

Browse Source
This commit is contained in:
Lynix
2024-02-09 20:59:53 +01:00
committed by Jérôme Leclercq
parent 139bed2b0a
commit e336c8a514
116 changed files with 3044 additions and 3042 deletions
Download Patch File Download Diff File Expand all files Collapse all files

457
src/Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.cpp
View File

@@ -1,457 +0,0 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/ChipmunkPhysics2D/ChipmunkConstraint2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkHelper.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&& constraint) noexcept :
m_constraint(std::move(constraint.m_constraint))
{
if (m_constraint)
cpConstraintSetUserData(m_constraint, this);
}
ChipmunkConstraint2D::~ChipmunkConstraint2D()
{
Destroy();
}
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()
{
NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
return *static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint)));
}
const ChipmunkRigidBody2D& ChipmunkConstraint2D::GetBodyB() const
{
NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
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;
}
bool ChipmunkConstraint2D::IsSingleBody() const
{
return cpConstraintGetBodyB(m_constraint) == cpSpaceGetStaticBody(cpConstraintGetSpace(m_constraint));
}
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) noexcept
{
Destroy();
m_constraint = std::move(rhs.m_constraint);
if (m_constraint)
cpConstraintSetUserData(m_constraint, this);
return *this;
}
void ChipmunkConstraint2D::Destroy()
{
if (m_constraint)
{
cpSpaceRemoveConstraint(cpConstraintGetSpace(m_constraint), m_constraint);
cpConstraintDestroy(m_constraint);
m_constraint = nullptr;
}
}
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(), ToChipmunk(firstAnchor), ToChipmunk(secondAnchor), 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, ToChipmunk(firstAnchor));
}
void ChipmunkDampedSpringConstraint2D::SetRestLength(float newLength)
{
cpDampedSpringSetRestLength(m_constraint, newLength);
}
void ChipmunkDampedSpringConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor)
{
cpDampedSpringSetAnchorB(m_constraint, ToChipmunk(firstAnchor));
}
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& body, const Vector2f& anchor) :
ChipmunkConstraint2D(body.GetWorld(), cpPinJointNew(body.GetHandle(), cpSpaceGetStaticBody(body.GetWorld()->GetHandle()), ToChipmunk(body.ToLocal(anchor)), ToChipmunk(body.ToLocal(anchor))))
{
}
ChipmunkPinConstraint2D::ChipmunkPinConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor) :
ChipmunkConstraint2D(first.GetWorld(), cpPinJointNew(first.GetHandle(), second.GetHandle(), ToChipmunk(firstAnchor), ToChipmunk(secondAnchor)))
{
}
float ChipmunkPinConstraint2D::GetDistance() const
{
return float(cpPinJointGetDist(m_constraint));
}
Vector2f ChipmunkPinConstraint2D::GetFirstAnchor() const
{
return FromChipmunk(cpBodyLocalToWorld(cpConstraintGetBodyA(m_constraint), cpPinJointGetAnchorA(m_constraint)));
}
Vector2f ChipmunkPinConstraint2D::GetSecondAnchor() const
{
return FromChipmunk(cpBodyLocalToWorld(cpConstraintGetBodyB(m_constraint), cpPinJointGetAnchorB(m_constraint)));
}
void ChipmunkPinConstraint2D::SetDistance(float newDistance)
{
cpPinJointSetDist(m_constraint, newDistance);
}
void ChipmunkPinConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor)
{
cpPinJointSetAnchorA(m_constraint, cpBodyWorldToLocal(cpConstraintGetBodyA(m_constraint), ToChipmunk(firstAnchor)));
}
void ChipmunkPinConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor)
{
cpPinJointSetAnchorB(m_constraint, cpBodyWorldToLocal(cpConstraintGetBodyB(m_constraint), ToChipmunk(firstAnchor)));
}
ChipmunkPivotConstraint2D::ChipmunkPivotConstraint2D(ChipmunkRigidBody2D& body, const Vector2f& anchor) :
ChipmunkConstraint2D(body.GetWorld(), cpPivotJointNew(cpSpaceGetStaticBody(body.GetWorld()->GetHandle()), body.GetHandle(), ToChipmunk(anchor)))
{
}
ChipmunkPivotConstraint2D::ChipmunkPivotConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& anchor) :
ChipmunkConstraint2D(first.GetWorld(), cpPivotJointNew(first.GetHandle(), second.GetHandle(), ToChipmunk(anchor)))
{
}
ChipmunkPivotConstraint2D::ChipmunkPivotConstraint2D(ChipmunkRigidBody2D& first, ChipmunkRigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor) :
ChipmunkConstraint2D(first.GetWorld(), cpPivotJointNew2(first.GetHandle(), second.GetHandle(), ToChipmunk(firstAnchor), ToChipmunk(secondAnchor)))
{
}
Vector2f ChipmunkPivotConstraint2D::GetFirstAnchor() const
{
return FromChipmunk(cpBodyLocalToWorld(cpConstraintGetBodyA(m_constraint), cpPivotJointGetAnchorA(m_constraint)));
}
Vector2f ChipmunkPivotConstraint2D::GetSecondAnchor() const
{
return FromChipmunk(cpBodyLocalToWorld(cpConstraintGetBodyB(m_constraint), cpPivotJointGetAnchorB(m_constraint)));
}
void ChipmunkPivotConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor)
{
cpPivotJointSetAnchorA(m_constraint, cpBodyWorldToLocal(cpConstraintGetBodyA(m_constraint), ToChipmunk(firstAnchor)));
}
void ChipmunkPivotConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor)
{
cpPivotJointSetAnchorB(m_constraint, cpBodyWorldToLocal(cpConstraintGetBodyB(m_constraint), ToChipmunk(firstAnchor)));
}
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(), ToChipmunk(firstAnchor), ToChipmunk(secondAnchor), 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, ToChipmunk(firstAnchor));
}
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, ToChipmunk(firstAnchor));
}
}

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

@@ -1,16 +0,0 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D 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;
}

11
src/Nazara/JoltPhysics3D/JoltAbstractBody.cpp
View File

@@ -1,11 +0,0 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/JoltAbstractBody.hpp>
#include <Nazara/JoltPhysics3D/Debug.hpp>
namespace Nz
{
JoltAbstractBody::~JoltAbstractBody() = default;
}

19
src/Nazara/JoltPhysics3D/JoltPhysicsStepListener.cpp
View File

@@ -1,19 +0,0 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/JoltPhysicsStepListener.hpp>
#include <Nazara/JoltPhysics3D/Debug.hpp>
namespace Nz
{
JoltPhysicsStepListener::~JoltPhysicsStepListener() = default;
void JoltPhysicsStepListener::PostSimulate(float /*elapsedTime*/)
{
}
void JoltPhysicsStepListener::PreSimulate(float /*elapsedTime*/)
{
}
}

10
src/Nazara/ChipmunkPhysics2D/ChipmunkHelper.hpp → src/Nazara/Physics2D/ChipmunkHelper.hpp
View File

@@ -1,11 +1,11 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D module"
// 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_CHIPMUNKHELPER_HPP
#define NAZARA_CHIPMUNKPHYSICS2D_CHIPMUNKHELPER_HPP
#ifndef NAZARA_PHYSICS2D_CHIPMUNKHELPER_HPP
#define NAZARA_PHYSICS2D_CHIPMUNKHELPER_HPP
#include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Math/Vector2.hpp>
@@ -17,6 +17,6 @@ namespace Nz
inline cpVect ToChipmunk(const Vector2f& vec);
}
#include <Nazara/ChipmunkPhysics2D/ChipmunkHelper.inl>
#include <Nazara/Physics2D/ChipmunkHelper.inl>
#endif // NAZARA_CHIPMUNKPHYSICS2D_CHIPMUNKHELPER_HPP
#endif // NAZARA_PHYSICS2D_CHIPMUNKHELPER_HPP

6
src/Nazara/ChipmunkPhysics2D/ChipmunkHelper.inl → src/Nazara/Physics2D/ChipmunkHelper.inl
View File

@@ -1,8 +1,8 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D module"
// 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>
#include <Nazara/Physics2D/Debug.hpp>
namespace Nz
{
@@ -17,4 +17,4 @@ namespace Nz
}
}
#include <Nazara/ChipmunkPhysics2D/DebugOff.hpp>
#include <Nazara/Physics2D/DebugOff.hpp>

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

@@ -1,15 +1,15 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D module"
// 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/ChipmunkCollider2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkHelper.hpp>
#include <Nazara/Physics2D/Collider2D.hpp>
#include <Nazara/Physics2D/ChipmunkHelper.hpp>
#include <NazaraUtils/CallOnExit.hpp>
#include <NazaraUtils/StackArray.hpp>
#include <chipmunk/chipmunk.h>
#include <chipmunk/chipmunk_structs.h>
#include <array>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
#include <Nazara/Physics2D/Debug.hpp>
namespace Nz
{
@@ -18,9 +18,9 @@ namespace Nz
constexpr cpSpaceDebugColor s_chipmunkWhite = { 1.f, 1.f, 1.f, 1.f };
}
ChipmunkCollider2D::~ChipmunkCollider2D() = default;
Collider2D::~Collider2D() = default;
void ChipmunkCollider2D::ForEachPolygon(const FunctionRef<void(const Vector2f* vertices, std::size_t vertexCount)>& callback) const
void Collider2D::ForEachPolygon(const FunctionRef<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
@@ -126,7 +126,7 @@ namespace Nz
cpSpaceDebugDraw(space, &drawOptions);
}
std::size_t ChipmunkCollider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
std::size_t Collider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{
std::size_t shapeCount = CreateShapes(body, shapes);
@@ -148,33 +148,33 @@ namespace Nz
/******************************** BoxCollider2D *********************************/
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 Vector2f& size, float radius) :
BoxCollider2D(Rectf(-size.x / 2.f, -size.y / 2.f, size.x, size.y), radius)
{
}
ChipmunkBoxCollider2D::ChipmunkBoxCollider2D(const Rectf& rect, float radius) :
BoxCollider2D::BoxCollider2D(const Rectf& rect, float radius) :
m_rect(rect),
m_radius(radius)
{
}
Vector2f ChipmunkBoxCollider2D::ComputeCenterOfMass() const
Vector2f BoxCollider2D::ComputeCenterOfMass() const
{
return m_rect.GetCenter();
}
float ChipmunkBoxCollider2D::ComputeMomentOfInertia(float mass) const
float BoxCollider2D::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)));
}
ChipmunkColliderType2D ChipmunkBoxCollider2D::GetType() const
ColliderType2D BoxCollider2D::GetType() const
{
return ChipmunkColliderType2D::Box;
return ColliderType2D::Box;
}
std::size_t ChipmunkBoxCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
std::size_t BoxCollider2D::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;
@@ -182,28 +182,28 @@ namespace Nz
/******************************** CircleCollider2D *********************************/
ChipmunkCircleCollider2D::ChipmunkCircleCollider2D(float radius, const Vector2f& offset) :
CircleCollider2D::CircleCollider2D(float radius, const Vector2f& offset) :
m_offset(offset),
m_radius(radius)
{
}
Vector2f ChipmunkCircleCollider2D::ComputeCenterOfMass() const
Vector2f CircleCollider2D::ComputeCenterOfMass() const
{
return m_offset;
}
float ChipmunkCircleCollider2D::ComputeMomentOfInertia(float mass) const
float CircleCollider2D::ComputeMomentOfInertia(float mass) const
{
return SafeCast<float>(cpMomentForCircle(mass, 0.f, m_radius, cpv(m_offset.x, m_offset.y)));
}
ChipmunkColliderType2D ChipmunkCircleCollider2D::GetType() const
ColliderType2D CircleCollider2D::GetType() const
{
return ChipmunkColliderType2D::Circle;
return ColliderType2D::Circle;
}
std::size_t ChipmunkCircleCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
std::size_t CircleCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{
shapes->push_back(cpCircleShapeNew(body, m_radius, cpv(m_offset.x, m_offset.y)));
return 1;
@@ -211,13 +211,13 @@ namespace Nz
/******************************** CompoundCollider2D *********************************/
ChipmunkCompoundCollider2D::ChipmunkCompoundCollider2D(std::vector<std::shared_ptr<ChipmunkCollider2D>> geoms) :
CompoundCollider2D::CompoundCollider2D(std::vector<std::shared_ptr<Collider2D>> geoms) :
m_geoms(std::move(geoms)),
m_doesOverrideCollisionProperties(true)
{
}
Vector2f ChipmunkCompoundCollider2D::ComputeCenterOfMass() const
Vector2f CompoundCollider2D::ComputeCenterOfMass() const
{
Vector2f centerOfMass = Vector2f::Zero();
for (const auto& geom : m_geoms)
@@ -226,7 +226,7 @@ namespace Nz
return centerOfMass / float(m_geoms.size());
}
float ChipmunkCompoundCollider2D::ComputeMomentOfInertia(float mass) const
float CompoundCollider2D::ComputeMomentOfInertia(float mass) const
{
///TODO: Correctly compute moment using parallel axis theorem:
/// https://chipmunk-physics.net/forum/viewtopic.php?t=1056
@@ -237,12 +237,12 @@ namespace Nz
return momentOfInertia;
}
ChipmunkColliderType2D ChipmunkCompoundCollider2D::GetType() const
ColliderType2D CompoundCollider2D::GetType() const
{
return ChipmunkColliderType2D::Compound;
return ColliderType2D::Compound;
}
std::size_t ChipmunkCompoundCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
std::size_t CompoundCollider2D::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
@@ -253,11 +253,11 @@ namespace Nz
return shapeCount;
}
std::size_t ChipmunkCompoundCollider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
std::size_t CompoundCollider2D::GenerateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
{
// This is our parent's default behavior
if (m_doesOverrideCollisionProperties)
return ChipmunkCollider2D::GenerateShapes(body, shapes);
return Collider2D::GenerateShapes(body, shapes);
else
{
std::size_t shapeCount = 0;
@@ -270,7 +270,7 @@ namespace Nz
/******************************** ConvexCollider2D *********************************/
ChipmunkConvexCollider2D::ChipmunkConvexCollider2D(SparsePtr<const Vector2f> vertices, std::size_t vertexCount, float radius) :
ConvexCollider2D::ConvexCollider2D(SparsePtr<const Vector2f> vertices, std::size_t vertexCount, float radius) :
m_radius(radius)
{
m_vertices.resize(vertexCount);
@@ -278,7 +278,7 @@ namespace Nz
m_vertices[i] = Vector2<cpFloat>(*vertices++);
}
Vector2f ChipmunkConvexCollider2D::ComputeCenterOfMass() const
Vector2f ConvexCollider2D::ComputeCenterOfMass() const
{
static_assert(sizeof(cpVect) == sizeof(Vector2d), "Chipmunk vector is not equivalent to Vector2d");
@@ -287,19 +287,19 @@ namespace Nz
return Vector2f(float(center.x), float(center.y));
}
float ChipmunkConvexCollider2D::ComputeMomentOfInertia(float mass) const
float ConvexCollider2D::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));
}
ChipmunkColliderType2D ChipmunkConvexCollider2D::GetType() const
ColliderType2D ConvexCollider2D::GetType() const
{
return ChipmunkColliderType2D::Convex;
return ColliderType2D::Convex;
}
std::size_t ChipmunkConvexCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
std::size_t ConvexCollider2D::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;
@@ -307,44 +307,44 @@ namespace Nz
/********************************* NullCollider2D **********************************/
ChipmunkColliderType2D ChipmunkNullCollider2D::GetType() const
ColliderType2D NullCollider2D::GetType() const
{
return ChipmunkColliderType2D::Null;
return ColliderType2D::Null;
}
Vector2f ChipmunkNullCollider2D::ComputeCenterOfMass() const
Vector2f NullCollider2D::ComputeCenterOfMass() const
{
return Vector2f::Zero();
}
float ChipmunkNullCollider2D::ComputeMomentOfInertia(float mass) const
float NullCollider2D::ComputeMomentOfInertia(float mass) const
{
return (mass > 0.f) ? 1.f : 0.f; //< Null inertia is only possible for static/kinematic objects
}
std::size_t ChipmunkNullCollider2D::CreateShapes(cpBody* /*body*/, std::vector<cpShape*>* /*shapes*/) const
std::size_t NullCollider2D::CreateShapes(cpBody* /*body*/, std::vector<cpShape*>* /*shapes*/) const
{
return 0;
}
/******************************** SegmentCollider2D *********************************/
Vector2f ChipmunkSegmentCollider2D::ComputeCenterOfMass() const
Vector2f SegmentCollider2D::ComputeCenterOfMass() const
{
return (m_first + m_second) / 2.f;
}
float ChipmunkSegmentCollider2D::ComputeMomentOfInertia(float mass) const
float SegmentCollider2D::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));
}
ChipmunkColliderType2D ChipmunkSegmentCollider2D::GetType() const
ColliderType2D SegmentCollider2D::GetType() const
{
return ChipmunkColliderType2D::Segment;
return ColliderType2D::Segment;
}
std::size_t ChipmunkSegmentCollider2D::CreateShapes(cpBody* body, std::vector<cpShape*>* shapes) const
std::size_t SegmentCollider2D::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));

44
src/Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.cpp → src/Nazara/Physics2D/PhysArbiter2D.cpp
View File

@@ -1,101 +1,101 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D module"
// 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 <Nazara/Physics2D/PhysArbiter2D.hpp>
#include <chipmunk/chipmunk.h>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
#include <Nazara/Physics2D/Debug.hpp>
namespace Nz
{
float ChipmunkArbiter2D::ComputeTotalKinematicEnergy() const
float PhysArbiter2D::ComputeTotalKinematicEnergy() const
{
return float(cpArbiterTotalKE(m_arbiter));
}
Vector2f ChipmunkArbiter2D::ComputeTotalImpulse() const
Vector2f PhysArbiter2D::ComputeTotalImpulse() const
{
cpVect impulse = cpArbiterTotalImpulse(m_arbiter);
return Vector2f(Vector2<cpFloat>(impulse.x, impulse.y));
}
std::pair<ChipmunkRigidBody2D*, ChipmunkRigidBody2D*> ChipmunkArbiter2D::GetBodies() const
std::pair<RigidBody2D*, RigidBody2D*> PhysArbiter2D::GetBodies() const
{
std::pair<ChipmunkRigidBody2D*, ChipmunkRigidBody2D*> bodies;
std::pair<RigidBody2D*, RigidBody2D*> bodies;
cpBody* firstBody;
cpBody* secondBody;
cpArbiterGetBodies(m_arbiter, &firstBody, &secondBody);
bodies.first = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
bodies.second = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
bodies.first = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
bodies.second = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
return bodies;
}
std::size_t ChipmunkArbiter2D::GetContactCount() const
std::size_t PhysArbiter2D::GetContactCount() const
{
return cpArbiterGetCount(m_arbiter);
}
float ChipmunkArbiter2D::GetContactDepth(std::size_t i) const
float PhysArbiter2D::GetContactDepth(std::size_t i) const
{
return float(cpArbiterGetDepth(m_arbiter, int(i)));
}
Vector2f ChipmunkArbiter2D::GetContactPointA(std::size_t i) const
Vector2f PhysArbiter2D::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
Vector2f PhysArbiter2D::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
float PhysArbiter2D::GetElasticity() const
{
return float(cpArbiterGetRestitution(m_arbiter));
}
float ChipmunkArbiter2D::GetFriction() const
float PhysArbiter2D::GetFriction() const
{
return float(cpArbiterGetFriction(m_arbiter));
}
Vector2f ChipmunkArbiter2D::GetNormal() const
Vector2f PhysArbiter2D::GetNormal() const
{
cpVect normal = cpArbiterGetNormal(m_arbiter);
return Vector2f(Vector2<cpFloat>(normal.x, normal.y));
}
Vector2f ChipmunkArbiter2D::GetSurfaceVelocity() const
Vector2f PhysArbiter2D::GetSurfaceVelocity() const
{
cpVect velocity = cpArbiterGetNormal(m_arbiter);
return Vector2f(Vector2<cpFloat>(velocity.x, velocity.y));
}
bool ChipmunkArbiter2D::IsFirstContact() const
bool PhysArbiter2D::IsFirstContact() const
{
return cpArbiterIsFirstContact(m_arbiter) == cpTrue;
}
bool ChipmunkArbiter2D::IsRemoval() const
bool PhysArbiter2D::IsRemoval() const
{
return cpArbiterIsRemoval(m_arbiter) == cpTrue;
}
void ChipmunkArbiter2D::SetElasticity(float elasticity)
void PhysArbiter2D::SetElasticity(float elasticity)
{
cpArbiterSetRestitution(m_arbiter, elasticity);
}
void ChipmunkArbiter2D::SetFriction(float friction)
void PhysArbiter2D::SetFriction(float friction)
{
cpArbiterSetFriction(m_arbiter, friction);
}
void ChipmunkArbiter2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity)
void PhysArbiter2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity)
{
cpArbiterSetSurfaceVelocity(m_arbiter, cpv(surfaceVelocity.x, surfaceVelocity.y));
}

457
src/Nazara/Physics2D/PhysConstraint2D.cpp Normal file
View File

@@ -0,0 +1,457 @@
// Copyright (C) 2024 Jérôme "SirLynix" 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/PhysConstraint2D.hpp>
#include <Nazara/Physics2D/ChipmunkHelper.hpp>
#include <chipmunk/chipmunk.h>
#include <Nazara/Physics2D/Debug.hpp>
namespace Nz
{
PhysConstraint2D::PhysConstraint2D(PhysWorld2D* world, cpConstraint* constraint) :
m_constraint(constraint)
{
cpConstraintSetUserData(m_constraint, this);
cpSpaceAddConstraint(world->GetHandle(), m_constraint);
}
PhysConstraint2D::PhysConstraint2D(PhysConstraint2D&& constraint) noexcept :
m_constraint(std::move(constraint.m_constraint))
{
if (m_constraint)
cpConstraintSetUserData(m_constraint, this);
}
PhysConstraint2D::~PhysConstraint2D()
{
Destroy();
}
void PhysConstraint2D::EnableBodyCollision(bool enable)
{
cpConstraintSetCollideBodies(m_constraint, (enable) ? cpTrue : cpFalse);
}
RigidBody2D& PhysConstraint2D::GetBodyA()
{
return *static_cast<RigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint)));
}
const RigidBody2D& PhysConstraint2D::GetBodyA() const
{
return *static_cast<RigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyA(m_constraint)));
}
RigidBody2D& PhysConstraint2D::GetBodyB()
{
NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
return *static_cast<RigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint)));
}
const RigidBody2D& PhysConstraint2D::GetBodyB() const
{
NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
return *static_cast<RigidBody2D*>(cpBodyGetUserData(cpConstraintGetBodyB(m_constraint)));
}
float PhysConstraint2D::GetErrorBias() const
{
return float(cpConstraintGetErrorBias(m_constraint));
}
float PhysConstraint2D::GetLastImpulse() const
{
return float(cpConstraintGetImpulse(m_constraint));
}
float PhysConstraint2D::GetMaxBias() const
{
return float(cpConstraintGetMaxBias(m_constraint));
}
float PhysConstraint2D::GetMaxForce() const
{
return float(cpConstraintGetMaxForce(m_constraint));
}
PhysWorld2D& PhysConstraint2D::GetWorld()
{
return *static_cast<PhysWorld2D*>(cpSpaceGetUserData(cpConstraintGetSpace(m_constraint)));
}
const PhysWorld2D& PhysConstraint2D::GetWorld() const
{
return *static_cast<PhysWorld2D*>(cpSpaceGetUserData(cpConstraintGetSpace(m_constraint)));
}
bool PhysConstraint2D::IsBodyCollisionEnabled() const
{
return cpConstraintGetCollideBodies(m_constraint) == cpTrue;
}
bool PhysConstraint2D::IsSingleBody() const
{
return cpConstraintGetBodyB(m_constraint) == cpSpaceGetStaticBody(cpConstraintGetSpace(m_constraint));
}
void PhysConstraint2D::SetErrorBias(float bias)
{
cpConstraintSetErrorBias(m_constraint, bias);
}
void PhysConstraint2D::SetMaxBias(float bias)
{
cpConstraintSetMaxBias(m_constraint, bias);
}
void PhysConstraint2D::SetMaxForce(float force)
{
cpConstraintSetMaxForce(m_constraint, force);
}
PhysConstraint2D& PhysConstraint2D::operator=(PhysConstraint2D&& rhs) noexcept
{
Destroy();
m_constraint = std::move(rhs.m_constraint);
if (m_constraint)
cpConstraintSetUserData(m_constraint, this);
return *this;
}
void PhysConstraint2D::Destroy()
{
if (m_constraint)
{
cpSpaceRemoveConstraint(cpConstraintGetSpace(m_constraint), m_constraint);
cpConstraintDestroy(m_constraint);
m_constraint = nullptr;
}
}
PhysDampedSpringConstraint2D::PhysDampedSpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float restLength, float stiffness, float damping) :
PhysConstraint2D(first.GetWorld(), cpDampedSpringNew(first.GetHandle(), second.GetHandle(), ToChipmunk(firstAnchor), ToChipmunk(secondAnchor), restLength, stiffness, damping))
{
}
float PhysDampedSpringConstraint2D::GetDamping() const
{
return float(cpDampedSpringGetDamping(m_constraint));
}
Vector2f PhysDampedSpringConstraint2D::GetFirstAnchor() const
{
cpVect anchor = cpDampedSpringGetAnchorA(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(anchor.y));
}
float PhysDampedSpringConstraint2D::GetRestLength() const
{
return float(cpDampedSpringGetRestLength(m_constraint));
}
Vector2f PhysDampedSpringConstraint2D::GetSecondAnchor() const
{
cpVect anchor = cpDampedSpringGetAnchorB(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(anchor.y));
}
float PhysDampedSpringConstraint2D::GetStiffness() const
{
return float(cpDampedSpringGetStiffness(m_constraint));
}
void PhysDampedSpringConstraint2D::SetDamping(float newDamping)
{
cpDampedSpringSetDamping(m_constraint, newDamping);
}
void PhysDampedSpringConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor)
{
cpDampedSpringSetAnchorA(m_constraint, ToChipmunk(firstAnchor));
}
void PhysDampedSpringConstraint2D::SetRestLength(float newLength)
{
cpDampedSpringSetRestLength(m_constraint, newLength);
}
void PhysDampedSpringConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor)
{
cpDampedSpringSetAnchorB(m_constraint, ToChipmunk(firstAnchor));
}
void PhysDampedSpringConstraint2D::SetStiffness(float newStiffness)
{
cpDampedSpringSetStiffness(m_constraint, newStiffness);
}
PhysDampedRotarySpringConstraint2D::PhysDampedRotarySpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& restAngle, float stiffness, float damping) :
PhysConstraint2D(first.GetWorld(), cpDampedRotarySpringNew(first.GetHandle(), second.GetHandle(), restAngle.value, stiffness, damping))
{
}
float PhysDampedRotarySpringConstraint2D::GetDamping() const
{
return float(cpDampedRotarySpringGetDamping(m_constraint));
}
RadianAnglef PhysDampedRotarySpringConstraint2D::GetRestAngle() const
{
return float(cpDampedRotarySpringGetRestAngle(m_constraint));
}
float PhysDampedRotarySpringConstraint2D::GetStiffness() const
{
return float(cpDampedRotarySpringGetStiffness(m_constraint));
}
void PhysDampedRotarySpringConstraint2D::SetDamping(float newDamping)
{
cpDampedSpringSetDamping(m_constraint, newDamping);
}
void PhysDampedRotarySpringConstraint2D::SetRestAngle(const RadianAnglef& newAngle)
{
cpDampedRotarySpringSetRestAngle(m_constraint, newAngle.value);
}
void PhysDampedRotarySpringConstraint2D::SetStiffness(float newStiffness)
{
cpDampedRotarySpringSetStiffness(m_constraint, newStiffness);
}
PhysGearConstraint2D::PhysGearConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratio) :
PhysConstraint2D(first.GetWorld(), cpGearJointNew(first.GetHandle(), second.GetHandle(), phase, ratio))
{
}
float PhysGearConstraint2D::GetPhase() const
{
return float(cpGearJointGetPhase(m_constraint));
}
float PhysGearConstraint2D::GetRatio() const
{
return float(cpGearJointGetRatio(m_constraint));
}
void PhysGearConstraint2D::SetPhase(float phase)
{
cpGearJointSetPhase(m_constraint, phase);
}
void PhysGearConstraint2D::SetRatio(float ratio)
{
cpGearJointSetRatio(m_constraint, ratio);
}
PhysMotorConstraint2D::PhysMotorConstraint2D(RigidBody2D& first, RigidBody2D& second, float rate) :
PhysConstraint2D(first.GetWorld(), cpSimpleMotorNew(first.GetHandle(), second.GetHandle(), rate))
{
}
float PhysMotorConstraint2D::GetRate() const
{
return float(cpSimpleMotorGetRate(m_constraint));
}
void PhysMotorConstraint2D::SetRate(float rate)
{
cpSimpleMotorSetRate(m_constraint, rate);
}
PhysPinConstraint2D::PhysPinConstraint2D(RigidBody2D& body, const Vector2f& anchor) :
PhysConstraint2D(body.GetWorld(), cpPinJointNew(body.GetHandle(), cpSpaceGetStaticBody(body.GetWorld()->GetHandle()), ToChipmunk(body.ToLocal(anchor)), ToChipmunk(body.ToLocal(anchor))))
{
}
PhysPinConstraint2D::PhysPinConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor) :
PhysConstraint2D(first.GetWorld(), cpPinJointNew(first.GetHandle(), second.GetHandle(), ToChipmunk(firstAnchor), ToChipmunk(secondAnchor)))
{
}
float PhysPinConstraint2D::GetDistance() const
{
return float(cpPinJointGetDist(m_constraint));
}
Vector2f PhysPinConstraint2D::GetFirstAnchor() const
{
return FromChipmunk(cpBodyLocalToWorld(cpConstraintGetBodyA(m_constraint), cpPinJointGetAnchorA(m_constraint)));
}
Vector2f PhysPinConstraint2D::GetSecondAnchor() const
{
return FromChipmunk(cpBodyLocalToWorld(cpConstraintGetBodyB(m_constraint), cpPinJointGetAnchorB(m_constraint)));
}
void PhysPinConstraint2D::SetDistance(float newDistance)
{
cpPinJointSetDist(m_constraint, newDistance);
}
void PhysPinConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor)
{
cpPinJointSetAnchorA(m_constraint, cpBodyWorldToLocal(cpConstraintGetBodyA(m_constraint), ToChipmunk(firstAnchor)));
}
void PhysPinConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor)
{
cpPinJointSetAnchorB(m_constraint, cpBodyWorldToLocal(cpConstraintGetBodyB(m_constraint), ToChipmunk(firstAnchor)));
}
PhysPivotConstraint2D::PhysPivotConstraint2D(RigidBody2D& body, const Vector2f& anchor) :
PhysConstraint2D(body.GetWorld(), cpPivotJointNew(cpSpaceGetStaticBody(body.GetWorld()->GetHandle()), body.GetHandle(), ToChipmunk(anchor)))
{
}
PhysPivotConstraint2D::PhysPivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& anchor) :
PhysConstraint2D(first.GetWorld(), cpPivotJointNew(first.GetHandle(), second.GetHandle(), ToChipmunk(anchor)))
{
}
PhysPivotConstraint2D::PhysPivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor) :
PhysConstraint2D(first.GetWorld(), cpPivotJointNew2(first.GetHandle(), second.GetHandle(), ToChipmunk(firstAnchor), ToChipmunk(secondAnchor)))
{
}
Vector2f PhysPivotConstraint2D::GetFirstAnchor() const
{
return FromChipmunk(cpBodyLocalToWorld(cpConstraintGetBodyA(m_constraint), cpPivotJointGetAnchorA(m_constraint)));
}
Vector2f PhysPivotConstraint2D::GetSecondAnchor() const
{
return FromChipmunk(cpBodyLocalToWorld(cpConstraintGetBodyB(m_constraint), cpPivotJointGetAnchorB(m_constraint)));
}
void PhysPivotConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor)
{
cpPivotJointSetAnchorA(m_constraint, cpBodyWorldToLocal(cpConstraintGetBodyA(m_constraint), ToChipmunk(firstAnchor)));
}
void PhysPivotConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor)
{
cpPivotJointSetAnchorB(m_constraint, cpBodyWorldToLocal(cpConstraintGetBodyB(m_constraint), ToChipmunk(firstAnchor)));
}
PhysRatchetConstraint2D::PhysRatchetConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratchet) :
PhysConstraint2D(first.GetWorld(), cpRatchetJointNew(first.GetHandle(), second.GetHandle(), phase, ratchet))
{
}
RadianAnglef PhysRatchetConstraint2D::GetAngle() const
{
return float(cpRatchetJointGetAngle(m_constraint));
}
float PhysRatchetConstraint2D::GetPhase() const
{
return float(cpRatchetJointGetPhase(m_constraint));
}
float PhysRatchetConstraint2D::GetRatchet() const
{
return float(cpRatchetJointGetRatchet(m_constraint));
}
void PhysRatchetConstraint2D::SetAngle(const RadianAnglef& angle)
{
cpRatchetJointSetAngle(m_constraint, angle.value);
}
void PhysRatchetConstraint2D::SetPhase(float phase)
{
cpRatchetJointSetPhase(m_constraint, phase);
}
void PhysRatchetConstraint2D::SetRatchet(float ratchet)
{
cpRatchetJointSetRatchet(m_constraint, ratchet);
}
PhysRotaryLimitConstraint2D::PhysRotaryLimitConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& minAngle, const RadianAnglef& maxAngle) :
PhysConstraint2D(first.GetWorld(), cpRotaryLimitJointNew(first.GetHandle(), second.GetHandle(), minAngle.value, maxAngle.value))
{
}
RadianAnglef PhysRotaryLimitConstraint2D::GetMaxAngle() const
{
return float(cpRotaryLimitJointGetMax(m_constraint));
}
RadianAnglef PhysRotaryLimitConstraint2D::GetMinAngle() const
{
return float(cpRotaryLimitJointGetMax(m_constraint));
}
void PhysRotaryLimitConstraint2D::SetMaxAngle(const RadianAnglef& maxAngle)
{
cpRotaryLimitJointSetMax(m_constraint, maxAngle.value);
}
void PhysRotaryLimitConstraint2D::SetMinAngle(const RadianAnglef& minAngle)
{
cpRotaryLimitJointSetMin(m_constraint, minAngle.value);
}
PhysSlideConstraint2D::PhysSlideConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float min, float max) :
PhysConstraint2D(first.GetWorld(), cpSlideJointNew(first.GetHandle(), second.GetHandle(), ToChipmunk(firstAnchor), ToChipmunk(secondAnchor), min, max))
{
}
Vector2f PhysSlideConstraint2D::GetFirstAnchor() const
{
cpVect anchor = cpSlideJointGetAnchorA(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(anchor.y));
}
float PhysSlideConstraint2D::GetMaxDistance() const
{
return float(cpSlideJointGetMax(m_constraint));
}
float PhysSlideConstraint2D::GetMinDistance() const
{
return float(cpSlideJointGetMin(m_constraint));
}
Vector2f PhysSlideConstraint2D::GetSecondAnchor() const
{
cpVect anchor = cpSlideJointGetAnchorB(m_constraint);
return Vector2f(static_cast<float>(anchor.x), static_cast<float>(anchor.y));
}
void PhysSlideConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor)
{
cpSlideJointSetAnchorA(m_constraint, ToChipmunk(firstAnchor));
}
void PhysSlideConstraint2D::SetMaxDistance(float newMaxDistance)
{
cpSlideJointSetMax(m_constraint, newMaxDistance);
}
void PhysSlideConstraint2D::SetMinDistance(float newMinDistance)
{
cpSlideJointSetMin(m_constraint, newMinDistance);
}
void PhysSlideConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor)
{
cpSlideJointSetAnchorB(m_constraint, ToChipmunk(firstAnchor));
}
}

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

@@ -1,12 +1,12 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D module"
// 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/ChipmunkPhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <Nazara/Physics2D/PhysArbiter2D.hpp>
#include <NazaraUtils/StackArray.hpp>
#include <chipmunk/chipmunk.h>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
#include <Nazara/Physics2D/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<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<PhysWorld2D::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<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<PhysWorld2D::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<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->polygonCallback)
{
if constexpr (sizeof(cpVect) == sizeof(Vector2f))
@@ -56,24 +56,24 @@ namespace Nz
void CpSegmentCallback(cpVect a, cpVect b, cpSpaceDebugColor color, cpDataPointer userdata)
{
auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<PhysWorld2D::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<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<PhysWorld2D::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<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
auto drawOptions = static_cast<PhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->colorCallback)
{
ChipmunkRigidBody2D& rigidBody = *static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
RigidBody2D& rigidBody = *static_cast<RigidBody2D*>(cpShapeGetUserData(shape));
return ColorToCpDebugColor(drawOptions->colorCallback(rigidBody, rigidBody.GetShapeIndex(shape), drawOptions->userdata));
}
else
@@ -81,7 +81,7 @@ namespace Nz
}
}
ChipmunkPhysWorld2D::ChipmunkPhysWorld2D() :
PhysWorld2D::PhysWorld2D() :
m_maxStepCount(50),
m_stepSize(Time::TickDuration(120)),
m_timestepAccumulator(Time::Zero())
@@ -90,12 +90,12 @@ namespace Nz
cpSpaceSetUserData(m_handle, this);
}
ChipmunkPhysWorld2D::~ChipmunkPhysWorld2D()
PhysWorld2D::~PhysWorld2D()
{
cpSpaceFree(m_handle);
}
void ChipmunkPhysWorld2D::DebugDraw(const DebugDrawOptions& options, bool drawShapes, bool drawConstraints, bool drawCollisions) const
void PhysWorld2D::DebugDraw(const DebugDrawOptions& options, bool drawShapes, bool drawConstraints, bool drawCollisions) const
{
auto ColorToCpDebugColor = [](Color c) -> cpSpaceDebugColor
{
@@ -131,45 +131,45 @@ namespace Nz
cpSpaceDebugDraw(m_handle, &drawOptions);
}
float ChipmunkPhysWorld2D::GetDamping() const
float PhysWorld2D::GetDamping() const
{
return float(cpSpaceGetDamping(m_handle));
}
Vector2f ChipmunkPhysWorld2D::GetGravity() const
Vector2f PhysWorld2D::GetGravity() const
{
cpVect gravity = cpSpaceGetGravity(m_handle);
return Vector2f(Vector2<cpFloat>(gravity.x, gravity.y));
}
cpSpace* ChipmunkPhysWorld2D::GetHandle() const
cpSpace* PhysWorld2D::GetHandle() const
{
return m_handle;
}
std::size_t ChipmunkPhysWorld2D::GetIterationCount() const
std::size_t PhysWorld2D::GetIterationCount() const
{
return cpSpaceGetIterations(m_handle);
}
std::size_t ChipmunkPhysWorld2D::GetMaxStepCount() const
std::size_t PhysWorld2D::GetMaxStepCount() const
{
return m_maxStepCount;
}
Time ChipmunkPhysWorld2D::GetStepSize() const
Time PhysWorld2D::GetStepSize() const
{
return m_stepSize;
}
bool ChipmunkPhysWorld2D::NearestBodyQuery(const Vector2f & from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, ChipmunkRigidBody2D** nearestBody)
bool PhysWorld2D::NearestBodyQuery(const Vector2f & from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RigidBody2D** 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<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
*nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(shape));
return true;
}
@@ -177,7 +177,7 @@ namespace Nz
return false;
}
bool ChipmunkPhysWorld2D::NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, NearestQueryResult* result)
bool PhysWorld2D::NearestBodyQuery(const Vector2f& from, float maxDistance, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, NearestQueryResult* result)
{
cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask);
@@ -190,7 +190,7 @@ namespace Nz
result->closestPoint = Vector2f(Vector2<cpFloat>(queryInfo.point.x, queryInfo.point.y));
result->distance = float(queryInfo.distance);
result->fraction = Vector2f(Vector2<cpFloat>(queryInfo.gradient.x, queryInfo.gradient.y));
result->nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(queryInfo.shape));
result->nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(queryInfo.shape));
return true;
}
@@ -206,7 +206,7 @@ namespace Nz
}
}
void ChipmunkPhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<void(const RaycastHit&)>& callback)
void PhysWorld2D::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)>;
@@ -218,7 +218,7 @@ namespace Nz
hitInfo.fraction = float(alpha);
hitInfo.hitNormal = Vector2f(Vector2<cpFloat>(normal.x, normal.y));
hitInfo.hitPos = Vector2f(Vector2<cpFloat>(point.x, point.y));
hitInfo.nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
hitInfo.nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(shape));
callback(hitInfo);
};
@@ -227,7 +227,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 ChipmunkPhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RaycastHit>* hitInfos)
bool PhysWorld2D::RaycastQuery(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RaycastHit>* hitInfos)
{
using ResultType = decltype(hitInfos);
@@ -239,7 +239,7 @@ namespace Nz
hitInfo.fraction = float(alpha);
hitInfo.hitNormal = Vector2f(Vector2<cpFloat>(normal.x, normal.y));
hitInfo.hitPos = Vector2f(Vector2<cpFloat>(point.x, point.y));
hitInfo.nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape));
hitInfo.nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(shape));
results->emplace_back(std::move(hitInfo));
};
@@ -252,7 +252,7 @@ namespace Nz
return hitInfos->size() != previousSize;
}
bool ChipmunkPhysWorld2D::RaycastQueryFirst(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RaycastHit* hitInfo)
bool PhysWorld2D::RaycastQueryFirst(const Vector2f& from, const Vector2f& to, float radius, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, RaycastHit* hitInfo)
{
cpShapeFilter filter = cpShapeFilterNew(collisionGroup, categoryMask, collisionMask);
@@ -265,7 +265,7 @@ namespace Nz
hitInfo->fraction = float(queryInfo.alpha);
hitInfo->hitNormal = Vector2f(Vector2<cpFloat>(queryInfo.normal.x, queryInfo.normal.y));
hitInfo->hitPos = Vector2f(Vector2<cpFloat>(queryInfo.point.x, queryInfo.point.y));
hitInfo->nearestBody = static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(queryInfo.shape));
hitInfo->nearestBody = static_cast<RigidBody2D*>(cpShapeGetUserData(queryInfo.shape));
return true;
}
@@ -281,65 +281,65 @@ namespace Nz
}
}
void ChipmunkPhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<void(ChipmunkRigidBody2D*)>& callback)
void PhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, const FunctionRef<void(RigidBody2D*)>& callback)
{
using CallbackType = std::remove_reference_t<decltype(callback)>;
auto cpCallback = [](cpShape* shape, void* data)
{
CallbackType& callback = *static_cast<CallbackType*>(data);
callback(static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape)));
callback(static_cast<RigidBody2D*>(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 ChipmunkPhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<ChipmunkRigidBody2D*>* bodies)
void PhysWorld2D::RegionQuery(const Rectf& boundingBox, UInt32 collisionGroup, UInt32 categoryMask, UInt32 collisionMask, std::vector<RigidBody2D*>* bodies)
{
using ResultType = decltype(bodies);
auto callback = [] (cpShape* shape, void* data)
{
ResultType results = static_cast<ResultType>(data);
results->push_back(static_cast<ChipmunkRigidBody2D*>(cpShapeGetUserData(shape)));
results->push_back(static_cast<RigidBody2D*>(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 ChipmunkPhysWorld2D::RegisterCallbacks(unsigned int collisionId, ContactCallbacks callbacks)
void PhysWorld2D::RegisterCallbacks(unsigned int collisionId, ContactCallbacks callbacks)
{
InitCallbacks(cpSpaceAddWildcardHandler(m_handle, collisionId), std::move(callbacks));
}
void ChipmunkPhysWorld2D::RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, ContactCallbacks callbacks)
void PhysWorld2D::RegisterCallbacks(unsigned int collisionIdA, unsigned int collisionIdB, ContactCallbacks callbacks)
{
InitCallbacks(cpSpaceAddCollisionHandler(m_handle, collisionIdA, collisionIdB), std::move(callbacks));
}
void ChipmunkPhysWorld2D::SetDamping(float dampingValue)
void PhysWorld2D::SetDamping(float dampingValue)
{
cpSpaceSetDamping(m_handle, dampingValue);
}
void ChipmunkPhysWorld2D::SetGravity(const Vector2f& gravity)
void PhysWorld2D::SetGravity(const Vector2f& gravity)
{
cpSpaceSetGravity(m_handle, cpv(gravity.x, gravity.y));
}
void ChipmunkPhysWorld2D::SetIterationCount(std::size_t iterationCount)
void PhysWorld2D::SetIterationCount(std::size_t iterationCount)
{
cpSpaceSetIterations(m_handle, SafeCast<int>(iterationCount));
}
void ChipmunkPhysWorld2D::SetMaxStepCount(std::size_t maxStepCount)
void PhysWorld2D::SetMaxStepCount(std::size_t maxStepCount)
{
m_maxStepCount = maxStepCount;
}
void ChipmunkPhysWorld2D::SetSleepTime(Time sleepTime)
void PhysWorld2D::SetSleepTime(Time sleepTime)
{
if (sleepTime > Time::Zero())
cpSpaceSetSleepTimeThreshold(m_handle, sleepTime.AsSeconds<cpFloat>());
@@ -347,12 +347,12 @@ namespace Nz
cpSpaceSetSleepTimeThreshold(m_handle, std::numeric_limits<cpFloat>::infinity());
}
void ChipmunkPhysWorld2D::SetStepSize(Time stepSize)
void PhysWorld2D::SetStepSize(Time stepSize)
{
m_stepSize = stepSize;
}
void ChipmunkPhysWorld2D::Step(Time timestep)
void PhysWorld2D::Step(Time timestep)
{
m_timestepAccumulator += timestep;
@@ -371,7 +371,7 @@ namespace Nz
{
for (auto&& [bodyIndex, callbackVec] : m_rigidBodyPostSteps)
{
ChipmunkRigidBody2D* rigidBody = m_bodies[bodyIndex];
RigidBody2D* rigidBody = m_bodies[bodyIndex];
assert(rigidBody);
for (const auto& step : callbackVec)
@@ -385,12 +385,12 @@ namespace Nz
}
}
void ChipmunkPhysWorld2D::UseSpatialHash(float cellSize, std::size_t entityCount)
void PhysWorld2D::UseSpatialHash(float cellSize, std::size_t entityCount)
{
cpSpaceUseSpatialHash(m_handle, cpFloat(cellSize), int(entityCount));
}
void ChipmunkPhysWorld2D::InitCallbacks(cpCollisionHandler* handler, ContactCallbacks callbacks)
void PhysWorld2D::InitCallbacks(cpCollisionHandler* handler, ContactCallbacks callbacks)
{
auto it = m_callbacks.find(handler);
if (it == m_callbacks.end())
@@ -409,11 +409,11 @@ namespace Nz
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
ChipmunkArbiter2D arbiter(arb);
PhysArbiter2D arbiter(arb);
const ContactCallbacks* customCallbacks = static_cast<const ContactCallbacks*>(data);
if (customCallbacks->startCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata))
@@ -438,11 +438,11 @@ namespace Nz
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
ChipmunkArbiter2D arbiter(arb);
PhysArbiter2D arbiter(arb);
const ContactCallbacks* customCallbacks = static_cast<const ContactCallbacks*>(data);
customCallbacks->endCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata);
@@ -463,11 +463,11 @@ namespace Nz
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
ChipmunkArbiter2D arbiter(arb);
PhysArbiter2D arbiter(arb);
const ContactCallbacks* customCallbacks = static_cast<const ContactCallbacks*>(data);
if (customCallbacks->preSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata))
@@ -492,11 +492,11 @@ namespace Nz
cpBody* secondBody;
cpArbiterGetBodies(arb, &firstBody, &secondBody);
ChipmunkPhysWorld2D* world = static_cast<ChipmunkPhysWorld2D*>(cpSpaceGetUserData(space));
ChipmunkRigidBody2D* firstRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(firstBody));
ChipmunkRigidBody2D* secondRigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(secondBody));
PhysWorld2D* world = static_cast<PhysWorld2D*>(cpSpaceGetUserData(space));
RigidBody2D* firstRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(firstBody));
RigidBody2D* secondRigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(secondBody));
ChipmunkArbiter2D arbiter(arb);
PhysArbiter2D arbiter(arb);
const ContactCallbacks* customCallbacks = static_cast<const ContactCallbacks*>(data);
customCallbacks->postSolveCallback(*world, arbiter, *firstRigidBody, *secondRigidBody, customCallbacks->userdata);
@@ -510,7 +510,7 @@ namespace Nz
}
}
void ChipmunkPhysWorld2D::DeferBodyAction(ChipmunkRigidBody2D& rigidBody, PostStep&& func)
void PhysWorld2D::DeferBodyAction(RigidBody2D& rigidBody, PostStep&& func)
{
// If space isn't locked, no need to wait
if (!cpSpaceIsLocked(m_handle))

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

@@ -0,0 +1,16 @@
// Copyright (C) 2024 Jérôme "SirLynix" 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;
}

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

@@ -1,20 +1,20 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D module"
// 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/ChipmunkRigidBody2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkArbiter2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkHelper.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp>
#include <Nazara/Physics2D/ChipmunkHelper.hpp>
#include <Nazara/Physics2D/PhysArbiter2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <chipmunk/chipmunk.h>
#include <chipmunk/chipmunk_private.h>
#include <algorithm>
#include <cmath>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
#include <Nazara/Physics2D/Debug.hpp>
namespace Nz
{
ChipmunkRigidBody2D::ChipmunkRigidBody2D(const ChipmunkRigidBody2D& object) :
RigidBody2D::RigidBody2D(const RigidBody2D& object) :
m_geom(object.m_geom),
m_world(object.m_world),
m_positionOffset(object.m_positionOffset),
@@ -43,7 +43,7 @@ namespace Nz
}
}
ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkRigidBody2D&& object) noexcept :
RigidBody2D::RigidBody2D(RigidBody2D&& object) noexcept :
m_shapes(std::move(object.m_shapes)),
m_geom(std::move(object.m_geom)),
m_handle(object.m_handle),
@@ -69,7 +69,7 @@ namespace Nz
object.m_handle = nullptr;
}
void ChipmunkRigidBody2D::AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys)
void RigidBody2D::AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys)
{
switch (coordSys)
{
@@ -83,7 +83,7 @@ namespace Nz
}
}
void ChipmunkRigidBody2D::AddImpulse(const Vector2f& impulse, const Vector2f& point, CoordSys coordSys)
void RigidBody2D::AddImpulse(const Vector2f& impulse, const Vector2f& point, CoordSys coordSys)
{
switch (coordSys)
{
@@ -97,12 +97,12 @@ namespace Nz
}
}
void ChipmunkRigidBody2D::AddTorque(const RadianAnglef& torque)
void RigidBody2D::AddTorque(const RadianAnglef& torque)
{
cpBodySetTorque(m_handle, cpBodyGetTorque(m_handle) + torque.value);
}
bool ChipmunkRigidBody2D::ClosestPointQuery(const Vector2f& position, Vector2f* closestPoint, float* closestDistance) const
bool RigidBody2D::ClosestPointQuery(const Vector2f& position, Vector2f* closestPoint, float* closestDistance) const
{
cpVect pos = cpv(cpFloat(position.x), cpFloat(position.y));
@@ -133,7 +133,7 @@ namespace Nz
return true;
}
void ChipmunkRigidBody2D::EnableSimulation(bool simulation)
void RigidBody2D::EnableSimulation(bool simulation)
{
if (m_isSimulationEnabled != simulation)
{
@@ -146,7 +146,7 @@ namespace Nz
}
}
void ChipmunkRigidBody2D::ForEachArbiter(const FunctionRef<void(ChipmunkArbiter2D&)>& callback)
void RigidBody2D::ForEachArbiter(const FunctionRef<void(PhysArbiter2D&)>& callback)
{
using CallbackType = std::remove_reference_t<decltype(callback)>;
@@ -154,23 +154,23 @@ namespace Nz
{
CallbackType& cb = *static_cast<CallbackType*>(data);
ChipmunkArbiter2D wrappedArbiter(arbiter);
PhysArbiter2D wrappedArbiter(arbiter);
cb(wrappedArbiter);
};
cpBodyEachArbiter(m_handle, Trampoline, const_cast<void*>(static_cast<const void*>(&callback)));
}
void ChipmunkRigidBody2D::ForceSleep()
void RigidBody2D::ForceSleep()
{
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](RigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) == CP_BODY_TYPE_DYNAMIC)
cpBodySleep(body->GetHandle());
});
}
Rectf ChipmunkRigidBody2D::GetAABB() const
Rectf RigidBody2D::GetAABB() const
{
if (m_shapes.empty())
return Rectf::Zero();
@@ -183,24 +183,24 @@ namespace Nz
return Rectf(Rect<cpFloat>(bb.l, bb.b, bb.r - bb.l, bb.t - bb.b));
}
RadianAnglef ChipmunkRigidBody2D::GetAngularVelocity() const
RadianAnglef RigidBody2D::GetAngularVelocity() const
{
return float(cpBodyGetAngularVelocity(m_handle));
}
float ChipmunkRigidBody2D::GetElasticity(std::size_t shapeIndex) const
float RigidBody2D::GetElasticity(std::size_t shapeIndex) const
{
assert(shapeIndex < m_shapes.size());
return float(cpShapeGetElasticity(m_shapes[shapeIndex]));
}
float ChipmunkRigidBody2D::GetFriction(std::size_t shapeIndex) const
float RigidBody2D::GetFriction(std::size_t shapeIndex) const
{
assert(shapeIndex < m_shapes.size());
return float(cpShapeGetFriction(m_shapes[shapeIndex]));
}
Vector2f ChipmunkRigidBody2D::GetMassCenter(CoordSys coordSys) const
Vector2f RigidBody2D::GetMassCenter(CoordSys coordSys) const
{
cpVect massCenter = cpBodyGetCenterOfGravity(m_handle);
@@ -217,77 +217,77 @@ namespace Nz
return Vector2f(static_cast<float>(massCenter.x), static_cast<float>(massCenter.y));
}
float ChipmunkRigidBody2D::GetMomentOfInertia() const
float RigidBody2D::GetMomentOfInertia() const
{
return float(cpBodyGetMoment(m_handle));
}
Vector2f ChipmunkRigidBody2D::GetPosition() const
Vector2f RigidBody2D::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 ChipmunkRigidBody2D::GetRotation() const
RadianAnglef RigidBody2D::GetRotation() const
{
return float(cpBodyGetAngle(m_handle));
}
Vector2f ChipmunkRigidBody2D::GetSurfaceVelocity(std::size_t shapeIndex) const
Vector2f RigidBody2D::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));
}
Vector2f ChipmunkRigidBody2D::GetVelocity() const
Vector2f RigidBody2D::GetVelocity() const
{
cpVect vel = cpBodyGetVelocity(m_handle);
return Vector2f(static_cast<float>(vel.x), static_cast<float>(vel.y));
}
bool ChipmunkRigidBody2D::IsSleeping() const
bool RigidBody2D::IsSleeping() const
{
return cpBodyIsSleeping(m_handle) != 0;
}
void ChipmunkRigidBody2D::ResetVelocityFunction()
void RigidBody2D::ResetVelocityFunction()
{
m_handle->velocity_func = cpBodyUpdateVelocity;
}
void ChipmunkRigidBody2D::SetAngularVelocity(const RadianAnglef& angularVelocity)
void RigidBody2D::SetAngularVelocity(const RadianAnglef& angularVelocity)
{
cpBodySetAngularVelocity(m_handle, angularVelocity.value);
}
void ChipmunkRigidBody2D::SetElasticity(float friction)
void RigidBody2D::SetElasticity(float friction)
{
cpFloat frict(friction);
for (cpShape* shape : m_shapes)
cpShapeSetElasticity(shape, frict);
}
void ChipmunkRigidBody2D::SetElasticity(std::size_t shapeIndex, float friction)
void RigidBody2D::SetElasticity(std::size_t shapeIndex, float friction)
{
assert(shapeIndex < m_shapes.size());
cpShapeSetElasticity(m_shapes[shapeIndex], cpFloat(friction));
}
void ChipmunkRigidBody2D::SetFriction(float friction)
void RigidBody2D::SetFriction(float friction)
{
cpFloat frict(friction);
for (cpShape* shape : m_shapes)
cpShapeSetFriction(shape, frict);
}
void ChipmunkRigidBody2D::SetFriction(std::size_t shapeIndex, float friction)
void RigidBody2D::SetFriction(std::size_t shapeIndex, float friction)
{
assert(shapeIndex < m_shapes.size());
cpShapeSetFriction(m_shapes[shapeIndex], cpFloat(friction));
}
void ChipmunkRigidBody2D::SetGeom(std::shared_ptr<ChipmunkCollider2D> geom, bool recomputeMoment, bool recomputeMassCenter)
void RigidBody2D::SetGeom(std::shared_ptr<Collider2D> 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
@@ -315,7 +315,7 @@ namespace Nz
if (geom)
m_geom = std::move(geom);
else
m_geom = std::make_shared<ChipmunkNullCollider2D>();
m_geom = std::make_shared<NullCollider2D>();
m_geom->GenerateShapes(m_handle, &m_shapes);
@@ -335,13 +335,13 @@ namespace Nz
SetMassCenter(m_geom->ComputeCenterOfMass());
}
void ChipmunkRigidBody2D::SetMass(float mass, bool recomputeMoment)
void RigidBody2D::SetMass(float mass, bool recomputeMoment)
{
if (m_mass > 0.f)
{
if (mass > 0.f)
{
m_world->DeferBodyAction(*this, [mass, recomputeMoment](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [mass, recomputeMoment](RigidBody2D* body)
{
cpBodySetMass(body->GetHandle(), mass);
@@ -350,11 +350,11 @@ namespace Nz
});
}
else
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body) { cpBodySetType(body->GetHandle(), (body->IsStatic()) ? CP_BODY_TYPE_STATIC : CP_BODY_TYPE_KINEMATIC); } );
m_world->DeferBodyAction(*this, [](RigidBody2D* body) { cpBodySetType(body->GetHandle(), (body->IsStatic()) ? CP_BODY_TYPE_STATIC : CP_BODY_TYPE_KINEMATIC); } );
}
else if (mass > 0.f)
{
m_world->DeferBodyAction(*this, [mass, recomputeMoment](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [mass, recomputeMoment](RigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_DYNAMIC)
{
@@ -370,7 +370,7 @@ namespace Nz
m_mass = mass;
}
void ChipmunkRigidBody2D::SetMassCenter(const Vector2f& center, CoordSys coordSys)
void RigidBody2D::SetMassCenter(const Vector2f& center, CoordSys coordSys)
{
cpVect massCenter = ToChipmunk(center);
@@ -387,64 +387,64 @@ namespace Nz
cpBodySetCenterOfGravity(m_handle, massCenter);
}
void ChipmunkRigidBody2D::SetMomentOfInertia(float moment)
void RigidBody2D::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->DeferBodyAction(*this, [moment] (ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [moment] (RigidBody2D* body)
{
cpBodySetMoment(body->GetHandle(), moment);
});
}
void ChipmunkRigidBody2D::SetPosition(const Vector2f& position)
void RigidBody2D::SetPosition(const Vector2f& position)
{
// Use cpTransformVect to rotate/scale the position offset
cpBodySetPosition(m_handle, cpvadd(ToChipmunk(position), cpTransformVect(m_handle->transform, ToChipmunk(m_positionOffset))));
if (m_isStatic)
{
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](RigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
}
}
void ChipmunkRigidBody2D::SetPositionOffset(const Vector2f& offset)
void RigidBody2D::SetPositionOffset(const Vector2f& offset)
{
Vector2f position = GetPosition();
m_positionOffset = offset;
SetPosition(position);
}
void ChipmunkRigidBody2D::SetRotation(const RadianAnglef& rotation)
void RigidBody2D::SetRotation(const RadianAnglef& rotation)
{
cpBodySetAngle(m_handle, rotation.value);
if (m_isStatic)
{
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](RigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
}
}
void ChipmunkRigidBody2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity)
void RigidBody2D::SetSurfaceVelocity(const Vector2f& surfaceVelocity)
{
Vector2<cpFloat> velocity(surfaceVelocity.x, surfaceVelocity.y);
for (cpShape* shape : m_shapes)
cpShapeSetSurfaceVelocity(shape, cpv(velocity.x, velocity.y));
}
void ChipmunkRigidBody2D::SetSurfaceVelocity(std::size_t shapeIndex, const Vector2f& surfaceVelocity)
void RigidBody2D::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 ChipmunkRigidBody2D::SetStatic(bool setStaticBody)
void RigidBody2D::SetStatic(bool setStaticBody)
{
m_isStatic = setStaticBody;
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](RigidBody2D* body)
{
if (body->IsStatic())
{
@@ -458,12 +458,12 @@ namespace Nz
});
}
void ChipmunkRigidBody2D::SetVelocity(const Vector2f& velocity)
void RigidBody2D::SetVelocity(const Vector2f& velocity)
{
cpBodySetVelocity(m_handle, ToChipmunk(velocity));
}
void ChipmunkRigidBody2D::SetVelocityFunction(VelocityFunc velocityFunc)
void RigidBody2D::SetVelocityFunction(VelocityFunc velocityFunc)
{
m_velocityFunc = std::move(velocityFunc);
@@ -471,7 +471,7 @@ namespace Nz
{
m_handle->velocity_func = [](cpBody* body, cpVect gravity, cpFloat damping, cpFloat dt)
{
ChipmunkRigidBody2D* rigidBody = static_cast<ChipmunkRigidBody2D*>(cpBodyGetUserData(body));
RigidBody2D* rigidBody = static_cast<RigidBody2D*>(cpBodyGetUserData(body));
const auto& callback = rigidBody->GetVelocityFunction();
assert(callback);
@@ -482,48 +482,48 @@ namespace Nz
m_handle->velocity_func = cpBodyUpdateVelocity;
}
void ChipmunkRigidBody2D::TeleportTo(const Vector2f& position, const RadianAnglef& rotation)
void RigidBody2D::TeleportTo(const Vector2f& position, const RadianAnglef& rotation)
{
// Use cpTransformVect to rotate/scale the position offset
cpBodySetPosition(m_handle, cpvadd(ToChipmunk(position), cpTransformVect(m_handle->transform, ToChipmunk(m_positionOffset))));
cpBodySetAngle(m_handle, rotation.value);
if (m_isStatic)
{
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](RigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
}
}
RadianAnglef ChipmunkRigidBody2D::ToLocal(const RadianAnglef& worldRotation)
RadianAnglef RigidBody2D::ToLocal(const RadianAnglef& worldRotation)
{
return worldRotation - GetRotation();
}
Vector2f ChipmunkRigidBody2D::ToLocal(const Vector2f& worldPosition)
Vector2f RigidBody2D::ToLocal(const Vector2f& worldPosition)
{
return FromChipmunk(cpBodyWorldToLocal(m_handle, ToChipmunk(worldPosition)));
}
RadianAnglef ChipmunkRigidBody2D::ToWorld(const RadianAnglef& localRotation)
RadianAnglef RigidBody2D::ToWorld(const RadianAnglef& localRotation)
{
return GetRotation() + localRotation;
}
Vector2f ChipmunkRigidBody2D::ToWorld(const Vector2f& localPosition)
Vector2f RigidBody2D::ToWorld(const Vector2f& localPosition)
{
return FromChipmunk(cpBodyLocalToWorld(m_handle, ToChipmunk(localPosition)));
}
void ChipmunkRigidBody2D::UpdateVelocity(const Vector2f& gravity, float damping, float deltaTime)
void RigidBody2D::UpdateVelocity(const Vector2f& gravity, float damping, float deltaTime)
{
cpBodyUpdateVelocity(m_handle, ToChipmunk(gravity), damping, deltaTime);
}
void ChipmunkRigidBody2D::Wakeup()
void RigidBody2D::Wakeup()
{
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](RigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_STATIC)
cpBodyActivate(body->GetHandle());
@@ -532,12 +532,12 @@ namespace Nz
});
}
ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(const ChipmunkRigidBody2D& object)
RigidBody2D& RigidBody2D::operator=(const RigidBody2D& object)
{
return operator=(ChipmunkRigidBody2D(object));
return operator=(RigidBody2D(object));
}
ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(ChipmunkRigidBody2D&& object) noexcept
RigidBody2D& RigidBody2D::operator=(RigidBody2D&& object) noexcept
{
Destroy();
@@ -569,7 +569,7 @@ namespace Nz
return *this;
}
void ChipmunkRigidBody2D::Create(ChipmunkPhysWorld2D& world, const DynamicSettings& settings)
void RigidBody2D::Create(PhysWorld2D& world, const DynamicSettings& settings)
{
m_isRegistered = false;
m_isSimulationEnabled = settings.isSimulationEnabled;
@@ -591,7 +591,7 @@ namespace Nz
SetVelocity(settings.linearVelocity);
}
void ChipmunkRigidBody2D::Create(ChipmunkPhysWorld2D& world, const StaticSettings& settings)
void RigidBody2D::Create(PhysWorld2D& world, const StaticSettings& settings)
{
m_gravityFactor = 1.f;
m_isRegistered = false;
@@ -611,7 +611,7 @@ namespace Nz
SetRotation(settings.rotation);
}
void ChipmunkRigidBody2D::Destroy()
void RigidBody2D::Destroy()
{
if (m_bodyIndex != InvalidBodyIndex)
{
@@ -622,7 +622,7 @@ namespace Nz
DestroyBody();
}
void ChipmunkRigidBody2D::DestroyBody()
void RigidBody2D::DestroyBody()
{
UnregisterFromSpace();
@@ -638,7 +638,7 @@ namespace Nz
m_shapes.clear();
}
void ChipmunkRigidBody2D::RegisterToSpace()
void RigidBody2D::RegisterToSpace()
{
if (!m_isRegistered)
{
@@ -653,7 +653,7 @@ namespace Nz
}
}
void ChipmunkRigidBody2D::UnregisterFromSpace()
void RigidBody2D::UnregisterFromSpace()
{
if (m_isRegistered)
{
@@ -668,7 +668,7 @@ namespace Nz
}
}
void ChipmunkRigidBody2D::CopyBodyData(cpBody* from, cpBody* to)
void RigidBody2D::CopyBodyData(cpBody* from, cpBody* to)
{
cpBodySetType(to, cpBodyGetType(from));
@@ -684,7 +684,7 @@ namespace Nz
to->velocity_func = from->velocity_func;
}
void ChipmunkRigidBody2D::CopyShapeData(cpShape* from, cpShape* to)
void RigidBody2D::CopyShapeData(cpShape* from, cpShape* to)
{
cpShapeSetElasticity(to, cpShapeGetElasticity(from));
cpShapeSetFriction(to, cpShapeGetFriction(from));

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

@@ -1,11 +1,11 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - ChipmunkPhysics2D module"
// 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/Systems/ChipmunkPhysics2DSystem.hpp>
#include <Nazara/Core/Components/DisabledComponent.hpp>
#include <Nazara/Physics2D/Systems/Physics2DSystem.hpp>
#include <Nazara/Utility/Components/NodeComponent.hpp>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
#include <Nazara/Physics2D/Debug.hpp>
namespace Nz
{
@@ -20,30 +20,30 @@ namespace Nz
}
}
ChipmunkPhysics2DSystem::ChipmunkPhysics2DSystem(entt::registry& registry) :
Physics2DSystem::Physics2DSystem(entt::registry& registry) :
m_registry(registry),
m_physicsConstructObserver(m_registry, entt::collector.group<ChipmunkRigidBody2DComponent, NodeComponent>())
m_physicsConstructObserver(m_registry, entt::collector.group<RigidBody2DComponent, NodeComponent>())
{
m_bodyConstructConnection = registry.on_construct<ChipmunkRigidBody2DComponent>().connect<&ChipmunkPhysics2DSystem::OnBodyConstruct>(this);
m_bodyDestructConnection = registry.on_destroy<ChipmunkRigidBody2DComponent>().connect<&ChipmunkPhysics2DSystem::OnBodyDestruct>(this);
m_bodyConstructConnection = registry.on_construct<RigidBody2DComponent>().connect<&Physics2DSystem::OnBodyConstruct>(this);
m_bodyDestructConnection = registry.on_destroy<RigidBody2DComponent>().connect<&Physics2DSystem::OnBodyDestruct>(this);
}
ChipmunkPhysics2DSystem::~ChipmunkPhysics2DSystem()
Physics2DSystem::~Physics2DSystem()
{
m_physicsConstructObserver.disconnect();
// Ensure every body is destroyed before world is
auto rigidBodyView = m_registry.view<ChipmunkRigidBody2DComponent>();
auto rigidBodyView = m_registry.view<RigidBody2DComponent>();
for (auto [entity, rigidBodyComponent] : rigidBodyView.each())
rigidBodyComponent.Destroy();
}
void ChipmunkPhysics2DSystem::Update(Time elapsedTime)
void Physics2DSystem::Update(Time elapsedTime)
{
// Move newly-created physics entities to their node position/rotation
m_physicsConstructObserver.each([&](entt::entity entity)
{
ChipmunkRigidBody2DComponent& entityPhysics = m_registry.get<ChipmunkRigidBody2DComponent>(entity);
RigidBody2DComponent& entityPhysics = m_registry.get<RigidBody2DComponent>(entity);
NodeComponent& entityNode = m_registry.get<NodeComponent>(entity);
entityPhysics.TeleportTo(Vector2f(entityNode.GetPosition()), AngleFromQuaternion(entityNode.GetRotation()));
@@ -52,7 +52,7 @@ namespace Nz
m_physWorld.Step(elapsedTime);
// Replicate rigid body position to their node components
auto view = m_registry.view<NodeComponent, const ChipmunkRigidBody2DComponent>(entt::exclude<DisabledComponent>);
auto view = m_registry.view<NodeComponent, const RigidBody2DComponent>(entt::exclude<DisabledComponent>);
for (auto [entity, nodeComponent, rigidBodyComponent] : view.each())
{
if (rigidBodyComponent.IsSleeping())
@@ -62,14 +62,14 @@ namespace Nz
}
}
ChipmunkPhysWorld2D::ContactCallbacks ChipmunkPhysics2DSystem::SetupContactCallbacks(ContactCallbacks callbacks)
PhysWorld2D::ContactCallbacks Physics2DSystem::SetupContactCallbacks(ContactCallbacks callbacks)
{
ChipmunkPhysWorld2D::ContactCallbacks trampolineCallbacks;
PhysWorld2D::ContactCallbacks trampolineCallbacks;
trampolineCallbacks.userdata = callbacks.userdata;
if (callbacks.endCallback)
{
trampolineCallbacks.endCallback = [this, cb = std::move(callbacks.endCallback)](ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)
trampolineCallbacks.endCallback = [this, cb = std::move(callbacks.endCallback)](PhysWorld2D& world, PhysArbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)
{
return cb(world, arbiter, GetRigidBodyEntity(bodyA.GetBodyIndex()), GetRigidBodyEntity(bodyB.GetBodyIndex()), userdata);
};
@@ -77,7 +77,7 @@ namespace Nz
if (callbacks.preSolveCallback)
{
trampolineCallbacks.preSolveCallback = [this, cb = std::move(callbacks.preSolveCallback)](ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)
trampolineCallbacks.preSolveCallback = [this, cb = std::move(callbacks.preSolveCallback)](PhysWorld2D& world, PhysArbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)
{
return cb(world, arbiter, GetRigidBodyEntity(bodyA.GetBodyIndex()), GetRigidBodyEntity(bodyB.GetBodyIndex()), userdata);
};
@@ -85,7 +85,7 @@ namespace Nz
if (callbacks.postSolveCallback)
{
trampolineCallbacks.postSolveCallback = [this, cb = std::move(callbacks.postSolveCallback)](ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)
trampolineCallbacks.postSolveCallback = [this, cb = std::move(callbacks.postSolveCallback)](PhysWorld2D& world, PhysArbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)
{
return cb(world, arbiter, GetRigidBodyEntity(bodyA.GetBodyIndex()), GetRigidBodyEntity(bodyB.GetBodyIndex()), userdata);
};
@@ -93,7 +93,7 @@ namespace Nz
if (callbacks.startCallback)
{
trampolineCallbacks.startCallback = [this, cb = std::move(callbacks.startCallback)](ChipmunkPhysWorld2D& world, ChipmunkArbiter2D& arbiter, ChipmunkRigidBody2D& bodyA, ChipmunkRigidBody2D& bodyB, void* userdata)
trampolineCallbacks.startCallback = [this, cb = std::move(callbacks.startCallback)](PhysWorld2D& world, PhysArbiter2D& arbiter, RigidBody2D& bodyA, RigidBody2D& bodyB, void* userdata)
{
return cb(world, arbiter, GetRigidBodyEntity(bodyA.GetBodyIndex()), GetRigidBodyEntity(bodyB.GetBodyIndex()), userdata);
};
@@ -102,9 +102,9 @@ namespace Nz
return trampolineCallbacks;
}
void ChipmunkPhysics2DSystem::OnBodyConstruct(entt::registry& registry, entt::entity entity)
void Physics2DSystem::OnBodyConstruct(entt::registry& registry, entt::entity entity)
{
ChipmunkRigidBody2DComponent& rigidBody = registry.get<ChipmunkRigidBody2DComponent>(entity);
RigidBody2DComponent& rigidBody = registry.get<RigidBody2DComponent>(entity);
rigidBody.Construct(m_physWorld);
UInt32 uniqueIndex = rigidBody.GetBodyIndex();
@@ -114,10 +114,10 @@ namespace Nz
m_bodyIndicesToEntity[uniqueIndex] = entity;
}
void ChipmunkPhysics2DSystem::OnBodyDestruct(entt::registry& registry, entt::entity entity)
void Physics2DSystem::OnBodyDestruct(entt::registry& registry, entt::entity entity)
{
// Unregister owning entity
ChipmunkRigidBody2DComponent& rigidBody = registry.get<ChipmunkRigidBody2DComponent>(entity);
RigidBody2DComponent& rigidBody = registry.get<RigidBody2DComponent>(entity);
UInt32 uniqueIndex = rigidBody.GetBodyIndex();
assert(uniqueIndex <= m_bodyIndicesToEntity.size());

120
src/Nazara/JoltPhysics3D/JoltCollider3D.cpp → src/Nazara/Physics3D/Collider3D.cpp
View File

@@ -1,10 +1,10 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/JoltCollider3D.hpp>
#include <Nazara/Physics3D/Collider3D.hpp>
#include <Nazara/Core/PrimitiveList.hpp>
#include <Nazara/JoltPhysics3D/JoltHelper.hpp>
#include <Nazara/Physics3D/JoltHelper.hpp>
#include <Nazara/Utility/Algorithm.hpp>
#include <Nazara/Utility/IndexBuffer.hpp>
#include <Nazara/Utility/SoftwareBuffer.hpp>
@@ -21,14 +21,14 @@
#include <Jolt/Physics/Collision/Shape/StaticCompoundShape.h>
#include <optional>
#include <unordered_map>
#include <Nazara/JoltPhysics3D/Debug.hpp>
#include <Nazara/Physics3D/Debug.hpp>
namespace Nz
{
JoltCollider3D::JoltCollider3D() = default;
JoltCollider3D::~JoltCollider3D() = default;
Collider3D::Collider3D() = default;
Collider3D::~Collider3D() = default;
std::shared_ptr<StaticMesh> JoltCollider3D::GenerateDebugMesh() const
std::shared_ptr<StaticMesh> Collider3D::GenerateDebugMesh() const
{
std::vector<Vector3f> colliderVertices;
std::vector<UInt16> colliderIndices;
@@ -44,12 +44,12 @@ namespace Nz
return colliderSubMesh;
}
std::shared_ptr<JoltCollider3D> JoltCollider3D::Build(const PrimitiveList& list)
std::shared_ptr<Collider3D> Collider3D::Build(const PrimitiveList& list)
{
std::size_t primitiveCount = list.GetSize();
if (primitiveCount > 1)
{
std::vector<JoltCompoundCollider3D::ChildCollider> childColliders(primitiveCount);
std::vector<CompoundCollider3D::ChildCollider> childColliders(primitiveCount);
for (unsigned int i = 0; i < primitiveCount; ++i)
{
@@ -59,7 +59,7 @@ namespace Nz
childColliders[i].rotation = primitive.matrix.GetRotation();
}
return std::make_shared<JoltCompoundCollider3D>(std::move(childColliders));
return std::make_shared<CompoundCollider3D>(std::move(childColliders));
}
else if (primitiveCount > 0)
return CreateGeomFromPrimitive(list.GetPrimitive(0));
@@ -67,12 +67,12 @@ namespace Nz
return nullptr;// std::make_shared<NullCollider3D>(); //< TODO
}
void JoltCollider3D::ResetShapeSettings()
void Collider3D::ResetShapeSettings()
{
m_shapeSettings.reset();
}
void JoltCollider3D::SetupShapeSettings(std::unique_ptr<JPH::ShapeSettings>&& shapeSettings)
void Collider3D::SetupShapeSettings(std::unique_ptr<JPH::ShapeSettings>&& shapeSettings)
{
assert(!m_shapeSettings);
m_shapeSettings = std::move(shapeSettings);
@@ -82,37 +82,37 @@ namespace Nz
throw std::runtime_error(std::string("shape creation failed: ") + result.GetError().c_str());
}
std::shared_ptr<JoltCollider3D> JoltCollider3D::CreateGeomFromPrimitive(const Primitive& primitive)
std::shared_ptr<Collider3D> Collider3D::CreateGeomFromPrimitive(const Primitive& primitive)
{
switch (primitive.type)
{
case PrimitiveType::Box:
return std::make_shared<JoltBoxCollider3D>(primitive.box.lengths);
return std::make_shared<BoxCollider3D>(primitive.box.lengths);
case PrimitiveType::Cone:
return nullptr; //< TODO
//return std::make_shared<ConeCollider3D>(primitive.cone.length, primitive.cone.radius);
case PrimitiveType::Plane:
return std::make_shared<JoltBoxCollider3D>(Vector3f(primitive.plane.size.x, 0.01f, primitive.plane.size.y));
return std::make_shared<BoxCollider3D>(Vector3f(primitive.plane.size.x, 0.01f, primitive.plane.size.y));
///TODO: PlaneGeom?
case PrimitiveType::Sphere:
return std::make_shared<JoltSphereCollider3D>(primitive.sphere.size);
return std::make_shared<SphereCollider3D>(primitive.sphere.size);
}
NazaraErrorFmt("Primitive type not handled ({0:#x})", UnderlyingCast(primitive.type));
return std::shared_ptr<JoltCollider3D>();
return std::shared_ptr<Collider3D>();
}
/********************************** JoltBoxCollider3D **********************************/
/********************************** BoxCollider3D **********************************/
JoltBoxCollider3D::JoltBoxCollider3D(const Vector3f& lengths, float convexRadius)
BoxCollider3D::BoxCollider3D(const Vector3f& lengths, float convexRadius)
{
SetupShapeSettings(std::make_unique<JPH::BoxShapeSettings>(ToJolt(lengths * 0.5f), convexRadius));
}
void JoltBoxCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
void BoxCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
{
auto InsertVertex = [&](float x, float y, float z) -> UInt16
{
@@ -154,24 +154,24 @@ namespace Nz
InsertEdge(v3, v7);
}
Vector3f JoltBoxCollider3D::GetLengths() const
Vector3f BoxCollider3D::GetLengths() const
{
return FromJolt(GetShapeSettingsAs<JPH::BoxShapeSettings>()->mHalfExtent) * 2.f;
}
JoltColliderType3D JoltBoxCollider3D::GetType() const
ColliderType3D BoxCollider3D::GetType() const
{
return JoltColliderType3D::Box;
return ColliderType3D::Box;
}
/********************************** JoltCapsuleCollider3D **********************************/
/********************************** CapsuleCollider3D **********************************/
JoltCapsuleCollider3D::JoltCapsuleCollider3D(float height, float radius)
CapsuleCollider3D::CapsuleCollider3D(float height, float radius)
{
SetupShapeSettings(std::make_unique<JPH::CapsuleShapeSettings>(height * 0.5f, radius));
}
void JoltCapsuleCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
void CapsuleCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
{
constexpr unsigned int cornerStepCount = 10;
constexpr unsigned int sliceCount = 4;
@@ -237,24 +237,24 @@ namespace Nz
}
}
float JoltCapsuleCollider3D::GetHeight() const
float CapsuleCollider3D::GetHeight() const
{
return GetShapeSettingsAs<JPH::CapsuleShapeSettings>()->mHalfHeightOfCylinder * 2.0f;
}
float JoltCapsuleCollider3D::GetRadius() const
float CapsuleCollider3D::GetRadius() const
{
return GetShapeSettingsAs<JPH::CapsuleShapeSettings>()->mRadius;
}
JoltColliderType3D JoltCapsuleCollider3D::GetType() const
ColliderType3D CapsuleCollider3D::GetType() const
{
return JoltColliderType3D::Capsule;
return ColliderType3D::Capsule;
}
/******************************* JoltCompoundCollider3D ********************************/
/******************************* CompoundCollider3D ********************************/
JoltCompoundCollider3D::JoltCompoundCollider3D(std::vector<ChildCollider> childs) :
CompoundCollider3D::CompoundCollider3D(std::vector<ChildCollider> childs) :
m_childs(std::move(childs))
{
auto shapeSettings = std::make_unique<JPH::StaticCompoundShapeSettings>();
@@ -264,31 +264,31 @@ namespace Nz
SetupShapeSettings(std::move(shapeSettings));
}
JoltCompoundCollider3D::~JoltCompoundCollider3D()
CompoundCollider3D::~CompoundCollider3D()
{
// We have to destroy shape settings first as it carries references on the inner colliders
ResetShapeSettings();
}
void JoltCompoundCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
void CompoundCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
{
for (const auto& child : m_childs)
child.collider->BuildDebugMesh(vertices, indices, offsetMatrix * Matrix4f::Transform(child.offset, child.rotation));
}
auto JoltCompoundCollider3D::GetGeoms() const -> const std::vector<ChildCollider>&
auto CompoundCollider3D::GetGeoms() const -> const std::vector<ChildCollider>&
{
return m_childs;
}
JoltColliderType3D JoltCompoundCollider3D::GetType() const
ColliderType3D CompoundCollider3D::GetType() const
{
return JoltColliderType3D::Compound;
return ColliderType3D::Compound;
}
/******************************** JoltConvexHullCollider3D *********************************/
/******************************** ConvexHullCollider3D *********************************/
JoltConvexHullCollider3D::JoltConvexHullCollider3D(SparsePtr<const Vector3f> vertices, std::size_t vertexCount, float hullTolerance, float convexRadius, float maxErrorConvexRadius)
ConvexHullCollider3D::ConvexHullCollider3D(SparsePtr<const Vector3f> vertices, std::size_t vertexCount, float hullTolerance, float convexRadius, float maxErrorConvexRadius)
{
std::unique_ptr<JPH::ConvexHullShapeSettings> settings = std::make_unique<JPH::ConvexHullShapeSettings>();
settings->mHullTolerance = hullTolerance;
@@ -302,7 +302,7 @@ namespace Nz
SetupShapeSettings(std::move(settings));
}
void JoltConvexHullCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
void ConvexHullCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
{
const JPH::ConvexHullShapeSettings* settings = GetShapeSettingsAs<JPH::ConvexHullShapeSettings>();
const JPH::ConvexHullShape* shape = SafeCast<const JPH::ConvexHullShape*>(settings->Create().Get().GetPtr());
@@ -348,14 +348,14 @@ namespace Nz
}
}
JoltColliderType3D JoltConvexHullCollider3D::GetType() const
ColliderType3D ConvexHullCollider3D::GetType() const
{
return JoltColliderType3D::Convex;
return ColliderType3D::Convex;
}
/******************************** JoltMeshCollider3D *********************************/
/******************************** MeshCollider3D *********************************/
JoltMeshCollider3D::JoltMeshCollider3D(SparsePtr<const Vector3f> vertices, std::size_t vertexCount, SparsePtr<const UInt16> indices, std::size_t indexCount)
MeshCollider3D::MeshCollider3D(SparsePtr<const Vector3f> vertices, std::size_t vertexCount, SparsePtr<const UInt16> indices, std::size_t indexCount)
{
std::unique_ptr<JPH::MeshShapeSettings> settings = std::make_unique<JPH::MeshShapeSettings>();
settings->mTriangleVertices.resize(vertexCount);
@@ -380,7 +380,7 @@ namespace Nz
SetupShapeSettings(std::move(settings));
}
JoltMeshCollider3D::JoltMeshCollider3D(SparsePtr<const Vector3f> vertices, std::size_t vertexCount, SparsePtr<const UInt32> indices, std::size_t indexCount)
MeshCollider3D::MeshCollider3D(SparsePtr<const Vector3f> vertices, std::size_t vertexCount, SparsePtr<const UInt32> indices, std::size_t indexCount)
{
std::unique_ptr<JPH::MeshShapeSettings> settings = std::make_unique<JPH::MeshShapeSettings>();
settings->mTriangleVertices.resize(vertexCount);
@@ -405,59 +405,59 @@ namespace Nz
SetupShapeSettings(std::move(settings));
}
void JoltMeshCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
void MeshCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
{
}
JoltColliderType3D JoltMeshCollider3D::GetType() const
ColliderType3D MeshCollider3D::GetType() const
{
return JoltColliderType3D::Mesh;
return ColliderType3D::Mesh;
}
/******************************** JoltSphereCollider3D *********************************/
/******************************** SphereCollider3D *********************************/
JoltSphereCollider3D::JoltSphereCollider3D(float radius)
SphereCollider3D::SphereCollider3D(float radius)
{
SetupShapeSettings(std::make_unique<JPH::SphereShapeSettings>(radius));
}
void JoltSphereCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
void SphereCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
{
}
float JoltSphereCollider3D::GetRadius() const
float SphereCollider3D::GetRadius() const
{
return GetShapeSettingsAs<JPH::SphereShapeSettings>()->mRadius;
}
JoltColliderType3D JoltSphereCollider3D::GetType() const
ColliderType3D SphereCollider3D::GetType() const
{
return JoltColliderType3D::Sphere;
return ColliderType3D::Sphere;
}
/******************************** JoltTranslatedRotatedCollider3D *********************************/
/******************************** TranslatedRotatedCollider3D *********************************/
JoltTranslatedRotatedCollider3D::JoltTranslatedRotatedCollider3D(std::shared_ptr<JoltCollider3D> collider, const Vector3f& translation, const Quaternionf& rotation) :
TranslatedRotatedCollider3D::TranslatedRotatedCollider3D(std::shared_ptr<Collider3D> collider, const Vector3f& translation, const Quaternionf& rotation) :
m_collider(std::move(collider))
{
SetupShapeSettings(std::make_unique<JPH::RotatedTranslatedShapeSettings>(ToJolt(translation), ToJolt(rotation), m_collider->GetShapeSettings()));
}
JoltTranslatedRotatedCollider3D::~JoltTranslatedRotatedCollider3D()
TranslatedRotatedCollider3D::~TranslatedRotatedCollider3D()
{
// We have to destroy shape settings first as it carries references on the inner collider
ResetShapeSettings();
}
void JoltTranslatedRotatedCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
void TranslatedRotatedCollider3D::BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const
{
const JPH::RotatedTranslatedShapeSettings* settings = GetShapeSettingsAs<JPH::RotatedTranslatedShapeSettings>();
m_collider->BuildDebugMesh(vertices, indices, offsetMatrix * Matrix4f::Transform(FromJolt(settings->mPosition), FromJolt(settings->mRotation)));
}
JoltColliderType3D JoltTranslatedRotatedCollider3D::GetType() const
ColliderType3D TranslatedRotatedCollider3D::GetType() const
{
return JoltColliderType3D::TranslatedRotatedDecoration;
return ColliderType3D::TranslatedRotatedDecoration;
}
}

10
src/Nazara/JoltPhysics3D/JoltHelper.hpp → src/Nazara/Physics3D/JoltHelper.hpp
View File

@@ -1,11 +1,11 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_JOLTPHYSICS3D_JOLTHELPER_HPP
#define NAZARA_JOLTPHYSICS3D_JOLTHELPER_HPP
#ifndef NAZARA_PHYSICS3D_JOLTHELPER_HPP
#define NAZARA_PHYSICS3D_JOLTHELPER_HPP
#include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/Math/Matrix4.hpp>
@@ -25,6 +25,6 @@ namespace Nz
inline JPH::Vec4 ToJolt(const Vector4f& vec);
}
#include <Nazara/JoltPhysics3D/JoltHelper.inl>
#include <Nazara/Physics3D/JoltHelper.inl>
#endif // NAZARA_JOLTPHYSICS3D_JOLTHELPER_HPP
#endif // NAZARA_PHYSICS3D_JOLTHELPER_HPP

6
src/Nazara/JoltPhysics3D/JoltHelper.inl → src/Nazara/Physics3D/JoltHelper.inl
View File

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

64
src/Nazara/JoltPhysics3D/JoltCharacter.cpp → src/Nazara/Physics3D/PhysCharacter3D.cpp
View File

@@ -1,27 +1,27 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/JoltCharacter.hpp>
#include <Nazara/JoltPhysics3D/JoltCollider3D.hpp>
#include <Nazara/JoltPhysics3D/JoltHelper.hpp>
#include <Nazara/JoltPhysics3D/JoltPhysWorld3D.hpp>
#include <Nazara/Physics3D/PhysCharacter3D.hpp>
#include <Nazara/Physics3D/Collider3D.hpp>
#include <Nazara/Physics3D/JoltHelper.hpp>
#include <Nazara/Physics3D/PhysWorld3D.hpp>
#include <Jolt/Jolt.h>
#include <Jolt/Physics/PhysicsSystem.h>
#include <Jolt/Physics/Character/Character.h>
#include <Jolt/Physics/Collision/ObjectLayer.h>
#include <Nazara/JoltPhysics3D/Debug.hpp>
#include <Nazara/Physics3D/Debug.hpp>
namespace Nz
{
JoltCharacter::JoltCharacter() = default;
PhysCharacter3D::PhysCharacter3D() = default;
JoltCharacter::JoltCharacter(JoltPhysWorld3D& physWorld, const Settings& settings)
PhysCharacter3D::PhysCharacter3D(PhysWorld3D& physWorld, const Settings& settings)
{
Create(physWorld, settings);
}
JoltCharacter::JoltCharacter(JoltCharacter&& character) noexcept :
PhysCharacter3D::PhysCharacter3D(PhysCharacter3D&& character) noexcept :
m_impl(std::move(character.m_impl)),
m_collider(std::move(character.m_collider)),
m_character(std::move(character.m_character)),
@@ -43,12 +43,12 @@ namespace Nz
}
}
JoltCharacter::~JoltCharacter()
PhysCharacter3D::~PhysCharacter3D()
{
Destroy();
}
void JoltCharacter::EnableSleeping(bool enable)
void PhysCharacter3D::EnableSleeping(bool enable)
{
const JPH::BodyLockInterfaceNoLock& bodyInterface = m_world->GetPhysicsSystem()->GetBodyLockInterfaceNoLock();
JPH::BodyLockWrite bodyLock(bodyInterface, m_character->GetBodyID());
@@ -58,27 +58,27 @@ namespace Nz
bodyLock.GetBody().SetAllowSleeping(enable);
}
UInt32 JoltCharacter::GetBodyIndex() const
UInt32 PhysCharacter3D::GetBodyIndex() const
{
return m_bodyIndex;
}
Vector3f JoltCharacter::GetLinearVelocity() const
Vector3f PhysCharacter3D::GetLinearVelocity() const
{
return FromJolt(m_character->GetLinearVelocity(false));
}
Quaternionf JoltCharacter::GetRotation() const
Quaternionf PhysCharacter3D::GetRotation() const
{
return FromJolt(m_character->GetRotation(false));
}
Vector3f JoltCharacter::GetPosition() const
Vector3f PhysCharacter3D::GetPosition() const
{
return FromJolt(m_character->GetPosition(false));
}
std::pair<Vector3f, Quaternionf> JoltCharacter::GetPositionAndRotation() const
std::pair<Vector3f, Quaternionf> PhysCharacter3D::GetPositionAndRotation() const
{
JPH::Vec3 position;
JPH::Quat rotation;
@@ -87,48 +87,48 @@ namespace Nz
return { FromJolt(position), FromJolt(rotation) };
}
Vector3f JoltCharacter::GetUp() const
Vector3f PhysCharacter3D::GetUp() const
{
return FromJolt(m_character->GetUp());
}
bool JoltCharacter::IsOnGround() const
bool PhysCharacter3D::IsOnGround() const
{
return m_character->GetGroundState() == JPH::Character::EGroundState::OnGround;
}
void JoltCharacter::SetFriction(float friction)
void PhysCharacter3D::SetFriction(float friction)
{
JPH::BodyInterface& bodyInterface = m_world->GetPhysicsSystem()->GetBodyInterfaceNoLock();
bodyInterface.SetFriction(m_character->GetBodyID(), friction);
}
void JoltCharacter::SetLinearVelocity(const Vector3f& linearVel)
void PhysCharacter3D::SetLinearVelocity(const Vector3f& linearVel)
{
m_character->SetLinearVelocity(ToJolt(linearVel), false);
}
void JoltCharacter::SetRotation(const Quaternionf& rotation)
void PhysCharacter3D::SetRotation(const Quaternionf& rotation)
{
m_character->SetRotation(ToJolt(rotation), JPH::EActivation::Activate, false);
}
void JoltCharacter::SetUp(const Vector3f& up)
void PhysCharacter3D::SetUp(const Vector3f& up)
{
m_character->SetUp(ToJolt(up));
}
void JoltCharacter::TeleportTo(const Vector3f& position, const Quaternionf& rotation)
void PhysCharacter3D::TeleportTo(const Vector3f& position, const Quaternionf& rotation)
{
m_character->SetPositionAndRotation(ToJolt(position), ToJolt(rotation), JPH::EActivation::Activate, false);
}
void JoltCharacter::WakeUp()
void PhysCharacter3D::WakeUp()
{
m_character->Activate(false);
}
JoltCharacter& JoltCharacter::operator=(JoltCharacter&& character) noexcept
PhysCharacter3D& PhysCharacter3D::operator=(PhysCharacter3D&& character) noexcept
{
Destroy();
@@ -155,7 +155,7 @@ namespace Nz
return *this;
}
void JoltCharacter::Create(JoltPhysWorld3D& physWorld, const Settings& settings)
void PhysCharacter3D::Create(PhysWorld3D& physWorld, const Settings& settings)
{
m_collider = settings.collider;
m_impl = physWorld.GetDefaultCharacterImpl();
@@ -180,7 +180,7 @@ namespace Nz
m_world->RegisterStepListener(this);
}
void JoltCharacter::Destroy()
void PhysCharacter3D::Destroy()
{
if (m_character)
{
@@ -197,25 +197,25 @@ namespace Nz
m_collider.reset();
}
void JoltCharacter::PostSimulate(float elapsedTime)
void PhysCharacter3D::PostSimulate(float elapsedTime)
{
m_character->PostSimulation(0.05f);
m_impl->PostSimulate(*this, elapsedTime);
}
void JoltCharacter::PreSimulate(float elapsedTime)
void PhysCharacter3D::PreSimulate(float elapsedTime)
{
m_impl->PreSimulate(*this, elapsedTime);
}
JoltCharacterImpl::~JoltCharacterImpl() = default;
PhysCharacter3DImpl::~PhysCharacter3DImpl() = default;
void JoltCharacterImpl::PostSimulate(JoltCharacter& /*character*/, float /*elapsedTime*/)
void PhysCharacter3DImpl::PostSimulate(PhysCharacter3D& /*character*/, float /*elapsedTime*/)
{
}
void JoltCharacterImpl::PreSimulate(JoltCharacter& /*character*/, float /*elapsedTime*/)
void PhysCharacter3DImpl::PreSimulate(PhysCharacter3D& /*character*/, float /*elapsedTime*/)
{
}
}

80
src/Nazara/JoltPhysics3D/JoltConstraint3D.cpp → src/Nazara/Physics3D/PhysConstraint3D.cpp
View File

@@ -1,70 +1,70 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/JoltConstraint3D.hpp>
#include <Nazara/JoltPhysics3D/JoltHelper.hpp>
#include <Nazara/Physics3D/PhysConstraint3D.hpp>
#include <Nazara/Physics3D/JoltHelper.hpp>
#include <Jolt/Jolt.h>
#include <Jolt/Physics/PhysicsSystem.h>
#include <Jolt/Physics/Constraints/DistanceConstraint.h>
#include <Jolt/Physics/Constraints/PointConstraint.h>
#include <cassert>
#include <Nazara/JoltPhysics3D/Debug.hpp>
#include <Nazara/Physics3D/Debug.hpp>
namespace Nz
{
JoltConstraint3D::JoltConstraint3D() = default;
PhysConstraint3D::PhysConstraint3D() = default;
JoltConstraint3D::JoltConstraint3D(JoltConstraint3D&& constraint) noexcept :
PhysConstraint3D::PhysConstraint3D(PhysConstraint3D&& constraint) noexcept :
m_constraint(std::move(constraint.m_constraint))
{
if (m_constraint)
m_constraint->SetUserData(SafeCast<UInt64>(BitCast<std::uintptr_t>(this)));
}
JoltConstraint3D::~JoltConstraint3D()
PhysConstraint3D::~PhysConstraint3D()
{
Destroy();
}
JoltRigidBody3D& JoltConstraint3D::GetBodyA()
RigidBody3D& PhysConstraint3D::GetBodyA()
{
return *BitCast<JoltRigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody1()->GetUserData()));
return *BitCast<RigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody1()->GetUserData()));
}
const JoltRigidBody3D& JoltConstraint3D::GetBodyA() const
const RigidBody3D& PhysConstraint3D::GetBodyA() const
{
return *BitCast<JoltRigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody1()->GetUserData()));
return *BitCast<RigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody1()->GetUserData()));
}
JoltRigidBody3D& JoltConstraint3D::GetBodyB()
RigidBody3D& PhysConstraint3D::GetBodyB()
{
NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
return *BitCast<JoltRigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody2()->GetUserData()));
return *BitCast<RigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody2()->GetUserData()));
}
const JoltRigidBody3D& JoltConstraint3D::GetBodyB() const
const RigidBody3D& PhysConstraint3D::GetBodyB() const
{
NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
return *BitCast<JoltRigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody2()->GetUserData()));
return *BitCast<RigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody2()->GetUserData()));
}
JoltPhysWorld3D& JoltConstraint3D::GetWorld()
PhysWorld3D& PhysConstraint3D::GetWorld()
{
return GetBodyA().GetWorld();
}
const JoltPhysWorld3D& JoltConstraint3D::GetWorld() const
const PhysWorld3D& PhysConstraint3D::GetWorld() const
{
return GetBodyA().GetWorld();
}
bool JoltConstraint3D::IsSingleBody() const
bool PhysConstraint3D::IsSingleBody() const
{
return m_constraint->GetBody2() == &JPH::Body::sFixedToWorld;
}
JoltConstraint3D& JoltConstraint3D::operator=(JoltConstraint3D&& constraint) noexcept
PhysConstraint3D& PhysConstraint3D::operator=(PhysConstraint3D&& constraint) noexcept
{
Destroy();
@@ -76,7 +76,7 @@ namespace Nz
return *this;
}
void JoltConstraint3D::Destroy()
void PhysConstraint3D::Destroy()
{
if (m_constraint)
{
@@ -87,7 +87,7 @@ namespace Nz
}
}
void JoltConstraint3D::SetupConstraint(std::unique_ptr<JPH::TwoBodyConstraint> constraint)
void PhysConstraint3D::SetupConstraint(std::unique_ptr<JPH::TwoBodyConstraint> constraint)
{
assert(!m_constraint);
m_constraint = std::move(constraint);
@@ -99,7 +99,7 @@ namespace Nz
}
JoltDistanceConstraint3D::JoltDistanceConstraint3D(JoltRigidBody3D& first, const Vector3f& pivot, float maxDist, float minDist)
PhysDistanceConstraint3D::PhysDistanceConstraint3D(RigidBody3D& first, const Vector3f& pivot, float maxDist, float minDist)
{
JPH::DistanceConstraintSettings settings;
settings.mPoint1 = ToJolt(pivot);
@@ -111,7 +111,7 @@ namespace Nz
SetupConstraint(std::make_unique<JPH::DistanceConstraint>(*first.GetBody(), JPH::Body::sFixedToWorld, settings));
}
JoltDistanceConstraint3D::JoltDistanceConstraint3D(JoltRigidBody3D& first, JoltRigidBody3D& second, const Vector3f& pivot, float maxDist, float minDist)
PhysDistanceConstraint3D::PhysDistanceConstraint3D(RigidBody3D& first, RigidBody3D& second, const Vector3f& pivot, float maxDist, float minDist)
{
JPH::DistanceConstraintSettings settings;
settings.mPoint1 = ToJolt(pivot);
@@ -123,7 +123,7 @@ namespace Nz
SetupConstraint(std::make_unique<JPH::DistanceConstraint>(*first.GetBody(), *second.GetBody(), settings));
}
JoltDistanceConstraint3D::JoltDistanceConstraint3D(JoltRigidBody3D& first, JoltRigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor, float maxDist, float minDist)
PhysDistanceConstraint3D::PhysDistanceConstraint3D(RigidBody3D& first, RigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor, float maxDist, float minDist)
{
JPH::DistanceConstraintSettings settings;
settings.mPoint1 = ToJolt(firstAnchor);
@@ -135,49 +135,49 @@ namespace Nz
SetupConstraint(std::make_unique<JPH::DistanceConstraint>(*first.GetBody(), *second.GetBody(), settings));
}
float JoltDistanceConstraint3D::GetDamping() const
float PhysDistanceConstraint3D::GetDamping() const
{
return GetConstraint<JPH::DistanceConstraint>()->GetLimitsSpringSettings().mDamping;
}
float JoltDistanceConstraint3D::GetFrequency() const
float PhysDistanceConstraint3D::GetFrequency() const
{
return GetConstraint<JPH::DistanceConstraint>()->GetLimitsSpringSettings().mFrequency;
}
float JoltDistanceConstraint3D::GetMaxDistance() const
float PhysDistanceConstraint3D::GetMaxDistance() const
{
return GetConstraint<JPH::DistanceConstraint>()->GetMaxDistance();
}
float JoltDistanceConstraint3D::GetMinDistance() const
float PhysDistanceConstraint3D::GetMinDistance() const
{
return GetConstraint<JPH::DistanceConstraint>()->GetMinDistance();
}
void JoltDistanceConstraint3D::SetDamping(float damping)
void PhysDistanceConstraint3D::SetDamping(float damping)
{
GetConstraint<JPH::DistanceConstraint>()->GetLimitsSpringSettings().mDamping = damping;
}
void JoltDistanceConstraint3D::SetDistance(float minDist, float maxDist)
void PhysDistanceConstraint3D::SetDistance(float minDist, float maxDist)
{
GetConstraint<JPH::DistanceConstraint>()->SetDistance(minDist, maxDist);
}
void JoltDistanceConstraint3D::SetFrequency(float frequency)
void PhysDistanceConstraint3D::SetFrequency(float frequency)
{
GetConstraint<JPH::DistanceConstraint>()->GetLimitsSpringSettings().mFrequency = frequency;
}
void JoltDistanceConstraint3D::SetMaxDistance(float maxDist)
void PhysDistanceConstraint3D::SetMaxDistance(float maxDist)
{
JPH::DistanceConstraint* constraint = GetConstraint<JPH::DistanceConstraint>();
constraint->SetDistance(constraint->GetMinDistance(), maxDist);
}
void JoltDistanceConstraint3D::SetMinDistance(float minDist)
void PhysDistanceConstraint3D::SetMinDistance(float minDist)
{
JPH::DistanceConstraint* constraint = GetConstraint<JPH::DistanceConstraint>();
@@ -185,7 +185,7 @@ namespace Nz
}
JoltPivotConstraint3D::JoltPivotConstraint3D(JoltRigidBody3D& first, const Vector3f& pivot)
PhysPivotConstraint3D::PhysPivotConstraint3D(RigidBody3D& first, const Vector3f& pivot)
{
JPH::PointConstraintSettings settings;
settings.mPoint1 = ToJolt(pivot);
@@ -195,7 +195,7 @@ namespace Nz
SetupConstraint(std::make_unique<JPH::PointConstraint>(*first.GetBody(), JPH::Body::sFixedToWorld, settings));
}
JoltPivotConstraint3D::JoltPivotConstraint3D(JoltRigidBody3D& first, JoltRigidBody3D& second, const Vector3f& pivot)
PhysPivotConstraint3D::PhysPivotConstraint3D(RigidBody3D& first, RigidBody3D& second, const Vector3f& pivot)
{
JPH::PointConstraintSettings settings;
settings.mPoint1 = ToJolt(pivot);
@@ -205,7 +205,7 @@ namespace Nz
SetupConstraint(std::make_unique<JPH::PointConstraint>(*first.GetBody(), *second.GetBody(), settings));
}
JoltPivotConstraint3D::JoltPivotConstraint3D(JoltRigidBody3D& first, JoltRigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor)
PhysPivotConstraint3D::PhysPivotConstraint3D(RigidBody3D& first, RigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor)
{
JPH::PointConstraintSettings settings;
settings.mPoint1 = ToJolt(firstAnchor);
@@ -215,27 +215,27 @@ namespace Nz
SetupConstraint(std::make_unique<JPH::PointConstraint>(*first.GetBody(), *second.GetBody(), settings));
}
Vector3f JoltPivotConstraint3D::GetFirstAnchor() const
Vector3f PhysPivotConstraint3D::GetFirstAnchor() const
{
const JPH::PointConstraint* constraint = GetConstraint<JPH::PointConstraint>();
return FromJolt(constraint->GetBody1()->GetCenterOfMassTransform() * constraint->GetLocalSpacePoint1());
}
Vector3f JoltPivotConstraint3D::GetSecondAnchor() const
Vector3f PhysPivotConstraint3D::GetSecondAnchor() const
{
const JPH::PointConstraint* constraint = GetConstraint<JPH::PointConstraint>();
return FromJolt(constraint->GetBody2()->GetCenterOfMassTransform() * constraint->GetLocalSpacePoint2());
}
void JoltPivotConstraint3D::SetFirstAnchor(const Vector3f& firstAnchor)
void PhysPivotConstraint3D::SetFirstAnchor(const Vector3f& firstAnchor)
{
GetConstraint<JPH::PointConstraint>()->SetPoint1(JPH::EConstraintSpace::WorldSpace, ToJolt(firstAnchor));
GetConstraint<JPH::PointConstraint>()->SetPoint2(JPH::EConstraintSpace::WorldSpace, ToJolt(firstAnchor));
}
void JoltPivotConstraint3D::SetSecondAnchor(const Vector3f& secondAnchor)
void PhysPivotConstraint3D::SetSecondAnchor(const Vector3f& secondAnchor)
{
GetConstraint<JPH::PointConstraint>()->SetPoint2(JPH::EConstraintSpace::WorldSpace, ToJolt(secondAnchor));
}

114
src/Nazara/JoltPhysics3D/JoltPhysWorld3D.cpp → src/Nazara/Physics3D/PhysWorld3D.cpp
View File

@@ -1,13 +1,13 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/JoltPhysWorld3D.hpp>
#include <Nazara/JoltPhysics3D/JoltCharacter.hpp>
#include <Nazara/JoltPhysics3D/JoltCollider3D.hpp>
#include <Nazara/JoltPhysics3D/JoltHelper.hpp>
#include <Nazara/JoltPhysics3D/JoltPhysics3D.hpp>
#include <Nazara/JoltPhysics3D/JoltPhysicsStepListener.hpp>
#include <Nazara/Physics3D/PhysWorld3D.hpp>
#include <Nazara/Physics3D/Collider3D.hpp>
#include <Nazara/Physics3D/JoltHelper.hpp>
#include <Nazara/Physics3D/PhysCharacter3D.hpp>
#include <Nazara/Physics3D/Physics3D.hpp>
#include <Nazara/Physics3D/Physiscs3DStepListener.hpp>
#include <NazaraUtils/MemoryPool.hpp>
#include <NazaraUtils/StackVector.hpp>
#include <Jolt/Jolt.h>
@@ -26,7 +26,7 @@
#include <Jolt/Physics/Collision/Shape/SphereShape.h>
#include <tsl/ordered_set.h>
#include <cassert>
#include <Nazara/JoltPhysics3D/Debug.hpp>
#include <Nazara/Physics3D/Debug.hpp>
namespace DitchMeAsap
{
@@ -168,7 +168,7 @@ namespace Nz
class PointCallbackHitResult : public JPH::CollidePointCollector
{
public:
PointCallbackHitResult(const JPH::BodyLockInterface& bodyLockInterface, const FunctionRef<std::optional<float>(const JoltPhysWorld3D::PointCollisionInfo& hitInfo)>& callback) :
PointCallbackHitResult(const JPH::BodyLockInterface& bodyLockInterface, const FunctionRef<std::optional<float>(const PhysWorld3D::PointCollisionInfo& hitInfo)>& callback) :
m_bodyLockInterface(bodyLockInterface),
m_callback(callback),
m_didHit(false)
@@ -177,7 +177,7 @@ namespace Nz
void AddHit(const JPH::CollidePointResult& result) override
{
JoltPhysWorld3D::PointCollisionInfo hitInfo;
PhysWorld3D::PointCollisionInfo hitInfo;
JPH::BodyLockWrite lock(m_bodyLockInterface, result.mBodyID);
if (!lock.Succeeded())
@@ -185,7 +185,7 @@ namespace Nz
JPH::Body& body = lock.GetBody();
hitInfo.hitBody = BitCast<JoltAbstractBody*>(static_cast<std::uintptr_t>(body.GetUserData()));
hitInfo.hitBody = BitCast<Physics3DBody*>(static_cast<std::uintptr_t>(body.GetUserData()));
if (auto fractionOpt = m_callback(hitInfo))
{
@@ -207,14 +207,14 @@ namespace Nz
private:
const JPH::BodyLockInterface& m_bodyLockInterface;
const FunctionRef<std::optional<float>(const JoltPhysWorld3D::PointCollisionInfo& hitInfo)>& m_callback;
const FunctionRef<std::optional<float>(const PhysWorld3D::PointCollisionInfo& hitInfo)>& m_callback;
bool m_didHit;
};
class ShapeCallbackHitResult : public JPH::CollideShapeCollector
{
public:
ShapeCallbackHitResult(const JPH::BodyLockInterface& bodyLockInterface, const FunctionRef<std::optional<float>(const JoltPhysWorld3D::ShapeCollisionInfo& hitInfo)>& callback) :
ShapeCallbackHitResult(const JPH::BodyLockInterface& bodyLockInterface, const FunctionRef<std::optional<float>(const PhysWorld3D::ShapeCollisionInfo& hitInfo)>& callback) :
m_bodyLockInterface(bodyLockInterface),
m_callback(callback),
m_didHit(false)
@@ -223,7 +223,7 @@ namespace Nz
void AddHit(const JPH::CollideShapeResult& result) override
{
JoltPhysWorld3D::ShapeCollisionInfo hitInfo;
PhysWorld3D::ShapeCollisionInfo hitInfo;
hitInfo.collisionPosition1 = FromJolt(result.mContactPointOn1);
hitInfo.collisionPosition2 = FromJolt(result.mContactPointOn2);
hitInfo.penetrationAxis = FromJolt(result.mPenetrationAxis);
@@ -235,7 +235,7 @@ namespace Nz
JPH::Body& body = lock.GetBody();
hitInfo.hitBody = BitCast<JoltAbstractBody*>(static_cast<std::uintptr_t>(body.GetUserData()));
hitInfo.hitBody = BitCast<Physics3DBody*>(static_cast<std::uintptr_t>(body.GetUserData()));
if (auto fractionOpt = m_callback(hitInfo))
{
@@ -257,14 +257,14 @@ namespace Nz
private:
const JPH::BodyLockInterface& m_bodyLockInterface;
const FunctionRef<std::optional<float>(const JoltPhysWorld3D::ShapeCollisionInfo& hitInfo)>& m_callback;
const FunctionRef<std::optional<float>(const PhysWorld3D::ShapeCollisionInfo& hitInfo)>& m_callback;
bool m_didHit;
};
class RaycastCallbackHitResult : public JPH::CastRayCollector
{
public:
RaycastCallbackHitResult(const JPH::BodyLockInterface& bodyLockInterface, const Vector3f& from, const Vector3f& to, const FunctionRef<std::optional<float>(const JoltPhysWorld3D::RaycastHit& hitInfo)>& callback) :
RaycastCallbackHitResult(const JPH::BodyLockInterface& bodyLockInterface, const Vector3f& from, const Vector3f& to, const FunctionRef<std::optional<float>(const PhysWorld3D::RaycastHit& hitInfo)>& callback) :
m_bodyLockInterface(bodyLockInterface),
m_callback(callback),
m_from(from),
@@ -275,7 +275,7 @@ namespace Nz
void AddHit(const JPH::RayCastResult& result) override
{
JoltPhysWorld3D::RaycastHit hitInfo;
PhysWorld3D::RaycastHit hitInfo;
hitInfo.fraction = result.mFraction;
hitInfo.hitPosition = Lerp(m_from, m_to, result.mFraction);
@@ -285,7 +285,7 @@ namespace Nz
JPH::Body& body = lock.GetBody();
hitInfo.hitBody = BitCast<JoltAbstractBody*>(static_cast<std::uintptr_t>(body.GetUserData()));
hitInfo.hitBody = BitCast<Physics3DBody*>(static_cast<std::uintptr_t>(body.GetUserData()));
hitInfo.hitNormal = FromJolt(body.GetWorldSpaceSurfaceNormal(result.mSubShapeID2, ToJolt(hitInfo.hitPosition)));
if (auto fractionOpt = m_callback(hitInfo))
@@ -308,19 +308,19 @@ namespace Nz
private:
const JPH::BodyLockInterface& m_bodyLockInterface;
const FunctionRef<std::optional<float>(const JoltPhysWorld3D::RaycastHit& hitInfo)>& m_callback;
const FunctionRef<std::optional<float>(const PhysWorld3D::RaycastHit& hitInfo)>& m_callback;
Vector3f m_from;
Vector3f m_to;
bool m_didHit;
};
}
class JoltPhysWorld3D::BodyActivationListener : public JPH::BodyActivationListener
class PhysWorld3D::BodyActivationListener : public JPH::BodyActivationListener
{
public:
static constexpr UInt32 BodyPerBlock = 64;
BodyActivationListener(JoltPhysWorld3D& physWorld) :
BodyActivationListener(PhysWorld3D& physWorld) :
m_physWorld(physWorld)
{
}
@@ -344,13 +344,13 @@ namespace Nz
}
private:
JoltPhysWorld3D& m_physWorld;
PhysWorld3D& m_physWorld;
};
class JoltPhysWorld3D::StepListener : public JPH::PhysicsStepListener
class PhysWorld3D::StepListener : public JPH::PhysicsStepListener
{
public:
StepListener(JoltPhysWorld3D& physWorld) :
StepListener(PhysWorld3D& physWorld) :
m_physWorld(physWorld)
{
}
@@ -361,10 +361,10 @@ namespace Nz
}
private:
JoltPhysWorld3D& m_physWorld;
PhysWorld3D& m_physWorld;
};
struct JoltPhysWorld3D::JoltWorld
struct PhysWorld3D::JoltWorld
{
using BodySet = tsl::ordered_set<JPH::BodyID, std::hash<JPH::BodyID>, std::equal_to<JPH::BodyID>, std::allocator<JPH::BodyID>, std::vector<JPH::BodyID>>;
@@ -376,14 +376,14 @@ namespace Nz
std::vector<JPH::BodyID> tempBodyIDVec;
std::unique_ptr<JPH::SphereShape> nullShape;
JoltPhysWorld3D::BodyActivationListener bodyActivationListener;
JoltPhysWorld3D::StepListener stepListener;
PhysWorld3D::BodyActivationListener bodyActivationListener;
PhysWorld3D::StepListener stepListener;
DitchMeAsap::BPLayerInterfaceImpl layerInterface;
DitchMeAsap::ObjectLayerPairFilterImpl objectLayerFilter;
DitchMeAsap::ObjectVsBroadPhaseLayerFilterImpl objectBroadphaseLayerFilter;
JoltWorld(JoltPhysWorld3D& world, JPH::uint tempAllocatorSize) :
JoltWorld(PhysWorld3D& world, JPH::uint tempAllocatorSize) :
tempAllocator(tempAllocatorSize),
bodyActivationListener(world),
stepListener(world)
@@ -397,7 +397,7 @@ namespace Nz
JoltWorld& operator=(JoltWorld&&) = delete;
};
JoltPhysWorld3D::JoltPhysWorld3D() :
PhysWorld3D::PhysWorld3D() :
m_maxStepCount(50),
m_gravity(Vector3f::Zero()),
m_stepSize(Time::TickDuration(120)),
@@ -420,9 +420,9 @@ namespace Nz
m_registeredBodies[i] = 0;
}
JoltPhysWorld3D::~JoltPhysWorld3D() = default;
PhysWorld3D::~PhysWorld3D() = default;
bool JoltPhysWorld3D::CollisionQuery(const Vector3f& point, const FunctionRef<std::optional<float>(const PointCollisionInfo& collisionInfo)>& callback)
bool PhysWorld3D::CollisionQuery(const Vector3f& point, const FunctionRef<std::optional<float>(const PointCollisionInfo& collisionInfo)>& callback)
{
NAZARA_USE_ANONYMOUS_NAMESPACE
@@ -432,12 +432,12 @@ namespace Nz
return collector.DidHit();
}
bool JoltPhysWorld3D::CollisionQuery(const JoltCollider3D& collider, const Matrix4f& colliderTransform, const FunctionRef<std::optional<float>(const ShapeCollisionInfo& hitInfo)>& callback)
bool PhysWorld3D::CollisionQuery(const Collider3D& collider, const Matrix4f& colliderTransform, const FunctionRef<std::optional<float>(const ShapeCollisionInfo& hitInfo)>& callback)
{
return CollisionQuery(collider, colliderTransform, Vector3f::Unit(), callback);
}
bool JoltPhysWorld3D::CollisionQuery(const JoltCollider3D& collider, const Matrix4f& colliderTransform, const Vector3f& colliderScale, const FunctionRef<std::optional<float>(const ShapeCollisionInfo& hitInfo)>& callback)
bool PhysWorld3D::CollisionQuery(const Collider3D& collider, const Matrix4f& colliderTransform, const Vector3f& colliderScale, const FunctionRef<std::optional<float>(const ShapeCollisionInfo& hitInfo)>& callback)
{
NAZARA_USE_ANONYMOUS_NAMESPACE
@@ -451,32 +451,32 @@ namespace Nz
return collector.DidHit();
}
UInt32 JoltPhysWorld3D::GetActiveBodyCount() const
UInt32 PhysWorld3D::GetActiveBodyCount() const
{
return m_world->physicsSystem.GetNumActiveBodies(JPH::EBodyType::RigidBody);
}
Vector3f JoltPhysWorld3D::GetGravity() const
Vector3f PhysWorld3D::GetGravity() const
{
return FromJolt(m_world->physicsSystem.GetGravity());
}
std::size_t JoltPhysWorld3D::GetMaxStepCount() const
std::size_t PhysWorld3D::GetMaxStepCount() const
{
return m_maxStepCount;
}
JPH::PhysicsSystem* JoltPhysWorld3D::GetPhysicsSystem()
JPH::PhysicsSystem* PhysWorld3D::GetPhysicsSystem()
{
return &m_world->physicsSystem;
}
Time JoltPhysWorld3D::GetStepSize() const
Time PhysWorld3D::GetStepSize() const
{
return m_stepSize;
}
bool JoltPhysWorld3D::RaycastQuery(const Vector3f& from, const Vector3f& to, const FunctionRef<std::optional<float>(const RaycastHit& hitInfo)>& callback)
bool PhysWorld3D::RaycastQuery(const Vector3f& from, const Vector3f& to, const FunctionRef<std::optional<float>(const RaycastHit& hitInfo)>& callback)
{
NAZARA_USE_ANONYMOUS_NAMESPACE
@@ -492,7 +492,7 @@ namespace Nz
return collector.DidHit();
}
bool JoltPhysWorld3D::RaycastQueryFirst(const Vector3f& from, const Vector3f& to, const FunctionRef<void(const RaycastHit& hitInfo)>& callback)
bool PhysWorld3D::RaycastQueryFirst(const Vector3f& from, const Vector3f& to, const FunctionRef<void(const RaycastHit& hitInfo)>& callback)
{
JPH::RRayCast rayCast;
rayCast.mDirection = ToJolt(to - from);
@@ -515,14 +515,14 @@ namespace Nz
RaycastHit hitInfo;
hitInfo.fraction = collector.mHit.GetEarlyOutFraction();
hitInfo.hitPosition = Lerp(from, to, hitInfo.fraction);
hitInfo.hitBody = BitCast<JoltAbstractBody*>(static_cast<std::uintptr_t>(body.GetUserData()));
hitInfo.hitBody = BitCast<Physics3DBody*>(static_cast<std::uintptr_t>(body.GetUserData()));
hitInfo.hitNormal = FromJolt(body.GetWorldSpaceSurfaceNormal(collector.mHit.mSubShapeID2, rayCast.GetPointOnRay(collector.mHit.GetEarlyOutFraction())));
callback(hitInfo);
return true;
}
void JoltPhysWorld3D::RefreshBodies()
void PhysWorld3D::RefreshBodies()
{
// Batch add bodies (keeps the broadphase efficient)
JPH::BodyInterface& bodyInterface = m_world->physicsSystem.GetBodyInterfaceNoLock();
@@ -569,22 +569,22 @@ namespace Nz
}
}
void JoltPhysWorld3D::SetGravity(const Vector3f& gravity)
void PhysWorld3D::SetGravity(const Vector3f& gravity)
{
m_world->physicsSystem.SetGravity(ToJolt(gravity));
}
void JoltPhysWorld3D::SetMaxStepCount(std::size_t maxStepCount)
void PhysWorld3D::SetMaxStepCount(std::size_t maxStepCount)
{
m_maxStepCount = maxStepCount;
}
void JoltPhysWorld3D::SetStepSize(Time stepSize)
void PhysWorld3D::SetStepSize(Time stepSize)
{
m_stepSize = stepSize;
}
bool JoltPhysWorld3D::Step(Time timestep)
bool PhysWorld3D::Step(Time timestep)
{
m_timestepAccumulator += timestep;
if (m_timestepAccumulator < m_stepSize)
@@ -592,7 +592,7 @@ namespace Nz
RefreshBodies();
JPH::JobSystem& jobSystem = JoltPhysics3D::Instance()->GetThreadPool();
JPH::JobSystem& jobSystem = Physics3D::Instance()->GetThreadPool();
float stepSize = m_stepSize.AsSeconds<float>();
std::size_t stepCount = 0;
@@ -600,7 +600,7 @@ namespace Nz
{
m_world->physicsSystem.Update(stepSize, 1, &m_world->tempAllocator, &jobSystem);
for (JoltPhysicsStepListener* stepListener : m_stepListeners)
for (Physiscs3DStepListener* stepListener : m_stepListeners)
stepListener->PostSimulate(stepSize);
m_timestepAccumulator -= m_stepSize;
@@ -610,7 +610,7 @@ namespace Nz
return true;
}
void JoltPhysWorld3D::RegisterBody(const JPH::BodyID& bodyID, bool activate, bool removeFromDeactivationList)
void PhysWorld3D::RegisterBody(const JPH::BodyID& bodyID, bool activate, bool removeFromDeactivationList)
{
assert(removeFromDeactivationList || !m_world->pendingDeactivations.contains(bodyID));
@@ -626,7 +626,7 @@ namespace Nz
}
}
void JoltPhysWorld3D::UnregisterBody(const JPH::BodyID& bodyID, bool destroy, bool removeFromActivationList)
void PhysWorld3D::UnregisterBody(const JPH::BodyID& bodyID, bool destroy, bool removeFromActivationList)
{
// Remove from list first as bodyID may be invalidated by destruction
if (removeFromActivationList)
@@ -656,15 +656,15 @@ namespace Nz
m_world->pendingDeactivations.insert(bodyID);
}
std::shared_ptr<JoltCharacterImpl> JoltPhysWorld3D::GetDefaultCharacterImpl()
std::shared_ptr<PhysCharacter3DImpl> PhysWorld3D::GetDefaultCharacterImpl()
{
if (!m_defaultCharacterImpl)
m_defaultCharacterImpl = std::make_shared<JoltCharacterImpl>();
m_defaultCharacterImpl = std::make_shared<PhysCharacter3DImpl>();
return m_defaultCharacterImpl;
}
const JPH::Shape* JoltPhysWorld3D::GetNullShape() const
const JPH::Shape* PhysWorld3D::GetNullShape() const
{
if (!m_world->nullShape)
{
@@ -675,9 +675,9 @@ namespace Nz
return m_world->nullShape.get();
}
void JoltPhysWorld3D::OnPreStep(float deltatime)
void PhysWorld3D::OnPreStep(float deltatime)
{
for (JoltPhysicsStepListener* stepListener : m_stepListeners)
for (Physiscs3DStepListener* stepListener : m_stepListeners)
stepListener->PreSimulate(deltatime);
}
}

18
src/Nazara/JoltPhysics3D/JoltPhysics3D.cpp → src/Nazara/Physics3D/Physics3D.cpp
View File

@@ -1,19 +1,19 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/JoltPhysics3D.hpp>
#include <Nazara/Physics3D/Physics3D.hpp>
#include <Nazara/Core/Core.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Log.hpp>
#include <Nazara/JoltPhysics3D/Config.hpp>
#include <Nazara/Physics3D/Config.hpp>
#include <Jolt/Jolt.h>
#include <Jolt/RegisterTypes.h>
#include <Jolt/Core/Factory.h>
#include <Jolt/Core/JobSystemThreadPool.h>
#include <Jolt/Physics/PhysicsSettings.h>
#include <cstdarg>
#include <Nazara/JoltPhysics3D/Debug.hpp>
#include <Nazara/Physics3D/Debug.hpp>
// Callback for traces, connect this to your own trace function if you have one
static void TraceImpl(const char* inFMT, ...)
@@ -31,8 +31,8 @@ static void TraceImpl(const char* inFMT, ...)
namespace Nz
{
JoltPhysics3D::JoltPhysics3D(Config /*config*/) :
ModuleBase("JoltPhysics3D", this)
Physics3D::Physics3D(Config /*config*/) :
ModuleBase("Physics3D", this)
{
JPH::RegisterDefaultAllocator();
JPH::Trace = TraceImpl;
@@ -47,7 +47,7 @@ namespace Nz
m_threadPool = std::make_unique<JPH::JobSystemThreadPool>(JPH::cMaxPhysicsJobs, JPH::cMaxPhysicsBarriers, threadCount);
}
JoltPhysics3D::~JoltPhysics3D()
Physics3D::~Physics3D()
{
m_threadPool.reset();
JPH::UnregisterTypes();
@@ -56,10 +56,10 @@ namespace Nz
JPH::Factory::sInstance = nullptr;
}
JPH::JobSystem& JoltPhysics3D::GetThreadPool()
JPH::JobSystem& Physics3D::GetThreadPool()
{
return *m_threadPool;
}
JoltPhysics3D* JoltPhysics3D::s_instance;
Physics3D* Physics3D::s_instance;
}

11
src/Nazara/Physics3D/Physics3DBody.cpp Normal file
View File

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

19
src/Nazara/Physics3D/Physiscs3DStepListener.cpp Normal file
View File

@@ -0,0 +1,19 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics3D/Physiscs3DStepListener.hpp>
#include <Nazara/Physics3D/Debug.hpp>
namespace Nz
{
Physiscs3DStepListener::~Physiscs3DStepListener() = default;
void Physiscs3DStepListener::PostSimulate(float /*elapsedTime*/)
{
}
void Physiscs3DStepListener::PreSimulate(float /*elapsedTime*/)
{
}
}

102
src/Nazara/JoltPhysics3D/JoltRigidBody3D.cpp → src/Nazara/Physics3D/RigidBody3D.cpp
View File

@@ -1,10 +1,10 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/JoltRigidBody3D.hpp>
#include <Nazara/JoltPhysics3D/JoltHelper.hpp>
#include <Nazara/JoltPhysics3D/JoltPhysWorld3D.hpp>
#include <Nazara/Physics3D/RigidBody3D.hpp>
#include <Nazara/Physics3D/JoltHelper.hpp>
#include <Nazara/Physics3D/PhysWorld3D.hpp>
#include <NazaraUtils/MemoryHelper.hpp>
#include <Jolt/Jolt.h>
#include <Jolt/Physics/PhysicsSystem.h>
@@ -12,11 +12,11 @@
#include <algorithm>
#include <array>
#include <cmath>
#include <Nazara/JoltPhysics3D/Debug.hpp>
#include <Nazara/Physics3D/Debug.hpp>
namespace Nz
{
JoltRigidBody3D::JoltRigidBody3D(JoltRigidBody3D&& body) noexcept :
RigidBody3D::RigidBody3D(RigidBody3D&& body) noexcept :
m_geom(std::move(body.m_geom)),
m_body(std::move(body.m_body)),
m_world(std::move(body.m_world)),
@@ -30,12 +30,12 @@ namespace Nz
m_body->SetUserData(SafeCast<UInt64>(BitCast<std::uintptr_t>(this)));
}
JoltRigidBody3D::~JoltRigidBody3D()
RigidBody3D::~RigidBody3D()
{
Destroy();
}
void JoltRigidBody3D::AddForce(const Vector3f& force, CoordSys coordSys)
void RigidBody3D::AddForce(const Vector3f& force, CoordSys coordSys)
{
switch (coordSys)
{
@@ -49,7 +49,7 @@ namespace Nz
}
}
void JoltRigidBody3D::AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys)
void RigidBody3D::AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys)
{
switch (coordSys)
{
@@ -63,7 +63,7 @@ namespace Nz
}
}
void JoltRigidBody3D::AddTorque(const Vector3f& torque, CoordSys coordSys)
void RigidBody3D::AddTorque(const Vector3f& torque, CoordSys coordSys)
{
switch (coordSys)
{
@@ -77,7 +77,7 @@ namespace Nz
}
}
void JoltRigidBody3D::EnableSimulation(bool enable)
void RigidBody3D::EnableSimulation(bool enable)
{
if (m_isSimulationEnabled == enable)
return;
@@ -90,24 +90,24 @@ namespace Nz
m_isSimulationEnabled = enable;
}
void JoltRigidBody3D::EnableSleeping(bool enable)
void RigidBody3D::EnableSleeping(bool enable)
{
m_body->SetAllowSleeping(enable);
}
void JoltRigidBody3D::FallAsleep()
void RigidBody3D::FallAsleep()
{
JPH::BodyInterface& bodyInterface = m_world->GetPhysicsSystem()->GetBodyInterface();
bodyInterface.DeactivateBody(m_body->GetID());
}
Boxf JoltRigidBody3D::GetAABB() const
Boxf RigidBody3D::GetAABB() const
{
const JPH::AABox& aabb = m_body->GetWorldSpaceBounds();
return Boxf(FromJolt(aabb.mMin), FromJolt(aabb.GetSize()));
}
float JoltRigidBody3D::GetAngularDamping() const
float RigidBody3D::GetAngularDamping() const
{
if NAZARA_UNLIKELY(IsStatic())
return 0.f;
@@ -115,17 +115,17 @@ namespace Nz
return m_body->GetMotionProperties()->GetAngularDamping();
}
Vector3f JoltRigidBody3D::GetAngularVelocity() const
Vector3f RigidBody3D::GetAngularVelocity() const
{
return FromJolt(m_body->GetAngularVelocity());
}
UInt32 JoltRigidBody3D::GetBodyIndex() const
UInt32 RigidBody3D::GetBodyIndex() const
{
return m_bodyIndex;
}
float JoltRigidBody3D::GetLinearDamping() const
float RigidBody3D::GetLinearDamping() const
{
if NAZARA_UNLIKELY(IsStatic())
return 0.f;
@@ -133,12 +133,12 @@ namespace Nz
return m_body->GetMotionProperties()->GetLinearDamping();
}
Vector3f JoltRigidBody3D::GetLinearVelocity() const
Vector3f RigidBody3D::GetLinearVelocity() const
{
return FromJolt(m_body->GetLinearVelocity());
}
float JoltRigidBody3D::GetMass() const
float RigidBody3D::GetMass() const
{
if NAZARA_UNLIKELY(IsStatic())
return 0.f;
@@ -146,17 +146,17 @@ namespace Nz
return 1.f / m_body->GetMotionProperties()->GetInverseMass();
}
Matrix4f JoltRigidBody3D::GetMatrix() const
Matrix4f RigidBody3D::GetMatrix() const
{
return FromJolt(m_body->GetCenterOfMassTransform());
}
Vector3f JoltRigidBody3D::GetPosition() const
Vector3f RigidBody3D::GetPosition() const
{
return FromJolt(m_body->GetPosition());
}
std::pair<Vector3f, Quaternionf> JoltRigidBody3D::GetPositionAndRotation() const
std::pair<Vector3f, Quaternionf> RigidBody3D::GetPositionAndRotation() const
{
JPH::Vec3 position = m_body->GetPosition();
JPH::Quat rotation = m_body->GetRotation();
@@ -164,27 +164,27 @@ namespace Nz
return { FromJolt(position), FromJolt(rotation) };
}
Quaternionf JoltRigidBody3D::GetRotation() const
Quaternionf RigidBody3D::GetRotation() const
{
return FromJolt(m_body->GetRotation());
}
bool JoltRigidBody3D::IsSleeping() const
bool RigidBody3D::IsSleeping() const
{
return !m_body->IsActive();
}
bool JoltRigidBody3D::IsSleepingEnabled() const
bool RigidBody3D::IsSleepingEnabled() const
{
return m_body->GetAllowSleeping();
}
bool JoltRigidBody3D::IsStatic() const
bool RigidBody3D::IsStatic() const
{
return m_body->GetMotionType() == JPH::EMotionType::Static;
}
void JoltRigidBody3D::SetAngularDamping(float angularDamping)
void RigidBody3D::SetAngularDamping(float angularDamping)
{
if NAZARA_UNLIKELY(IsStatic())
return;
@@ -192,12 +192,12 @@ namespace Nz
m_body->GetMotionProperties()->SetAngularDamping(angularDamping);
}
void JoltRigidBody3D::SetAngularVelocity(const Vector3f& angularVelocity)
void RigidBody3D::SetAngularVelocity(const Vector3f& angularVelocity)
{
m_body->SetAngularVelocity(ToJolt(angularVelocity));
}
void JoltRigidBody3D::SetGeom(std::shared_ptr<JoltCollider3D> geom, bool recomputeInertia)
void RigidBody3D::SetGeom(std::shared_ptr<Collider3D> geom, bool recomputeInertia)
{
if (m_geom != geom)
{
@@ -224,7 +224,7 @@ namespace Nz
}
}
void JoltRigidBody3D::SetLinearDamping(float damping)
void RigidBody3D::SetLinearDamping(float damping)
{
if NAZARA_UNLIKELY(IsStatic())
return;
@@ -232,12 +232,12 @@ namespace Nz
m_body->GetMotionProperties()->SetLinearDamping(damping);
}
void JoltRigidBody3D::SetLinearVelocity(const Vector3f& velocity)
void RigidBody3D::SetLinearVelocity(const Vector3f& velocity)
{
m_body->SetLinearVelocity(ToJolt(velocity));
}
void JoltRigidBody3D::SetMass(float mass, bool recomputeInertia)
void RigidBody3D::SetMass(float mass, bool recomputeInertia)
{
NazaraAssert(mass >= 0.f, "Mass must be positive and finite");
NazaraAssert(std::isfinite(mass), "Mass must be positive and finite");
@@ -261,51 +261,51 @@ namespace Nz
}
}
void JoltRigidBody3D::SetPosition(const Vector3f& position)
void RigidBody3D::SetPosition(const Vector3f& position)
{
JPH::BodyInterface& bodyInterface = m_world->GetPhysicsSystem()->GetBodyInterfaceNoLock();
bodyInterface.SetPosition(m_body->GetID(), ToJolt(position), (ShouldActivate()) ? JPH::EActivation::Activate : JPH::EActivation::DontActivate);
}
void JoltRigidBody3D::SetRotation(const Quaternionf& rotation)
void RigidBody3D::SetRotation(const Quaternionf& rotation)
{
JPH::BodyInterface& bodyInterface = m_world->GetPhysicsSystem()->GetBodyInterfaceNoLock();
bodyInterface.SetRotation(m_body->GetID(), ToJolt(rotation), (ShouldActivate()) ? JPH::EActivation::Activate : JPH::EActivation::DontActivate);
}
void JoltRigidBody3D::TeleportTo(const Vector3f& position, const Quaternionf& rotation)
void RigidBody3D::TeleportTo(const Vector3f& position, const Quaternionf& rotation)
{
JPH::BodyInterface& bodyInterface = m_world->GetPhysicsSystem()->GetBodyInterfaceNoLock();
bodyInterface.SetPositionAndRotation(m_body->GetID(), ToJolt(position), ToJolt(rotation), (ShouldActivate()) ? JPH::EActivation::Activate : JPH::EActivation::DontActivate);
}
Quaternionf JoltRigidBody3D::ToLocal(const Quaternionf& worldRotation)
Quaternionf RigidBody3D::ToLocal(const Quaternionf& worldRotation)
{
return GetRotation().Conjugate() * worldRotation;
}
Vector3f JoltRigidBody3D::ToLocal(const Vector3f& worldPosition)
Vector3f RigidBody3D::ToLocal(const Vector3f& worldPosition)
{
return FromJolt(m_body->GetInverseCenterOfMassTransform() * ToJolt(worldPosition));
}
Quaternionf JoltRigidBody3D::ToWorld(const Quaternionf& localRotation)
Quaternionf RigidBody3D::ToWorld(const Quaternionf& localRotation)
{
return GetRotation() * localRotation;
}
Vector3f JoltRigidBody3D::ToWorld(const Vector3f& localPosition)
Vector3f RigidBody3D::ToWorld(const Vector3f& localPosition)
{
return FromJolt(m_body->GetCenterOfMassTransform() * ToJolt(localPosition));
}
void JoltRigidBody3D::WakeUp()
void RigidBody3D::WakeUp()
{
JPH::BodyInterface& bodyInterface = m_world->GetPhysicsSystem()->GetBodyInterface();
bodyInterface.ActivateBody(m_body->GetID());
}
JoltRigidBody3D& JoltRigidBody3D::operator=(JoltRigidBody3D&& body) noexcept
RigidBody3D& RigidBody3D::operator=(RigidBody3D&& body) noexcept
{
Destroy();
@@ -325,7 +325,7 @@ namespace Nz
}
void JoltRigidBody3D::Create(JoltPhysWorld3D& world, const DynamicSettings& settings)
void RigidBody3D::Create(PhysWorld3D& world, const DynamicSettings& settings)
{
m_geom = settings.geom;
m_isSimulationEnabled = settings.isSimulationEnabled;
@@ -345,7 +345,7 @@ namespace Nz
m_world->RegisterBody(bodyId, !settings.initiallySleeping, false);
}
void JoltRigidBody3D::Create(JoltPhysWorld3D& world, const StaticSettings& settings)
void RigidBody3D::Create(PhysWorld3D& world, const StaticSettings& settings)
{
m_geom = settings.geom;
m_isSimulationEnabled = settings.isSimulationEnabled;
@@ -365,7 +365,7 @@ namespace Nz
m_world->RegisterBody(bodyId, false, false); //< static bodies cannot be activated
}
void JoltRigidBody3D::Destroy(bool worldDestruction)
void RigidBody3D::Destroy(bool worldDestruction)
{
if (m_body)
{
@@ -376,7 +376,7 @@ namespace Nz
m_geom.reset();
}
void JoltRigidBody3D::BuildSettings(const DynamicSettings& settings, JPH::BodyCreationSettings& creationSettings)
void RigidBody3D::BuildSettings(const DynamicSettings& settings, JPH::BodyCreationSettings& creationSettings)
{
BuildSettings(static_cast<const CommonSettings&>(settings), creationSettings);
@@ -404,19 +404,19 @@ namespace Nz
switch (settings.motionQuality)
{
case JoltMotionQuality::Discrete: creationSettings.mMotionQuality = JPH::EMotionQuality::Discrete; break;
case JoltMotionQuality::LinearCast: creationSettings.mMotionQuality = JPH::EMotionQuality::LinearCast; break;
case PhysMotionQuality3D::Discrete: creationSettings.mMotionQuality = JPH::EMotionQuality::Discrete; break;
case PhysMotionQuality3D::LinearCast: creationSettings.mMotionQuality = JPH::EMotionQuality::LinearCast; break;
}
}
void JoltRigidBody3D::BuildSettings(const StaticSettings& settings, JPH::BodyCreationSettings& creationSettings)
void RigidBody3D::BuildSettings(const StaticSettings& settings, JPH::BodyCreationSettings& creationSettings)
{
BuildSettings(static_cast<const CommonSettings&>(settings), creationSettings);
creationSettings.mMotionType = JPH::EMotionType::Static;
}
void JoltRigidBody3D::BuildSettings(const CommonSettings& settings, JPH::BodyCreationSettings& creationSettings)
void RigidBody3D::BuildSettings(const CommonSettings& settings, JPH::BodyCreationSettings& creationSettings)
{
if (settings.geom)
{
@@ -434,7 +434,7 @@ namespace Nz
creationSettings.mUserData = SafeCast<UInt64>(BitCast<std::uintptr_t>(this));
}
bool JoltRigidBody3D::ShouldActivate() const
bool RigidBody3D::ShouldActivate() const
{
return m_isSimulationEnabled && m_world->IsBodyRegistered(m_bodyIndex);
}

86
src/Nazara/JoltPhysics3D/Systems/JoltPhysics3DSystem.cpp → src/Nazara/Physics3D/Systems/Physics3DSystem.cpp
View File

@@ -1,47 +1,47 @@
// Copyright (C) 2024 Jérôme "SirLynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module"
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/JoltPhysics3D/Systems/JoltPhysics3DSystem.hpp>
#include <Nazara/Physics3D/Systems/Physics3DSystem.hpp>
#include <Nazara/Core/Components/DisabledComponent.hpp>
#include <Nazara/JoltPhysics3D/JoltAbstractBody.hpp>
#include <Nazara/Physics3D/Physics3DBody.hpp>
#include <Nazara/Utility/Components/NodeComponent.hpp>
#include <Nazara/JoltPhysics3D/Debug.hpp>
#include <Nazara/Physics3D/Debug.hpp>
namespace Nz
{
JoltPhysics3DSystem::JoltPhysics3DSystem(entt::registry& registry) :
Physics3DSystem::Physics3DSystem(entt::registry& registry) :
m_registry(registry),
m_characterConstructObserver(m_registry, entt::collector.group<JoltCharacterComponent, NodeComponent>(entt::exclude<DisabledComponent, JoltRigidBody3DComponent>)),
m_rigidBodyConstructObserver(m_registry, entt::collector.group<JoltRigidBody3DComponent, NodeComponent>(entt::exclude<DisabledComponent, JoltCharacterComponent>))
m_characterConstructObserver(m_registry, entt::collector.group<PhysCharacter3DComponent, NodeComponent>(entt::exclude<DisabledComponent, RigidBody3DComponent>)),
m_rigidBodyConstructObserver(m_registry, entt::collector.group<RigidBody3DComponent, NodeComponent>(entt::exclude<DisabledComponent, PhysCharacter3DComponent>))
{
m_bodyConstructConnection = registry.on_construct<JoltRigidBody3DComponent>().connect<&JoltPhysics3DSystem::OnBodyConstruct>(this);
m_bodyDestructConnection = registry.on_destroy<JoltRigidBody3DComponent>().connect<&JoltPhysics3DSystem::OnBodyDestruct>(this);
m_characterConstructConnection = registry.on_construct<JoltCharacterComponent>().connect<&JoltPhysics3DSystem::OnCharacterConstruct>(this);
m_characterDestructConnection = registry.on_destroy<JoltCharacterComponent>().connect<&JoltPhysics3DSystem::OnCharacterDestruct>(this);
m_bodyConstructConnection = registry.on_construct<RigidBody3DComponent>().connect<&Physics3DSystem::OnBodyConstruct>(this);
m_bodyDestructConnection = registry.on_destroy<RigidBody3DComponent>().connect<&Physics3DSystem::OnBodyDestruct>(this);
m_characterConstructConnection = registry.on_construct<PhysCharacter3DComponent>().connect<&Physics3DSystem::OnCharacterConstruct>(this);
m_characterDestructConnection = registry.on_destroy<PhysCharacter3DComponent>().connect<&Physics3DSystem::OnCharacterDestruct>(this);
}
JoltPhysics3DSystem::~JoltPhysics3DSystem()
Physics3DSystem::~Physics3DSystem()
{
m_characterConstructObserver.disconnect();
m_rigidBodyConstructObserver.disconnect();
// Ensure every RigidBody3D is destroyed before world is
auto characterView = m_registry.view<JoltCharacterComponent>();
auto characterView = m_registry.view<PhysCharacter3DComponent>();
for (auto [entity, characterComponent] : characterView.each())
characterComponent.Destroy();
auto rigidBodyView = m_registry.view<JoltRigidBody3DComponent>();
auto rigidBodyView = m_registry.view<RigidBody3DComponent>();
for (auto [entity, rigidBodyComponent] : rigidBodyView.each())
rigidBodyComponent.Destroy(true);
}
bool JoltPhysics3DSystem::CollisionQuery(const Vector3f& point, const FunctionRef<std::optional<float>(const PointCollisionInfo& collisionInfo)>& callback)
bool Physics3DSystem::CollisionQuery(const Vector3f& point, const FunctionRef<std::optional<float>(const PointCollisionInfo& collisionInfo)>& callback)
{
return m_physWorld.CollisionQuery(point, [&](const JoltPhysWorld3D::PointCollisionInfo& hitInfo)
return m_physWorld.CollisionQuery(point, [&](const PhysWorld3D::PointCollisionInfo& hitInfo)
{
PointCollisionInfo extendedHitInfo;
static_cast<JoltPhysWorld3D::PointCollisionInfo&>(extendedHitInfo) = hitInfo;
static_cast<PhysWorld3D::PointCollisionInfo&>(extendedHitInfo) = hitInfo;
if (extendedHitInfo.hitBody)
{
@@ -54,17 +54,17 @@ namespace Nz
});
}
bool JoltPhysics3DSystem::CollisionQuery(const JoltCollider3D& collider, const Matrix4f& shapeTransform, const FunctionRef<std::optional<float>(const ShapeCollisionInfo& hitInfo)>& callback)
bool Physics3DSystem::CollisionQuery(const Collider3D& collider, const Matrix4f& shapeTransform, const FunctionRef<std::optional<float>(const ShapeCollisionInfo& hitInfo)>& callback)
{
return CollisionQuery(collider, shapeTransform, Vector3f::Unit(), callback);
}
bool JoltPhysics3DSystem::CollisionQuery(const JoltCollider3D& collider, const Matrix4f& colliderTransform, const Vector3f& colliderScale, const FunctionRef<std::optional<float>(const ShapeCollisionInfo& hitInfo)>& callback)
bool Physics3DSystem::CollisionQuery(const Collider3D& collider, const Matrix4f& colliderTransform, const Vector3f& colliderScale, const FunctionRef<std::optional<float>(const ShapeCollisionInfo& hitInfo)>& callback)
{
return m_physWorld.CollisionQuery(collider, colliderTransform, colliderScale, [&](const JoltPhysWorld3D::ShapeCollisionInfo& hitInfo)
return m_physWorld.CollisionQuery(collider, colliderTransform, colliderScale, [&](const PhysWorld3D::ShapeCollisionInfo& hitInfo)
{
ShapeCollisionInfo extendedHitInfo;
static_cast<JoltPhysWorld3D::ShapeCollisionInfo&>(extendedHitInfo) = hitInfo;
static_cast<PhysWorld3D::ShapeCollisionInfo&>(extendedHitInfo) = hitInfo;
if (extendedHitInfo.hitBody)
{
@@ -77,12 +77,12 @@ namespace Nz
});
}
bool JoltPhysics3DSystem::RaycastQuery(const Vector3f& from, const Vector3f& to, const FunctionRef<std::optional<float>(const RaycastHit& hitInfo)>& callback)
bool Physics3DSystem::RaycastQuery(const Vector3f& from, const Vector3f& to, const FunctionRef<std::optional<float>(const RaycastHit& hitInfo)>& callback)
{
return m_physWorld.RaycastQuery(from, to, [&](const JoltPhysWorld3D::RaycastHit& hitInfo)
return m_physWorld.RaycastQuery(from, to, [&](const PhysWorld3D::RaycastHit& hitInfo)
{
RaycastHit extendedHitInfo;
static_cast<JoltPhysWorld3D::RaycastHit&>(extendedHitInfo) = hitInfo;
static_cast<PhysWorld3D::RaycastHit&>(extendedHitInfo) = hitInfo;
if (extendedHitInfo.hitBody)
{
@@ -95,12 +95,12 @@ namespace Nz
});
}
bool JoltPhysics3DSystem::RaycastQueryFirst(const Vector3f& from, const Vector3f& to, const FunctionRef<void(const RaycastHit& hitInfo)>& callback)
bool Physics3DSystem::RaycastQueryFirst(const Vector3f& from, const Vector3f& to, const FunctionRef<void(const RaycastHit& hitInfo)>& callback)
{
return m_physWorld.RaycastQueryFirst(from, to, [&](const JoltPhysWorld3D::RaycastHit& hitInfo)
return m_physWorld.RaycastQueryFirst(from, to, [&](const PhysWorld3D::RaycastHit& hitInfo)
{
RaycastHit extendedHitInfo;
static_cast<JoltPhysWorld3D::RaycastHit&>(extendedHitInfo) = hitInfo;
static_cast<PhysWorld3D::RaycastHit&>(extendedHitInfo) = hitInfo;
if (extendedHitInfo.hitBody)
{
@@ -113,12 +113,12 @@ namespace Nz
});
}
void JoltPhysics3DSystem::Update(Time elapsedTime)
void Physics3DSystem::Update(Time elapsedTime)
{
// Move newly-created physics entities to their node position/rotation
m_characterConstructObserver.each([this](entt::entity entity)
{
JoltCharacterComponent& entityCharacter = m_registry.get<JoltCharacterComponent>(entity);
PhysCharacter3DComponent& entityCharacter = m_registry.get<PhysCharacter3DComponent>(entity);
NodeComponent& entityNode = m_registry.get<NodeComponent>(entity);
entityCharacter.TeleportTo(entityNode.GetPosition(), entityNode.GetRotation());
@@ -126,7 +126,7 @@ namespace Nz
m_rigidBodyConstructObserver.each([this](entt::entity entity)
{
JoltRigidBody3DComponent& entityBody = m_registry.get<JoltRigidBody3DComponent>(entity);
RigidBody3DComponent& entityBody = m_registry.get<RigidBody3DComponent>(entity);
NodeComponent& entityNode = m_registry.get<NodeComponent>(entity);
entityBody.TeleportTo(entityNode.GetPosition(), entityNode.GetRotation());
@@ -138,10 +138,10 @@ namespace Nz
// Replicate characters to their NodeComponent
{
auto view = m_registry.view<NodeComponent, const JoltCharacterComponent>(entt::exclude<DisabledComponent>);
auto view = m_registry.view<NodeComponent, const PhysCharacter3DComponent>(entt::exclude<DisabledComponent>);
for (auto entity : view)
{
auto& characterComponent = view.get<const JoltCharacterComponent>(entity);
auto& characterComponent = view.get<const PhysCharacter3DComponent>(entity);
if (!m_physWorld.IsBodyActive(characterComponent.GetBodyIndex()))
continue;
@@ -154,10 +154,10 @@ namespace Nz
// Replicate active rigid body position to their node components
{
auto view = m_registry.view<NodeComponent, const JoltRigidBody3DComponent>(entt::exclude<DisabledComponent>);
for (auto entity : m_registry.view<NodeComponent, const JoltRigidBody3DComponent>(entt::exclude<DisabledComponent>))
auto view = m_registry.view<NodeComponent, const RigidBody3DComponent>(entt::exclude<DisabledComponent>);
for (auto entity : m_registry.view<NodeComponent, const RigidBody3DComponent>(entt::exclude<DisabledComponent>))
{
auto& rigidBodyComponent = view.get<const JoltRigidBody3DComponent>(entity);
auto& rigidBodyComponent = view.get<const RigidBody3DComponent>(entity);
if (!m_physWorld.IsBodyActive(rigidBodyComponent.GetBodyIndex()))
continue;
@@ -169,10 +169,10 @@ namespace Nz
}
}
void JoltPhysics3DSystem::OnBodyConstruct(entt::registry& registry, entt::entity entity)
void Physics3DSystem::OnBodyConstruct(entt::registry& registry, entt::entity entity)
{
// Register rigid body owning entity
JoltRigidBody3DComponent& rigidBody = registry.get<JoltRigidBody3DComponent>(entity);
RigidBody3DComponent& rigidBody = registry.get<RigidBody3DComponent>(entity);
rigidBody.Construct(m_physWorld);
UInt32 uniqueIndex = rigidBody.GetBodyIndex();
@@ -182,19 +182,19 @@ namespace Nz
m_bodyIndicesToEntity[uniqueIndex] = entity;
}
void JoltPhysics3DSystem::OnBodyDestruct(entt::registry& registry, entt::entity entity)
void Physics3DSystem::OnBodyDestruct(entt::registry& registry, entt::entity entity)
{
// Unregister owning entity
JoltRigidBody3DComponent& rigidBody = registry.get<JoltRigidBody3DComponent>(entity);
RigidBody3DComponent& rigidBody = registry.get<RigidBody3DComponent>(entity);
UInt32 uniqueIndex = rigidBody.GetBodyIndex();
assert(uniqueIndex <= m_bodyIndicesToEntity.size());
m_bodyIndicesToEntity[uniqueIndex] = entt::null;
}
void JoltPhysics3DSystem::OnCharacterConstruct(entt::registry& registry, entt::entity entity)
void Physics3DSystem::OnCharacterConstruct(entt::registry& registry, entt::entity entity)
{
JoltCharacterComponent& character = registry.get<JoltCharacterComponent>(entity);
PhysCharacter3DComponent& character = registry.get<PhysCharacter3DComponent>(entity);
character.Construct(m_physWorld);
UInt32 uniqueIndex = character.GetBodyIndex();
@@ -204,10 +204,10 @@ namespace Nz
m_bodyIndicesToEntity[uniqueIndex] = entity;
}
void JoltPhysics3DSystem::OnCharacterDestruct(entt::registry& registry, entt::entity entity)
void Physics3DSystem::OnCharacterDestruct(entt::registry& registry, entt::entity entity)
{
// Unregister owning entity
JoltCharacterComponent& character = registry.get<JoltCharacterComponent>(entity);
PhysCharacter3DComponent& character = registry.get<PhysCharacter3DComponent>(entity);
UInt32 uniqueIndex = character.GetBodyIndex();
assert(uniqueIndex <= m_bodyIndicesToEntity.size());