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

ChipmunkPhysics2D/RigidBody2D: Add unique body index and remove userdata

This commit is contained in:
SirLynix 2023-08-10 08:40:21 +02:00
parent 09f282f2fe
commit 5484967498
7 changed files with 138 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
include/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp
View File

@ -14,11 +14,13 @@
#include <Nazara/Core/Time.hpp>
#include <Nazara/Math/Angle.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <NazaraUtils/Bitset.hpp>
#include <NazaraUtils/FunctionRef.hpp>
#include <NazaraUtils/Signal.hpp>
#include <functional>
#include <memory>
#include <unordered_map>
#include <vector>
struct cpCollisionHandler;
struct cpSpace;
@ -51,10 +53,10 @@ namespace Nz
ChipmunkPhysWorld2D();
ChipmunkPhysWorld2D(const ChipmunkPhysWorld2D&) = delete;
ChipmunkPhysWorld2D(ChipmunkPhysWorld2D&&) = delete; ///TODO
ChipmunkPhysWorld2D(ChipmunkPhysWorld2D&&) = delete;
~ChipmunkPhysWorld2D();
void DebugDraw(const DebugDrawOptions& options, bool drawShapes = true, bool drawConstraints = true, bool drawCollisions = true);
void DebugDraw(const DebugDrawOptions& options, bool drawShapes = true, bool drawConstraints = true, bool drawCollisions = true) const;
float GetDamping() const;
Vector2f GetGravity() const;
@ -135,32 +137,27 @@ namespace Nz
NazaraSignal(OnPhysWorld2DPostStep, const ChipmunkPhysWorld2D* /*physWorld*/, float /*invStepCount*/);
private:
void InitCallbacks(cpCollisionHandler* handler, Callback callbacks);
using PostStep = std::function<void(ChipmunkRigidBody2D* body)>;
void OnRigidBodyMoved(ChipmunkRigidBody2D* oldPointer, ChipmunkRigidBody2D* newPointer);
void OnRigidBodyRelease(ChipmunkRigidBody2D* rigidBody);
static constexpr std::size_t FreeBodyIdGrowRate = 256;
void RegisterPostStep(ChipmunkRigidBody2D* rigidBody, PostStep&& func);
struct PostStepContainer
{
NazaraSlot(ChipmunkRigidBody2D, OnRigidBody2DMove, onMovedSlot);
NazaraSlot(ChipmunkRigidBody2D, OnRigidBody2DRelease, onReleaseSlot);
std::vector<PostStep> funcs;
};
static_assert(std::is_nothrow_move_constructible<PostStepContainer>::value, "PostStepContainer should be noexcept MoveConstructible");
void DeferBodyAction(ChipmunkRigidBody2D& rigidBody, PostStep&& func);
void InitCallbacks(cpCollisionHandler* handler, Callback callbacks);
inline UInt32 RegisterBody(ChipmunkRigidBody2D& rigidBody);
inline void UnregisterBody(UInt32 bodyIndex);
inline void UpdateBodyPointer(ChipmunkRigidBody2D& rigidBody);
std::size_t m_maxStepCount;
std::unordered_map<cpCollisionHandler*, std::unique_ptr<Callback>> m_callbacks;
std::unordered_map<ChipmunkRigidBody2D*, PostStepContainer> m_rigidPostSteps;
std::unordered_map<UInt32, std::vector<PostStep>> m_rigidBodyPostSteps;
std::vector<ChipmunkRigidBody2D*> m_bodies;
cpSpace* m_handle;
Bitset<UInt64> m_freeBodyIndices;
Time m_stepSize;
Time m_timestepAccumulator;
};
}
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.inl>
#endif // NAZARA_CHIPMUNKPHYSICS2D_CHIPMUNKPHYSWORLD2D_HPP

47
include/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.inl Normal file
View File

