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

Rename Physics2D to ChipmunkPhysics2D

Browse Source
This commit is contained in:
SirLynix
2023-04-10 13:49:36 +02:00
committed by Jérôme Leclercq
parent b1255ad2ad
commit 26b23ccce6
54 changed files with 1620 additions and 1620 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/Physics2D/Collider2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkCollider2D.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::BoxCollider2D box(aabb);
Nz::ChipmunkBoxCollider2D box(aabb);
THEN("We expect those to be true")
{
CHECK(box.GetRect() == aabb);
CHECK(box.GetSize() == aabb.GetLengths());
CHECK(box.GetType() == Nz::ColliderType2D::Box);
CHECK(box.GetType() == Nz::ChipmunkColliderType2D::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::BoxCollider2D box(vec);
Nz::ChipmunkBoxCollider2D box(vec);
THEN("We expect those to be true")
{
CHECK(box.GetRect() == aabb);
CHECK(box.GetSize() == vec);
CHECK(box.GetType() == Nz::ColliderType2D::Box);
CHECK(box.GetType() == Nz::ChipmunkColliderType2D::Box);
}
}
@@ -37,30 +37,30 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]")
{
Nz::Vector2f position(5.f, 3.f);
float radius = 7.f;
Nz::CircleCollider2D circle(radius, position);
Nz::ChipmunkCircleCollider2D circle(radius, position);
THEN("We expect those to be true")
{
CHECK(circle.GetRadius() == Catch::Approx(radius));
CHECK(circle.GetType() == Nz::ColliderType2D::Circle);
CHECK(circle.GetType() == Nz::ChipmunkColliderType2D::Circle);
}
}
WHEN("We construct a compound")
{
Nz::Rectf aabb(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::BoxCollider2D> box1 = std::make_shared<Nz::BoxCollider2D>(aabb);
std::shared_ptr<Nz::ChipmunkBoxCollider2D> box1 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
aabb.Translate(Nz::Vector2f::Unit());
std::shared_ptr<Nz::BoxCollider2D> box2 = std::make_shared<Nz::BoxCollider2D>(aabb);
std::shared_ptr<Nz::ChipmunkBoxCollider2D> box2 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::vector<std::shared_ptr<Nz::Collider2D>> colliders;
std::vector<std::shared_ptr<Nz::ChipmunkCollider2D>> colliders;
colliders.push_back(box1);
colliders.push_back(box2);
Nz::CompoundCollider2D compound(colliders);
Nz::ChipmunkCompoundCollider2D compound(colliders);
THEN("We expect those to be true")
{
CHECK(compound.GetType() == Nz::ColliderType2D::Compound);
CHECK(compound.GetType() == Nz::ChipmunkColliderType2D::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::ConvexCollider2D convex(Nz::SparsePtr<const Nz::Vector2f>(vertices.data()), vertices.size());
Nz::ChipmunkConvexCollider2D convex(Nz::SparsePtr<const Nz::Vector2f>(vertices.data()), vertices.size());
THEN("We expect those to be true")
{
CHECK(convex.GetType() == Nz::ColliderType2D::Convex);
CHECK(convex.GetType() == Nz::ChipmunkColliderType2D::Convex);
}
}
WHEN("We construct a null")
{
Nz::NullCollider2D null;
Nz::ChipmunkNullCollider2D null;
THEN("We expect those to be true")
{
CHECK(null.GetType() == Nz::ColliderType2D::Null);
CHECK(null.GetType() == Nz::ChipmunkColliderType2D::Null);
}
}
@@ -94,21 +94,21 @@ SCENARIO("Collider2D", "[PHYSICS2D][COLLIDER2D]")
{
Nz::Vector2f firstPoint(2.f, 1.f);
Nz::Vector2f secondPoint(-4.f, -3.f);
Nz::SegmentCollider2D segment(firstPoint, secondPoint);
Nz::ChipmunkSegmentCollider2D 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::ColliderType2D::Segment);
CHECK(segment.GetType() == Nz::ChipmunkColliderType2D::Segment);
}
}
WHEN("We verify general purpose methods")
{
Nz::Rectf aabb(5.f, 3.f, 10.f, 6.f);
Nz::BoxCollider2D box(aabb);
Nz::ChipmunkBoxCollider2D box(aabb);
Nz::UInt32 categoryMask = 1;
Nz::UInt32 groupId = 2;

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

@@ -1,8 +1,8 @@
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world, const Nz::Vector2f& position, bool isMoving = true, const Nz::Vector2f& lengths = Nz::Vector2f::Unit());
Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& 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::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D world;
std::vector<Nz::RigidBody2D> bodies;
std::vector<Nz::ChipmunkRigidBody2D> 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::PhysWorld2D::NearestQueryResult result;
Nz::ChipmunkPhysWorld2D::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::PhysWorld2D::RaycastHit result;
Nz::ChipmunkPhysWorld2D::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::PhysWorld2D::RaycastHit> results;
std::vector<Nz::ChipmunkPhysWorld2D::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::PhysWorld2D::RaycastHit& result = results[i];
const Nz::ChipmunkPhysWorld2D::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::RigidBody2D*> results;
std::vector<Nz::ChipmunkRigidBody2D*> 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::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D world;
Nz::Rectf characterAABB(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::Collider2D> characterBox = std::make_shared<Nz::BoxCollider2D>(characterAABB);
std::shared_ptr<Nz::ChipmunkCollider2D> characterBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(characterAABB);
characterBox->SetCollisionId(CHARACTER_COLLISION_ID);
Nz::RigidBody2D character(&world, 1.f, characterBox);
Nz::ChipmunkRigidBody2D character(&world, 1.f, characterBox);
character.SetPosition(Nz::Vector2f::Zero());
Nz::Rectf wallAABB(0.f, 0.f, 1.f, 2.f);
std::shared_ptr<Nz::Collider2D> wallBox = std::make_shared<Nz::BoxCollider2D>(wallAABB);
std::shared_ptr<Nz::ChipmunkCollider2D> wallBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(wallAABB);
wallBox->SetCollisionId(WALL_COLLISION_ID);
Nz::RigidBody2D wall(&world, 0.f, wallBox);
Nz::ChipmunkRigidBody2D wall(&world, 0.f, wallBox);
wall.SetPosition(Nz::Vector2f(5.f, 0.f));
Nz::Rectf triggerAABB(0.f, 0.f, 1.f, 1.f);
std::shared_ptr<Nz::Collider2D> triggerBox = std::make_shared<Nz::BoxCollider2D>(triggerAABB);
std::shared_ptr<Nz::ChipmunkCollider2D> triggerBox = std::make_shared<Nz::ChipmunkBoxCollider2D>(triggerAABB);
triggerBox->SetTrigger(true);
triggerBox->SetCollisionId(TRIGGER_COLLISION_ID);
Nz::RigidBody2D trigger(&world, 0.f, triggerBox);
Nz::ChipmunkRigidBody2D trigger(&world, 0.f, triggerBox);
trigger.SetPosition(Nz::Vector2f(2.f, 0.f));
world.Step(Nz::Time::Zero());
Nz::PhysWorld2D::Callback characterTriggerCallback;
characterTriggerCallback.startCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool {
Nz::ChipmunkPhysWorld2D::Callback characterTriggerCallback;
characterTriggerCallback.startCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool {
statusTriggerCollision = statusTriggerCollision | 1 << 0;
return true;
};
characterTriggerCallback.preSolveCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool {
characterTriggerCallback.preSolveCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool {
statusTriggerCollision = statusTriggerCollision | 1 << 1;
return true;
};
characterTriggerCallback.postSolveCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) {
characterTriggerCallback.postSolveCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) {
statusTriggerCollision = statusTriggerCollision | 1 << 2;
};
characterTriggerCallback.endCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) {
characterTriggerCallback.endCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) {
statusTriggerCollision = statusTriggerCollision | 1 << 3;
};
world.RegisterCallbacks(CHARACTER_COLLISION_ID, TRIGGER_COLLISION_ID, characterTriggerCallback);
int statusWallCollision = 0;
Nz::PhysWorld2D::Callback characterWallCallback;
characterWallCallback.startCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) -> bool {
Nz::ChipmunkPhysWorld2D::Callback characterWallCallback;
characterWallCallback.startCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) -> bool {
statusWallCollision = statusWallCollision | 1 << 0;
return true;
};
characterWallCallback.endCallback = [&](Nz::PhysWorld2D&, Nz::Arbiter2D&, Nz::RigidBody2D&, Nz::RigidBody2D&, void*) {
characterWallCallback.endCallback = [&](Nz::ChipmunkPhysWorld2D&, Nz::ChipmunkArbiter2D&, Nz::ChipmunkRigidBody2D&, Nz::ChipmunkRigidBody2D&, void*) {
statusWallCollision = statusWallCollision | 1 << 1;
};
world.RegisterCallbacks(CHARACTER_COLLISION_ID, WALL_COLLISION_ID, characterWallCallback);
@@ -193,14 +193,14 @@ SCENARIO("PhysWorld2D", "[PHYSICS2D][PHYSWORLD2D]")
}
}
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world, const Nz::Vector2f& position, bool isMoving, const Nz::Vector2f& lengths)
Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& 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::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb);
std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
box->SetCategoryMask(categoryMask);
box->SetCollisionMask(collisionMask);
float mass = isMoving ? 1.f : 0.f;
Nz::RigidBody2D rigidBody(&world, mass, box);
Nz::ChipmunkRigidBody2D rigidBody(&world, mass, box);
rigidBody.SetPosition(position);
return rigidBody;
}

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

