Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-09 01:17:14 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

add shapeVsList etc to dispatch table

Browse source 
renamed some functions for more readability
This commit is contained in:
Andrew Meadows 2014-08-22 11:20:53 -07:00
parent 3ebd8c1969
commit 1be922f986
3 changed files with 70 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

187
libraries/shared/src/ShapeCollider.cpp
View file

@ -50,27 +50,27 @@ void initDispatchTable() {
// NOTE: no need to update any that are notImplemented, but we leave them // NOTE: no need to update any that are notImplemented, but we leave them
// commented out in the code so that we remember that they exist. // commented out in the code so that we remember that they exist.
dispatchTable[getDispatchKey(SPHERE_SHAPE, SPHERE_SHAPE)] = &sphereSphere; dispatchTable[getDispatchKey(SPHERE_SHAPE, SPHERE_SHAPE)] = &sphereVsSphere;
dispatchTable[getDispatchKey(SPHERE_SHAPE, CAPSULE_SHAPE)] = &sphereCapsule; dispatchTable[getDispatchKey(SPHERE_SHAPE, CAPSULE_SHAPE)] = &sphereVsCapsule;
dispatchTable[getDispatchKey(SPHERE_SHAPE, PLANE_SHAPE)] = &spherePlane; dispatchTable[getDispatchKey(SPHERE_SHAPE, PLANE_SHAPE)] = &sphereVsPlane;
//dispatchTable[getDispatchKey(SPHERE_SHAPE, LIST_SHAPE)] = &notImplemented; dispatchTable[getDispatchKey(SPHERE_SHAPE, LIST_SHAPE)] = &shapeVsList;
dispatchTable[getDispatchKey(CAPSULE_SHAPE, SPHERE_SHAPE)] = &capsuleSphere; dispatchTable[getDispatchKey(CAPSULE_SHAPE, SPHERE_SHAPE)] = &capsuleVsSphere;
dispatchTable[getDispatchKey(CAPSULE_SHAPE, CAPSULE_SHAPE)] = &capsuleCapsule; dispatchTable[getDispatchKey(CAPSULE_SHAPE, CAPSULE_SHAPE)] = &capsuleVsCapsule;
dispatchTable[getDispatchKey(CAPSULE_SHAPE, PLANE_SHAPE)] = &capsulePlane; dispatchTable[getDispatchKey(CAPSULE_SHAPE, PLANE_SHAPE)] = &capsuleVsPlane;
//dispatchTable[getDispatchKey(CAPSULE_SHAPE, LIST_SHAPE)] = &notImplemented; dispatchTable[getDispatchKey(CAPSULE_SHAPE, LIST_SHAPE)] = &shapeVsList;
dispatchTable[getDispatchKey(PLANE_SHAPE, SPHERE_SHAPE)] = &planeSphere; dispatchTable[getDispatchKey(PLANE_SHAPE, SPHERE_SHAPE)] = &planeVsSphere;
dispatchTable[getDispatchKey(PLANE_SHAPE, CAPSULE_SHAPE)] = &planeCapsule; dispatchTable[getDispatchKey(PLANE_SHAPE, CAPSULE_SHAPE)] = &planeVsCapsule;
dispatchTable[getDispatchKey(PLANE_SHAPE, PLANE_SHAPE)] = &planePlane; dispatchTable[getDispatchKey(PLANE_SHAPE, PLANE_SHAPE)] = &planeVsPlane;
//dispatchTable[getDispatchKey(PLANE_SHAPE, LIST_SHAPE)] = &notImplemented; dispatchTable[getDispatchKey(PLANE_SHAPE, LIST_SHAPE)] = &shapeVsList;
//dispatchTable[getDispatchKey(LIST_SHAPE, SPHERE_SHAPE)] = &notImplemented; dispatchTable[getDispatchKey(LIST_SHAPE, SPHERE_SHAPE)] = &listVsShape;
//dispatchTable[getDispatchKey(LIST_SHAPE, CAPSULE_SHAPE)] = &notImplemented; dispatchTable[getDispatchKey(LIST_SHAPE, CAPSULE_SHAPE)] = &listVsShape;
//dispatchTable[getDispatchKey(LIST_SHAPE, PLANE_SHAPE)] = &notImplemented; dispatchTable[getDispatchKey(LIST_SHAPE, PLANE_SHAPE)] = &listVsShape;
//dispatchTable[getDispatchKey(LIST_SHAPE, LIST_SHAPE)] = &notImplemented; dispatchTable[getDispatchKey(LIST_SHAPE, LIST_SHAPE)] = &listVsList;
// all of the UNKNOWN_SHAPE pairings point at notImplemented // all of the UNKNOWN_SHAPE pairings are notImplemented
} }
bool collideShapes(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool collideShapes(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
@ -79,31 +79,6 @@ bool collideShapes(const Shape* shapeA, const Shape* shapeB, CollisionList& coll
static CollisionList tempCollisions(32); static CollisionList tempCollisions(32);
bool collideShapesCoarse(const QVector<const Shape*>& shapesA, const QVector<const Shape*>& shapesB, CollisionInfo& collision) {
tempCollisions.clear();
foreach (const Shape* shapeA, shapesA) {
foreach (const Shape* shapeB, shapesB) {
collideShapes(shapeA, shapeB, tempCollisions);
}
}
if (tempCollisions.size() > 0) {
glm::vec3 totalPenetration(0.0f);
glm::vec3 averageContactPoint(0.0f);
for (int j = 0; j < tempCollisions.size(); ++j) {
CollisionInfo* c = tempCollisions.getCollision(j);
totalPenetration = addPenetrations(totalPenetration, c->_penetration);
averageContactPoint += c->_contactPoint;
}
collision._penetration = totalPenetration;
collision._contactPoint = averageContactPoint / (float)(tempCollisions.size());
// there are no valid shape pointers for this collision so we set them NULL
collision._shapeA = NULL;
collision._shapeB = NULL;
return true;
}
return false;
}
bool collideShapeWithShapes(const Shape* shapeA, const QVector<Shape*>& shapes, int startIndex, CollisionList& collisions) { bool collideShapeWithShapes(const Shape* shapeA, const QVector<Shape*>& shapes, int startIndex, CollisionList& collisions) {
bool collided = false; bool collided = false;
if (shapeA) { if (shapeA) {
@ -145,9 +120,9 @@ bool collideShapesWithShapes(const QVector<Shape*>& shapesA, const QVector<Shape
bool collideShapeWithAACube(const Shape* shapeA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions) { bool collideShapeWithAACube(const Shape* shapeA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions) {
Shape::Type typeA = shapeA->getType(); Shape::Type typeA = shapeA->getType();
if (typeA == SPHERE_SHAPE) { if (typeA == SPHERE_SHAPE) {
return sphereAACube(static_cast<const SphereShape*>(shapeA), cubeCenter, cubeSide, collisions); return sphereVsAACube(static_cast<const SphereShape*>(shapeA), cubeCenter, cubeSide, collisions);
} else if (typeA == CAPSULE_SHAPE) { } else if (typeA == CAPSULE_SHAPE) {
return capsuleAACube(static_cast<const CapsuleShape*>(shapeA), cubeCenter, cubeSide, collisions); return capsuleVsAACube(static_cast<const CapsuleShape*>(shapeA), cubeCenter, cubeSide, collisions);
} else if (typeA == LIST_SHAPE) { } else if (typeA == LIST_SHAPE) {
const ListShape* listA = static_cast<const ListShape*>(shapeA); const ListShape* listA = static_cast<const ListShape*>(shapeA);
bool touching = false; bool touching = false;
@ -155,9 +130,9 @@ bool collideShapeWithAACube(const Shape* shapeA, const glm::vec3& cubeCenter, fl
const Shape* subShape = listA->getSubShape(i); const Shape* subShape = listA->getSubShape(i);
int subType = subShape->getType(); int subType = subShape->getType();
if (subType == SPHERE_SHAPE) { if (subType == SPHERE_SHAPE) {
touching = sphereAACube(static_cast<const SphereShape*>(subShape), cubeCenter, cubeSide, collisions) || touching; touching = sphereVsAACube(static_cast<const SphereShape*>(subShape), cubeCenter, cubeSide, collisions) || touching;
} else if (subType == CAPSULE_SHAPE) { } else if (subType == CAPSULE_SHAPE) {
touching = capsuleAACube(static_cast<const CapsuleShape*>(subShape), cubeCenter, cubeSide, collisions) || touching; touching = capsuleVsAACube(static_cast<const CapsuleShape*>(subShape), cubeCenter, cubeSide, collisions) || touching;
} }
} }
return touching; return touching;
@ -165,7 +140,7 @@ bool collideShapeWithAACube(const Shape* shapeA, const glm::vec3& cubeCenter, fl
return false; return false;
} }
bool sphereSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool sphereVsSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
const SphereShape* sphereA = static_cast<const SphereShape*>(shapeA); const SphereShape* sphereA = static_cast<const SphereShape*>(shapeA);
const SphereShape* sphereB = static_cast<const SphereShape*>(shapeB); const SphereShape* sphereB = static_cast<const SphereShape*>(shapeB);
glm::vec3 BA = sphereB->getTranslation() - sphereA->getTranslation(); glm::vec3 BA = sphereB->getTranslation() - sphereA->getTranslation();
@ -195,7 +170,7 @@ bool sphereSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& colli
return false; return false;
} }
bool sphereCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool sphereVsCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
const SphereShape* sphereA = static_cast<const SphereShape*>(shapeA); const SphereShape* sphereA = static_cast<const SphereShape*>(shapeA);
const CapsuleShape* capsuleB = static_cast<const CapsuleShape*>(shapeB); const CapsuleShape* capsuleB = static_cast<const CapsuleShape*>(shapeB);
// find sphereA's closest approach to axis of capsuleB // find sphereA's closest approach to axis of capsuleB
@ -266,7 +241,7 @@ bool sphereCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& coll
return false; return false;
} }
bool spherePlane(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool sphereVsPlane(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
const SphereShape* sphereA = static_cast<const SphereShape*>(shapeA); const SphereShape* sphereA = static_cast<const SphereShape*>(shapeA);
const PlaneShape* planeB = static_cast<const PlaneShape*>(shapeB); const PlaneShape* planeB = static_cast<const PlaneShape*>(shapeB);
glm::vec3 penetration; glm::vec3 penetration;
@ -284,7 +259,7 @@ bool spherePlane(const Shape* shapeA, const Shape* shapeB, CollisionList& collis
return false; return false;
} }
bool capsuleSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool capsuleVsSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
const CapsuleShape* capsuleA = static_cast<const CapsuleShape*>(shapeA); const CapsuleShape* capsuleA = static_cast<const CapsuleShape*>(shapeA);
const SphereShape* sphereB = static_cast<const SphereShape*>(shapeB); const SphereShape* sphereB = static_cast<const SphereShape*>(shapeB);
// find sphereB's closest approach to axis of capsuleA // find sphereB's closest approach to axis of capsuleA
@ -427,7 +402,7 @@ bool lineCylinder(const glm::vec3& lineP, const glm::vec3& lineDir,
return true; return true;
} }
bool capsuleCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool capsuleVsCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
const CapsuleShape* capsuleA = static_cast<const CapsuleShape*>(shapeA); const CapsuleShape* capsuleA = static_cast<const CapsuleShape*>(shapeA);
const CapsuleShape* capsuleB = static_cast<const CapsuleShape*>(shapeB); const CapsuleShape* capsuleB = static_cast<const CapsuleShape*>(shapeB);
glm::vec3 axisA; glm::vec3 axisA;
@ -588,7 +563,7 @@ bool capsuleCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& col
return false; return false;
} }
bool capsulePlane(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool capsuleVsPlane(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
const CapsuleShape* capsuleA = static_cast<const CapsuleShape*>(shapeA); const CapsuleShape* capsuleA = static_cast<const CapsuleShape*>(shapeA);
const PlaneShape* planeB = static_cast<const PlaneShape*>(shapeB); const PlaneShape* planeB = static_cast<const PlaneShape*>(shapeB);
glm::vec3 start, end, penetration; glm::vec3 start, end, penetration;
@ -610,7 +585,7 @@ bool capsulePlane(const Shape* shapeA, const Shape* shapeB, CollisionList& colli
return false; return false;
} }
bool planeSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool planeVsSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
const PlaneShape* planeA = static_cast<const PlaneShape*>(shapeA); const PlaneShape* planeA = static_cast<const PlaneShape*>(shapeA);
const SphereShape* sphereB = static_cast<const SphereShape*>(shapeB); const SphereShape* sphereB = static_cast<const SphereShape*>(shapeB);
glm::vec3 penetration; glm::vec3 penetration;
@ -629,7 +604,7 @@ bool planeSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& collis
return false; return false;
} }
bool planeCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool planeVsCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
const PlaneShape* planeA = static_cast<const PlaneShape*>(shapeA); const PlaneShape* planeA = static_cast<const PlaneShape*>(shapeA);
const CapsuleShape* capsuleB = static_cast<const CapsuleShape*>(shapeB); const CapsuleShape* capsuleB = static_cast<const CapsuleShape*>(shapeB);
glm::vec3 start, end, penetration; glm::vec3 start, end, penetration;
@ -651,115 +626,33 @@ bool planeCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& colli
return false; return false;
} }
bool planePlane(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool planeVsPlane(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
// technically, planes always collide unless they're parallel and not coincident; however, that's // technically, planes always collide unless they're parallel and not coincident; however, that's
// not going to give us any useful information // not going to give us any useful information
return false; return false;
} }
bool sphereList(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool shapeVsList(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
bool touching = false; bool touching = false;
const ListShape* listB = static_cast<const ListShape*>(shapeB); const ListShape* listB = static_cast<const ListShape*>(shapeB);
for (int i = 0; i < listB->size() && !collisions.isFull(); ++i) { for (int i = 0; i < listB->size() && !collisions.isFull(); ++i) {
const Shape* subShape = listB->getSubShape(i); const Shape* subShape = listB->getSubShape(i);
int subType = subShape->getType(); touching = collideShapes(shapeA, subShape, collisions) || touching;
if (subType == SPHERE_SHAPE) {
touching = sphereSphere(shapeA, subShape, collisions) || touching;
} else if (subType == CAPSULE_SHAPE) {
touching = sphereCapsule(shapeA, subShape, collisions) || touching;
} else if (subType == PLANE_SHAPE) {
touching = spherePlane(shapeA, subShape, collisions) || touching;
}
} }
return touching; return touching;
} }
bool capsuleList(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool listVsShape(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
bool touching = false;
const ListShape* listB = static_cast<const ListShape*>(shapeB);
for (int i = 0; i < listB->size() && !collisions.isFull(); ++i) {
const Shape* subShape = listB->getSubShape(i);
int subType = subShape->getType();
if (subType == SPHERE_SHAPE) {
touching = capsuleSphere(shapeA, subShape, collisions) || touching;
} else if (subType == CAPSULE_SHAPE) {
touching = capsuleCapsule(shapeA, subShape, collisions) || touching;
} else if (subType == PLANE_SHAPE) {
touching = capsulePlane(shapeA, subShape, collisions) || touching;
}
}
return touching;
}
bool planeList(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
bool touching = false;
const ListShape* listB = static_cast<const ListShape*>(shapeB);
for (int i = 0; i < listB->size() && !collisions.isFull(); ++i) {
const Shape* subShape = listB->getSubShape(i);
int subType = subShape->getType();
if (subType == SPHERE_SHAPE) {
touching = planeSphere(shapeA, subShape, collisions) || touching;
} else if (subType == CAPSULE_SHAPE) {
touching = planeCapsule(shapeA, subShape, collisions) || touching;
} else if (subType == PLANE_SHAPE) {
touching = planePlane(shapeA, subShape, collisions) || touching;
}
}
return touching;
}
bool listSphere(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
bool touching = false; bool touching = false;
const ListShape* listA = static_cast<const ListShape*>(shapeA); const ListShape* listA = static_cast<const ListShape*>(shapeA);
for (int i = 0; i < listA->size() && !collisions.isFull(); ++i) { for (int i = 0; i < listA->size() && !collisions.isFull(); ++i) {
const Shape* subShape = listA->getSubShape(i); const Shape* subShape = listA->getSubShape(i);
int subType = subShape->getType(); touching = collideShapes(subShape, shapeB, collisions) || touching;
if (subType == SPHERE_SHAPE) {
touching = sphereSphere(subShape, shapeB, collisions) || touching;
} else if (subType == CAPSULE_SHAPE) {
touching = capsuleSphere(subShape, shapeB, collisions) || touching;
} else if (subType == PLANE_SHAPE) {
touching = planeSphere(subShape, shapeB, collisions) || touching;
}
} }
return touching; return touching;
} }
bool listCapsule(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) { bool listVsList(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
bool touching = false;
const ListShape* listA = static_cast<const ListShape*>(shapeA);
for (int i = 0; i < listA->size() && !collisions.isFull(); ++i) {
const Shape* subShape = listA->getSubShape(i);
int subType = subShape->getType();
if (subType == SPHERE_SHAPE) {
touching = sphereCapsule(subShape, shapeB, collisions) || touching;
} else if (subType == CAPSULE_SHAPE) {
touching = capsuleCapsule(subShape, shapeB, collisions) || touching;
} else if (subType == PLANE_SHAPE) {
touching = planeCapsule(subShape, shapeB, collisions) || touching;
}
}
return touching;
}
bool listPlane(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
bool touching = false;
const ListShape* listA = static_cast<const ListShape*>(shapeA);
for (int i = 0; i < listA->size() && !collisions.isFull(); ++i) {
const Shape* subShape = listA->getSubShape(i);
int subType = subShape->getType();
if (subType == SPHERE_SHAPE) {
touching = spherePlane(subShape, shapeB, collisions) || touching;
} else if (subType == CAPSULE_SHAPE) {
touching = capsulePlane(subShape, shapeB, collisions) || touching;
} else if (subType == PLANE_SHAPE) {
touching = planePlane(subShape, shapeB, collisions) || touching;
}
}
return touching;
}
bool listList(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions) {
bool touching = false; bool touching = false;
const ListShape* listA = static_cast<const ListShape*>(shapeA); const ListShape* listA = static_cast<const ListShape*>(shapeA);
const ListShape* listB = static_cast<const ListShape*>(shapeB); const ListShape* listB = static_cast<const ListShape*>(shapeB);
@ -773,7 +666,7 @@ bool listList(const Shape* shapeA, const Shape* shapeB, CollisionList& collision
} }
// helper function // helper function
bool sphereAACube(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& cubeCenter, bool sphereVsAACube(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& cubeCenter,
float cubeSide, CollisionList& collisions) { float cubeSide, CollisionList& collisions) {
// sphere is A // sphere is A
// cube is B // cube is B
@ -921,11 +814,11 @@ bool sphereAACube_StarkAngles(const glm::vec3& sphereCenter, float sphereRadius,
} }
*/ */
bool sphereAACube(const SphereShape* sphereA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions) { bool sphereVsAACube(const SphereShape* sphereA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions) {
return sphereAACube(sphereA->getTranslation(), sphereA->getRadius(), cubeCenter, cubeSide, collisions); return sphereVsAACube(sphereA->getTranslation(), sphereA->getRadius(), cubeCenter, cubeSide, collisions);
} }
bool capsuleAACube(const CapsuleShape* capsuleA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions) { bool capsuleVsAACube(const CapsuleShape* capsuleA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions) {
// find nerest approach of capsule line segment to cube // find nerest approach of capsule line segment to cube
glm::vec3 capsuleAxis; glm::vec3 capsuleAxis;
capsuleA->computeNormalizedAxis(capsuleAxis); capsuleA->computeNormalizedAxis(capsuleAxis);
@ -938,7 +831,7 @@ bool capsuleAACube(const CapsuleShape* capsuleA, const glm::vec3& cubeCenter, fl
} }
glm::vec3 nearestApproach = capsuleA->getTranslation() + offset * capsuleAxis; glm::vec3 nearestApproach = capsuleA->getTranslation() + offset * capsuleAxis;
// collide nearest approach like a sphere at that point // collide nearest approach like a sphere at that point
return sphereAACube(nearestApproach, capsuleA->getRadius(), cubeCenter, cubeSide, collisions); return sphereVsAACube(nearestApproach, capsuleA->getRadius(), cubeCenter, cubeSide, collisions);
} }
bool findRayIntersectionWithShapes(const QVector<Shape*> shapes, const glm::vec3& rayStart, const glm::vec3& rayDirection, float& minDistance) { bool findRayIntersectionWithShapes(const QVector<Shape*> shapes, const glm::vec3& rayStart, const glm::vec3& rayDirection, float& minDistance) {

73
libraries/shared/src/ShapeCollider.h
View file

@ -35,13 +35,6 @@ namespace ShapeCollider {
/// \param collisions[out] collision details /// \param collisions[out] collision details
/// \return true if shapes collide /// \return true if shapes collide
bool collideShapes(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions); bool collideShapes(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions);
bool collideShapesOld(const Shape* shapeA, const Shape* shapeB, CollisionList& collisions);
/// \param shapesA list of shapes
/// \param shapeB list of shapes
/// \param collisions[out] average collision details
/// \return true if any shapes collide
bool collideShapesCoarse(const QVector<const Shape*>& shapesA, const QVector<const Shape*>& shapesB, CollisionInfo& collision);
bool collideShapeWithShapes(const Shape* shapeA, const QVector<Shape*>& shapes, int startIndex, CollisionList& collisions); bool collideShapeWithShapes(const Shape* shapeA, const QVector<Shape*>& shapes, int startIndex, CollisionList& collisions);
bool collideShapesWithShapes(const QVector<Shape*>& shapesA, const QVector<Shape*>& shapesB, CollisionList& collisions); bool collideShapesWithShapes(const QVector<Shape*>& shapesA, const QVector<Shape*>& shapesB, CollisionList& collisions);
@ -57,111 +50,87 @@ namespace ShapeCollider {
/// \param sphereB pointer to second shape (cannot be NULL) /// \param sphereB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool sphereSphere(const Shape* sphereA, const Shape* sphereB, CollisionList& collisions); bool sphereVsSphere(const Shape* sphereA, const Shape* sphereB, CollisionList& collisions);
/// \param sphereA pointer to first shape (cannot be NULL) /// \param sphereA pointer to first shape (cannot be NULL)
/// \param capsuleB pointer to second shape (cannot be NULL) /// \param capsuleB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool sphereCapsule(const Shape* sphereA, const Shape* capsuleB, CollisionList& collisions); bool sphereVsCapsule(const Shape* sphereA, const Shape* capsuleB, CollisionList& collisions);
/// \param sphereA pointer to first shape (cannot be NULL) /// \param sphereA pointer to first shape (cannot be NULL)
/// \param planeB pointer to second shape (cannot be NULL) /// \param planeB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool spherePlane(const Shape* sphereA, const Shape* planeB, CollisionList& collisions); bool sphereVsPlane(const Shape* sphereA, const Shape* planeB, CollisionList& collisions);
/// \param capsuleA pointer to first shape (cannot be NULL) /// \param capsuleA pointer to first shape (cannot be NULL)
/// \param sphereB pointer to second shape (cannot be NULL) /// \param sphereB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool capsuleSphere(const Shape* capsuleA, const Shape* sphereB, CollisionList& collisions); bool capsuleVsSphere(const Shape* capsuleA, const Shape* sphereB, CollisionList& collisions);
/// \param capsuleA pointer to first shape (cannot be NULL) /// \param capsuleA pointer to first shape (cannot be NULL)
/// \param capsuleB pointer to second shape (cannot be NULL) /// \param capsuleB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool capsuleCapsule(const Shape* capsuleA, const Shape* capsuleB, CollisionList& collisions); bool capsuleVsCapsule(const Shape* capsuleA, const Shape* capsuleB, CollisionList& collisions);
/// \param capsuleA pointer to first shape (cannot be NULL) /// \param capsuleA pointer to first shape (cannot be NULL)
/// \param planeB pointer to second shape (cannot be NULL) /// \param planeB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool capsulePlane(const Shape* capsuleA, const Shape* planeB, CollisionList& collisions); bool capsuleVsPlane(const Shape* capsuleA, const Shape* planeB, CollisionList& collisions);
/// \param planeA pointer to first shape (cannot be NULL) /// \param planeA pointer to first shape (cannot be NULL)
/// \param sphereB pointer to second shape (cannot be NULL) /// \param sphereB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool planeSphere(const Shape* planeA, const Shape* sphereB, CollisionList& collisions); bool planeVsSphere(const Shape* planeA, const Shape* sphereB, CollisionList& collisions);
/// \param planeA pointer to first shape (cannot be NULL) /// \param planeA pointer to first shape (cannot be NULL)
/// \param capsuleB pointer to second shape (cannot be NULL) /// \param capsuleB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool planeCapsule(const Shape* planeA, const Shape* capsuleB, CollisionList& collisions); bool planeVsCapsule(const Shape* planeA, const Shape* capsuleB, CollisionList& collisions);
/// \param planeA pointer to first shape (cannot be NULL) /// \param planeA pointer to first shape (cannot be NULL)
/// \param planeB pointer to second shape (cannot be NULL) /// \param planeB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool planePlane(const Shape* planeA, const Shape* planeB, CollisionList& collisions); bool planeVsPlane(const Shape* planeA, const Shape* planeB, CollisionList& collisions);
/// \param sphereA pointer to first shape (cannot be NULL) /// \param shapeA pointer to first shape (cannot be NULL)
/// \param listB pointer to second shape (cannot be NULL) /// \param listB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool sphereList(const Shape* sphereA, const Shape* listB, CollisionList& collisions); bool shapeVsList(const Shape* shapeA, const Shape* listB, CollisionList& collisions);
/// \param capuleA pointer to first shape (cannot be NULL) /// \param listA pointer to first shape (cannot be NULL)
/// \param shapeB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details
/// \return true if shapes collide
bool listVsShape(const Shape* listA, const Shape* shapeB, CollisionList& collisions);
/// \param listA pointer to first shape (cannot be NULL)
/// \param listB pointer to second shape (cannot be NULL) /// \param listB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if shapes collide /// \return true if shapes collide
bool capsuleList(const Shape* capsuleA, const Shape* listB, CollisionList& collisions); bool listVsList(const Shape* listA, const Shape* listB, CollisionList& collisions);
/// \param planeA pointer to first shape (cannot be NULL)
/// \param listB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details
/// \return true if shapes collide
bool planeList(const Shape* planeA, const Shape* listB, CollisionList& collisions);
/// \param listA pointer to first shape (cannot be NULL)
/// \param sphereB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details
/// \return true if shapes collide
bool listSphere(const Shape* listA, const Shape* sphereB, CollisionList& collisions);
/// \param listA pointer to first shape (cannot be NULL)
/// \param capsuleB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details
/// \return true if shapes collide
bool listCapsule(const Shape* listA, const Shape* capsuleB, CollisionList& collisions);
/// \param listA pointer to first shape (cannot be NULL)
/// \param planeB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details
/// \return true if shapes collide
bool listPlane(const Shape* listA, const Shape* planeB, CollisionList& collisions);
/// \param listA pointer to first shape (cannot be NULL)
/// \param capsuleB pointer to second shape (cannot be NULL)
/// \param[out] collisions where to append collision details
/// \return true if shapes collide
bool listList(const Shape* listA, const Shape* listB, CollisionList& collisions);
/// \param sphereA pointer to sphere (cannot be NULL) /// \param sphereA pointer to sphere (cannot be NULL)
/// \param cubeCenter center of cube /// \param cubeCenter center of cube
/// \param cubeSide lenght of side of cube /// \param cubeSide lenght of side of cube
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if sphereA collides with axis aligned cube /// \return true if sphereA collides with axis aligned cube
bool sphereAACube(const SphereShape* sphereA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions); bool sphereVsAACube(const SphereShape* sphereA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions);
/// \param capsuleA pointer to capsule (cannot be NULL) /// \param capsuleA pointer to capsule (cannot be NULL)
/// \param cubeCenter center of cube /// \param cubeCenter center of cube
/// \param cubeSide lenght of side of cube /// \param cubeSide lenght of side of cube
/// \param[out] collisions where to append collision details /// \param[out] collisions where to append collision details
/// \return true if capsuleA collides with axis aligned cube /// \return true if capsuleA collides with axis aligned cube
bool capsuleAACube(const CapsuleShape* capsuleA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions); bool capsuleVsAACube(const CapsuleShape* capsuleA, const glm::vec3& cubeCenter, float cubeSide, CollisionList& collisions);
/// \param shapes list of pointers to shapes (shape pointers may be NULL) /// \param shapes list of pointers to shapes (shape pointers may be NULL)
/// \param startPoint beginning of ray /// \param startPoint beginning of ray

18
tests/physics/src/ShapeColliderTests.cpp
View file

@ -713,7 +713,7 @@ void ShapeColliderTests::sphereTouchesAACubeFaces() {
sphereCenter = cubeCenter + sphereOffset * axis; sphereCenter = cubeCenter + sphereOffset * axis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (!ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (!ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should collide with cube. axis = " << axis << std::endl; std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should collide with cube. axis = " << axis << std::endl;
} }
CollisionInfo* collision = collisions[0]; CollisionInfo* collision = collisions[0];
@ -746,7 +746,7 @@ void ShapeColliderTests::sphereTouchesAACubeFaces() {
sphereCenter = cubeCenter + sphereOffset * axis; sphereCenter = cubeCenter + sphereOffset * axis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (!ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (!ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should collide with cube." std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should collide with cube."
<< " axis = " << axis << " axis = " << axis
<< std::endl; << std::endl;
@ -820,7 +820,7 @@ void ShapeColliderTests::sphereTouchesAACubeEdges() {
sphereCenter = cubeCenter + (lengthAxis * 0.5f * cubeSide + sphereRadius - overlap) * axis; sphereCenter = cubeCenter + (lengthAxis * 0.5f * cubeSide + sphereRadius - overlap) * axis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (!ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (!ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should collide with cube. axis = " << axis << std::endl; std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should collide with cube. axis = " << axis << std::endl;
} }
CollisionInfo* collision = collisions[i]; CollisionInfo* collision = collisions[i];
@ -861,42 +861,42 @@ void ShapeColliderTests::sphereMissesAACube() {
// top // top
sphereCenter = cubeCenter + sphereOffset * yAxis; sphereCenter = cubeCenter + sphereOffset * yAxis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl; std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl;
} }
// bottom // bottom
sphereCenter = cubeCenter - sphereOffset * yAxis; sphereCenter = cubeCenter - sphereOffset * yAxis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl; std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl;
} }
// left // left
sphereCenter = cubeCenter + sphereOffset * xAxis; sphereCenter = cubeCenter + sphereOffset * xAxis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl; std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl;
} }
// right // right
sphereCenter = cubeCenter - sphereOffset * xAxis; sphereCenter = cubeCenter - sphereOffset * xAxis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl; std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl;
} }
// forward // forward
sphereCenter = cubeCenter + sphereOffset * zAxis; sphereCenter = cubeCenter + sphereOffset * zAxis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl; std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl;
} }
// back // back
sphereCenter = cubeCenter - sphereOffset * zAxis; sphereCenter = cubeCenter - sphereOffset * zAxis;
sphere.setTranslation(sphereCenter); sphere.setTranslation(sphereCenter);
if (ShapeCollider::sphereAACube(&sphere, cubeCenter, cubeSide, collisions)){ if (ShapeCollider::sphereVsAACube(&sphere, cubeCenter, cubeSide, collisions)){
std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl; std::cout << __FILE__ << ":" << __LINE__ << " ERROR: sphere should NOT collide with cube" << std::endl;
} }
} }