@ -0,0 +1,47 @@
// Copyright (C) 2023 Jérôme "Lynix" 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 <cassert>
#include <Nazara/ChipmunkPhysics2D/Debug.hpp>
namespace Nz
{
inline UInt32 ChipmunkPhysWorld2D::RegisterBody(ChipmunkRigidBody2D& rigidBody)
{
std::size_t bodyIndex = m_freeBodyIndices.FindFirst();
if (bodyIndex == m_freeBodyIndices.npos)
{
bodyIndex = m_freeBodyIndices.GetSize();
m_freeBodyIndices.Resize(bodyIndex + FreeBodyIdGrowRate, true);
m_bodies.resize(m_freeBodyIndices.GetSize());
}
assert(m_freeBodyIndices.Test(bodyIndex));
m_freeBodyIndices.Set(bodyIndex, false);
assert(!m_bodies[bodyIndex]);
m_bodies[bodyIndex] = &rigidBody;
return SafeCast<UInt32>(bodyIndex);
}
inline void ChipmunkPhysWorld2D::UnregisterBody(UInt32 bodyIndex)
{
assert(!m_freeBodyIndices.Test(bodyIndex));
m_freeBodyIndices.Set(bodyIndex, true);
assert(m_bodies[bodyIndex]);
m_bodies[bodyIndex] = nullptr;
m_rigidBodyPostSteps.erase(bodyIndex);
}
inline void ChipmunkPhysWorld2D::UpdateBodyPointer(ChipmunkRigidBody2D& rigidBody)
{
UInt32 bodyIndex = rigidBody.GetBodyIndex();
assert(m_bodies[bodyIndex]);
m_bodies[bodyIndex] = &rigidBody;
}
}
#include <Nazara/ChipmunkPhysics2D/DebugOff.hpp>

12
include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp
View File

@ -53,6 +53,7 @@ namespace Nz
Rectf GetAABB() const;
RadianAnglef GetAngularVelocity() const;
inline UInt32 GetBodyIndex() const;
float GetElasticity(std::size_t shapeIndex = 0) const;
float GetFriction(std::size_t shapeIndex = 0) const;
inline const std::shared_ptr<ChipmunkCollider2D>& GetGeom() const;
@ -66,7 +67,6 @@ namespace Nz
inline std::size_t GetShapeCount() const;
inline std::size_t GetShapeIndex(cpShape* shape) const;
Vector2f GetSurfaceVelocity(std::size_t shapeIndex = 0) const;
inline void* GetUserdata() const;
Vector2f GetVelocity() const;
inline const VelocityFunc& GetVelocityFunction() const;
inline ChipmunkPhysWorld2D* GetWorld() const;
@ -93,7 +93,6 @@ namespace Nz
void SetSurfaceVelocity(const Vector2f& surfaceVelocity);
void SetSurfaceVelocity(std::size_t shapeIndex, const Vector2f& surfaceVelocity);
void SetStatic(bool setStaticBody = true);
inline void SetUserdata(void* ud);
void SetVelocity(const Vector2f& velocity);
void SetVelocityFunction(VelocityFunc velocityFunc);
@ -104,11 +103,9 @@ namespace Nz
void Wakeup();
ChipmunkRigidBody2D& operator=(const ChipmunkRigidBody2D& object);
ChipmunkRigidBody2D& operator=(ChipmunkRigidBody2D&& object);
NazaraSignal(OnRigidBody2DMove, ChipmunkRigidBody2D* /*oldPointer*/, ChipmunkRigidBody2D* /*newPointer*/);
NazaraSignal(OnRigidBody2DRelease, ChipmunkRigidBody2D* /*rigidBody*/);
ChipmunkRigidBody2D& operator=(ChipmunkRigidBody2D&& object) noexcept;
static constexpr UInt32 InvalidBodyIndex = std::numeric_limits<UInt32>::max();
static constexpr std::size_t InvalidShapeIndex = std::numeric_limits<std::size_t>::max();
struct CommonSettings
@ -151,6 +148,7 @@ namespace Nz
void Destroy();
private:
void DestroyBody();
void RegisterToSpace();
void UnregisterFromSpace();
@ -161,7 +159,7 @@ namespace Nz
std::shared_ptr<ChipmunkCollider2D> m_geom;
MovablePtr<cpBody> m_handle;
MovablePtr<ChipmunkPhysWorld2D> m_world;
MovablePtr<void> m_userData;
UInt32 m_bodyIndex;
Vector2f m_positionOffset;
VelocityFunc m_velocityFunc;
bool m_isRegistered;

