mrq/reactphysics3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git-svn-id: https://reactphysics3d.googlecode.com/svn/trunk@267 92aac97c-a6ce-11dd-a772-7fcde58d38e6

Browse Source
This commit is contained in:
chappuis.daniel 2010-02-06 19:39:19 +00:00
parent a210ed8894
commit 298b66ef2a
3 changed files with 11 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
sources/reactphysics3d/collision/CollisionDetection.cpp
View File

@ -34,7 +34,7 @@ CollisionDetection::CollisionDetection() {
// Construct the broad-phase algorithm that will be used (Separating axis with AABB) // Construct the broad-phase algorithm that will be used (Separating axis with AABB)
broadPhaseAlgorithm = new NoBroadPhaseAlgorithm(); broadPhaseAlgorithm = new NoBroadPhaseAlgorithm();
// Construct the narrow-phase algorithm that will be used (Separating axis with OBB) // Construct the narrow-phase algorithm that will be used (Separating axis algorithm)
narrowPhaseAlgorithm = new SATAlgorithm(); narrowPhaseAlgorithm = new SATAlgorithm();
} }
@ -43,15 +43,14 @@ CollisionDetection::~CollisionDetection() {
} }
// Compute the collision detection for the time interval [0, timeMax] // Compute the collision detection
// The method returns true if a collision occurs in the time interval [0, timeMax] bool CollisionDetection::computeCollisionDetection(PhysicsWorld* world) {
bool CollisionDetection::computeCollisionDetection(CollisionWorld* collisionWorld) {
bool existsCollision = false; // True if a collision is found in the time interval [0, timeMax] bool existsCollision = false; // True if a collision is found in the time interval [0, timeMax]
// For each pair of bodies in the collisionWorld // For each pair of bodies in the physics world
for(std::vector<Body*>::const_iterator it1 = collisionWorld->getBodyListStartIterator(); it1 != collisionWorld->getBodyListEndIterator(); ++it1) { for(std::vector<Body*>::const_iterator it1 = world->getBodyListStartIterator(); it1 != world->getBodyListEndIterator(); ++it1) {
for(std::vector<Body*>::const_iterator it2 = it1; it2 != collisionWorld->getBodyListEndIterator(); ++it2) { for(std::vector<Body*>::const_iterator it2 = it1; it2 != world->getBodyListEndIterator(); ++it2) {
// If both bodies are RigidBody and are different // If both bodies are RigidBody and are different
RigidBody* rigidBody1 = dynamic_cast<RigidBody*>(*it1); RigidBody* rigidBody1 = dynamic_cast<RigidBody*>(*it1);
RigidBody* rigidBody2 = dynamic_cast<RigidBody*>(*it2); RigidBody* rigidBody2 = dynamic_cast<RigidBody*>(*it2);
@ -72,7 +71,7 @@ bool CollisionDetection::computeCollisionDetection(CollisionWorld* collisionWorl
Vector3D test = contact->getNormal(); // TODO : Delete this Vector3D test = contact->getNormal(); // TODO : Delete this
// Add the new collision contact into the collision world // Add the new collision contact into the collision world
collisionWorld->addConstraint(contact); world->addConstraint(contact);
} }
} }
} }

8
sources/reactphysics3d/collision/CollisionDetection.h
View File

@ -24,7 +24,7 @@
#include "BroadPhaseAlgorithm.h" #include "BroadPhaseAlgorithm.h"
#include "NarrowPhaseAlgorithm.h" #include "NarrowPhaseAlgorithm.h"
#include "../body/Body.h" #include "../body/Body.h"
#include "../engine/CollisionWorld.h" #include "../engine/PhysicsWorld.h"
#include <vector> #include <vector>
// ReactPhysics3D namespace // ReactPhysics3D namespace
@ -44,14 +44,14 @@ class CollisionDetection {
BroadPhaseAlgorithm* broadPhaseAlgorithm; // Broad-phase algorithm BroadPhaseAlgorithm* broadPhaseAlgorithm; // Broad-phase algorithm
NarrowPhaseAlgorithm* narrowPhaseAlgorithm; // Narrow-phase algorithm NarrowPhaseAlgorithm* narrowPhaseAlgorithm; // Narrow-phase algorithm
void addPossibleCollisionPair(Body* body1, Body* body2); // Add a possible collision pair of bodies in the possibleCollisionPairList void addPossibleCollisionPair(Body* body1, Body* body2); // Add a possible collision pair of bodies in the possibleCollisionPairList
void initPossibleCollisionPairList(); // Initialize the possibleCollisionPairList void initPossibleCollisionPairList(); // Initialize the possibleCollisionPairList
public : public :
CollisionDetection(); // Constructor CollisionDetection(); // Constructor
~CollisionDetection(); // Destructor ~CollisionDetection(); // Destructor
bool computeCollisionDetection(CollisionWorld* collisionWorld); // Compute the collision detection bool computeCollisionDetection(PhysicsWorld* world); // Compute the collision detection
}; };
// Add a possible collision pair of bodies in the possibleCollisionPairList // Add a possible collision pair of bodies in the possibleCollisionPairList

