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

Physics3D: Switch from Newton Dynamics to Bullet3

Browse Source
This commit is contained in:
SirLynix
2023-03-07 19:17:49 +01:00
committed by Jérôme Leclercq
parent ec1efb5e56
commit 795efae3a0
13 changed files with 625 additions and 935 deletions
Download Patch File Download Diff File Expand all files Collapse all files

235
include/Nazara/Physics3D/Collider3D.hpp
View File

@@ -18,40 +18,38 @@
#include <NazaraUtils/SparsePtr.hpp>
#include <unordered_map>
class NewtonCollision;
class btBoxShape;
class btCapsuleShape;
class btCompoundShape;
class btCollisionShape;
class btConeShape;
class btConvexHullShape;
class btCylinderShape;
class btSphereShape;
namespace Nz
{
///TODO: CollisionModifier
///TODO: HeightfieldGeom
///TODO: PlaneGeom ?
///TODO: SceneGeom
///TODO: TreeGeom
class PrimitiveList;
class PhysWorld3D;
class StaticMesh;
struct Primitive;
class NAZARA_PHYSICS3D_API Collider3D
{
friend class Physics3D;
public:
Collider3D() = default;
Collider3D(const Collider3D&) = delete;
Collider3D(Collider3D&&) = delete;
virtual ~Collider3D();
virtual void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix = Matrix4f::Identity()) const = 0;
Boxf ComputeAABB(const Vector3f& translation, const Quaternionf& rotation, const Vector3f& scale) const;
virtual Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const;
virtual void ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const;
virtual float ComputeVolume() const;
virtual void ComputeInertia(float mass, Vector3f* inertia) const;
virtual void ForEachPolygon(const std::function<void(const Vector3f* vertices, std::size_t vertexCount)>& callback) const;
virtual std::shared_ptr<StaticMesh> GenerateDebugMesh() const;
virtual std::shared_ptr<StaticMesh> GenerateMesh() const;
NewtonCollision* GetHandle(PhysWorld3D* world) const;
virtual btCollisionShape* GetShape() const = 0;
virtual ColliderType3D GetType() const = 0;
Collider3D& operator=(const Collider3D&) = delete;
@@ -59,146 +57,153 @@ namespace Nz
static std::shared_ptr<Collider3D> Build(const PrimitiveList& list);
// Signals:
NazaraSignal(OnColliderRelease, const Collider3D* /*collider*/);
protected:
virtual NewtonCollision* CreateHandle(PhysWorld3D* world) const = 0;
mutable std::unordered_map<PhysWorld3D*, NewtonCollision*> m_handles;
private:
static std::shared_ptr<Collider3D> CreateGeomFromPrimitive(const Primitive& primitive);
};
class NAZARA_PHYSICS3D_API BoxCollider3D : public Collider3D
class NAZARA_PHYSICS3D_API BoxCollider3D final : public Collider3D
{
public:
BoxCollider3D(const Vector3f& lengths, const Matrix4f& transformMatrix = Matrix4f::Identity());
BoxCollider3D(const Vector3f& lengths, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
BoxCollider3D(const Vector3f& lengths);
~BoxCollider3D();
Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const override;
float ComputeVolume() const override;
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
Vector3f GetLengths() const;
btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override;
private:
NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
Matrix4f m_matrix;
std::unique_ptr<btBoxShape> m_shape;
Vector3f m_lengths;
};
class NAZARA_PHYSICS3D_API CapsuleCollider3D : public Collider3D
class NAZARA_PHYSICS3D_API CapsuleCollider3D final : public Collider3D
{
public:
CapsuleCollider3D(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
CapsuleCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
CapsuleCollider3D(float length, float radius);
~CapsuleCollider3D();
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
float GetLength() const;
float GetRadius() const;
btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override;
private:
NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
std::unique_ptr<btCapsuleShape> m_shape;
float m_length;
float m_radius;
};
class NAZARA_PHYSICS3D_API CompoundCollider3D final : public Collider3D
{
public:
struct ChildCollider;
CompoundCollider3D(std::vector<ChildCollider> childs);
~CompoundCollider3D();
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
const std::vector<ChildCollider>& GetGeoms() const;
btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override;
struct ChildCollider
{
std::shared_ptr<Collider3D> collider;
Matrix4f offsetMatrix;
};
private:
std::unique_ptr<btCompoundShape> m_shape;
std::vector<ChildCollider> m_childs;
};
class NAZARA_PHYSICS3D_API ConeCollider3D final : public Collider3D
{
public:
ConeCollider3D(float length, float radius);
~ConeCollider3D();
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
float GetLength() const;
float GetRadius() const;
btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override;
private:
std::unique_ptr<btConeShape> m_shape;
float m_length;
float m_radius;
};
class NAZARA_PHYSICS3D_API ConvexCollider3D final : public Collider3D
{
public:
ConvexCollider3D(SparsePtr<const Vector3f> vertices, unsigned int vertexCount);
~ConvexCollider3D();
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override;
private:
std::unique_ptr<btConvexHullShape> m_shape;
};
class NAZARA_PHYSICS3D_API CylinderCollider3D final : public Collider3D
{
public:
CylinderCollider3D(float length, float radius);
~CylinderCollider3D();
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
float GetLength() const;
float GetRadius() const;
btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override;
private:
std::unique_ptr<btCylinderShape> m_shape;
Matrix4f m_matrix;
float m_length;
float m_radius;
};
class NAZARA_PHYSICS3D_API CompoundCollider3D : public Collider3D
class NAZARA_PHYSICS3D_API NullCollider3D final : public Collider3D
{
public:
CompoundCollider3D(std::vector<std::shared_ptr<Collider3D>> geoms);
NullCollider3D() = default;
~NullCollider3D() = default;
const std::vector<std::shared_ptr<Collider3D>>& GetGeoms() const;
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
void ComputeInertia(float mass, Vector3f* inertia) const override;
btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override;
private:
NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
std::vector<std::shared_ptr<Collider3D>> m_geoms;
};
class NAZARA_PHYSICS3D_API ConeCollider3D : public Collider3D
class NAZARA_PHYSICS3D_API SphereCollider3D final : public Collider3D
{
public:
ConeCollider3D(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
ConeCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
SphereCollider3D(float radius);
~SphereCollider3D();
float GetLength() const;
float GetRadius() const;
ColliderType3D GetType() const override;
private:
NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
Matrix4f m_matrix;
float m_length;
float m_radius;
};
class NAZARA_PHYSICS3D_API ConvexCollider3D : public Collider3D
{
public:
ConvexCollider3D(SparsePtr<const Vector3f> vertices, unsigned int vertexCount, float tolerance = 0.002f, const Matrix4f& transformMatrix = Matrix4f::Identity());
ConvexCollider3D(SparsePtr<const Vector3f> vertices, unsigned int vertexCount, float tolerance, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
ColliderType3D GetType() const override;
private:
NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
std::vector<Vector3f> m_vertices;
Matrix4f m_matrix;
float m_tolerance;
};
class NAZARA_PHYSICS3D_API CylinderCollider3D : public Collider3D
{
public:
CylinderCollider3D(float length, float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
CylinderCollider3D(float length, float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
float GetLength() const;
float GetRadius() const;
ColliderType3D GetType() const override;
private:
NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
Matrix4f m_matrix;
float m_length;
float m_radius;
};
class NAZARA_PHYSICS3D_API NullCollider3D : public Collider3D
{
public:
NullCollider3D();
void ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const override;
ColliderType3D GetType() const override;
private:
NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
};
class NAZARA_PHYSICS3D_API SphereCollider3D : public Collider3D
{
public:
SphereCollider3D(float radius, const Matrix4f& transformMatrix = Matrix4f::Identity());
SphereCollider3D(float radius, const Vector3f& translation, const Quaternionf& rotation = Quaternionf::Identity());
Boxf ComputeAABB(const Matrix4f& offsetMatrix = Matrix4f::Identity(), const Vector3f& scale = Vector3f::Unit()) const override;
float ComputeVolume() const override;
void BuildDebugMesh(std::vector<Vector3f>& vertices, std::vector<UInt16>& indices, const Matrix4f& offsetMatrix) const override;
float GetRadius() const;
btCollisionShape* GetShape() const override;
ColliderType3D GetType() const override;
private:
NewtonCollision* CreateHandle(PhysWorld3D* world) const override;
std::unique_ptr<btSphereShape> m_shape;
Vector3f m_position;
float m_radius;
};

42
include/Nazara/Physics3D/PhysWorld3D.hpp
View File

@@ -13,52 +13,27 @@
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Physics3D/Config.hpp>
#include <NazaraUtils/MovablePtr.hpp>
#include <string>
#include <unordered_map>
class NewtonBody;
class NewtonJoint;
class NewtonMaterial;
class NewtonWorld;
class btDynamicsWorld;
namespace Nz
{
class RigidBody3D;
class NAZARA_PHYSICS3D_API PhysWorld3D
{
public:
using BodyIterator = std::function<bool(RigidBody3D& body)>;
using AABBOverlapCallback = std::function<bool(const RigidBody3D& firstBody, const RigidBody3D& secondBody)>;
using CollisionCallback = std::function<bool(const RigidBody3D& firstBody, const RigidBody3D& secondBody)>;
PhysWorld3D();
PhysWorld3D(const PhysWorld3D&) = delete;
PhysWorld3D(PhysWorld3D&& ph) noexcept;
~PhysWorld3D();
int CreateMaterial(std::string name = {});
void ForEachBodyInAABB(const Boxf& box, const BodyIterator& iterator);
btDynamicsWorld* GetDynamicsWorld();
Vector3f GetGravity() const;
NewtonWorld* GetHandle() const;
int GetMaterial(const std::string& name);
std::size_t GetMaxStepCount() const;
Time GetStepSize() const;
unsigned int GetThreadCount() const;
void SetGravity(const Vector3f& gravity);
void SetMaxStepCount(std::size_t maxStepCount);
void SetStepSize(Time stepSize);
void SetThreadCount(unsigned int threadCount);
void SetMaterialCollisionCallback(int firstMaterial, int secondMaterial, AABBOverlapCallback aabbOverlapCallback, CollisionCallback collisionCallback);
void SetMaterialDefaultCollidable(int firstMaterial, int secondMaterial, bool collidable);
void SetMaterialDefaultElasticity(int firstMaterial, int secondMaterial, float elasticCoef);
void SetMaterialDefaultFriction(int firstMaterial, int secondMaterial, float staticFriction, float kineticFriction);
void SetMaterialDefaultSoftness(int firstMaterial, int secondMaterial, float softness);
void SetMaterialSurfaceThickness(int firstMaterial, int secondMaterial, float thickness);
void Step(Time timestep);
@@ -66,19 +41,10 @@ namespace Nz
PhysWorld3D& operator=(PhysWorld3D&&) noexcept;
private:
struct Callback
{
AABBOverlapCallback aabbOverlapCallback;
CollisionCallback collisionCallback;
};
struct BulletWorld;
static int OnAABBOverlap(const NewtonJoint* const contact, float timestep, int threadIndex);
static void ProcessContact(const NewtonJoint* const contact, float timestep, int threadIndex);
std::unordered_map<Nz::UInt64, std::unique_ptr<Callback>> m_callbacks;
std::unordered_map<std::string, int> m_materialIds;
std::size_t m_maxStepCount;
MovablePtr<NewtonWorld> m_world;
std::unique_ptr<BulletWorld> m_world;
Vector3f m_gravity;
Time m_stepSize;
Time m_timestepAccumulator;

2
include/Nazara/Physics3D/Physics3D.hpp
View File

@@ -25,8 +25,6 @@ namespace Nz
Physics3D(Config /*config*/);
~Physics3D() = default;
unsigned int GetMemoryUsed();
private:
static Physics3D* s_instance;
};

44
include/Nazara/Physics3D/RigidBody3D.hpp
View File

@@ -16,7 +16,7 @@
#include <Nazara/Physics3D/Config.hpp>
#include <NazaraUtils/MovablePtr.hpp>
class NewtonBody;
class btRigidBody;
namespace Nz
{
@@ -27,7 +27,7 @@ namespace Nz
public:
RigidBody3D(PhysWorld3D* world, const Matrix4f& mat = Matrix4f::Identity());
RigidBody3D(PhysWorld3D* world, std::shared_ptr<Collider3D> geom, const Matrix4f& mat = Matrix4f::Identity());
RigidBody3D(const RigidBody3D& object);
RigidBody3D(const RigidBody3D& object) = delete;
RigidBody3D(RigidBody3D&& object) noexcept;
~RigidBody3D();
@@ -35,64 +35,54 @@ namespace Nz
void AddForce(const Vector3f& force, const Vector3f& point, CoordSys coordSys = CoordSys::Global);
void AddTorque(const Vector3f& torque, CoordSys coordSys = CoordSys::Global);
void EnableAutoSleep(bool autoSleep);
void EnableSimulation(bool simulation);
inline void DisableSleeping();
void EnableSleeping(bool enable);
void FallAsleep();
Boxf GetAABB() const;
Vector3f GetAngularDamping() const;
float GetAngularDamping() const;
Vector3f GetAngularVelocity() const;
const std::shared_ptr<Collider3D>& GetGeom() const;
float GetGravityFactor() const;
NewtonBody* GetHandle() const;
float GetLinearDamping() const;
Vector3f GetLinearVelocity() const;
float GetMass() const;
Vector3f GetMassCenter(CoordSys coordSys = CoordSys::Local) const;
int GetMaterial() const;
Matrix4f GetMatrix() const;
Vector3f GetPosition() const;
btRigidBody* GetRigidBody() const;
Quaternionf GetRotation() const;
void* GetUserdata() const;
PhysWorld3D* GetWorld() const;
bool IsAutoSleepEnabled() const;
bool IsMoveable() const;
bool IsSimulationEnabled() const;
bool IsSleeping() const;
bool IsSleepingEnabled() const;
void SetAngularDamping(const Vector3f& angularDamping);
void SetAngularDamping(float angularDamping);
void SetAngularVelocity(const Vector3f& angularVelocity);
void SetGeom(std::shared_ptr<Collider3D> geom);
void SetGravityFactor(float gravityFactor);
void SetGeom(std::shared_ptr<Collider3D> geom, bool recomputeInertia = true);
void SetLinearDamping(float damping);
void SetLinearVelocity(const Vector3f& velocity);
void SetMass(float mass);
void SetMassCenter(const Vector3f& center);
void SetMaterial(const std::string& materialName);
void SetMaterial(int materialIndex);
void SetPosition(const Vector3f& position);
void SetRotation(const Quaternionf& rotation);
void SetUserdata(void* ud);
RigidBody3D& operator=(const RigidBody3D& object);
void WakeUp();
RigidBody3D& operator=(const RigidBody3D& object) = delete;
RigidBody3D& operator=(RigidBody3D&& object) noexcept;
protected:
void Destroy();
private:
void UpdateBody(const Matrix4f& transformMatrix);
static void ForceAndTorqueCallback(const NewtonBody* body, float timeStep, int threadIndex);
std::shared_ptr<Collider3D> m_geom;
MovablePtr<NewtonBody> m_body;
Vector3f m_forceAccumulator;
Vector3f m_torqueAccumulator;
std::unique_ptr<btRigidBody> m_body;
PhysWorld3D* m_world;
void* m_userdata;
float m_gravityFactor;
float m_mass;
};
}
#include <Nazara/Physics3D/RigidBody3D.inl>
#endif // NAZARA_PHYSICS3D_RIGIDBODY3D_HPP

16
include/Nazara/Physics3D/RigidBody3D.inl Normal file
View File

@@ -0,0 +1,16 @@
// Copyright (C) 2023 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - Physics3D module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Physics3D/RigidBody3D.hpp>
#include <Nazara/Physics3D/Debug.hpp>
namespace Nz
{
inline void RigidBody3D::DisableSleeping()
{
return EnableSleeping(false);
}
}
#include <Nazara/Physics3D/DebugOff.hpp>