3062 lines
141 KiB
C++
3062 lines
141 KiB
C++
/********************************************************************************
|
|
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
|
|
* Copyright (c) 2010-2016 Daniel Chappuis *
|
|
*********************************************************************************
|
|
* *
|
|
* This software is provided 'as-is', without any express or implied warranty. *
|
|
* In no event will the authors be held liable for any damages arising from the *
|
|
* use of this software. *
|
|
* *
|
|
* Permission is granted to anyone to use this software for any purpose, *
|
|
* including commercial applications, and to alter it and redistribute it *
|
|
* freely, subject to the following restrictions: *
|
|
* *
|
|
* 1. The origin of this software must not be misrepresented; you must not claim *
|
|
* that you wrote the original software. If you use this software in a *
|
|
* product, an acknowledgment in the product documentation would be *
|
|
* appreciated but is not required. *
|
|
* *
|
|
* 2. Altered source versions must be plainly marked as such, and must not be *
|
|
* misrepresented as being the original software. *
|
|
* *
|
|
* 3. This notice may not be removed or altered from any source distribution. *
|
|
* *
|
|
********************************************************************************/
|
|
|
|
#ifndef TEST_COLLISION_WORLD_H
|
|
#define TEST_COLLISION_WORLD_H
|
|
|
|
// Libraries
|
|
#include "reactphysics3d.h"
|
|
#include "Test.h"
|
|
#include <map>
|
|
|
|
/// Reactphysics3D namespace
|
|
namespace reactphysics3d {
|
|
|
|
// Enumeration for categories
|
|
enum CollisionCategory {
|
|
CATEGORY_1 = 0x0001,
|
|
CATEGORY_2 = 0x0002,
|
|
CATEGORY_3 = 0x0004
|
|
};
|
|
|
|
// Contact point collision data
|
|
struct CollisionPointData {
|
|
|
|
Vector3 localPointBody1;
|
|
Vector3 localPointBody2;
|
|
decimal penetrationDepth;
|
|
|
|
CollisionPointData(const Vector3& point1, const Vector3& point2, decimal penDepth) {
|
|
localPointBody1 = point1;
|
|
localPointBody2 = point2;
|
|
penetrationDepth = penDepth;
|
|
}
|
|
|
|
bool isContactPointSimilarTo(const Vector3& pointBody1, const Vector3& pointBody2, decimal penDepth, decimal epsilon = 0.001) const {
|
|
|
|
return approxEqual(pointBody1, localPointBody1, epsilon) &&
|
|
approxEqual(pointBody2, localPointBody2, epsilon) &&
|
|
approxEqual(penetrationDepth, penDepth, epsilon);
|
|
}
|
|
};
|
|
|
|
// Contact manifold collision data
|
|
struct CollisionManifoldData {
|
|
|
|
std::vector<CollisionPointData> contactPoints;
|
|
|
|
int getNbContactPoints() const {
|
|
return contactPoints.size();
|
|
}
|
|
|
|
bool hasContactPointSimilarTo(const Vector3& localPointBody1, const Vector3& localPointBody2, decimal penetrationDepth, decimal epsilon = 0.001) const {
|
|
|
|
std::vector<CollisionPointData>::const_iterator it;
|
|
for (it = contactPoints.cbegin(); it != contactPoints.cend(); ++it) {
|
|
|
|
Vector3 vec = it->localPointBody1;
|
|
if (it->isContactPointSimilarTo(localPointBody1, localPointBody2, penetrationDepth)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
};
|
|
|
|
// Collision data between two proxy shapes
|
|
struct CollisionData {
|
|
|
|
std::pair<const ProxyShape*, const ProxyShape*> proxyShapes;
|
|
std::pair<CollisionBody*, CollisionBody*> bodies;
|
|
std::vector<CollisionManifoldData> contactManifolds;
|
|
|
|
int getNbContactManifolds() const {
|
|
return contactManifolds.size();
|
|
}
|
|
|
|
int getTotalNbContactPoints() const {
|
|
|
|
int nbPoints = 0;
|
|
|
|
std::vector<CollisionManifoldData>::const_iterator it;
|
|
for (it = contactManifolds.begin(); it != contactManifolds.end(); ++it) {
|
|
|
|
nbPoints += it->getNbContactPoints();
|
|
}
|
|
|
|
return nbPoints;
|
|
}
|
|
|
|
const CollisionBody* getBody1() const {
|
|
return bodies.first;
|
|
}
|
|
|
|
const CollisionBody* getBody2() const {
|
|
return bodies.second;
|
|
}
|
|
|
|
bool hasContactPointSimilarTo(const Vector3& localPointBody1, const Vector3& localPointBody2, decimal penetrationDepth, decimal epsilon = 0.001) const {
|
|
|
|
std::vector<CollisionManifoldData>::const_iterator it;
|
|
for (it = contactManifolds.cbegin(); it != contactManifolds.cend(); ++it) {
|
|
|
|
if (it->hasContactPointSimilarTo(localPointBody1, localPointBody2, penetrationDepth)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
};
|
|
|
|
// Class
|
|
class WorldCollisionCallback : public CollisionCallback
|
|
{
|
|
private:
|
|
|
|
std::map<std::pair<const ProxyShape*, const ProxyShape*>, CollisionData> mCollisionDatas;
|
|
|
|
std::pair<const ProxyShape*, const ProxyShape*> getCollisionKeyPair(std::pair<const ProxyShape*, const ProxyShape*> pair) const {
|
|
|
|
if (pair.first > pair.second) {
|
|
return std::make_pair(pair.second, pair.first);
|
|
}
|
|
|
|
return pair;
|
|
}
|
|
|
|
public:
|
|
|
|
WorldCollisionCallback()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
void reset()
|
|
{
|
|
mCollisionDatas.clear();
|
|
}
|
|
|
|
bool hasContacts() const {
|
|
return mCollisionDatas.size() > 0;
|
|
}
|
|
|
|
bool areProxyShapesColliding(const ProxyShape* proxyShape1, const ProxyShape* proxyShape2) {
|
|
return mCollisionDatas.find(getCollisionKeyPair(std::make_pair(proxyShape1, proxyShape2))) != mCollisionDatas.end();
|
|
}
|
|
|
|
const CollisionData* getCollisionData(const ProxyShape* proxyShape1, const ProxyShape* proxyShape2) const {
|
|
std::map<std::pair<const ProxyShape*, const ProxyShape*>, CollisionData>::const_iterator it = mCollisionDatas.find(getCollisionKeyPair(std::make_pair(proxyShape1, proxyShape2)));
|
|
if (it != mCollisionDatas.end()) {
|
|
return &(it->second);
|
|
}
|
|
else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
// This method will be called for each contact
|
|
virtual void notifyContact(const CollisionCallbackInfo& collisionCallbackInfo) override {
|
|
|
|
CollisionData collisionData;
|
|
collisionData.bodies = std::make_pair(collisionCallbackInfo.body1, collisionCallbackInfo.body2);
|
|
collisionData.proxyShapes = std::make_pair(collisionCallbackInfo.proxyShape1, collisionCallbackInfo.proxyShape2);
|
|
|
|
ContactManifoldListElement* element = collisionCallbackInfo.contactManifoldElements;
|
|
while (element != nullptr) {
|
|
|
|
ContactManifold* contactManifold = element->getContactManifold();
|
|
|
|
CollisionManifoldData collisionManifold;
|
|
|
|
ContactPoint* contactPoint = contactManifold->getContactPoints();
|
|
while (contactPoint != nullptr) {
|
|
|
|
CollisionPointData collisionPoint(contactPoint->getLocalPointOnShape1(), contactPoint->getLocalPointOnShape2(), contactPoint->getPenetrationDepth());
|
|
collisionManifold.contactPoints.push_back(collisionPoint);
|
|
|
|
contactPoint = contactPoint->getNext();
|
|
}
|
|
|
|
collisionData.contactManifolds.push_back(collisionManifold);
|
|
mCollisionDatas.insert(std::make_pair(getCollisionKeyPair(collisionData.proxyShapes), collisionData));
|
|
|
|
element = element->getNext();
|
|
}
|
|
}
|
|
};
|
|
|
|
/// Overlap callback
|
|
class WorldOverlapCallback : public OverlapCallback {
|
|
|
|
private:
|
|
|
|
std::vector<CollisionBody*> mOverlapBodies;
|
|
|
|
public:
|
|
|
|
/// Destructor
|
|
virtual ~WorldOverlapCallback() {
|
|
reset();
|
|
}
|
|
|
|
/// This method will be called for each reported overlapping bodies
|
|
virtual void notifyOverlap(CollisionBody* collisionBody) override {
|
|
mOverlapBodies.push_back(collisionBody);
|
|
}
|
|
|
|
void reset() {
|
|
mOverlapBodies.clear();
|
|
}
|
|
|
|
bool hasOverlap() const {
|
|
return !mOverlapBodies.empty();
|
|
}
|
|
|
|
std::vector<CollisionBody*>& getOverlapBodies() {
|
|
return mOverlapBodies;
|
|
}
|
|
};
|
|
|
|
// Class TestCollisionWorld
|
|
/**
|
|
* Unit test for the CollisionWorld class.
|
|
*/
|
|
class TestCollisionWorld : public Test {
|
|
|
|
private :
|
|
|
|
// ---------- Atributes ---------- //
|
|
|
|
// Physics world
|
|
CollisionWorld* mWorld;
|
|
|
|
// Bodies
|
|
CollisionBody* mBoxBody1;
|
|
CollisionBody* mBoxBody2;
|
|
CollisionBody* mSphereBody1;
|
|
CollisionBody* mSphereBody2;
|
|
CollisionBody* mCapsuleBody1;
|
|
CollisionBody* mCapsuleBody2;
|
|
CollisionBody* mConvexMeshBody1;
|
|
CollisionBody* mConvexMeshBody2;
|
|
CollisionBody* mConcaveMeshBody;
|
|
|
|
// Collision shapes
|
|
BoxShape* mBoxShape1;
|
|
BoxShape* mBoxShape2;
|
|
SphereShape* mSphereShape1;
|
|
SphereShape* mSphereShape2;
|
|
CapsuleShape* mCapsuleShape1;
|
|
CapsuleShape* mCapsuleShape2;
|
|
ConvexMeshShape* mConvexMeshShape1;
|
|
ConvexMeshShape* mConvexMeshShape2;
|
|
ConcaveMeshShape* mConcaveMeshShape;
|
|
|
|
// Proxy shapes
|
|
ProxyShape* mBoxProxyShape1;
|
|
ProxyShape* mBoxProxyShape2;
|
|
ProxyShape* mSphereProxyShape1;
|
|
ProxyShape* mSphereProxyShape2;
|
|
ProxyShape* mCapsuleProxyShape1;
|
|
ProxyShape* mCapsuleProxyShape2;
|
|
ProxyShape* mConvexMeshProxyShape1;
|
|
ProxyShape* mConvexMeshProxyShape2;
|
|
ProxyShape* mConcaveMeshProxyShape;
|
|
|
|
PolygonVertexArray* mConvexMesh1PolygonVertexArray;
|
|
PolygonVertexArray* mConvexMesh2PolygonVertexArray;
|
|
PolyhedronMesh* mConvexMesh1PolyhedronMesh;
|
|
PolyhedronMesh* mConvexMesh2PolyhedronMesh;
|
|
PolygonVertexArray::PolygonFace* mConvexMeshPolygonFaces;
|
|
|
|
TriangleVertexArray* mConcaveMeshTriangleVertexArray;
|
|
Vector3 mConvexMesh1CubeVertices[8];
|
|
Vector3 mConvexMesh2CubeVertices[8];
|
|
int mConvexMeshCubeIndices[24];
|
|
|
|
Vector3 mConcaveMeshPlaneVertices[36];
|
|
int mConcaveMeshPlaneIndices[25 * 2 * 3];
|
|
TriangleMesh* mConcaveTriangleMesh;
|
|
|
|
// Collision callback
|
|
WorldCollisionCallback mCollisionCallback;
|
|
|
|
// Overlap callback
|
|
WorldOverlapCallback mOverlapCallback;
|
|
|
|
public :
|
|
|
|
// ---------- Methods ---------- //
|
|
|
|
/// Constructor
|
|
TestCollisionWorld(const std::string& name) : Test(name) {
|
|
|
|
// Create the collision world
|
|
mWorld = new CollisionWorld();
|
|
|
|
// ---------- Boxes ---------- //
|
|
Transform boxTransform1(Vector3(-20, 20, 0), Quaternion::identity());
|
|
mBoxBody1 = mWorld->createCollisionBody(boxTransform1);
|
|
mBoxShape1 = new BoxShape(Vector3(3, 3, 3));
|
|
mBoxProxyShape1 = mBoxBody1->addCollisionShape(mBoxShape1, Transform::identity());
|
|
|
|
Transform boxTransform2(Vector3(-10, 20, 0), Quaternion::identity());
|
|
mBoxBody2 = mWorld->createCollisionBody(boxTransform2);
|
|
mBoxShape2 = new BoxShape(Vector3(4, 2, 8));
|
|
mBoxProxyShape2 = mBoxBody2->addCollisionShape(mBoxShape2, Transform::identity());
|
|
|
|
// ---------- Spheres ---------- //
|
|
mSphereShape1 = new SphereShape(3.0);
|
|
Transform sphereTransform1(Vector3(10, 20, 0), Quaternion::identity());
|
|
mSphereBody1 = mWorld->createCollisionBody(sphereTransform1);
|
|
mSphereProxyShape1 = mSphereBody1->addCollisionShape(mSphereShape1, Transform::identity());
|
|
|
|
mSphereShape2 = new SphereShape(5.0);
|
|
Transform sphereTransform2(Vector3(20, 20, 0), Quaternion::identity());
|
|
mSphereBody2 = mWorld->createCollisionBody(sphereTransform2);
|
|
mSphereProxyShape2 = mSphereBody2->addCollisionShape(mSphereShape2, Transform::identity());
|
|
|
|
// ---------- Capsules ---------- //
|
|
mCapsuleShape1 = new CapsuleShape(2, 6);
|
|
Transform capsuleTransform1(Vector3(-10, 0, 0), Quaternion::identity());
|
|
mCapsuleBody1 = mWorld->createCollisionBody(capsuleTransform1);
|
|
mCapsuleProxyShape1 = mCapsuleBody1->addCollisionShape(mCapsuleShape1, Transform::identity());
|
|
|
|
mCapsuleShape2 = new CapsuleShape(3, 4);
|
|
Transform capsuleTransform2(Vector3(-20, 0, 0), Quaternion::identity());
|
|
mCapsuleBody2 = mWorld->createCollisionBody(capsuleTransform2);
|
|
mCapsuleProxyShape2 = mCapsuleBody2->addCollisionShape(mCapsuleShape2, Transform::identity());
|
|
|
|
// ---------- Convex Meshes ---------- //
|
|
mConvexMesh1CubeVertices[0] = Vector3(-3, -3, 3);
|
|
mConvexMesh1CubeVertices[1] = Vector3(3, -3, 3);
|
|
mConvexMesh1CubeVertices[2] = Vector3(3, -3, -3);
|
|
mConvexMesh1CubeVertices[3] = Vector3(-3, -3, -3);
|
|
mConvexMesh1CubeVertices[4] = Vector3(-3, 3, 3);
|
|
mConvexMesh1CubeVertices[5] = Vector3(3, 3, 3);
|
|
mConvexMesh1CubeVertices[6] = Vector3(3, 3, -3);
|
|
mConvexMesh1CubeVertices[7] = Vector3(-3, 3, -3);
|
|
|
|
mConvexMeshCubeIndices[0] = 0; mConvexMeshCubeIndices[1] = 3; mConvexMeshCubeIndices[2] = 2; mConvexMeshCubeIndices[3] = 1;
|
|
mConvexMeshCubeIndices[4] = 4; mConvexMeshCubeIndices[5] = 5; mConvexMeshCubeIndices[6] = 6; mConvexMeshCubeIndices[7] = 7;
|
|
mConvexMeshCubeIndices[8] = 0; mConvexMeshCubeIndices[9] = 1; mConvexMeshCubeIndices[10] = 5; mConvexMeshCubeIndices[11] = 4;
|
|
mConvexMeshCubeIndices[12] = 1; mConvexMeshCubeIndices[13] = 2; mConvexMeshCubeIndices[14] = 6; mConvexMeshCubeIndices[15] = 5;
|
|
mConvexMeshCubeIndices[16] = 2; mConvexMeshCubeIndices[17] = 3; mConvexMeshCubeIndices[18] = 7; mConvexMeshCubeIndices[19] = 6;
|
|
mConvexMeshCubeIndices[20] = 0; mConvexMeshCubeIndices[21] = 4; mConvexMeshCubeIndices[22] = 7; mConvexMeshCubeIndices[23] = 3;
|
|
|
|
mConvexMeshPolygonFaces = new rp3d::PolygonVertexArray::PolygonFace[6];
|
|
rp3d::PolygonVertexArray::PolygonFace* face = mConvexMeshPolygonFaces;
|
|
for (int f = 0; f < 6; f++) {
|
|
face->indexBase = f * 4;
|
|
face->nbVertices = 4;
|
|
face++;
|
|
}
|
|
mConvexMesh1PolygonVertexArray = new rp3d::PolygonVertexArray(8, &(mConvexMesh1CubeVertices[0]), sizeof(Vector3),
|
|
&(mConvexMeshCubeIndices[0]), sizeof(int), 6, mConvexMeshPolygonFaces,
|
|
rp3d::PolygonVertexArray::VertexDataType::VERTEX_FLOAT_TYPE,
|
|
rp3d::PolygonVertexArray::IndexDataType::INDEX_INTEGER_TYPE);
|
|
mConvexMesh1PolyhedronMesh = new rp3d::PolyhedronMesh(mConvexMesh1PolygonVertexArray);
|
|
mConvexMeshShape1 = new rp3d::ConvexMeshShape(mConvexMesh1PolyhedronMesh);
|
|
Transform convexMeshTransform1(Vector3(10, 0, 0), Quaternion::identity());
|
|
mConvexMeshBody1 = mWorld->createCollisionBody(convexMeshTransform1);
|
|
mConvexMeshProxyShape1 = mConvexMeshBody1->addCollisionShape(mConvexMeshShape1, Transform::identity());
|
|
|
|
mConvexMesh2CubeVertices[0] = Vector3(-4, -2, 8);
|
|
mConvexMesh2CubeVertices[1] = Vector3(4, -2, 8);
|
|
mConvexMesh2CubeVertices[2] = Vector3(4, -2, -8);
|
|
mConvexMesh2CubeVertices[3] = Vector3(-4, -2, -8);
|
|
mConvexMesh2CubeVertices[4] = Vector3(-4, 2, 8);
|
|
mConvexMesh2CubeVertices[5] = Vector3(4, 2, 8);
|
|
mConvexMesh2CubeVertices[6] = Vector3(4, 2, -8);
|
|
mConvexMesh2CubeVertices[7] = Vector3(-4, 2, -8);
|
|
|
|
mConvexMesh2PolygonVertexArray = new rp3d::PolygonVertexArray(8, &(mConvexMesh2CubeVertices[0]), sizeof(Vector3),
|
|
&(mConvexMeshCubeIndices[0]), sizeof(int), 6, mConvexMeshPolygonFaces,
|
|
rp3d::PolygonVertexArray::VertexDataType::VERTEX_FLOAT_TYPE,
|
|
rp3d::PolygonVertexArray::IndexDataType::INDEX_INTEGER_TYPE);
|
|
mConvexMesh2PolyhedronMesh = new rp3d::PolyhedronMesh(mConvexMesh2PolygonVertexArray);
|
|
mConvexMeshShape2 = new rp3d::ConvexMeshShape(mConvexMesh2PolyhedronMesh);
|
|
Transform convexMeshTransform2(Vector3(20, 0, 0), Quaternion::identity());
|
|
mConvexMeshBody2 = mWorld->createCollisionBody(convexMeshTransform2);
|
|
mConvexMeshProxyShape2 = mConvexMeshBody2->addCollisionShape(mConvexMeshShape2, Transform::identity());
|
|
|
|
// ---------- Concave Meshes ---------- //
|
|
for (int i = 0; i < 6; i++) {
|
|
for (int j = 0; j < 6; j++) {
|
|
mConcaveMeshPlaneVertices[i * 6 + j] = Vector3(-2.5f + i, 0, -2.5f + j);
|
|
}
|
|
}
|
|
int triangleIndex = 0;
|
|
for (int i = 0; i < 5; i++) {
|
|
for (int j = 0; j < 5; j++) {
|
|
|
|
// Triangle 1
|
|
mConcaveMeshPlaneIndices[triangleIndex * 3] = i * 6 + j;
|
|
mConcaveMeshPlaneIndices[triangleIndex * 3 + 1] = (i+1) * 6 + (j+1);
|
|
mConcaveMeshPlaneIndices[triangleIndex * 3 + 2] = i * 6 + (j+1);
|
|
triangleIndex++;
|
|
|
|
// Triangle 2
|
|
mConcaveMeshPlaneIndices[triangleIndex * 3] = i * 6 + j;
|
|
mConcaveMeshPlaneIndices[triangleIndex * 3 + 1] = (i+1) * 6 + j;
|
|
mConcaveMeshPlaneIndices[triangleIndex * 3 + 2] = (i+1) * 6 + (j+1);
|
|
triangleIndex++;
|
|
}
|
|
}
|
|
|
|
mConcaveMeshTriangleVertexArray = new rp3d::TriangleVertexArray(36, &(mConcaveMeshPlaneVertices[0]), sizeof(Vector3),
|
|
25, &(mConcaveMeshPlaneIndices[0]), 3 * sizeof(int),
|
|
rp3d::TriangleVertexArray::VertexDataType::VERTEX_FLOAT_TYPE,
|
|
rp3d::TriangleVertexArray::IndexDataType::INDEX_INTEGER_TYPE);
|
|
|
|
// Add the triangle vertex array of the subpart to the triangle mesh
|
|
Transform concaveMeshTransform(Vector3(0, -20, 0), Quaternion::identity());
|
|
mConcaveTriangleMesh = new TriangleMesh();
|
|
mConcaveTriangleMesh->addSubpart(mConcaveMeshTriangleVertexArray);
|
|
mConcaveMeshShape = new rp3d::ConcaveMeshShape(mConcaveTriangleMesh);
|
|
mConcaveMeshBody = mWorld->createCollisionBody(concaveMeshTransform);
|
|
mConcaveMeshProxyShape = mConcaveMeshBody->addCollisionShape(mConcaveMeshShape, rp3d::Transform::identity());
|
|
}
|
|
|
|
/// Destructor
|
|
virtual ~TestCollisionWorld() {
|
|
|
|
delete mBoxShape1;
|
|
delete mBoxShape2;
|
|
|
|
delete mSphereShape1;
|
|
delete mSphereShape2;
|
|
|
|
delete mCapsuleShape1;
|
|
delete mCapsuleShape2;
|
|
|
|
delete mConvexMeshShape1;
|
|
delete mConvexMeshShape2;
|
|
delete mConvexMesh1PolyhedronMesh;
|
|
delete mConvexMesh2PolyhedronMesh;
|
|
delete mConvexMesh1PolygonVertexArray;
|
|
delete mConvexMesh2PolygonVertexArray;
|
|
delete mConvexMeshPolygonFaces;
|
|
|
|
delete mConcaveMeshShape;
|
|
delete mConcaveTriangleMesh;
|
|
delete mConcaveMeshTriangleVertexArray;
|
|
|
|
delete mWorld;
|
|
}
|
|
|
|
/// Run the tests
|
|
void run() {
|
|
|
|
testNoCollisions();
|
|
testNoOverlap();
|
|
testNoAABBOverlap();
|
|
|
|
testSphereVsSphereCollision();
|
|
testSphereVsBoxCollision();
|
|
testSphereVsCapsuleCollision();
|
|
testSphereVsConvexMeshCollision();
|
|
testSphereVsConcaveMeshCollision();
|
|
|
|
testBoxVsBoxCollision();
|
|
testBoxVsConvexMeshCollision();
|
|
testBoxVsCapsuleCollision();
|
|
testBoxVsConcaveMeshCollision();
|
|
|
|
testCapsuleVsCapsuleCollision();
|
|
testCapsuleVsConcaveMeshCollision();
|
|
|
|
testConvexMeshVsConvexMeshCollision();
|
|
testConvexMeshVsCapsuleCollision();
|
|
testConvexMeshVsConcaveMeshCollision();
|
|
}
|
|
|
|
void testNoCollisions() {
|
|
|
|
// All the shapes of the world are not touching when they are created.
|
|
// Here we test that at the beginning, there is no collision at all.
|
|
|
|
// ---------- Global test ---------- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
// ---------- Single body test ---------- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody2, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody2, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
// Two bodies test
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, mBoxBody2, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mSphereBody2, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, mSphereBody1, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, mSphereBody2, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody2, mSphereBody1, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody2, mSphereBody2, &mCollisionCallback);
|
|
test(!mCollisionCallback.hasContacts());
|
|
}
|
|
|
|
void testNoOverlap() {
|
|
|
|
// All the shapes of the world are not touching when they are created.
|
|
// Here we test that at the beginning, there is no overlap at all.
|
|
|
|
// ---------- Single body test ---------- //
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody1, &mOverlapCallback);
|
|
test(!mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody2, &mOverlapCallback);
|
|
test(!mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(!mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody2, &mOverlapCallback);
|
|
test(!mOverlapCallback.hasOverlap());
|
|
|
|
// Two bodies test
|
|
|
|
test(!mWorld->testOverlap(mBoxBody1, mBoxBody2));
|
|
test(!mWorld->testOverlap(mSphereBody1, mSphereBody2));
|
|
test(!mWorld->testOverlap(mBoxBody1, mSphereBody1));
|
|
test(!mWorld->testOverlap(mBoxBody1, mSphereBody2));
|
|
test(!mWorld->testOverlap(mBoxBody2, mSphereBody1));
|
|
test(!mWorld->testOverlap(mBoxBody2, mSphereBody2));
|
|
}
|
|
|
|
void testNoAABBOverlap() {
|
|
|
|
// All the shapes of the world are not touching when they are created.
|
|
// Here we test that at the beginning, there is no AABB overlap at all.
|
|
|
|
// Two bodies test
|
|
|
|
test(!mWorld->testAABBOverlap(mBoxBody1, mBoxBody2));
|
|
test(!mWorld->testAABBOverlap(mSphereBody1, mSphereBody2));
|
|
test(!mWorld->testAABBOverlap(mBoxBody1, mSphereBody1));
|
|
test(!mWorld->testAABBOverlap(mBoxBody1, mSphereBody2));
|
|
test(!mWorld->testAABBOverlap(mBoxBody2, mSphereBody1));
|
|
test(!mWorld->testAABBOverlap(mBoxBody2, mSphereBody2));
|
|
}
|
|
|
|
void testSphereVsSphereCollision() {
|
|
|
|
Transform initTransform1 = mSphereBody1->getTransform();
|
|
Transform initTransform2 = mSphereBody2->getTransform();
|
|
|
|
Transform transform1(Vector3(10, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(17, 20, 50), Quaternion::fromEulerAngles(rp3d::PI / 8.0f, rp3d::PI / 4.0f, rp3d::PI / 16.0f));
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mSphereBody2->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mSphereBody2));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody2, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mSphereProxyShape2));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mSphereProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point(3, 0, 0);
|
|
Vector3 localBody2Point = transform2.getInverse() * Vector3(12, 20, 50);
|
|
decimal penetrationDepth = 1.0f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mSphereProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mSphereProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mSphereProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mSphereProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mSphereBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mSphereProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mSphereProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// Reset the init transforms
|
|
mSphereBody1->setTransform(initTransform1);
|
|
mSphereBody2->setTransform(initTransform2);
|
|
}
|
|
|
|
void testSphereVsBoxCollision() {
|
|
|
|
Transform initTransform1 = mSphereBody1->getTransform();
|
|
Transform initTransform2 = mBoxBody1->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs Box Face collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(14, 20, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mBoxBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mBoxBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point(3, 0, 0);
|
|
Vector3 localBody2Point(-3, 0, 0);
|
|
decimal penetrationDepth = 2.0f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs Box Edge collision *
|
|
*********************************************************************************/
|
|
|
|
transform1 = Transform(Vector3(10, 20, 50), Quaternion::identity());
|
|
transform2 = Transform(Vector3(14, 16, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mBoxBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mBoxBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
localBody1Point = std::sqrt(4.5f) * Vector3(1, -1, 0);
|
|
localBody2Point = Vector3(-3, 3, 0);
|
|
penetrationDepth = decimal(3.0) - std::sqrt(2);
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs Box Vertex collision *
|
|
*********************************************************************************/
|
|
|
|
transform1 = Transform(Vector3(10, 20, 50), Quaternion::identity());
|
|
transform2 = Transform(Vector3(14, 16, 46), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mBoxBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mBoxBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
localBody1Point = std::sqrt(9.0f / 3.0f) * Vector3(1, -1, -1);
|
|
localBody2Point = Vector3(-3, 3, 3);
|
|
penetrationDepth = decimal(3.0) - std::sqrt(3);
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mBoxProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mBoxProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// Reset the init transforms
|
|
mSphereBody1->setTransform(initTransform1);
|
|
mBoxBody1->setTransform(initTransform2);
|
|
}
|
|
|
|
void testSphereVsCapsuleCollision() {
|
|
|
|
Transform initTransform1 = mSphereBody1->getTransform();
|
|
Transform initTransform2 = mCapsuleBody1->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs Capsule (sphere side) collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(10, 14, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mCapsuleBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mCapsuleBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point(0, -3, 0);
|
|
Vector3 localBody2Point(0, 5, 0);
|
|
decimal penetrationDepth = 2.0f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs Box Capsule (cylinder side) collision *
|
|
*********************************************************************************/
|
|
|
|
transform1 = Transform(Vector3(10, 20, 50), Quaternion::identity());
|
|
transform2 = Transform(Vector3(14, 19, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mCapsuleBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mCapsuleBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
localBody1Point = Vector3(3, 0, 0);
|
|
localBody2Point = Vector3(-2, 1, 0);
|
|
penetrationDepth = decimal(1.0);
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// Reset the init transforms
|
|
mSphereBody1->setTransform(initTransform1);
|
|
mCapsuleBody1->setTransform(initTransform2);
|
|
}
|
|
|
|
void testSphereVsConvexMeshCollision() {
|
|
|
|
Transform initTransform1 = mSphereBody1->getTransform();
|
|
Transform initTransform2 = mConvexMeshBody1->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs Convex Mesh (Cube Face) collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(14, 20, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mConvexMeshBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mConvexMeshBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConvexMeshBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point(3, 0, 0);
|
|
Vector3 localBody2Point(-3, 0, 0);
|
|
decimal penetrationDepth = 2.0f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs Convex Mesh (Cube Edge) collision *
|
|
*********************************************************************************/
|
|
|
|
transform1 = Transform(Vector3(10, 20, 50), Quaternion::identity());
|
|
transform2 = Transform(Vector3(14, 16, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mConvexMeshBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mConvexMeshBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConvexMeshBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
localBody1Point = std::sqrt(4.5f) * Vector3(1, -1, 0);
|
|
localBody2Point = Vector3(-3, 3, 0);
|
|
penetrationDepth = decimal(3.0) - std::sqrt(2);
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs ConvexMesh (Cube Vertex) collision *
|
|
*********************************************************************************/
|
|
|
|
transform1 = Transform(Vector3(10, 20, 50), Quaternion::identity());
|
|
transform2 = Transform(Vector3(14, 16, 46), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mConvexMeshBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mConvexMeshBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConvexMeshBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
localBody1Point = std::sqrt(9.0f / 3.0f) * Vector3(1, -1, -1);
|
|
localBody2Point = Vector3(-3, 3, 3);
|
|
penetrationDepth = decimal(3.0) - std::sqrt(3);
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConvexMeshProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConvexMeshProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// Reset the init transforms
|
|
mSphereBody1->setTransform(initTransform1);
|
|
mConvexMeshBody1->setTransform(initTransform2);
|
|
}
|
|
|
|
void testSphereVsConcaveMeshCollision() {
|
|
|
|
Transform initTransform1 = mSphereBody1->getTransform();
|
|
Transform initTransform2 = mConcaveMeshBody->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Sphere vs Concave Mesh
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 22.98f, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(10, 20, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mSphereBody1->setTransform(transform1);
|
|
mConcaveMeshBody->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mSphereBody1, mConcaveMeshBody));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mSphereBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConcaveMeshBody, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point(0, -3, 0);
|
|
Vector3 localBody2Point(0, 0, 0);
|
|
decimal penetrationDepth = 0.02f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConcaveMeshBody, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mSphereBody1, mConcaveMeshBody, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mSphereProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mSphereProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mSphereBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// Reset the init transforms
|
|
mSphereBody1->setTransform(initTransform1);
|
|
mConcaveMeshBody->setTransform(initTransform2);
|
|
}
|
|
|
|
void testBoxVsBoxCollision() {
|
|
|
|
Transform initTransform1 = mBoxBody1->getTransform();
|
|
Transform initTransform2 = mBoxBody2->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Box vs Box Face collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(11, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(4.5, 16, 40), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mBoxBody1->setTransform(transform1);
|
|
mBoxBody2->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mBoxBody1, mBoxBody2));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody2, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mBoxProxyShape2));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mBoxProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point1(-3, -2, -2);
|
|
Vector3 localBody2Point1(4, 2, 8);
|
|
decimal penetrationDepth1 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
Vector3 localBody1Point2(-3, -2, -3);
|
|
Vector3 localBody2Point2(4, 2, 7);
|
|
decimal penetrationDepth2 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
Vector3 localBody1Point3(-3, -3, -2);
|
|
Vector3 localBody2Point3(4, 1, 8);
|
|
decimal penetrationDepth3 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
Vector3 localBody1Point4(-3, -3, -3);
|
|
Vector3 localBody2Point4(4, 1, 7);
|
|
decimal penetrationDepth4 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mBoxProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mBoxProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mBoxProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mBoxProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, mBoxBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mBoxProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mBoxProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// reset the init transforms
|
|
mBoxBody1->setTransform(initTransform1);
|
|
mBoxBody2->setTransform(initTransform2);
|
|
}
|
|
|
|
void testBoxVsConvexMeshCollision() {
|
|
|
|
Transform initTransform1 = mBoxBody1->getTransform();
|
|
Transform initTransform2 = mConvexMeshBody2->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Box vs Convex Mesh collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(11, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(4.5, 16, 40), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mBoxBody1->setTransform(transform1);
|
|
mConvexMeshBody2->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mBoxBody1, mConvexMeshBody2));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConvexMeshBody2, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mConvexMeshProxyShape2));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mConvexMeshProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point1(-3, -2, -2);
|
|
Vector3 localBody2Point1(4, 2, 8);
|
|
decimal penetrationDepth1 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
Vector3 localBody1Point2(-3, -2, -3);
|
|
Vector3 localBody2Point2(4, 2, 7);
|
|
decimal penetrationDepth2 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
Vector3 localBody1Point3(-3, -3, -2);
|
|
Vector3 localBody2Point3(4, 1, 8);
|
|
decimal penetrationDepth3 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
Vector3 localBody1Point4(-3, -3, -3);
|
|
Vector3 localBody2Point4(4, 1, 7);
|
|
decimal penetrationDepth4 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mConvexMeshProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mConvexMeshProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mConvexMeshProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mConvexMeshProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, mConvexMeshBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mConvexMeshProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mConvexMeshProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// reset the init transforms
|
|
mBoxBody1->setTransform(initTransform1);
|
|
mConvexMeshBody2->setTransform(initTransform2);
|
|
}
|
|
|
|
void testConvexMeshVsConvexMeshCollision() {
|
|
|
|
Transform initTransform1 = mConvexMeshBody1->getTransform();
|
|
Transform initTransform2 = mConvexMeshBody2->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Convex Mesh vs Convex Mesh collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(11, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(4.5, 16, 40), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mConvexMeshBody1->setTransform(transform1);
|
|
mConvexMeshBody2->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mConvexMeshBody1, mConvexMeshBody2));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConvexMeshBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConvexMeshBody2, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mConvexMeshProxyShape2));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mConvexMeshProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point1(-3, -2, -2);
|
|
Vector3 localBody2Point1(4, 2, 8);
|
|
decimal penetrationDepth1 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
Vector3 localBody1Point2(-3, -2, -3);
|
|
Vector3 localBody2Point2(4, 2, 7);
|
|
decimal penetrationDepth2 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
Vector3 localBody1Point3(-3, -3, -2);
|
|
Vector3 localBody2Point3(4, 1, 8);
|
|
decimal penetrationDepth3 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
Vector3 localBody1Point4(-3, -3, -3);
|
|
Vector3 localBody2Point4(4, 1, 7);
|
|
decimal penetrationDepth4 = 0.5f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mConvexMeshProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mConvexMeshProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mConvexMeshProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mConvexMeshProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, mConvexMeshBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mConvexMeshProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mConvexMeshProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
|
|
swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
|
|
penetrationDepth2));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
|
|
swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
|
|
penetrationDepth3));
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
|
|
swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
|
|
penetrationDepth4));
|
|
|
|
// reset the init transforms
|
|
mConvexMeshBody1->setTransform(initTransform1);
|
|
mConvexMeshBody2->setTransform(initTransform2);
|
|
}
|
|
|
|
void testBoxVsCapsuleCollision() {
|
|
|
|
Transform initTransform1 = mBoxBody1->getTransform();
|
|
Transform initTransform2 = mCapsuleBody1->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Box vs Capsule collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(17, 21, 50), Quaternion::fromEulerAngles(0, 0, rp3d::PI * 0.5f));
|
|
|
|
// Move spheres to collide with each other
|
|
mBoxBody1->setTransform(transform1);
|
|
mCapsuleBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mBoxBody1, mCapsuleBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point1(3, 1, 0);
|
|
Vector3 localBody2Point1(0, 5, 0);
|
|
decimal penetrationDepth1 = 1.0f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
|
|
// reset the init transforms
|
|
mBoxBody1->setTransform(initTransform1);
|
|
mCapsuleBody1->setTransform(initTransform2);
|
|
}
|
|
|
|
void testConvexMeshVsCapsuleCollision() {
|
|
|
|
Transform initTransform1 = mConvexMeshBody1->getTransform();
|
|
Transform initTransform2 = mCapsuleBody1->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Convex Mesh vs Capsule collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(17, 21, 50), Quaternion::fromEulerAngles(0, 0, rp3d::PI * 0.5f));
|
|
|
|
// Move spheres to collide with each other
|
|
mConvexMeshBody1->setTransform(transform1);
|
|
mCapsuleBody1->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mConvexMeshBody1, mCapsuleBody1));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConvexMeshBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point1(3, 1, 0);
|
|
Vector3 localBody2Point1(0, 5, 0);
|
|
decimal penetrationDepth1 = 1.0f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mCapsuleProxyShape1));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mCapsuleProxyShape1);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
|
|
swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
|
|
penetrationDepth1));
|
|
|
|
// reset the init transforms
|
|
mConvexMeshBody1->setTransform(initTransform1);
|
|
mCapsuleBody1->setTransform(initTransform2);
|
|
}
|
|
|
|
void testBoxVsConcaveMeshCollision() {
|
|
|
|
Transform initTransform1 = mBoxBody1->getTransform();
|
|
Transform initTransform2 = mConcaveMeshBody->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Box vs Concave Mesh
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 22, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(10, 20, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mBoxBody1->setTransform(transform1);
|
|
mConcaveMeshBody->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mBoxBody1, mConcaveMeshBody));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mBoxBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConcaveMeshBody, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
for (int i=0; i<collisionData->contactManifolds[0].contactPoints.size(); i++) {
|
|
test(approxEqual(collisionData->contactManifolds[0].contactPoints[i].penetrationDepth, 1.0f));
|
|
}
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
for (int i=0; i<collisionData->contactManifolds[0].contactPoints.size(); i++) {
|
|
test(approxEqual(collisionData->contactManifolds[0].contactPoints[i].penetrationDepth, 1.0f));
|
|
}
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConcaveMeshBody, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
for (int i=0; i<collisionData->contactManifolds[0].contactPoints.size(); i++) {
|
|
test(approxEqual(collisionData->contactManifolds[0].contactPoints[i].penetrationDepth, 1.0f));
|
|
}
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mBoxBody1, mConcaveMeshBody, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mBoxProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mBoxProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mBoxBody1->getId();
|
|
|
|
// Test contact points
|
|
for (int i=0; i<collisionData->contactManifolds[0].contactPoints.size(); i++) {
|
|
test(approxEqual(collisionData->contactManifolds[0].contactPoints[i].penetrationDepth, 1.0f));
|
|
}
|
|
|
|
// Reset the init transforms
|
|
mBoxBody1->setTransform(initTransform1);
|
|
mConcaveMeshBody->setTransform(initTransform2);
|
|
}
|
|
|
|
void testConvexMeshVsConcaveMeshCollision() {
|
|
|
|
Transform initTransform1 = mConvexMeshBody1->getTransform();
|
|
Transform initTransform2 = mConcaveMeshBody->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Box vs Concave Mesh
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 22, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(10, 20, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mConvexMeshBody1->setTransform(transform1);
|
|
mConcaveMeshBody->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mConvexMeshBody1, mConcaveMeshBody));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConvexMeshBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConcaveMeshBody, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
for (int i=0; i<collisionData->contactManifolds[0].contactPoints.size(); i++) {
|
|
test(approxEqual(collisionData->contactManifolds[0].contactPoints[i].penetrationDepth, 1.0f));
|
|
}
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
for (int i=0; i<collisionData->contactManifolds[0].contactPoints.size(); i++) {
|
|
test(approxEqual(collisionData->contactManifolds[0].contactPoints[i].penetrationDepth, 1.0f));
|
|
}
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConcaveMeshBody, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
for (int i=0; i<collisionData->contactManifolds[0].contactPoints.size(); i++) {
|
|
test(approxEqual(collisionData->contactManifolds[0].contactPoints[i].penetrationDepth, 1.0f));
|
|
}
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConvexMeshBody1, mConcaveMeshBody, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mConvexMeshProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mConvexMeshProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 4);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mConvexMeshBody1->getId();
|
|
|
|
// Test contact points
|
|
for (int i=0; i<collisionData->contactManifolds[0].contactPoints.size(); i++) {
|
|
test(approxEqual(collisionData->contactManifolds[0].contactPoints[i].penetrationDepth, 1.0f));
|
|
}
|
|
|
|
// Reset the init transforms
|
|
mConvexMeshBody1->setTransform(initTransform1);
|
|
mConcaveMeshBody->setTransform(initTransform2);
|
|
}
|
|
|
|
void testCapsuleVsCapsuleCollision() {
|
|
|
|
Transform initTransform1 = mCapsuleBody1->getTransform();
|
|
Transform initTransform2 = mCapsuleBody2->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Capsule (sphere cap) vs Capsule (sphere cap) collision *
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 20, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(16, 23, 50), Quaternion::fromEulerAngles(0, 0, rp3d::PI * 0.5f));
|
|
|
|
// Move spheres to collide with each other
|
|
mCapsuleBody1->setTransform(transform1);
|
|
mCapsuleBody2->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mCapsuleBody1, mCapsuleBody2));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody2, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mCapsuleProxyShape2));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mCapsuleProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point(2, 3, 0);
|
|
Vector3 localBody2Point(0, 5, 0);
|
|
decimal penetrationDepth = 1.0f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mCapsuleProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mCapsuleProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mCapsuleProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mCapsuleProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, mCapsuleBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mCapsuleProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mCapsuleProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
/********************************************************************************
|
|
* Test Capsule (sphere cap) vs Capsule (cylinder side) collision *
|
|
*********************************************************************************/
|
|
|
|
transform1 = Transform(Vector3(10, 20, 50), Quaternion::identity());
|
|
transform2 = Transform(Vector3(10, 27, 50), Quaternion::fromEulerAngles(0, 0, rp3d::PI * 0.5f));
|
|
|
|
// Move spheres to collide with each other
|
|
mCapsuleBody1->setTransform(transform1);
|
|
mCapsuleBody2->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mCapsuleBody1, mCapsuleBody2));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody2, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mCapsuleProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mCapsuleProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
localBody1Point = Vector3(0, 5, 0);
|
|
localBody2Point = Vector3(-3, 0, 0);
|
|
penetrationDepth = decimal(1.0);
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mCapsuleProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mCapsuleProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mCapsuleProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mCapsuleProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, mCapsuleBody2, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mCapsuleProxyShape2));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mCapsuleProxyShape2);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// Reset the init transforms
|
|
mCapsuleBody1->setTransform(initTransform1);
|
|
mCapsuleBody2->setTransform(initTransform2);
|
|
}
|
|
|
|
void testCapsuleVsConcaveMeshCollision() {
|
|
|
|
Transform initTransform1 = mCapsuleBody1->getTransform();
|
|
Transform initTransform2 = mConcaveMeshBody->getTransform();
|
|
|
|
/********************************************************************************
|
|
* Test Capsule vs Concave Mesh
|
|
*********************************************************************************/
|
|
|
|
Transform transform1(Vector3(10, 24.98f, 50), Quaternion::identity());
|
|
Transform transform2(Vector3(10, 20, 50), Quaternion::identity());
|
|
|
|
// Move spheres to collide with each other
|
|
mCapsuleBody1->setTransform(transform1);
|
|
mConcaveMeshBody->setTransform(transform2);
|
|
|
|
// ----- Test AABB overlap ----- //
|
|
|
|
test(mWorld->testAABBOverlap(mCapsuleBody1, mConcaveMeshBody));
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mCapsuleBody1, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
mOverlapCallback.reset();
|
|
mWorld->testOverlap(mConcaveMeshBody, &mOverlapCallback);
|
|
test(mOverlapCallback.hasOverlap());
|
|
|
|
// ----- Test global collision test ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(&mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
const CollisionData* collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
bool swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
Vector3 localBody1Point(0, -5, 0);
|
|
Vector3 localBody2Point(0, 0, 0);
|
|
decimal penetrationDepth = 0.02f;
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 1 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against body 2 only ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mConcaveMeshBody, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// ----- Test collision against selected body 1 and 2 ----- //
|
|
|
|
mCollisionCallback.reset();
|
|
mWorld->testCollision(mCapsuleBody1, mConcaveMeshBody, &mCollisionCallback);
|
|
|
|
test(mCollisionCallback.areProxyShapesColliding(mCapsuleProxyShape1, mConcaveMeshProxyShape));
|
|
|
|
// Get collision data
|
|
collisionData = mCollisionCallback.getCollisionData(mCapsuleProxyShape1, mConcaveMeshProxyShape);
|
|
test(collisionData != nullptr);
|
|
test(collisionData->getNbContactManifolds() == 1);
|
|
test(collisionData->getTotalNbContactPoints() == 1);
|
|
|
|
// True if the bodies are swapped in the collision callback response
|
|
swappedBodiesCollisionData = collisionData->getBody1()->getId() != mCapsuleBody1->getId();
|
|
|
|
// Test contact points
|
|
test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
|
|
swappedBodiesCollisionData ? localBody1Point : localBody2Point,
|
|
penetrationDepth));
|
|
|
|
// Reset the init transforms
|
|
mCapsuleBody1->setTransform(initTransform1);
|
|
mConcaveMeshBody->setTransform(initTransform2);
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|