37
sources/reactphysics3d/collision/SATAlgorithm.cpp
View File

@ -29,8 +29,6 @@
// We want to use the ReactPhysics3D namespace // We want to use the ReactPhysics3D namespace
using namespace reactphysics3d; using namespace reactphysics3d;
// TODO : Remove all the std::cout
// TODO : Check and modify all comments on this file in order that // TODO : Check and modify all comments on this file in order that
//  everything have to do with the new SAT algorithm //  everything have to do with the new SAT algorithm
@ -128,14 +126,7 @@ bool SATAlgorithm::computeCollisionTest(const OBB* const obb1, const OBB* const
normal = computeContactNormal(obb1->getAxis(0), boxDistance); // Compute the contact normal with the correct sign normal = computeContactNormal(obb1->getAxis(0), boxDistance); // Compute the contact normal with the correct sign
} }
// TODO : Delete this
std::cout << "min1 : " << min1 << std::endl;
std::cout << "max1 : " << max1 << std::endl;
std::cout << "min2 : " << min2 << std::endl;
std::cout << "max2 : " << max2 << std::endl;
// Axis A1 // Axis A1
//std::cout << "----- AXIS A1 -----" << std::endl;
for (int i=0; i<3; ++i) { for (int i=0; i<3; ++i) {
c[1][i] = obb1->getAxis(1).scalarProduct(obb2->getAxis(i)); c[1][i] = obb1->getAxis(1).scalarProduct(obb2->getAxis(i));
absC[1][i] = fabs(c[1][i]); absC[1][i] = fabs(c[1][i]);
@ -161,12 +152,6 @@ bool SATAlgorithm::computeCollisionTest(const OBB* const obb1, const OBB* const
normal = computeContactNormal(obb1->getAxis(1), boxDistance); // Compute the contact normal with the correct sign normal = computeContactNormal(obb1->getAxis(1), boxDistance); // Compute the contact normal with the correct sign
} }
// TODO : Delete this
std::cout << "min1 : " << min1 << std::endl;
std::cout << "max1 : " << max1 << std::endl;
std::cout << "min2 : " << min2 << std::endl;
std::cout << "max2 : " << max2 << std::endl;
// Axis A2 // Axis A2
for (int i=0; i<3; ++i) { for (int i=0; i<3; ++i) {
c[2][i] = obb1->getAxis(2).scalarProduct(obb2->getAxis(i)); c[2][i] = obb1->getAxis(2).scalarProduct(obb2->getAxis(i));
@ -193,12 +178,6 @@ bool SATAlgorithm::computeCollisionTest(const OBB* const obb1, const OBB* const
normal = computeContactNormal(obb1->getAxis(2), boxDistance); // Compute the contact normal with the correct sign normal = computeContactNormal(obb1->getAxis(2), boxDistance); // Compute the contact normal with the correct sign
} }
// TODO : Delete this
std::cout << "min1 : " << min1 << std::endl;
std::cout << "max1 : " << max1 << std::endl;
std::cout << "min2 : " << min2 << std::endl;
std::cout << "max2 : " << max2 << std::endl;
// Axis B0 // Axis B0
udc2[0] = obb2->getAxis(0).scalarProduct(boxDistance); udc2[0] = obb2->getAxis(0).scalarProduct(boxDistance);
center = udc2[0]; center = udc2[0];
@ -219,7 +198,6 @@ bool SATAlgorithm::computeCollisionTest(const OBB* const obb1, const OBB* const
} }
// Axis B1 // Axis B1
//std::cout << "----- AXIS B1 -----" << std::endl;
udc2[1] = obb2->getAxis(1).scalarProduct(boxDistance); udc2[1] = obb2->getAxis(1).scalarProduct(boxDistance);
center = udc2[1]; center = udc2[1];
radius1 = obb1->getExtent(0)*absC[0][1] + obb1->getExtent(1)*absC[1][1] + obb1->getExtent(2) * absC[2][1]; radius1 = obb1->getExtent(0)*absC[0][1] + obb1->getExtent(1)*absC[1][1] + obb1->getExtent(2) * absC[2][1];
@ -228,10 +206,6 @@ bool SATAlgorithm::computeCollisionTest(const OBB* const obb1, const OBB* const
max1 = radius1; max1 = radius1;
min2 = center - radius2; min2 = center - radius2;
max2 = center + radius2; max2 = center + radius2;
std::cout << "min1 : " << min1 << std::endl;
std::cout << "max1 : " << max1 << std::endl;
std::cout << "min2 : " << min2 << std::endl;
std::cout << "max2 : " << max2 << std::endl;
penetrationDepth = computePenetrationDepth(min1, max1, min2, max2, sideTemp); penetrationDepth = computePenetrationDepth(min1, max1, min2, max2, sideTemp);
if (penetrationDepth < 0) { // We have found a separation axis, therefore the two OBBs don't collide if (penetrationDepth < 0) { // We have found a separation axis, therefore the two OBBs don't collide
return false; return false;
@ -261,16 +235,10 @@ bool SATAlgorithm::computeCollisionTest(const OBB* const obb1, const OBB* const
normal = computeContactNormal(obb2->getAxis(2), boxDistance); // Compute the contact normal with the correct sign normal = computeContactNormal(obb2->getAxis(2), boxDistance); // Compute the contact normal with the correct sign
} }
// If there exists a parallel pair of face normals // If there exists a parallel pair of face normals
if (existsParallelPair) { if (existsParallelPair) {
// There exists a parallel pair of face normals and we have already checked all the face // There exists a parallel pair of face normals and we have already checked all the face
// normals for separation. Therefore the OBBs must intersect // normals for separation. Therefore the OBBs must intersect
//std::cout << "PARALLEL PAIR" << std::endl;
//std::cout << "Current -- 1 -- MIN Points : " << currentInterval1.getMinProjectedPoints().size() << " MAX : " << currentInterval1.getMaxProjectedPoints().size() << std::endl;
//std::cout << "Current -- 1 -- min : " << currentInterval1.getMin() << std::endl;
//std::cout << "Timefirst : " << timeFirst.getValue() << std::endl;
std::cout << "CONTACT FOUND " << std::endl;
// Compute the collision contact // Compute the collision contact
computeContact(obb1, obb2, normal.getUnit(), minPenetrationDepth, obb1->getExtremeVertices(normal), obb2->getExtremeVertices(normal.getOpposite()), contact); computeContact(obb1, obb2, normal.getUnit(), minPenetrationDepth, obb1->getExtremeVertices(normal), obb2->getExtremeVertices(normal.getOpposite()), contact);
@ -440,11 +408,6 @@ bool SATAlgorithm::computeCollisionTest(const OBB* const obb1, const OBB* const
normal = computeContactNormal(obb1->getAxis(2).crossProduct(obb2->getAxis(2)), boxDistance); // Compute the contact normal with the correct sign normal = computeContactNormal(obb1->getAxis(2).crossProduct(obb2->getAxis(2)), boxDistance); // Compute the contact normal with the correct sign
} }
// TODO : Delete this
//(*contact) = new Contact(obb1->getBodyPointer(), obb2->getBodyPointer(), Vector3D(1,0,0), timeFirst);
std::cout << "Contact2 : " << contact << std::endl;
std::cout << "CONTACT FOUND" << std::endl;
// Compute the collision contact // Compute the collision contact
computeContact(obb1, obb2, normal.getUnit(), minPenetrationDepth, obb1->getExtremeVertices(normal), obb2->getExtremeVertices(normal.getOpposite()), contact); computeContact(obb1, obb2, normal.getUnit(), minPenetrationDepth, obb1->getExtremeVertices(normal), obb2->getExtremeVertices(normal.getOpposite()), contact);