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

JoltPhysics3D: Add JoltPivotConstraint3D

This commit is contained in:
SirLynix 2023-03-30 13:23:36 +02:00 committed by Jérôme Leclercq
parent d697450a60
commit 6447686ad9
5 changed files with 133 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
include/Nazara/JoltPhysics3D/JoltConstraint3D.hpp
View File

@ -3,63 +3,68 @@
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once #pragma once
#if 0
#ifndef NAZARA_JOLTPHYSICS3D_JOLTCONSTRAINT3D_HPP #ifndef NAZARA_JOLTPHYSICS3D_JOLTCONSTRAINT3D_HPP
#define NAZARA_JOLTPHYSICS3D_JOLTCONSTRAINT3D_HPP #define NAZARA_JOLTPHYSICS3D_JOLTCONSTRAINT3D_HPP
#include <NazaraUtils/Prerequisites.hpp> #include <NazaraUtils/Prerequisites.hpp>
#include <Nazara/BulletPhysics3D/BulletPhysWorld3D.hpp> #include <Nazara/JoltPhysics3D/JoltPhysWorld3D.hpp>
#include <Nazara/BulletPhysics3D/BulletRigidBody3D.hpp> #include <Nazara/JoltPhysics3D/JoltRigidBody3D.hpp>
#include <Nazara/BulletPhysics3D/Config.hpp> #include <Nazara/JoltPhysics3D/Config.hpp>
#include <Nazara/Core/HandledObject.hpp> #include <Nazara/Core/HandledObject.hpp>
#include <Nazara/Core/ObjectHandle.hpp> #include <Nazara/Core/ObjectHandle.hpp>
class btTypedConstraint; namespace JPH
{
class TwoBodyConstraint;
}
namespace Nz namespace Nz
{ {
class BulletConstraint3D; class JoltConstraint3D;
using BulletConstraint3DHandle = ObjectHandle<BulletConstraint3D>; using JoltConstraint3DHandle = ObjectHandle<JoltConstraint3D>;
class NAZARA_BULLETPHYSICS3D_API BulletConstraint3D : public HandledObject<BulletConstraint3D> class NAZARA_JOLTPHYSICS3D_API JoltConstraint3D : public HandledObject<JoltConstraint3D>
{ {
public: public:
BulletConstraint3D(const BulletConstraint3D&) = delete; JoltConstraint3D(const JoltConstraint3D&) = delete;
BulletConstraint3D(BulletConstraint3D&& constraint) noexcept; JoltConstraint3D(JoltConstraint3D&& constraint) noexcept;
virtual ~BulletConstraint3D(); virtual ~JoltConstraint3D();
BulletRigidBody3D& GetBodyA(); JoltRigidBody3D& GetBodyA();
const BulletRigidBody3D& GetBodyA() const; const JoltRigidBody3D& GetBodyA() const;
BulletRigidBody3D& GetBodyB(); JoltRigidBody3D& GetBodyB();
const BulletRigidBody3D& GetBodyB() const; const JoltRigidBody3D& GetBodyB() const;
BulletPhysWorld3D& GetWorld(); JoltPhysWorld3D& GetWorld();
const BulletPhysWorld3D& GetWorld() const; const JoltPhysWorld3D& GetWorld() const;
inline bool IsBodyCollisionEnabled() const;
bool IsSingleBody() const; bool IsSingleBody() const;
BulletConstraint3D& operator=(const BulletConstraint3D&) = delete; JoltConstraint3D& operator=(const JoltConstraint3D&) = delete;
BulletConstraint3D& operator=(BulletConstraint3D&& constraint) noexcept; JoltConstraint3D& operator=(JoltConstraint3D&& constraint) noexcept;
protected: protected:
BulletConstraint3D(std::unique_ptr<btTypedConstraint> constraint, bool disableCollisions = false); JoltConstraint3D();
template<typename T> T* GetConstraint(); template<typename T> T* GetConstraint();
template<typename T> const T* GetConstraint() const; template<typename T> const T* GetConstraint() const;
void SetupConstraint(std::unique_ptr<JPH::TwoBodyConstraint> constraint);
private: private:
std::unique_ptr<btTypedConstraint> m_constraint; void Destroy();
bool m_bodyCollisionEnabled;
std::unique_ptr<JPH::TwoBodyConstraint> m_constraint;
}; };
class NAZARA_BULLETPHYSICS3D_API BulletPivotConstraint3D : public BulletConstraint3D class NAZARA_JOLTPHYSICS3D_API JoltPivotConstraint3D : public JoltConstraint3D
{ {
public: public:
BulletPivotConstraint3D(BulletRigidBody3D& first, const Vector3f& pivot); JoltPivotConstraint3D(JoltRigidBody3D& first, const Vector3f& pivot);
BulletPivotConstraint3D(BulletRigidBody3D& first, BulletRigidBody3D& second, const Vector3f& pivot, bool disableCollisions = false); JoltPivotConstraint3D(JoltRigidBody3D& first, JoltRigidBody3D& second, const Vector3f& pivot);
BulletPivotConstraint3D(BulletRigidBody3D& first, BulletRigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor, bool disableCollisions = false); JoltPivotConstraint3D(JoltRigidBody3D& first, JoltRigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor);
~BulletPivotConstraint3D() = default; ~JoltPivotConstraint3D() = default;
Vector3f GetFirstAnchor() const; Vector3f GetFirstAnchor() const;
Vector3f GetSecondAnchor() const; Vector3f GetSecondAnchor() const;
@ -69,7 +74,6 @@ namespace Nz
}; };
} }
#include <Nazara/BulletPhysics3D/BulletConstraint3D.inl> #include <Nazara/JoltPhysics3D/JoltConstraint3D.inl>
#endif // NAZARA_BULLETPHYSICS3D_BULLETCONSTRAINT3D_HPP #endif // NAZARA_BULLETPHYSICS3D_BULLETCONSTRAINT3D_HPP
#endif // NAZARA_JOLTPHYSICS3D_JOLTCONSTRAINT3D_HPP

