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

38
tests/UnitTests/Engine/Physics2D/Collider2DTest.cpp
View File

@@ -1,4 +1,4 @@
#include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.hpp>
#include <Nazara/Physics2D/Collider2D.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
@@ -9,13 +9,13 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]")
WHEN("We construct a box with Rect")
{
Nz::Rectf aabb(5.f, 3.f, 10.f, 6.f);
Nz::ChipmunkBoxCollider2D box(aabb);
Nz::BoxCollider2D box(aabb);
THEN("We expect those to be true")
{
CHECK(box.GetRect() == aabb);
CHECK(box.GetSize() == aabb.GetLengths());
CHECK(box.GetType() == Nz::ChipmunkColliderType2D::Box);
CHECK(box.GetType() == Nz::ColliderType2D::Box);
}
}
@@ -23,13 +23,13 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]")
{
Nz::Vector2f vec(5.f, 3.f);
Nz::Rectf aabb(-2.5f, -1.5f, 5.f, 3.f);
Nz::ChipmunkBoxCollider2D box(vec);
Nz::BoxCollider2D box(vec);
THEN("We expect those to be true")
{
CHECK(box.GetRect() == aabb);
CHECK(box.GetSize() == vec);
CHECK(box.GetType() == Nz::ChipmunkColliderType2D::Box);
CHECK(box.GetType() == Nz::ColliderType2D::Box);
}
}
@@ -37,30 +37,30 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]")
{
Nz::Vector2f position(5.f, 3.f);
float radius = 7.f;
Nz::ChipmunkCircleCollider2D circle(radius, position);
Nz::CircleCollider2D circle(radius, position);
THEN("We expect those to be true")
{
CHECK(circle.GetRadius() == Catch::Approx(radius));
CHECK(circle.GetType() == Nz::ChipmunkColliderType2D::Circle);
CHECK(circle.GetType() == Nz::ColliderType2D::Circle);
}
}
WHEN("We construct a compound")
{
Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::ChipmunkBoxCollider2D> box1 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::shared_ptr<Nz::BoxCollider2D> box1 = std::make_shared<Nz::BoxCollider2D>(aabb);
aabb.Translate(Nz::Vector2f::Unit());
std::shared_ptr<Nz::ChipmunkBoxCollider2D> box2 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::shared_ptr<Nz::BoxCollider2D> box2 = std::make_shared<Nz::BoxCollider2D>(aabb);
std::vector<std::shared_ptr<Nz::ChipmunkCollider2D>> colliders;
std::vector<std::shared_ptr<Nz::Collider2D>> colliders;
colliders.push_back(box1);
colliders.push_back(box2);
Nz::ChipmunkCompoundCollider2D compound(colliders);
Nz::CompoundCollider2D compound(colliders);
THEN("We expect those to be true")
{
CHECK(compound.GetType() == Nz::ChipmunkColliderType2D::Compound);
CHECK(compound.GetType() == Nz::ColliderType2D::Compound);
}
}
@@ -72,21 +72,21 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]")
vertices.push_back(Nz::Vector2f(1.f, 1.f));
vertices.push_back(Nz::Vector2f(1.f, 0.f));
Nz::ChipmunkConvexCollider2D convex(Nz::SparsePtr<const Nz::Vector2f>(vertices.data()), vertices.size());
Nz::ConvexCollider2D convex(Nz::SparsePtr<const Nz::Vector2f>(vertices.data()), vertices.size());
THEN("We expect those to be true")
{
CHECK(convex.GetType() == Nz::ChipmunkColliderType2D::Convex);
CHECK(convex.GetType() == Nz::ColliderType2D::Convex);
}
}
WHEN("We construct a null")
{
Nz::ChipmunkNullCollider2D null;
Nz::NullCollider2D null;
THEN("We expect those to be true")
{
CHECK(null.GetType() == Nz::ChipmunkColliderType2D::Null);
CHECK(null.GetType() == Nz::ColliderType2D::Null);
}
}
@@ -94,21 +94,21 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]")
{
Nz::Vector2f firstPoint(2.f, 1.f);
Nz::Vector2f secondPoint(-4.f, -3.f);
Nz::ChipmunkSegmentCollider2D segment(firstPoint, secondPoint);
Nz::SegmentCollider2D segment(firstPoint, secondPoint);
THEN("We expect those to be true")
{
CHECK(segment.GetFirstPoint() == firstPoint);
CHECK(segment.GetLength() == Catch::Approx(firstPoint.Distance(secondPoint)));
CHECK(segment.GetSecondPoint() == secondPoint);
CHECK(segment.GetType() == Nz::ChipmunkColliderType2D::Segment);
CHECK(segment.GetType() == Nz::ColliderType2D::Segment);
}
}
WHEN("We verify general purpose methods")
{
Nz::Rectf aabb(5.f, 3.f, 10.f, 6.f);
Nz::ChipmunkBoxCollider2D box(aabb);
Nz::BoxCollider2D box(aabb);
Nz::UInt32 categoryMask = 1;
Nz::UInt32 groupId = 2;

56
tests/UnitTests/Engine/Physics2D/PhysWorld2DTest.cpp
View File

@@ -1,8 +1,8 @@
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world, const Nz::Vector2f& position, bool isMoving = true, const Nz::Vector2f& lengths = Nz::Vector2f::Unit());
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world, const Nz::Vector2f& position, bool isMoving = true, const Nz::Vector2f& lengths = Nz::Vector2f::Unit());
Nz::UInt32 collisionGroup = 1;
Nz::UInt32 categoryMask = 2;
@@ -12,9 +12,9 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
{
GIVEN("A physic world and a bunch of entities on a grid")
{
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
std::vector<Nz::ChipmunkRigidBody2D> bodies;
std::vector<Nz::RigidBody2D> bodies;
const int numberOfBodiesPerLign = 3;
for (int i = 0; i != numberOfBodiesPerLign; ++i)
{
@@ -28,7 +28,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
WHEN("We ask for the nearest body")
{
Nz::ChipmunkPhysWorld2D::NearestQueryResult result;
Nz::PhysWorld2D::NearestQueryResult result;
REQUIRE(world.NearestBodyQuery(-Nz::Vector2f::UnitY() * 1.f, 2.f, collisionGroup, categoryMask, collisionMask, &result));
THEN("It should be the one on the origin")
@@ -54,7 +54,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
{
Nz::Vector2f origin = -Nz::Vector2f::UnitY() * 2.f;
Nz::Vector2f end = (numberOfBodiesPerLign + 1) * 10.f * Nz::Vector2f::UnitY();
Nz::ChipmunkPhysWorld2D::RaycastHit result;
Nz::PhysWorld2D::RaycastHit result;
REQUIRE(world.RaycastQueryFirst(origin, end, 1.f, collisionGroup, categoryMask, collisionMask, &result));
THEN("It should be the one on the origin")
@@ -70,7 +70,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
{
Nz::Vector2f origin = -Nz::Vector2f::UnitY() * 2.f;
Nz::Vector2f end = (numberOfBodiesPerLign + 1) * 10.f * Nz::Vector2f::UnitY();
std::vector<Nz::ChipmunkPhysWorld2D::RaycastHit> results;
std::vector<Nz::PhysWorld2D::RaycastHit> results;
REQUIRE(world.RaycastQuery(origin, end, 1.f, collisionGroup, categoryMask, collisionMask, &results));
THEN("It should be the first lign")
@@ -79,7 +79,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
for (int i = 0; i != numberOfBodiesPerLign; ++i)
{
const Nz::ChipmunkPhysWorld2D::RaycastHit& result = results[i];
const Nz::PhysWorld2D::RaycastHit& result = results[i];
CHECK(result.nearestBody == &bodies[i]);
CHECK(result.fraction == Catch::Approx(i / 4.f).margin(0.1f));
CHECK(result.hitPos == Nz::Vector2f(0.f, i * 10.f));
@@ -90,7 +90,7 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
WHEN("We ask for a region")
{
std::vector<Nz::ChipmunkRigidBody2D*> results;
std::vector<Nz::RigidBody2D*> results;
world.RegionQuery(Nz::Rectf(-5.f, -5.f, 5.f, 5.f), collisionGroup, categoryMask, collisionMask, &results);
THEN("It should be the one on the origin")
@@ -109,53 +109,53 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
int statusTriggerCollision = 0;
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
Nz::Rectf characterAABB(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::ChipmunkCollider2D> characterBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(characterAABB);
std::shared_ptr<Nz::Collider2D> characterBox = std::make_shared<Nz::BoxCollider2D>(characterAABB);
characterBox->SetCollisionId(CHARACTER_COLLISION_ID);
Nz::ChipmunkRigidBody2D character(world, Nz::ChipmunkRigidBody2D::DynamicSettings(characterBox, 1.f));
Nz::RigidBody2D character(world, Nz::RigidBody2D::DynamicSettings(characterBox, 1.f));
character.SetPosition(Nz::Vector2f::Zero());
Nz::Rectf wallAABB(0.f, 0.f, 1.f, 2.f);
std::shared_ptr<Nz::ChipmunkCollider2D> wallBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(wallAABB);
std::shared_ptr<Nz::Collider2D> wallBox = std::make_shared<Nz::BoxCollider2D>(wallAABB);
wallBox->SetCollisionId(WALL_COLLISION_ID);
Nz::ChipmunkRigidBody2D wall(world, Nz::ChipmunkRigidBody2D::StaticSettings(wallBox));
Nz::RigidBody2D wall(world, Nz::RigidBody2D::StaticSettings(wallBox));
wall.SetPosition(Nz::Vector2f(5.f, 0.f));
Nz::Rectf triggerAABB(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::ChipmunkCollider2D> triggerBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(triggerAABB);
std::shared_ptr<Nz::Collider2D> triggerBox = std::make_shared<Nz::BoxCollider2D>(triggerAABB);
triggerBox->SetTrigger(true);
triggerBox->SetCollisionId(TRIGGER_COLLISION_ID);
Nz::ChipmunkRigidBody2D trigger(world, Nz::ChipmunkRigidBody2D::StaticSettings(triggerBox));
Nz::RigidBody2D trigger(world, Nz::RigidBody2D::StaticSettings(triggerBox));
trigger.SetPosition(Nz::Vector2f(2.f, 0.f));
world.Step(Nz::Time::Zero());
Nz::ChipmunkPhysWorld2D::ContactCallbacks characterTriggerCallback;
characterTriggerCallback.startCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool {
Nz::PhysWorld2D::ContactCallbacks characterTriggerCallback;
characterTriggerCallback.startCallback = [&](Nz::PhysWorld2D&, Nz::PhysArbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool {
statusTriggerCollision = statusTriggerCollision | 1 << 0;
return true;
};
characterTriggerCallback.preSolveCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool {
characterTriggerCallback.preSolveCallback = [&](Nz::PhysWorld2D&, Nz::PhysArbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool {
statusTriggerCollision = statusTriggerCollision | 1 << 1;
return true;
};
characterTriggerCallback.postSolveCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) {
characterTriggerCallback.postSolveCallback = [&](Nz::PhysWorld2D&, Nz::PhysArbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) {
statusTriggerCollision = statusTriggerCollision | 1 << 2;
};
characterTriggerCallback.endCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) {
characterTriggerCallback.endCallback = [&](Nz::PhysWorld2D&, Nz::PhysArbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) {
statusTriggerCollision = statusTriggerCollision | 1 << 3;
};
world.RegisterCallbacks(CHARACTER_COLLISION_ID, TRIGGER_COLLISION_ID, characterTriggerCallback);
int statusWallCollision = 0;
Nz::ChipmunkPhysWorld2D::ContactCallbacks characterWallCallback;
characterWallCallback.startCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool {
Nz::PhysWorld2D::ContactCallbacks characterWallCallback;
characterWallCallback.startCallback = [&](Nz::PhysWorld2D&, Nz::PhysArbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool {
statusWallCollision = statusWallCollision | 1 << 0;
return true;
};
characterWallCallback.endCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) {
characterWallCallback.endCallback = [&](Nz::PhysWorld2D&, Nz::PhysArbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) {
statusWallCollision = statusWallCollision | 1 << 1;
};
world.RegisterCallbacks(CHARACTER_COLLISION_ID, WALL_COLLISION_ID, characterWallCallback);
@@ -193,17 +193,17 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
}
}
Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world, const Nz::Vector2f& position, bool isMoving, const Nz::Vector2f& lengths)
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world, const Nz::Vector2f& position, bool isMoving, const Nz::Vector2f& lengths)
{
Nz::Rectf aabb(0.f, 0.f, lengths.x, lengths.y);
std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb);
box->SetCategoryMask(categoryMask);
box->SetCollisionMask(collisionMask);
Nz::ChipmunkRigidBody2D::DynamicSettings settings;
Nz::RigidBody2D::DynamicSettings settings;
settings.geom = std::move(box);
settings.mass = isMoving ? 1.f : 0.f;
settings.position = position;
return Nz::ChipmunkRigidBody2D(world, settings);
return Nz::RigidBody2D(world, settings);
}

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

@@ -1,30 +1,30 @@
#include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <Nazara/Physics2D/RigidBody2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <iostream>
#include <limits>
Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world);
void EQUALITY(const Nz::ChipmunkRigidBody2D& left, const Nz::ChipmunkRigidBody2D& right);
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world);
void EQUALITY(const Nz::RigidBody2D& left, const Nz::RigidBody2D& right);
void EQUALITY(const Nz::Rectf& left, const Nz::Rectf& right);
SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
{
GIVEN("A physic world and a rigid body")
{
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
world.SetStepSize(Nz::Time::TickDuration(200)); //< FIXME: Tests fail on Linux with default step size
Nz::Vector2f positionAABB(3.f, 4.f);
Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f);
Nz::ChipmunkRigidBody2D::DynamicSettings dynamicSettings;
dynamicSettings.geom = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
Nz::RigidBody2D::DynamicSettings dynamicSettings;
dynamicSettings.geom = std::make_shared<Nz::BoxCollider2D>(aabb);
dynamicSettings.mass = 1.f;
Nz::ChipmunkRigidBody2D body(world, dynamicSettings);
Nz::RigidBody2D body(world, dynamicSettings);
float angularVelocity = 0.2f;
body.SetAngularVelocity(angularVelocity);
Nz::Vector2f massCenter(5.f, 7.f);
@@ -38,12 +38,12 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
world.Step(Nz::Time::Second());
Nz::ChipmunkRigidBody2D::StaticSettings staticSettings;
Nz::RigidBody2D::StaticSettings staticSettings;
WHEN("We copy construct the body")
{
body.AddForce(Nz::Vector2f(3.f, 5.f));
Nz::ChipmunkRigidBody2D copiedBody(body);
Nz::RigidBody2D copiedBody(body);
EQUALITY(copiedBody, body);
world.Step(Nz::Time::Second());
EQUALITY(copiedBody, body);
@@ -51,22 +51,22 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
WHEN("We move construct the body")
{
Nz::ChipmunkRigidBody2D copiedBody(body);
Nz::ChipmunkRigidBody2D movedBody(std::move(body));
Nz::RigidBody2D copiedBody(body);
Nz::RigidBody2D movedBody(std::move(body));
EQUALITY(movedBody, copiedBody);
}
WHEN("We copy assign the body")
{
Nz::ChipmunkRigidBody2D copiedBody(world, staticSettings);
Nz::RigidBody2D copiedBody(world, staticSettings);
copiedBody = body;
EQUALITY(copiedBody, body);
}
WHEN("We move assign the body")
{
Nz::ChipmunkRigidBody2D copiedBody(body);
Nz::ChipmunkRigidBody2D movedBody(world, staticSettings);
Nz::RigidBody2D copiedBody(body);
Nz::RigidBody2D movedBody(world, staticSettings);
movedBody = std::move(body);
EQUALITY(movedBody, copiedBody);
}
@@ -74,7 +74,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
WHEN("We set a new geometry")
{
float radius = 5.f;
body.SetGeom(std::make_shared<Nz::ChipmunkCircleCollider2D>(radius));
body.SetGeom(std::make_shared<Nz::CircleCollider2D>(radius));
world.Step(Nz::Time::Second());
@@ -89,14 +89,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world")
{
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Rectf aabb(3.f, 4.f, 1.f, 2.f);
WHEN("We get a rigid body from a function")
{
std::vector<Nz::ChipmunkRigidBody2D> tmp;
std::vector<Nz::RigidBody2D> tmp;
tmp.push_back(CreateBody(world));
tmp.push_back(CreateBody(world));
@@ -112,18 +112,18 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body")
{
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Vector2f positionAABB(3.f, 4.f);
Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f);
Nz::ChipmunkRigidBody2D::DynamicSettings dynamicSettings;
Nz::RigidBody2D::DynamicSettings dynamicSettings;
dynamicSettings.mass = 1.f;
auto box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
auto box = std::make_shared<Nz::BoxCollider2D>(aabb);
Nz::ChipmunkRigidBody2D body(world, dynamicSettings);
Nz::RigidBody2D body(world, dynamicSettings);
body.SetGeom(box, true, false);
Nz::Vector2f position = Nz::Vector2f::Zero();
@@ -215,15 +215,15 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of circle")
{
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Vector2f position(3.f, 4.f);
float radius = 5.f;
std::shared_ptr<Nz::ChipmunkCollider2D> circle = std::make_shared<Nz::ChipmunkCircleCollider2D>(radius, position);
std::shared_ptr<Nz::Collider2D> circle = std::make_shared<Nz::CircleCollider2D>(radius, position);
Nz::ChipmunkRigidBody2D body(world, Nz::ChipmunkRigidBody2D::DynamicSettings({}, 1.f));
Nz::RigidBody2D body(world, Nz::RigidBody2D::DynamicSettings({}, 1.f));
body.SetGeom(circle, true, false);
world.Step(Nz::Time::Second());
@@ -240,21 +240,21 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of compound")
{
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::ChipmunkBoxCollider2D> box1 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::shared_ptr<Nz::BoxCollider2D> box1 = std::make_shared<Nz::BoxCollider2D>(aabb);
aabb.Translate(Nz::Vector2f::Unit());
std::shared_ptr<Nz::ChipmunkBoxCollider2D> box2 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::shared_ptr<Nz::BoxCollider2D> box2 = std::make_shared<Nz::BoxCollider2D>(aabb);
std::vector<std::shared_ptr<Nz::ChipmunkCollider2D>> colliders;
std::vector<std::shared_ptr<Nz::Collider2D>> colliders;
colliders.push_back(box1);
colliders.push_back(box2);
std::shared_ptr<Nz::ChipmunkCompoundCollider2D> compound = std::make_shared<Nz::ChipmunkCompoundCollider2D>(colliders);
std::shared_ptr<Nz::CompoundCollider2D> compound = std::make_shared<Nz::CompoundCollider2D>(colliders);
float mass = 1.f;
Nz::ChipmunkRigidBody2D body(world, Nz::ChipmunkRigidBody2D::DynamicSettings({}, mass));
Nz::RigidBody2D body(world, Nz::RigidBody2D::DynamicSettings({}, mass));
body.SetGeom(compound, true, false);
world.Step(Nz::Time::Second());
@@ -271,7 +271,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of circle")
{
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
std::vector<Nz::Vector2f> vertices;
@@ -281,9 +281,9 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
vertices.emplace_back(1.f, 0.f);
Nz::SparsePtr<const Nz::Vector2f> sparsePtr(vertices.data());
std::shared_ptr<Nz::ChipmunkConvexCollider2D> convex = std::make_shared<Nz::ChipmunkConvexCollider2D>(sparsePtr, vertices.size());
std::shared_ptr<Nz::ConvexCollider2D> convex = std::make_shared<Nz::ConvexCollider2D>(sparsePtr, vertices.size());
float mass = 1.f;
Nz::ChipmunkRigidBody2D body(world, Nz::ChipmunkRigidBody2D::DynamicSettings({}, mass));
Nz::RigidBody2D body(world, Nz::RigidBody2D::DynamicSettings({}, mass));
body.SetGeom(convex, true, false);
world.Step(Nz::Time::Second());
@@ -300,14 +300,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of segment")
{
Nz::ChipmunkPhysWorld2D world;
Nz::PhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
Nz::Vector2f positionA(3.f, 4.f);
Nz::Vector2f positionB(1.f, -4.f);
std::shared_ptr<Nz::ChipmunkCollider2D> segment = std::make_shared<Nz::ChipmunkSegmentCollider2D>(positionA, positionB, 0.f);
std::shared_ptr<Nz::Collider2D> segment = std::make_shared<Nz::SegmentCollider2D>(positionA, positionB, 0.f);
float mass = 1.f;
Nz::ChipmunkRigidBody2D body(world, Nz::ChipmunkRigidBody2D::DynamicSettings({}, mass));
Nz::RigidBody2D body(world, Nz::RigidBody2D::DynamicSettings({}, mass));
body.SetGeom(segment, true, false);
world.Step(Nz::Time::Second());
@@ -323,20 +323,20 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
}
}
Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world)
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world)
{
Nz::Vector2f positionAABB(3.f, 4.f);
Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f);
std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb);
float mass = 1.f;
Nz::ChipmunkRigidBody2D body(world, Nz::ChipmunkRigidBody2D::DynamicSettings(box, mass));
Nz::RigidBody2D body(world, Nz::RigidBody2D::DynamicSettings(box, mass));
body.SetPosition(Nz::Vector2f::Zero());
return body;
}
void EQUALITY(const Nz::ChipmunkRigidBody2D& left, const Nz::ChipmunkRigidBody2D& right)
void EQUALITY(const Nz::RigidBody2D& left, const Nz::RigidBody2D& right)
{
CHECK(left.GetAABB() == right.GetAABB());
CHECK(left.GetAngularVelocity() == right.GetAngularVelocity());