@@ -1,26 +1,26 @@
#include <Nazara/Physics2D/RigidBody2D.hpp>
#include <Nazara/Physics2D/PhysWorld2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkRigidBody2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysWorld2D.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <iostream>
#include <limits>
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world);
void EQUALITY(const Nz::RigidBody2D& left, const Nz::RigidBody2D& right);
Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world);
void EQUALITY(const Nz::ChipmunkRigidBody2D& left, const Nz::ChipmunkRigidBody2D& right);
void EQUALITY(const Nz::Rectf& left, const Nz::Rectf& right);
SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
{
GIVEN("A physic world and a rigid body")
{
Nz::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D 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);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb);
std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
float mass = 1.f;
Nz::RigidBody2D body(&world, mass, box);
Nz::ChipmunkRigidBody2D body(&world, mass, box);
float angularVelocity = 0.2f;
body.SetAngularVelocity(angularVelocity);
Nz::Vector2f massCenter(5.f, 7.f);
@@ -39,7 +39,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
WHEN("We copy construct the body")
{
body.AddForce(Nz::Vector2f(3.f, 5.f));
Nz::RigidBody2D copiedBody(body);
Nz::ChipmunkRigidBody2D copiedBody(body);
EQUALITY(copiedBody, body);
world.Step(Nz::Time::Second());
EQUALITY(copiedBody, body);
@@ -47,22 +47,22 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
WHEN("We move construct the body")
{
Nz::RigidBody2D copiedBody(body);
Nz::RigidBody2D movedBody(std::move(body));
Nz::ChipmunkRigidBody2D copiedBody(body);
Nz::ChipmunkRigidBody2D movedBody(std::move(body));
EQUALITY(movedBody, copiedBody);
}
WHEN("We copy assign the body")
{
Nz::RigidBody2D copiedBody(&world, 0.f);
Nz::ChipmunkRigidBody2D copiedBody(&world, 0.f);
copiedBody = body;
EQUALITY(copiedBody, body);
}
WHEN("We move assign the body")
{
Nz::RigidBody2D copiedBody(body);
Nz::RigidBody2D movedBody(&world, 0.f);
Nz::ChipmunkRigidBody2D copiedBody(body);
Nz::ChipmunkRigidBody2D movedBody(&world, 0.f);
movedBody = std::move(body);
EQUALITY(movedBody, copiedBody);
}
@@ -70,7 +70,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
WHEN("We set a new geometry")
{
float radius = 5.f;
body.SetGeom(std::make_shared<Nz::CircleCollider2D>(radius));
body.SetGeom(std::make_shared<Nz::ChipmunkCircleCollider2D>(radius));
world.Step(Nz::Time::Second());
@@ -85,14 +85,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world")
{
Nz::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D 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::RigidBody2D> tmp;
std::vector<Nz::ChipmunkRigidBody2D> tmp;
tmp.push_back(CreateBody(world));
tmp.push_back(CreateBody(world));
@@ -108,14 +108,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body")
{
Nz::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D 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);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb);
std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
float mass = 1.f;
Nz::RigidBody2D body(&world, mass);
Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(box, true, false);
bool userData = false;
@@ -211,14 +211,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of circle")
{
Nz::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D 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::Collider2D> circle = std::make_shared<Nz::CircleCollider2D>(radius, position);
std::shared_ptr<Nz::ChipmunkCollider2D> circle = std::make_shared<Nz::ChipmunkCircleCollider2D>(radius, position);
float mass = 1.f;
Nz::RigidBody2D body(&world, mass);
Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(circle, true, false);
world.Step(Nz::Time::Second());
@@ -235,21 +235,21 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of compound")
{
Nz::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D 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::BoxCollider2D> box1 = std::make_shared<Nz::BoxCollider2D>(aabb);
std::shared_ptr<Nz::ChipmunkBoxCollider2D> box1 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
aabb.Translate(Nz::Vector2f::Unit());
std::shared_ptr<Nz::BoxCollider2D> box2 = std::make_shared<Nz::BoxCollider2D>(aabb);
std::shared_ptr<Nz::ChipmunkBoxCollider2D> box2 = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
std::vector<std::shared_ptr<Nz::Collider2D>> colliders;
std::vector<std::shared_ptr<Nz::ChipmunkCollider2D>> colliders;
colliders.push_back(box1);
colliders.push_back(box2);
std::shared_ptr<Nz::CompoundCollider2D> compound = std::make_shared<Nz::CompoundCollider2D>(colliders);
std::shared_ptr<Nz::ChipmunkCompoundCollider2D> compound = std::make_shared<Nz::ChipmunkCompoundCollider2D>(colliders);
float mass = 1.f;
Nz::RigidBody2D body(&world, mass);
Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(compound, true, false);
world.Step(Nz::Time::Second());
@@ -266,7 +266,7 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of circle")
{
Nz::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D world;
world.SetMaxStepCount(std::numeric_limits<std::size_t>::max());
std::vector<Nz::Vector2f> vertices;
@@ -276,9 +276,9 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
vertices.emplace_back(1.f, 0.f);
Nz::SparsePtr<const Nz::Vector2f> sparsePtr(vertices.data());
std::shared_ptr<Nz::ConvexCollider2D> convex = std::make_shared<Nz::ConvexCollider2D>(sparsePtr, vertices.size());
std::shared_ptr<Nz::ChipmunkConvexCollider2D> convex = std::make_shared<Nz::ChipmunkConvexCollider2D>(sparsePtr, vertices.size());
float mass = 1.f;
Nz::RigidBody2D body(&world, mass);
Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(convex, true, false);
world.Step(Nz::Time::Second());
@@ -295,14 +295,14 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
GIVEN("A physic world and a rigid body of segment")
{
Nz::PhysWorld2D world;
Nz::ChipmunkPhysWorld2D 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::Collider2D> segment = std::make_shared<Nz::SegmentCollider2D>(positionA, positionB, 0.f);
std::shared_ptr<Nz::ChipmunkCollider2D> segment = std::make_shared<Nz::ChipmunkSegmentCollider2D>(positionA, positionB, 0.f);
float mass = 1.f;
Nz::RigidBody2D body(&world, mass);
Nz::ChipmunkRigidBody2D body(&world, mass);
body.SetGeom(segment, true, false);
world.Step(Nz::Time::Second());
@@ -318,20 +318,20 @@ SCENARIO("RigidBody2D", "[PHYSICS2D][RIGIDBODY2D]")
}
}
Nz::RigidBody2D CreateBody(Nz::PhysWorld2D& world)
Nz::ChipmunkRigidBody2D CreateBody(Nz::ChipmunkPhysWorld2D& world)
{
Nz::Vector2f positionAABB(3.f, 4.f);
Nz::Rectf aabb(positionAABB.x, positionAABB.y, 1.f, 2.f);
std::shared_ptr<Nz::Collider2D> box = std::make_shared<Nz::BoxCollider2D>(aabb);
std::shared_ptr<Nz::ChipmunkCollider2D> box = std::make_shared<Nz::ChipmunkBoxCollider2D>(aabb);
float mass = 1.f;
Nz::RigidBody2D body(&world, mass, box);
Nz::ChipmunkRigidBody2D body(&world, mass, box);
body.SetPosition(Nz::Vector2f::Zero());
return body;
}
void EQUALITY(const Nz::RigidBody2D& left, const Nz::RigidBody2D& right)
void EQUALITY(const Nz::ChipmunkRigidBody2D& left, const Nz::ChipmunkRigidBody2D& right)
{
CHECK(left.GetAABB() == right.GetAABB());
CHECK(left.GetAngularVelocity() == right.GetAngularVelocity());