/********************************************************************************
* 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 "constraint/ContactPoint.h"
#include "collision/ContactManifold.h"
#include <map>
#include <vector>

/// 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 pair collision data
struct ContactPairData {

	std::vector<CollisionPointData> contactPoints;

    uint 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 colliders
struct CollisionData {

    std::pair<const Collider*, const Collider*> colliders;
	std::pair<CollisionBody*, CollisionBody*> bodies;
    std::vector<ContactPairData> contactPairs;

    int getNbContactPairs() const {
        return contactPairs.size();
	}

	int getTotalNbContactPoints() const {
		
		int nbPoints = 0;

        std::vector<ContactPairData>::const_iterator it;
        for (it = contactPairs.begin(); it != contactPairs.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<ContactPairData>::const_iterator it;
        for (it = contactPairs.cbegin(); it != contactPairs.cend(); ++it) {

			if (it->hasContactPointSimilarTo(localPointBody1, localPointBody2, penetrationDepth)) {
				return true;
			}
		}

		return false;
	}

};

// Class
class WorldCollisionCallback : public CollisionCallback
{
	private:

		std::map<std::pair<const Collider*, const Collider*>, CollisionData> mCollisionDatas;

		std::pair<const Collider*, const Collider*> getCollisionKeyPair(std::pair<const Collider*, const Collider*> 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 areCollidersColliding(const Collider* collider1, const Collider* collider2) {
            return mCollisionDatas.find(getCollisionKeyPair(std::make_pair(collider1, collider2))) != mCollisionDatas.end();
		}

        const CollisionData* getCollisionData(const Collider* collider1, const Collider* collider2) const {
            std::map<std::pair<const Collider*, const Collider*>, CollisionData>::const_iterator it = mCollisionDatas.find(getCollisionKeyPair(std::make_pair(collider1, collider2)));
			if (it != mCollisionDatas.end()) {
					return &(it->second);
			}
			else {
				return nullptr;
			}
		}

        // This method is called when some contacts occur
        virtual void onContact(const CallbackData& callbackData) override {

            CollisionData collisionData;

            // For each contact pair
            for (uint p=0; p < callbackData.getNbContactPairs(); p++) {

                ContactPairData contactPairData;
                ContactPair contactPair = callbackData.getContactPair(p);

                collisionData.bodies = std::make_pair(contactPair.getBody1(), contactPair.getBody2());
                collisionData.colliders = std::make_pair(contactPair.getCollider1(), contactPair.getCollider2());

                // For each contact point
                for (uint c=0; c < contactPair.getNbContactPoints(); c++) {

                    ContactPoint contactPoint = contactPair.getContactPoint(c);

                    CollisionPointData collisionPoint(contactPoint.getLocalPointOnShape1(), contactPoint.getLocalPointOnShape2(), contactPoint.getPenetrationDepth());
                    contactPairData.contactPoints.push_back(collisionPoint);
                }

                collisionData.contactPairs.push_back(contactPairData);
            }

            mCollisionDatas.insert(std::make_pair(getCollisionKeyPair(collisionData.colliders), collisionData));
        }
};

/// Overlap callback
class WorldOverlapCallback : public OverlapCallback {

	private:

        std::vector<std::pair<CollisionBody*, CollisionBody*>> mOverlapBodies;

	public:

		/// Destructor
        virtual ~WorldOverlapCallback() override {
			reset();
		}

		/// This method will be called for each reported overlapping bodies
        virtual void onOverlap(CallbackData& callbackData) override {

            // For each overlapping pair
            for (uint i=0; i < callbackData.getNbOverlappingPairs(); i++) {

                OverlapPair overlapPair = callbackData.getOverlappingPair(i);
                mOverlapBodies.push_back(std::make_pair(overlapPair.getBody1(), overlapPair.getBody2()));
            }
		}

		void reset() {
			mOverlapBodies.clear();
		}

        bool hasOverlapWithBody(CollisionBody* collisionBody) const {

            for (uint i=0; i < mOverlapBodies.size(); i++) {

                if (mOverlapBodies[i].first == collisionBody || mOverlapBodies[i].second == collisionBody) {
                    return true;
                }
            }

            return false;
		}
};

// Class TestCollisionWorld
/**
 * Unit test for the CollisionWorld class.
 */
