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

2
tests/UnitTests/Engine/Modules.hpp
View File

@@ -2,6 +2,6 @@
#include <Nazara/Core.hpp>
#include <Nazara/Math.hpp>
#include <Nazara/Network.hpp>
#include <Nazara/Physics2D.hpp>
#include <Nazara/ChipmunkPhysics2D.hpp>
#include <Nazara/BulletPhysics3D.hpp>
#include <Nazara/Utility.hpp>

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());

4
tests/UnitTests/main.cpp
View File

@@ -6,12 +6,12 @@
#include <Nazara/Core/AbstractLogger.hpp>
#include <Nazara/Core/Modules.hpp>
#include <Nazara/Network/Network.hpp>
#include <Nazara/Physics2D/Physics2D.hpp>
#include <Nazara/ChipmunkPhysics2D/ChipmunkPhysics2D.hpp>
#include <Nazara/Utility/Utility.hpp>
int main(int argc, char* argv[])
{
Nz::Modules<Nz::Audio, Nz::Network, Nz::Physics2D, Nz::Utility> nazaza;
Nz::Modules<Nz::Audio, Nz::Network, Nz::ChipmunkPhysics2D, Nz::Utility> nazaza;
return Catch::Session().run(argc, argv);
}

2
tests/UnitTests/xmake.lua
View File

@@ -5,7 +5,7 @@ if is_mode("asan") then
add_defines("CATCH_CONFIG_NO_POSIX_SIGNALS")
end
add_deps("NazaraAudio", "NazaraCore", "NazaraNetwork", "NazaraPhysics2D")
add_deps("NazaraAudio", "NazaraCore", "NazaraNetwork", "NazaraChipmunkPhysics2D")
add_packages("catch2", "entt")
add_headerfiles("Engine/**.hpp", { prefixdir = "private", install = false })
add_files("resources.cpp")