9
include/Nazara/JoltPhysics3D/JoltConstraint3D.inl
View File

@ -6,19 +6,14 @@
namespace Nz namespace Nz
{ {
inline bool BulletConstraint3D::IsBodyCollisionEnabled() const
{
return m_bodyCollisionEnabled;
}
template<typename T> template<typename T>
T* BulletConstraint3D::GetConstraint() T* JoltConstraint3D::GetConstraint()
{ {
return SafeCast<T*>(m_constraint.get()); return SafeCast<T*>(m_constraint.get());
} }
template<typename T> template<typename T>
const T* BulletConstraint3D::GetConstraint() const const T* JoltConstraint3D::GetConstraint() const
{ {
return SafeCast<const T*>(m_constraint.get()); return SafeCast<const T*>(m_constraint.get());
} }

2
include/Nazara/JoltPhysics3D/JoltRigidBody3D.hpp
View File

@ -46,6 +46,8 @@ namespace Nz
Boxf GetAABB() const; Boxf GetAABB() const;
float GetAngularDamping() const; float GetAngularDamping() const;
Vector3f GetAngularVelocity() const; Vector3f GetAngularVelocity() const;
inline JPH::Body* GetBody();
inline const JPH::Body* GetBody() const;
inline UInt32 GetBodyIndex() const; inline UInt32 GetBodyIndex() const;
inline const std::shared_ptr<JoltCollider3D>& GetGeom() const; inline const std::shared_ptr<JoltCollider3D>& GetGeom() const;
float GetLinearDamping() const; float GetLinearDamping() const;

10
include/Nazara/JoltPhysics3D/JoltRigidBody3D.inl
View File

@ -11,6 +11,16 @@ namespace Nz
return EnableSleeping(false); return EnableSleeping(false);
} }
inline JPH::Body* JoltRigidBody3D::GetBody()
{
return m_body;
}
inline const JPH::Body* JoltRigidBody3D::GetBody() const
{
return m_body;
}
inline UInt32 JoltRigidBody3D::GetBodyIndex() const inline UInt32 JoltRigidBody3D::GetBodyIndex() const
{ {
return m_bodyIndex; return m_bodyIndex;

139
src/Nazara/JoltPhysics3D/JoltConstraint3D.cpp
View File

@ -1,125 +1,156 @@
// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com) // Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - JoltPhysics3D module" // This file is part of the "Nazara Engine - JoltPhysics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp // For conditions of distribution and use, see copyright notice in Config.hpp
#if 0
#include <Nazara/JoltPhysics3D/JoltConstraint3D.hpp> #include <Nazara/JoltPhysics3D/JoltConstraint3D.hpp>
#include <Nazara/BulletPhysics3D/BulletConstraint3D.hpp> #include <Nazara/JoltPhysics3D/JoltConstraint3D.hpp>
#include <Nazara/BulletPhysics3D/BulletHelper.hpp> #include <Nazara/JoltPhysics3D/JoltHelper.hpp>
#include <BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h> #include <Jolt/Jolt.h>
#include <BulletDynamics/Dynamics/btDynamicsWorld.h> #include <Jolt/Physics/PhysicsSystem.h>
#include <Jolt/Physics/Constraints/PointConstraint.h>
#include <cassert>
#include <Nazara/JoltPhysics3D/Debug.hpp> #include <Nazara/JoltPhysics3D/Debug.hpp>
namespace Nz namespace Nz
{ {
BulletConstraint3D::BulletConstraint3D(std::unique_ptr<btTypedConstraint> constraint, bool disableCollisions) : JoltConstraint3D::JoltConstraint3D() = default;
m_constraint(std::move(constraint)),
m_bodyCollisionEnabled(!disableCollisions)
{
btDynamicsWorld* world = GetWorld().GetDynamicsWorld();
world->addConstraint(m_constraint.get(), disableCollisions);
}
BulletConstraint3D::BulletConstraint3D(BulletConstraint3D&& constraint) noexcept : JoltConstraint3D::JoltConstraint3D(JoltConstraint3D&& constraint) noexcept :
m_constraint(std::move(constraint.m_constraint)), m_constraint(std::move(constraint.m_constraint))
m_bodyCollisionEnabled(constraint.m_bodyCollisionEnabled)
{ {
if (m_constraint) if (m_constraint)
m_constraint->setUserConstraintPtr(this); m_constraint->SetUserData(SafeCast<UInt64>(reinterpret_cast<std::uintptr_t>(this)));
} }
BulletConstraint3D::~BulletConstraint3D() JoltConstraint3D::~JoltConstraint3D()
{ {
if (m_constraint) Destroy();
{
btDynamicsWorld* world = GetWorld().GetDynamicsWorld();
world->removeConstraint(m_constraint.get());
}
} }
BulletRigidBody3D& BulletConstraint3D::GetBodyA() JoltRigidBody3D& JoltConstraint3D::GetBodyA()
{ {
return *static_cast<BulletRigidBody3D*>(m_constraint->getRigidBodyA().getUserPointer()); return *reinterpret_cast<JoltRigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody1()->GetUserData()));
} }
const BulletRigidBody3D& BulletConstraint3D::GetBodyA() const const JoltRigidBody3D& JoltConstraint3D::GetBodyA() const
{ {
return *static_cast<BulletRigidBody3D*>(m_constraint->getRigidBodyA().getUserPointer()); return *reinterpret_cast<JoltRigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody1()->GetUserData()));
} }
BulletRigidBody3D& BulletConstraint3D::GetBodyB() JoltRigidBody3D& JoltConstraint3D::GetBodyB()
{ {
NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body"); NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
return *static_cast<BulletRigidBody3D*>(m_constraint->getRigidBodyB().getUserPointer()); return *reinterpret_cast<JoltRigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody2()->GetUserData()));
} }
const BulletRigidBody3D& BulletConstraint3D::GetBodyB() const const JoltRigidBody3D& JoltConstraint3D::GetBodyB() const
{ {
NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body"); NazaraAssert(!IsSingleBody(), "constraint is not attached to a second body");
return *static_cast<BulletRigidBody3D*>(m_constraint->getRigidBodyB().getUserPointer()); return *reinterpret_cast<JoltRigidBody3D*>(static_cast<std::uintptr_t>(m_constraint->GetBody2()->GetUserData()));
} }
BulletPhysWorld3D& BulletConstraint3D::GetWorld() JoltPhysWorld3D& JoltConstraint3D::GetWorld()
{ {
return *GetBodyA().GetWorld(); return *GetBodyA().GetWorld();
} }
const BulletPhysWorld3D& BulletConstraint3D::GetWorld() const const JoltPhysWorld3D& JoltConstraint3D::GetWorld() const
{ {
return *GetBodyA().GetWorld(); return *GetBodyA().GetWorld();
} }
bool BulletConstraint3D::IsSingleBody() const bool JoltConstraint3D::IsSingleBody() const
{ {
return &m_constraint->getRigidBodyB() == &btTypedConstraint::getFixedBody(); return m_constraint->GetBody2() == &JPH::Body::sFixedToWorld;
} }
BulletConstraint3D& BulletConstraint3D::operator=(BulletConstraint3D&& constraint) noexcept JoltConstraint3D& JoltConstraint3D::operator=(JoltConstraint3D&& constraint) noexcept
{ {
m_constraint.reset(); Destroy();
m_constraint = std::move(constraint.m_constraint); m_constraint = std::move(constraint.m_constraint);
m_bodyCollisionEnabled = constraint.m_bodyCollisionEnabled;
if (m_constraint) if (m_constraint)
m_constraint->setUserConstraintPtr(this); m_constraint->SetUserData(SafeCast<UInt64>(reinterpret_cast<std::uintptr_t>(this)));
return *this; return *this;
} }
void JoltConstraint3D::Destroy()
BulletPivotConstraint3D::BulletPivotConstraint3D(BulletRigidBody3D& first, const Vector3f& pivot) :
BulletConstraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), ToBullet(first.ToLocal(pivot))))
{ {
if (m_constraint)
{
JPH::PhysicsSystem* physicsSystem = GetWorld().GetPhysicsSystem();
physicsSystem->RemoveConstraint(m_constraint.get());
m_constraint.reset();
}
} }
BulletPivotConstraint3D::BulletPivotConstraint3D(BulletRigidBody3D& first, BulletRigidBody3D& second, const Vector3f& pivot, bool disableCollisions) : void JoltConstraint3D::SetupConstraint(std::unique_ptr<JPH::TwoBodyConstraint> constraint)
BulletConstraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), *second.GetRigidBody(), ToBullet(first.ToLocal(pivot)), ToBullet(second.ToLocal(pivot))), disableCollisions)
{ {
assert(!m_constraint);
m_constraint = std::move(constraint);
m_constraint->SetEmbedded();
m_constraint->SetUserData(SafeCast<UInt64>(reinterpret_cast<std::uintptr_t>(this)));
JPH::PhysicsSystem* physicsSystem = GetWorld().GetPhysicsSystem();
physicsSystem->AddConstraint(m_constraint.get());
} }
BulletPivotConstraint3D::BulletPivotConstraint3D(BulletRigidBody3D& first, BulletRigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor, bool disableCollisions) :
BulletConstraint3D(std::make_unique<btPoint2PointConstraint>(*first.GetRigidBody(), *second.GetRigidBody(), ToBullet(firstAnchor), ToBullet(secondAnchor)), disableCollisions) JoltPivotConstraint3D::JoltPivotConstraint3D(JoltRigidBody3D& first, const Vector3f& pivot)
{ {
JPH::PointConstraintSettings settings;
settings.mPoint1 = ToJolt(pivot);
settings.mPoint2 = ToJolt(pivot);
settings.mSpace = JPH::EConstraintSpace::WorldSpace;
SetupConstraint(std::make_unique<JPH::PointConstraint>(*first.GetBody(), JPH::Body::sFixedToWorld, settings));
} }
Vector3f BulletPivotConstraint3D::GetFirstAnchor() const JoltPivotConstraint3D::JoltPivotConstraint3D(JoltRigidBody3D& first, JoltRigidBody3D& second, const Vector3f& pivot)
{ {
return FromBullet(GetConstraint<btPoint2PointConstraint>()->getPivotInA()); JPH::PointConstraintSettings settings;
settings.mPoint1 = ToJolt(pivot);
settings.mPoint2 = ToJolt(pivot);
settings.mSpace = JPH::EConstraintSpace::WorldSpace;
SetupConstraint(std::make_unique<JPH::PointConstraint>(*first.GetBody(), *second.GetBody(), settings));
} }
Vector3f BulletPivotConstraint3D::GetSecondAnchor() const JoltPivotConstraint3D::JoltPivotConstraint3D(JoltRigidBody3D& first, JoltRigidBody3D& second, const Vector3f& firstAnchor, const Vector3f& secondAnchor)
{ {
return FromBullet(GetConstraint<btPoint2PointConstraint>()->getPivotInB()); JPH::PointConstraintSettings settings;
settings.mPoint1 = ToJolt(firstAnchor);
settings.mPoint2 = ToJolt(secondAnchor);
settings.mSpace = JPH::EConstraintSpace::WorldSpace;
SetupConstraint(std::make_unique<JPH::PointConstraint>(*first.GetBody(), *second.GetBody(), settings));
} }
void BulletPivotConstraint3D::SetFirstAnchor(const Vector3f& firstAnchor) Vector3f JoltPivotConstraint3D::GetFirstAnchor() const
{ {
GetConstraint<btPoint2PointConstraint>()->setPivotA(ToBullet(firstAnchor)); const JPH::PointConstraint* constraint = GetConstraint<JPH::PointConstraint>();
return FromJolt(constraint->GetBody1()->GetCenterOfMassTransform() * constraint->GetLocalSpacePoint1());
} }
void BulletPivotConstraint3D::SetSecondAnchor(const Vector3f& secondAnchor) Vector3f JoltPivotConstraint3D::GetSecondAnchor() const
{ {
GetConstraint<btPoint2PointConstraint>()->setPivotB(ToBullet(secondAnchor)); const JPH::PointConstraint* constraint = GetConstraint<JPH::PointConstraint>();
return FromJolt(constraint->GetBody2()->GetCenterOfMassTransform() * constraint->GetLocalSpacePoint2());
}
void JoltPivotConstraint3D::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)
{
GetConstraint<JPH::PointConstraint>()->SetPoint2(JPH::EConstraintSpace::WorldSpace, ToJolt(secondAnchor));
} }
} }
#endif