class TestCollisionWorld : public Test {

    private :

        // ---------- Atributes ---------- //

        PhysicsCommon mPhysicsCommon;

        // Physics world
        PhysicsWorld* 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;

        // Colliders
        Collider* mBoxCollider1;
        Collider* mBoxCollider2;
        Collider* mSphereCollider1;
        Collider* mSphereCollider2;
        Collider* mCapsuleCollider1;
        Collider* mCapsuleCollider2;
        Collider* mConvexMeshCollider1;
        Collider* mConvexMeshCollider2;
        Collider* mConcaveMeshCollider;

		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 = mPhysicsCommon.createPhysicsWorld();

            // ---------- Boxes ---------- //
            Transform boxTransform1(Vector3(-20, 20, 0), Quaternion::identity());
            mBoxBody1 = mWorld->createCollisionBody(boxTransform1);
            mBoxShape1 = mPhysicsCommon.createBoxShape(Vector3(3, 3, 3));
            mBoxCollider1 = mBoxBody1->addCollider(mBoxShape1, Transform::identity());

			Transform boxTransform2(Vector3(-10, 20, 0), Quaternion::identity());
			mBoxBody2 = mWorld->createCollisionBody(boxTransform2);
            mBoxShape2 = mPhysicsCommon.createBoxShape(Vector3(4, 2, 8));
            mBoxCollider2 = mBoxBody2->addCollider(mBoxShape2, Transform::identity());

			// ---------- Spheres ---------- //
            mSphereShape1 = mPhysicsCommon.createSphereShape(3.0);
            Transform sphereTransform1(Vector3(10, 20, 0), Quaternion::identity());
            mSphereBody1 = mWorld->createCollisionBody(sphereTransform1);
            mSphereCollider1 = mSphereBody1->addCollider(mSphereShape1, Transform::identity());

            mSphereShape2 = mPhysicsCommon.createSphereShape(5.0);
			Transform sphereTransform2(Vector3(20, 20, 0), Quaternion::identity());
			mSphereBody2 = mWorld->createCollisionBody(sphereTransform2);
            mSphereCollider2 = mSphereBody2->addCollider(mSphereShape2, Transform::identity());

			// ---------- Capsules ---------- //
            mCapsuleShape1 = mPhysicsCommon.createCapsuleShape(2, 6);
            Transform capsuleTransform1(Vector3(-10, 0, 0), Quaternion::identity());
            mCapsuleBody1 = mWorld->createCollisionBody(capsuleTransform1);
            mCapsuleCollider1 = mCapsuleBody1->addCollider(mCapsuleShape1, Transform::identity());