17
include/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.inl
View File

@ -18,8 +18,6 @@ namespace Nz
inline ChipmunkRigidBody2D::~ChipmunkRigidBody2D()
{
OnRigidBody2DRelease(this);
Destroy();
}
@ -33,6 +31,11 @@ namespace Nz
return AddImpulse(impulse, GetMassCenter(coordSys), coordSys);
}
inline UInt32 ChipmunkRigidBody2D::GetBodyIndex() const
{
return m_bodyIndex;
}
inline const std::shared_ptr<ChipmunkCollider2D>& ChipmunkRigidBody2D::GetGeom() const
{
return m_geom;
@ -67,11 +70,6 @@ namespace Nz
return m_shapes.size();
}
inline void* ChipmunkRigidBody2D::GetUserdata() const
{
return m_userData;
}
inline const ChipmunkRigidBody2D::VelocityFunc& ChipmunkRigidBody2D::GetVelocityFunction() const
{
return m_velocityFunc;
@ -96,11 +94,6 @@ namespace Nz
{
return m_isStatic;
}
inline void ChipmunkRigidBody2D::SetUserdata(void* ud)
{
m_userData = ud;
}
}
#include <Nazara/ChipmunkPhysics2D/DebugOff.hpp>

64
src/Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.cpp
View File

@ -41,13 +41,16 @@ namespace Nz
auto drawOptions = static_cast<ChipmunkPhysWorld2D::DebugDrawOptions*>(userdata);
if (drawOptions->polygonCallback)
{
//TODO: constexpr if to prevent copy/cast if sizeof(cpVect) == sizeof(Vector2f)
if constexpr (sizeof(cpVect) == sizeof(Vector2f))
drawOptions->polygonCallback(reinterpret_cast<const Vector2f*>(vertices), vertexCount, float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata);
else
{
StackArray<Vector2f> nVertices = NazaraStackArray(Vector2f, vertexCount);
for (int i = 0; i < vertexCount; ++i)
nVertices[i] = Vector2f(float(vertices[i].x), float(vertices[i].y));
StackArray<Vector2f> nVertices = NazaraStackArray(Vector2f, vertexCount);
for (int i = 0; i < vertexCount; ++i)
nVertices[i] = Vector2f(float(vertices[i].x), float(vertices[i].y));
drawOptions->polygonCallback(nVertices.data(), vertexCount, float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata);
drawOptions->polygonCallback(nVertices.data(), vertexCount, float(radius), CpDebugColorToColor(outlineColor), CpDebugColorToColor(fillColor), drawOptions->userdata);
}
}
}
@ -92,7 +95,7 @@ namespace Nz
cpSpaceFree(m_handle);
}
void ChipmunkPhysWorld2D::DebugDraw(const DebugDrawOptions& options, bool drawShapes, bool drawConstraints, bool drawCollisions)
void ChipmunkPhysWorld2D::DebugDraw(const DebugDrawOptions& options, bool drawShapes, bool drawConstraints, bool drawCollisions) const
{
auto ColorToCpDebugColor = [](Color c) -> cpSpaceDebugColor
{
@ -103,7 +106,7 @@ namespace Nz
drawOptions.collisionPointColor = ColorToCpDebugColor(options.collisionPointColor);
drawOptions.constraintColor = ColorToCpDebugColor(options.constraintColor);
drawOptions.shapeOutlineColor = ColorToCpDebugColor(options.shapeOutlineColor);
drawOptions.data = const_cast<DebugDrawOptions*>(&options); //< Yeah, I know, shame :bell: but it won't be used for writing anyway
drawOptions.data = const_cast<DebugDrawOptions*>(&options); //< won't be used to write
std::underlying_type_t<cpSpaceDebugDrawFlags> drawFlags = 0;
if (drawCollisions)
@ -364,15 +367,18 @@ namespace Nz
cpSpaceStep(m_handle, dt);
OnPhysWorld2DPostStep(this, invStepCount);
if (!m_rigidPostSteps.empty())
if (!m_rigidBodyPostSteps.empty())
{
for (const auto& pair : m_rigidPostSteps)
for (auto&& [bodyIndex, callbackVec] : m_rigidBodyPostSteps)
{
for (const auto& step : pair.second.funcs)
step(pair.first);
ChipmunkRigidBody2D* rigidBody = m_bodies[bodyIndex];
assert(rigidBody);
for (const auto& step : callbackVec)
step(rigidBody);
}
m_rigidPostSteps.clear();
m_rigidBodyPostSteps.clear();
}
m_timestepAccumulator -= m_stepSize;
@ -504,40 +510,16 @@ namespace Nz
}
}
void ChipmunkPhysWorld2D::OnRigidBodyMoved(ChipmunkRigidBody2D* oldPointer, ChipmunkRigidBody2D* newPointer)
{
auto it = m_rigidPostSteps.find(oldPointer);
if (it == m_rigidPostSteps.end())
return; //< Shouldn't happen
m_rigidPostSteps.emplace(std::make_pair(newPointer, std::move(it->second)));
m_rigidPostSteps.erase(oldPointer);
}
void ChipmunkPhysWorld2D::OnRigidBodyRelease(ChipmunkRigidBody2D* rigidBody)
{
m_rigidPostSteps.erase(rigidBody);
}
void ChipmunkPhysWorld2D::RegisterPostStep(ChipmunkRigidBody2D* rigidBody, PostStep&& func)
void ChipmunkPhysWorld2D::DeferBodyAction(ChipmunkRigidBody2D& rigidBody, PostStep&& func)
{
// If space isn't locked, no need to wait
if (!cpSpaceIsLocked(m_handle))
{
func(rigidBody);
func(&rigidBody);
return;
}
auto it = m_rigidPostSteps.find(rigidBody);
if (it == m_rigidPostSteps.end())
{
PostStepContainer postStep;
postStep.onMovedSlot.Connect(rigidBody->OnRigidBody2DMove, this, &ChipmunkPhysWorld2D::OnRigidBodyMoved);
postStep.onReleaseSlot.Connect(rigidBody->OnRigidBody2DRelease, this, &ChipmunkPhysWorld2D::OnRigidBodyRelease);
it = m_rigidPostSteps.insert(std::make_pair(rigidBody, std::move(postStep))).first;
}
it->second.funcs.emplace_back(std::move(func));
UInt32 bodyIndex = rigidBody.GetBodyIndex();
m_rigidBodyPostSteps[bodyIndex].emplace_back(std::move(func));
}
}

