228 lines
8.3 KiB
C++
228 lines
8.3 KiB
C++
/** @file
|
|
* @author Edouard DUPIN
|
|
* @copyright 2017, Edouard DUPIN, all right reserved
|
|
* @license MPL v2.0 (see license file)
|
|
*/
|
|
|
|
#include <etest/etest.hpp>
|
|
#include <ephysics/ephysics.hpp>
|
|
/*
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB m_AABB2(vec3(-5, 4, -30), vec3(-2, 20, 30));
|
|
ephysics::AABB m_AABB3(vec3(-25, -25, -25), vec3(25, 25, 25));
|
|
ephysics::AABB m_AABB4(vec3(-40, -40, -40), vec3(-15, -25, -12));
|
|
*/
|
|
|
|
TEST(TestAABB, methode_constructors) {
|
|
ephysics::AABB aabb1;
|
|
ephysics::AABB aabb2(vec3(-3, -5, -8), vec3(65, -1, 56));
|
|
vec3 trianglePoints[] = {
|
|
vec3(-5, 7, 23), vec3(45, -34, -73), vec3(-12, 98, 76)
|
|
};
|
|
ephysics::AABB aabb3 = ephysics::AABB::createAABBForTriangle(trianglePoints);
|
|
|
|
EXPECT_EQ(aabb1.getMin().x(), 0);
|
|
EXPECT_EQ(aabb1.getMin().y(), 0);
|
|
EXPECT_EQ(aabb1.getMin().z(), 0);
|
|
EXPECT_EQ(aabb1.getMax().x(), 0);
|
|
EXPECT_EQ(aabb1.getMax().y(), 0);
|
|
EXPECT_EQ(aabb1.getMax().z(), 0);
|
|
|
|
EXPECT_EQ(aabb2.getMin().x(), -3);
|
|
EXPECT_EQ(aabb2.getMin().y(), -5);
|
|
EXPECT_EQ(aabb2.getMin().z(), -8);
|
|
EXPECT_EQ(aabb2.getMax().x(), 65);
|
|
EXPECT_EQ(aabb2.getMax().y(), -1);
|
|
EXPECT_EQ(aabb2.getMax().z(), 56);
|
|
|
|
EXPECT_EQ(aabb3.getMin().x(), -12);
|
|
EXPECT_EQ(aabb3.getMin().y(), -34);
|
|
EXPECT_EQ(aabb3.getMin().z(), -73);
|
|
EXPECT_EQ(aabb3.getMax().x(), 45);
|
|
EXPECT_EQ(aabb3.getMax().y(), 98);
|
|
EXPECT_EQ(aabb3.getMax().z(), 76);
|
|
}
|
|
|
|
TEST(TestAABB, methode_inflate) {
|
|
ephysics::AABB aabbInflate(vec3(-3, 4, 8), vec3(-1, 6, 32));
|
|
aabbInflate.inflate(1, 2, 3);
|
|
EXPECT_FLOAT_EQ(aabbInflate.getMin().x(), -4);
|
|
EXPECT_FLOAT_EQ(aabbInflate.getMin().y(), 2);
|
|
EXPECT_FLOAT_EQ(aabbInflate.getMin().z(), 5);
|
|
EXPECT_FLOAT_EQ(aabbInflate.getMax().x(), 0);
|
|
EXPECT_FLOAT_EQ(aabbInflate.getMax().y(), 8);
|
|
EXPECT_FLOAT_EQ(aabbInflate.getMax().z(), 35);
|
|
}
|
|
|
|
TEST(TestAABB, methode_getExtent) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB m_AABB2(vec3(-5, 4, -30), vec3(-2, 20, 30));
|
|
ephysics::AABB m_AABB3(vec3(-25, -25, -25), vec3(25, 25, 25));
|
|
EXPECT_FLOAT_EQ(m_AABB1.getExtent().x(), 20);
|
|
EXPECT_FLOAT_EQ(m_AABB1.getExtent().y(), 20);
|
|
EXPECT_FLOAT_EQ(m_AABB1.getExtent().z(), 20);
|
|
|
|
EXPECT_FLOAT_EQ(m_AABB2.getExtent().x(), 3);
|
|
EXPECT_FLOAT_EQ(m_AABB2.getExtent().y(), 16);
|
|
EXPECT_FLOAT_EQ(m_AABB2.getExtent().z(), 60);
|
|
|
|
EXPECT_FLOAT_EQ(m_AABB3.getExtent().x(), 50);
|
|
EXPECT_FLOAT_EQ(m_AABB3.getExtent().y(), 50);
|
|
EXPECT_FLOAT_EQ(m_AABB3.getExtent().z(), 50);
|
|
}
|
|
|
|
TEST(TestAABB, methode_getCenter) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB m_AABB2(vec3(-5, 4, -30), vec3(-2, 20, 30));
|
|
EXPECT_EQ(m_AABB1.getCenter().x(), 0);
|
|
EXPECT_EQ(m_AABB1.getCenter().y(), 0);
|
|
EXPECT_EQ(m_AABB1.getCenter().z(), 0);
|
|
EXPECT_FLOAT_EQ(m_AABB2.getCenter().x(), -3.5);
|
|
EXPECT_FLOAT_EQ(m_AABB2.getCenter().y(), 12);
|
|
EXPECT_FLOAT_EQ(m_AABB2.getCenter().z(), 0);
|
|
}
|
|
|
|
TEST(TestAABB, methode_minMax) {
|
|
ephysics::AABB aabb5;
|
|
aabb5.setMin(vec3(-12, 34, 6));
|
|
aabb5.setMax(vec3(-3, 56, 20));
|
|
EXPECT_EQ(aabb5.getMin().x(), -12);
|
|
EXPECT_EQ(aabb5.getMin().y(), 34);
|
|
EXPECT_EQ(aabb5.getMin().z(), 6);
|
|
EXPECT_EQ(aabb5.getMax().x(), -3);
|
|
EXPECT_EQ(aabb5.getMax().y(), 56);
|
|
EXPECT_EQ(aabb5.getMax().z(), 20);
|
|
}
|
|
|
|
TEST(TestAABB, methode_asignement) {
|
|
ephysics::AABB aabb2(vec3(-3, -5, -8), vec3(65, -1, 56));
|
|
ephysics::AABB aabb6;
|
|
aabb6 = aabb2;
|
|
EXPECT_EQ(aabb6.getMin().x(), -3);
|
|
EXPECT_EQ(aabb6.getMin().y(), -5);
|
|
EXPECT_EQ(aabb6.getMin().z(), -8);
|
|
EXPECT_EQ(aabb6.getMax().x(), 65);
|
|
EXPECT_EQ(aabb6.getMax().y(), -1);
|
|
EXPECT_EQ(aabb6.getMax().z(), 56);
|
|
|
|
}
|
|
|
|
TEST(TestAABB, methode_getVolume) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB m_AABB2(vec3(-5, 4, -30), vec3(-2, 20, 30));
|
|
EXPECT_FLOAT_EQ(m_AABB1.getVolume(), 8000);
|
|
EXPECT_FLOAT_EQ(m_AABB2.getVolume(), 2880);
|
|
}
|
|
|
|
TEST(TestAABB, merge_mergeTwoAABBs) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB m_AABB4(vec3(-40, -40, -40), vec3(-15, -25, -12));
|
|
ephysics::AABB aabb1(vec3(-45, 7, -2), vec3(23, 8, 1));
|
|
ephysics::AABB aabb2(vec3(-15, 6, 23), vec3(-5, 9, 45));
|
|
|
|
ephysics::AABB aabb3;
|
|
aabb3.mergeTwoAABBs(aabb1, m_AABB1);
|
|
EXPECT_EQ(aabb3.getMin().x(), -45);
|
|
EXPECT_EQ(aabb3.getMin().y(), -10);
|
|
EXPECT_EQ(aabb3.getMin().z(), -10);
|
|
EXPECT_EQ(aabb3.getMax().x(), 23);
|
|
EXPECT_EQ(aabb3.getMax().y(), 10);
|
|
EXPECT_EQ(aabb3.getMax().z(), 10);
|
|
ephysics::AABB aabb4;
|
|
aabb4.mergeTwoAABBs(aabb1, aabb2);
|
|
EXPECT_EQ(aabb4.getMin().x(), -45);
|
|
EXPECT_EQ(aabb4.getMin().y(), 6);
|
|
EXPECT_EQ(aabb4.getMin().z(), -2);
|
|
EXPECT_EQ(aabb4.getMax().x(), 23);
|
|
EXPECT_EQ(aabb4.getMax().y(), 9);
|
|
EXPECT_EQ(aabb4.getMax().z(), 45);
|
|
}
|
|
|
|
TEST(TestAABB, merge_mergeWithAABB) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB aabb1(vec3(-45, 7, -2), vec3(23, 8, 1));
|
|
ephysics::AABB aabb2(vec3(-15, 6, 23), vec3(-5, 9, 45));
|
|
aabb1.mergeWithAABB(m_AABB1);
|
|
EXPECT_EQ(aabb1.getMin().x(), -45);
|
|
EXPECT_EQ(aabb1.getMin().y(), -10);
|
|
EXPECT_EQ(aabb1.getMin().z(), -10);
|
|
EXPECT_EQ(aabb1.getMax().x(), 23);
|
|
EXPECT_EQ(aabb1.getMax().y(), 10);
|
|
EXPECT_EQ(aabb1.getMax().z(), 10);
|
|
aabb2.mergeWithAABB(m_AABB1);
|
|
EXPECT_EQ(aabb2.getMin().x(), -15);
|
|
EXPECT_EQ(aabb2.getMin().y(), -10);
|
|
EXPECT_EQ(aabb2.getMin().z(), -10);
|
|
EXPECT_EQ(aabb2.getMax().x(), 10);
|
|
EXPECT_EQ(aabb2.getMax().y(), 10);
|
|
EXPECT_EQ(aabb2.getMax().z(), 45);
|
|
}
|
|
|
|
TEST(TestAABB, intersection_containsAABB) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB m_AABB2(vec3(-5, 4, -30), vec3(-2, 20, 30));
|
|
ephysics::AABB m_AABB3(vec3(-25, -25, -25), vec3(25, 25, 25));
|
|
ephysics::AABB m_AABB4(vec3(-40, -40, -40), vec3(-15, -25, -12));
|
|
EXPECT_EQ(m_AABB1.contains(m_AABB2), false);
|
|
EXPECT_EQ(m_AABB3.contains(m_AABB1), true);
|
|
EXPECT_EQ(m_AABB1.contains(m_AABB3), false);
|
|
EXPECT_EQ(m_AABB1.contains(m_AABB4), false);
|
|
EXPECT_EQ(m_AABB4.contains(m_AABB1), false);
|
|
}
|
|
|
|
TEST(TestAABB, intersection_containsVec3) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
EXPECT_EQ(m_AABB1.contains(vec3(0, 0, 0)), true);
|
|
EXPECT_EQ(m_AABB1.contains(vec3(-5, 6, 9)), true);
|
|
EXPECT_EQ(m_AABB1.contains(vec3(-9, -4, -9)), true);
|
|
EXPECT_EQ(m_AABB1.contains(vec3(9, 4, 7)), true);
|
|
EXPECT_EQ(m_AABB1.contains(vec3(-11, -4, -9)), false);
|
|
EXPECT_EQ(m_AABB1.contains(vec3(1, 12, -9)), false);
|
|
EXPECT_EQ(m_AABB1.contains(vec3(1, 8, -13)), false);
|
|
EXPECT_EQ(m_AABB1.contains(vec3(-14, 82, -13)), false);
|
|
}
|
|
|
|
TEST(TestAABB, intersection_testCollision) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB m_AABB2(vec3(-5, 4, -30), vec3(-2, 20, 30));
|
|
ephysics::AABB m_AABB3(vec3(-25, -25, -25), vec3(25, 25, 25));
|
|
ephysics::AABB m_AABB4(vec3(-40, -40, -40), vec3(-15, -25, -12));
|
|
EXPECT_EQ(m_AABB1.testCollision(m_AABB2), true);
|
|
EXPECT_EQ(m_AABB2.testCollision(m_AABB1), true);
|
|
EXPECT_EQ(m_AABB1.testCollision(m_AABB3), true);
|
|
EXPECT_EQ(m_AABB3.testCollision(m_AABB1), true);
|
|
EXPECT_EQ(m_AABB1.testCollision(m_AABB4), false);
|
|
EXPECT_EQ(m_AABB4.testCollision(m_AABB1), false);
|
|
}
|
|
|
|
TEST(TestAABB, intersection_testCollisionTriangleAABB) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::AABB aabb(vec3(100, 100, 100), vec3(200, 200, 200));
|
|
vec3 trianglePoints[] = {
|
|
vec3(-2, 4, 6), vec3(20, -34, -73), vec3(-12, 98, 76)
|
|
};
|
|
EXPECT_EQ(m_AABB1.testCollisionTriangleAABB(trianglePoints), true);
|
|
EXPECT_EQ(aabb.testCollisionTriangleAABB(trianglePoints), false);
|
|
}
|
|
|
|
TEST(TestAABB, intersection_testRayIntersect) {
|
|
ephysics::AABB m_AABB1(vec3(-10, -10, -10), vec3(10, 10, 10));
|
|
ephysics::Ray ray1(vec3(-20, 4, -7), vec3(20, 4, -7));
|
|
ephysics::Ray ray2(vec3(-20, 11, -7), vec3(20, 11, -7));
|
|
ephysics::Ray ray3(vec3(0, 15, 0), vec3(0, -15, 0));
|
|
ephysics::Ray ray4(vec3(0, -15, 0), vec3(0, 15, 0));
|
|
ephysics::Ray ray5(vec3(-3, 4, 8), vec3(-7, 9, 4));
|
|
ephysics::Ray ray6(vec3(-4, 6, -100), vec3(-4, 6, -9));
|
|
ephysics::Ray ray7(vec3(-4, 6, -100), vec3(-4, 6, -11), 0.6);
|
|
ephysics::Ray ray8(vec3(-403, -432, -100), vec3(134, 643, 23));
|
|
EXPECT_EQ(m_AABB1.testRayIntersect(ray1), true);
|
|
EXPECT_EQ(m_AABB1.testRayIntersect(ray2), false);
|
|
EXPECT_EQ(m_AABB1.testRayIntersect(ray3), true);
|
|
EXPECT_EQ(m_AABB1.testRayIntersect(ray4), true);
|
|
EXPECT_EQ(m_AABB1.testRayIntersect(ray5), true);
|
|
EXPECT_EQ(m_AABB1.testRayIntersect(ray6), true);
|
|
EXPECT_EQ(m_AABB1.testRayIntersect(ray7), false);
|
|
EXPECT_EQ(m_AABB1.testRayIntersect(ray8), false);
|
|
}
|
|
|