            mCapsuleShape2 = mPhysicsCommon.createCapsuleShape(3, 4);
			Transform capsuleTransform2(Vector3(-20, 0, 0), Quaternion::identity());
			mCapsuleBody2 = mWorld->createCollisionBody(capsuleTransform2);
            mCapsuleCollider2 = mCapsuleBody2->addCollider(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 = mPhysicsCommon.createPolyhedronMesh(mConvexMesh1PolygonVertexArray);
            mConvexMeshShape1 = mPhysicsCommon.createConvexMeshShape(mConvexMesh1PolyhedronMesh);
            Transform convexMeshTransform1(Vector3(10, 0, 0), Quaternion::identity());
            mConvexMeshBody1 = mWorld->createCollisionBody(convexMeshTransform1);
            mConvexMeshCollider1 = mConvexMeshBody1->addCollider(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 = mPhysicsCommon.createPolyhedronMesh(mConvexMesh2PolygonVertexArray);
            mConvexMeshShape2 = mPhysicsCommon.createConvexMeshShape(mConvexMesh2PolyhedronMesh);
            Transform convexMeshTransform2(Vector3(20, 0, 0), Quaternion::identity());
            mConvexMeshBody2 = mWorld->createCollisionBody(convexMeshTransform2);
            mConvexMeshCollider2 = mConvexMeshBody2->addCollider(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 = mPhysicsCommon.createTriangleMesh();
            mConcaveTriangleMesh->addSubpart(mConcaveMeshTriangleVertexArray);
            mConcaveMeshShape = mPhysicsCommon.createConcaveMeshShape(mConcaveTriangleMesh);
            mConcaveMeshBody = mWorld->createCollisionBody(concaveMeshTransform);
            mConcaveMeshCollider = mConcaveMeshBody->addCollider(mConcaveMeshShape, rp3d::Transform::identity());
        }

        /// Destructor
        virtual ~TestCollisionWorld() {

            mPhysicsCommon.destroyPhysicsWorld(mWorld);

            mPhysicsCommon.destroyBoxShape(mBoxShape1);
            mPhysicsCommon.destroyBoxShape(mBoxShape2);

            mPhysicsCommon.destroySphereShape(mSphereShape1);
            mPhysicsCommon.destroySphereShape(mSphereShape2);

            mPhysicsCommon.destroyCapsuleShape(mCapsuleShape1);
            mPhysicsCommon.destroyCapsuleShape(mCapsuleShape2);

            mPhysicsCommon.destroyConvexMeshShape(mConvexMeshShape1);
            mPhysicsCommon.destroyConvexMeshShape(mConvexMeshShape2);

            mPhysicsCommon.destroyPolyhedronMesh(mConvexMesh1PolyhedronMesh);
            mPhysicsCommon.destroyPolyhedronMesh(mConvexMesh2PolyhedronMesh);

			delete mConvexMesh1PolygonVertexArray;
			delete mConvexMesh2PolygonVertexArray;
            delete[] mConvexMeshPolygonFaces;

            mPhysicsCommon.destroyConcaveMeshShape(mConcaveMeshShape);

            mPhysicsCommon.destroyTriangleMesh(mConcaveTriangleMesh);

            delete mConcaveMeshTriangleVertexArray;

        }

        /// Run the tests
        void run() {

			testNoCollisions();
			testNoOverlap();

			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);
            rp3d_test(!mCollisionCallback.hasContacts());

			// ---------- Single body test ---------- //

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody2, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody2, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			// Two bodies test

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mBoxBody2, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mSphereBody2, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mSphereBody1, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mSphereBody2, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody2, mSphereBody1, mCollisionCallback);
            rp3d_test(!mCollisionCallback.hasContacts());

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody2, mSphereBody2, mCollisionCallback);
            rp3d_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);
            rp3d_test(!mOverlapCallback.hasOverlapWithBody(mBoxBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody2, mOverlapCallback);
            rp3d_test(!mOverlapCallback.hasOverlapWithBody(mBoxBody2));

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(!mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody2, mOverlapCallback);
            rp3d_test(!mOverlapCallback.hasOverlapWithBody(mSphereBody2));

			// Two bodies test

            rp3d_test(!mWorld->testOverlap(mBoxBody1, mBoxBody2));
            rp3d_test(!mWorld->testOverlap(mSphereBody1, mSphereBody2));
            rp3d_test(!mWorld->testOverlap(mBoxBody1, mSphereBody1));
            rp3d_test(!mWorld->testOverlap(mBoxBody1, mSphereBody2));
            rp3d_test(!mWorld->testOverlap(mBoxBody2, mSphereBody1));
            rp3d_test(!mWorld->testOverlap(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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody2, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody2));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mSphereCollider2));

			// Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mSphereCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
			Vector3 localBody1Point(3, 0, 0);
			Vector3 localBody2Point = transform2.getInverse() * Vector3(12, 20, 50);
			decimal penetrationDepth = 1.0f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
												         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
													     penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mSphereCollider2));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mSphereCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
														 swappedBodiesCollisionData ? localBody1Point : localBody2Point,
														 penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody2, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mSphereCollider2));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mSphereCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mSphereCollider2));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mSphereCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mBoxBody1));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
			Vector3 localBody1Point(3, 0, 0);
			Vector3 localBody2Point(-3, 0, 0);
			decimal penetrationDepth = 2.0f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
												         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
													     penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
														 swappedBodiesCollisionData ? localBody1Point : localBody2Point,
														 penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mBoxBody1));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
			localBody1Point = std::sqrt(4.5f) * Vector3(1, -1, 0);
			localBody2Point = Vector3(-3, 3, 0);
			penetrationDepth = decimal(3.0) - std::sqrt(2);
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
												         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
													     penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
														 swappedBodiesCollisionData ? localBody1Point : localBody2Point,
														 penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mBoxBody1));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// 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);
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
												         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
													     penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
														 swappedBodiesCollisionData ? localBody1Point : localBody2Point,
														 penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mBoxCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mBoxCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody1));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mCapsuleCollider1));

			// Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
			Vector3 localBody1Point(0, -3, 0);
			Vector3 localBody2Point(0, 5, 0);
			decimal penetrationDepth = 2.0f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
				swappedBodiesCollisionData ? localBody1Point : localBody2Point,
				penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mCapsuleCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
				swappedBodiesCollisionData ? localBody1Point : localBody2Point,
				penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mCapsuleCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mCapsuleCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody1));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mCapsuleCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
			localBody1Point = Vector3(3, 0, 0);
			localBody2Point = Vector3(-2, 1, 0);
			penetrationDepth = decimal(1.0);
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
				swappedBodiesCollisionData ? localBody1Point : localBody2Point,
				penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mCapsuleCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
				swappedBodiesCollisionData ? localBody1Point : localBody2Point,
				penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mCapsuleCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mCapsuleCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mConvexMeshBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConvexMeshBody1));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
			Vector3 localBody1Point(3, 0, 0);
			Vector3 localBody2Point(-3, 0, 0);
			decimal penetrationDepth = 2.0f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
												         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
													     penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
														 swappedBodiesCollisionData ? localBody1Point : localBody2Point,
														 penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mConvexMeshBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConvexMeshBody1));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
			localBody1Point = std::sqrt(4.5f) * Vector3(1, -1, 0);
			localBody2Point = Vector3(-3, 3, 0);
			penetrationDepth = decimal(3.0) - std::sqrt(2);
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
												         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
													     penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
														 swappedBodiesCollisionData ? localBody1Point : localBody2Point,
														 penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

			mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

			mOverlapCallback.reset();
            mWorld->testOverlap(mConvexMeshBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConvexMeshBody1));

			// ----- Test global collision test ----- // 

			mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// 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);
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
												         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
													     penetrationDepth));

			// ----- Test collision against body 1 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
														 swappedBodiesCollisionData ? localBody1Point : localBody2Point,
														 penetrationDepth));

			// ----- Test collision against body 2 only ----- //

			mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConvexMeshCollider1));

			// Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConvexMeshCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

			// True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

			// Test contact points
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mSphereBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mSphereBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mConcaveMeshBody, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConcaveMeshBody));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConcaveMeshCollider));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

            // Test contact points
            Vector3 localBody1Point(0, -3, 0);
            Vector3 localBody2Point(0, 0, 0);
            decimal penetrationDepth = 0.02f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                                                         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                                                         penetrationDepth));

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mSphereBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                                                         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                                                         penetrationDepth));

            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConcaveMeshBody, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

            // Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mSphereCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mSphereCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mSphereBody1->getEntity();

            // Test contact points
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mBoxBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody2, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mBoxBody2));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mBoxCollider2));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mBoxCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            Vector3 localBody1Point1(-3, -2, -2);
            Vector3 localBody2Point1(4, 2, 8);
            decimal penetrationDepth1 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            Vector3 localBody1Point2(-3, -2, -3);
            Vector3 localBody2Point2(4, 2, 7);
            decimal penetrationDepth2 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            Vector3 localBody1Point3(-3, -3, -2);
            Vector3 localBody2Point3(4, 1, 8);
            decimal penetrationDepth3 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            Vector3 localBody1Point4(-3, -3, -3);
            Vector3 localBody2Point4(4, 1, 7);
            decimal penetrationDepth4 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
                                                         swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
                                                         penetrationDepth4));

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mBoxCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mBoxCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
                                                         swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
                                                         penetrationDepth4));
            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody2, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mBoxCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mBoxCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mBoxCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mBoxCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mBoxBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mConvexMeshBody2, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConvexMeshBody2));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mConvexMeshCollider2));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mConvexMeshCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            Vector3 localBody1Point1(-3, -2, -2);
            Vector3 localBody2Point1(4, 2, 8);
            decimal penetrationDepth1 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            Vector3 localBody1Point2(-3, -2, -3);
            Vector3 localBody2Point2(4, 2, 7);
            decimal penetrationDepth2 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            Vector3 localBody1Point3(-3, -3, -2);
            Vector3 localBody2Point3(4, 1, 8);
            decimal penetrationDepth3 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            Vector3 localBody1Point4(-3, -3, -3);
            Vector3 localBody2Point4(4, 1, 7);
            decimal penetrationDepth4 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
                                                         swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
                                                         penetrationDepth4));

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mConvexMeshCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mConvexMeshCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
                                                         swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
                                                         penetrationDepth4));
            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody2, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mConvexMeshCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mConvexMeshCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mConvexMeshCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mConvexMeshCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mConvexMeshBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConvexMeshBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mConvexMeshBody2, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConvexMeshBody2));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mConvexMeshCollider2));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mConvexMeshCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mConvexMeshBody1->getEntity();

            // Test contact points
            Vector3 localBody1Point1(-3, -2, -2);
            Vector3 localBody2Point1(4, 2, 8);
            decimal penetrationDepth1 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            Vector3 localBody1Point2(-3, -2, -3);
            Vector3 localBody2Point2(4, 2, 7);
            decimal penetrationDepth2 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            Vector3 localBody1Point3(-3, -3, -2);
            Vector3 localBody2Point3(4, 1, 8);
            decimal penetrationDepth3 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            Vector3 localBody1Point4(-3, -3, -3);
            Vector3 localBody2Point4(4, 1, 7);
            decimal penetrationDepth4 = 0.5f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
                                                         swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
                                                         penetrationDepth4));

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mConvexMeshCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mConvexMeshCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mConvexMeshBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point4 : localBody1Point4,
                                                         swappedBodiesCollisionData ? localBody1Point4 : localBody2Point4,
                                                         penetrationDepth4));
            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody2, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mConvexMeshCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mConvexMeshCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mConvexMeshBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mConvexMeshCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mConvexMeshCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mConvexMeshBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point2 : localBody1Point2,
                                                         swappedBodiesCollisionData ? localBody1Point2 : localBody2Point2,
                                                         penetrationDepth2));
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point3 : localBody1Point3,
                                                         swappedBodiesCollisionData ? localBody1Point3 : localBody2Point3,
                                                         penetrationDepth3));
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mBoxBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody1));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mCapsuleCollider1));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            Vector3 localBody1Point1(3, 1, 0);
            Vector3 localBody2Point1(0, 5, 0);
            decimal penetrationDepth1 = 1.0f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mCapsuleCollider1));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));

            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mCapsuleCollider1));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mCapsuleCollider1));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mBoxBody1->getEntity();

            // Test contact points
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mConvexMeshBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConvexMeshBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody1));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mCapsuleCollider1));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mConvexMeshBody1->getEntity();

            // Test contact points
            Vector3 localBody1Point1(3, 1, 0);
            Vector3 localBody2Point1(0, 5, 0);
            decimal penetrationDepth1 = 1.0f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));
            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mCapsuleCollider1));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mConvexMeshBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point1 : localBody1Point1,
                                                         swappedBodiesCollisionData ? localBody1Point1 : localBody2Point1,
                                                         penetrationDepth1));

            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mCapsuleCollider1));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mConvexMeshBody1->getEntity();

            // Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mCapsuleCollider1));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mCapsuleCollider1);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mConvexMeshBody1->getEntity();

            // Test contact points
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mBoxBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mBoxBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mConcaveMeshBody, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConcaveMeshBody));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mConcaveMeshCollider));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            for (size_t i=0; i<collisionData->contactPairs[0].contactPoints.size(); i++) {
                rp3d_test(approxEqual(collisionData->contactPairs[0].contactPoints[i].penetrationDepth, 1.0f));
            }

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            for (size_t i=0; i<collisionData->contactPairs[0].contactPoints.size(); i++) {
                rp3d_test(approxEqual(collisionData->contactPairs[0].contactPoints[i].penetrationDepth, 1.0f));
            }

            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConcaveMeshBody, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            for (size_t i=0; i<collisionData->contactPairs[0].contactPoints.size(); i++) {
                rp3d_test(approxEqual(collisionData->contactPairs[0].contactPoints[i].penetrationDepth, 1.0f));
            }

            // ----- Test collision against selected body 1 and 2 ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mBoxBody1, mConcaveMeshBody, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mBoxCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mBoxCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // Test contact points
            for (size_t i=0; i<collisionData->contactPairs[0].contactPoints.size(); i++) {
                rp3d_test(approxEqual(collisionData->contactPairs[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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mConvexMeshBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConvexMeshBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mConcaveMeshBody, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConcaveMeshBody));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mConcaveMeshCollider));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            for (size_t i=0; i<collisionData->contactPairs[0].contactPoints.size(); i++) {
                rp3d_test(approxEqual(collisionData->contactPairs[0].contactPoints[i].penetrationDepth, 1.0f));
            }

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            for (size_t i=0; i<collisionData->contactPairs[0].contactPoints.size(); i++) {
                rp3d_test(approxEqual(collisionData->contactPairs[0].contactPoints[i].penetrationDepth, 1.0f));
            }

            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConcaveMeshBody, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            for (size_t i=0; i<collisionData->contactPairs[0].contactPoints.size(); i++) {
                rp3d_test(approxEqual(collisionData->contactPairs[0].contactPoints[i].penetrationDepth, 1.0f));
            }

            // ----- Test collision against selected body 1 and 2 ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConvexMeshBody1, mConcaveMeshBody, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mConvexMeshCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mConvexMeshCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 4);

            // Test contact points
            for (size_t i=0; i<collisionData->contactPairs[0].contactPoints.size(); i++) {
                rp3d_test(approxEqual(collisionData->contactPairs[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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody2, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody2));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mCapsuleCollider2));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mCapsuleCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            Vector3 localBody1Point(2, 3, 0);
            Vector3 localBody2Point(0, 5, 0);
            decimal penetrationDepth = 1.0f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                penetrationDepth));

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mCapsuleCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mCapsuleCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                penetrationDepth));

            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody2, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mCapsuleCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mCapsuleCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mCapsuleCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mCapsuleCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody2, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody2));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mCapsuleCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mCapsuleCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            localBody1Point = Vector3(0, 5, 0);
            localBody2Point = Vector3(-3, 0, 0);
            penetrationDepth = decimal(1.0);
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                penetrationDepth));

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mCapsuleCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mCapsuleCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                penetrationDepth));

            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody2, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mCapsuleCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mCapsuleCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mCapsuleCollider2));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mCapsuleCollider2);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_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);

            mOverlapCallback.reset();
            mWorld->testOverlap(mCapsuleBody1, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mCapsuleBody1));

            mOverlapCallback.reset();
            mWorld->testOverlap(mConcaveMeshBody, mOverlapCallback);
            rp3d_test(mOverlapCallback.hasOverlapWithBody(mConcaveMeshBody));

            // ----- Test global collision test ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mConcaveMeshCollider));

            // Get collision data
            const CollisionData* collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            bool swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            Vector3 localBody1Point(0, -5, 0);
            Vector3 localBody2Point(0, 0, 0);
            decimal penetrationDepth = 0.02f;
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                                                         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                                                         penetrationDepth));

            // ----- Test collision against body 1 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mCapsuleBody1, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                                                         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                                                         penetrationDepth));

            // ----- Test collision against body 2 only ----- //

            mCollisionCallback.reset();
            mWorld->testCollision(mConcaveMeshBody, mCollisionCallback);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_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);

            rp3d_test(mCollisionCallback.areCollidersColliding(mCapsuleCollider1, mConcaveMeshCollider));

            // Get collision data
            collisionData = mCollisionCallback.getCollisionData(mCapsuleCollider1, mConcaveMeshCollider);
            rp3d_test(collisionData != nullptr);
            rp3d_test(collisionData->getNbContactPairs() == 1);
            rp3d_test(collisionData->getTotalNbContactPoints() == 1);

            // True if the bodies are swapped in the collision callback response
            swappedBodiesCollisionData = collisionData->getBody1()->getEntity() != mCapsuleBody1->getEntity();

            // Test contact points
            rp3d_test(collisionData->hasContactPointSimilarTo(swappedBodiesCollisionData ? localBody2Point : localBody1Point,
                                                         swappedBodiesCollisionData ? localBody1Point : localBody2Point,
                                                         penetrationDepth));

            // Reset the init transforms
            mCapsuleBody1->setTransform(initTransform1);
            mConcaveMeshBody->setTransform(initTransform2);
        }
 };

}

#endif