74
src/Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.cpp
View File

@ -16,7 +16,6 @@ namespace Nz
ChipmunkRigidBody2D::ChipmunkRigidBody2D(const ChipmunkRigidBody2D& object) :
m_geom(object.m_geom),
m_world(object.m_world),
m_userData(object.m_userData),
m_positionOffset(object.m_positionOffset),
m_isRegistered(false),
m_isSimulationEnabled(true),
@ -27,6 +26,7 @@ namespace Nz
NazaraAssert(m_world, "Invalid world");
NazaraAssert(m_geom, "Invalid geometry");
m_bodyIndex = m_world->RegisterBody(*this);
m_handle = cpBodyNew(m_mass, object.GetMomentOfInertia());
cpBodySetUserData(m_handle, this);
@ -43,13 +43,11 @@ namespace Nz
}
ChipmunkRigidBody2D::ChipmunkRigidBody2D(ChipmunkRigidBody2D&& object) noexcept :
OnRigidBody2DMove(std::move(object.OnRigidBody2DMove)),
OnRigidBody2DRelease(std::move(object.OnRigidBody2DRelease)),
m_shapes(std::move(object.m_shapes)),
m_geom(std::move(object.m_geom)),
m_handle(object.m_handle),
m_world(object.m_world),
m_userData(object.m_userData),
m_bodyIndex(object.m_bodyIndex),
m_positionOffset(std::move(object.m_positionOffset)),
m_isRegistered(object.m_isRegistered),
m_isSimulationEnabled(object.m_isSimulationEnabled),
@ -57,13 +55,17 @@ namespace Nz
m_gravityFactor(object.m_gravityFactor),
m_mass(object.m_mass)
{
cpBodySetUserData(m_handle, this);
for (cpShape* shape : m_shapes)
cpShapeSetUserData(shape, this);
if (m_handle)
{
cpBodySetUserData(m_handle, this);
for (cpShape* shape : m_shapes)
cpShapeSetUserData(shape, this);
m_world->UpdateBodyPointer(*this);
}
object.m_bodyIndex = InvalidBodyIndex;
object.m_handle = nullptr;
OnRigidBody2DMove(&object, this);
}
void ChipmunkRigidBody2D::AddForce(const Vector2f& force, const Vector2f& point, CoordSys coordSys)
@ -160,7 +162,7 @@ namespace Nz
void ChipmunkRigidBody2D::ForceSleep()
{
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) == CP_BODY_TYPE_DYNAMIC)
cpBodySleep(body->GetHandle());
@ -298,7 +300,7 @@ namespace Nz
CopyBodyData(m_handle, newHandle);
Destroy();
DestroyBody();
m_handle = newHandle;
}
@ -332,7 +334,7 @@ namespace Nz
{
if (mass > 0.f)
{
m_world->RegisterPostStep(this, [mass, recomputeMoment](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [mass, recomputeMoment](ChipmunkRigidBody2D* body)
{
cpBodySetMass(body->GetHandle(), mass);
@ -341,11 +343,11 @@ namespace Nz
});
}
else
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body) { cpBodySetType(body->GetHandle(), (body->IsStatic()) ? CP_BODY_TYPE_STATIC : CP_BODY_TYPE_KINEMATIC); } );
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body) { cpBodySetType(body->GetHandle(), (body->IsStatic()) ? CP_BODY_TYPE_STATIC : CP_BODY_TYPE_KINEMATIC); } );
}
else if (mass > 0.f)
{
m_world->RegisterPostStep(this, [mass, recomputeMoment](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [mass, recomputeMoment](ChipmunkRigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_DYNAMIC)
{
@ -381,7 +383,7 @@ namespace Nz
void ChipmunkRigidBody2D::SetMomentOfInertia(float moment)
{
// Even though Chipmunk allows us to change this anytime, we need to do it in a post-step to prevent other post-steps to override this
m_world->RegisterPostStep(this, [moment] (ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [moment] (ChipmunkRigidBody2D* body)
{
cpBodySetMoment(body->GetHandle(), moment);
});
@ -393,7 +395,7 @@ namespace Nz
cpBodySetPosition(m_handle, cpvadd(cpv(position.x, position.y), cpTransformVect(m_handle->transform, cpv(m_positionOffset.x, m_positionOffset.y))));
if (m_isStatic)
{
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
@ -412,7 +414,7 @@ namespace Nz
cpBodySetAngle(m_handle, rotation.value);
if (m_isStatic)
{
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
@ -435,7 +437,7 @@ namespace Nz
void ChipmunkRigidBody2D::SetStatic(bool setStaticBody)
{
m_isStatic = setStaticBody;
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
{
if (body->IsStatic())
{
@ -480,7 +482,7 @@ namespace Nz
cpBodySetAngle(m_handle, rotation.value);
if (m_isStatic)
{
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
{
cpSpaceReindexShapesForBody(body->GetWorld()->GetHandle(), body->GetHandle());
});
@ -494,7 +496,7 @@ namespace Nz
void ChipmunkRigidBody2D::Wakeup()
{
m_world->RegisterPostStep(this, [](ChipmunkRigidBody2D* body)
m_world->DeferBodyAction(*this, [](ChipmunkRigidBody2D* body)
{
if (cpBodyGetType(body->GetHandle()) != CP_BODY_TYPE_STATIC)
cpBodyActivate(body->GetHandle());
@ -505,17 +507,14 @@ namespace Nz
ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(const ChipmunkRigidBody2D& object)
{
ChipmunkRigidBody2D physObj(object);
return operator=(std::move(physObj));
return operator=(ChipmunkRigidBody2D(object));
}
ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(ChipmunkRigidBody2D&& object)
ChipmunkRigidBody2D& ChipmunkRigidBody2D::operator=(ChipmunkRigidBody2D&& object) noexcept
{
Destroy();
OnRigidBody2DMove = std::move(object.OnRigidBody2DMove);
OnRigidBody2DRelease = std::move(object.OnRigidBody2DRelease);
m_bodyIndex = object.m_bodyIndex;
m_handle = object.m_handle;
m_isRegistered = object.m_isRegistered;
m_isSimulationEnabled = object.m_isSimulationEnabled;
@ -525,7 +524,6 @@ namespace Nz
m_mass = object.m_mass;
m_positionOffset = object.m_positionOffset;
m_shapes = std::move(object.m_shapes);
m_userData = object.m_userData;
m_velocityFunc = std::move(object.m_velocityFunc);
m_world = object.m_world;
@ -534,12 +532,13 @@ namespace Nz
cpBodySetUserData(m_handle, this);
for (cpShape* shape : m_shapes)
cpShapeSetUserData(shape, this);
m_world->UpdateBodyPointer(*this);
}
object.m_bodyIndex = InvalidBodyIndex;
object.m_handle = nullptr;
OnRigidBody2DMove(&object, this);
return *this;
}
@ -551,9 +550,10 @@ namespace Nz
m_gravityFactor = settings.gravityFactor;
m_mass = settings.mass;
m_positionOffset = Vector2f::Zero();
m_userData = nullptr;
m_world = &world;
m_bodyIndex = m_world->RegisterBody(*this);
m_handle = cpBodyNew(m_mass, 0.f); // moment will be recomputed by SetGeom
cpBodySetUserData(m_handle, this);
if (m_mass <= 0.f)
@ -574,9 +574,10 @@ namespace Nz
m_isStatic = true;
m_mass = 0.f;
m_positionOffset = Vector2f::Zero();
m_userData = nullptr;
m_world = &world;
m_bodyIndex = m_world->RegisterBody(*this);
m_handle = cpBodyNewStatic();
cpBodySetUserData(m_handle, this);
@ -586,6 +587,17 @@ namespace Nz
}
void ChipmunkRigidBody2D::Destroy()
{
if (m_bodyIndex != InvalidBodyIndex)
{
m_world->UnregisterBody(m_bodyIndex);
m_bodyIndex = InvalidBodyIndex;
}
DestroyBody();
}
void ChipmunkRigidBody2D::DestroyBody()
{
UnregisterFromSpace();

7
tests/UnitTests/Engine/Physics2D/RigidBody2DTest.cpp
View File

@ -34,8 +34,6 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
body.SetRotation(rotation);
Nz::Vector2f velocity(-4.f, -2.f);
body.SetVelocity(velocity);
bool userdata = false;
body.SetUserdata(&userdata);
world.Step(Nz::Time::Second());
@ -127,9 +125,6 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
Nz::ChipmunkRigidBody2D body(world, dynamicSettings);
body.SetGeom(box, true, false);
bool userData = false;
body.SetUserdata(&userData);
Nz::Vector2f position = Nz::Vector2f::Zero();
body.SetPosition(position);
@ -146,7 +141,6 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
CHECK(body.GetMass() == Catch::Approx(dynamicSettings.mass));
CHECK(body.GetPosition() == position);
CHECK(body.GetRotation().value == Catch::Approx(0.f));
CHECK(body.GetUserdata() == &userData);
CHECK(body.GetVelocity() == Nz::Vector2f::Zero());
CHECK(body.IsKinematic() == false);
@ -351,7 +345,6 @@ void EQUALITY(const Nz::ChipmunkRigidBody2D& left, const Nz::ChipmunkRigidBody2D
CHECK(left.GetMass() == Catch::Approx(right.GetMass()));
CHECK(left.GetPosition() == right.GetPosition());
CHECK(left.GetRotation().value == Catch::Approx(right.GetRotation().value));
CHECK(left.GetUserdata() == right.GetUserdata());
CHECK(left.GetVelocity() == right.GetVelocity());
}