CollisionDetectionNamespace::Collision_detector_Triangles Class Reference

Collision detector to test 2 Triangles. More...

#include <collision_detectors.h>

Inheritance diagram for CollisionDetectionNamespace::Collision_detector_Triangles:

List of all members.

Public Member Functions
	Collision_detector_Triangles ()
	Class constructor.
CollisionReport	FindCollision (void *pNode1, void *pNode2)
Private Member Functions
bool	intersectSegmentTriangle (VECTOR3 p, VECTOR3 q, Triangle *triangle, VECTOR3 &C)

---

Detailed Description

Collision detector to test 2 Triangles.

Definition at line 78 of file collision_detectors.h.

---

Constructor & Destructor Documentation

CollisionDetectionNamespace::Collision_detector_Triangles::Collision_detector_Triangles

(

)

[inline]

Class constructor.

Definition at line 82 of file collision_detectors.h.

{;}

---

Member Function Documentation

CollisionReport Collision_detector_Triangles::FindCollision	(	void *	pNode1,
		void *	pNode2
	)			[virtual]

Detect collision

Parameters:

[in]	object	1
[in]	object	2

Returns:

CollisionReport filled with collision detection results

Implements CollisionDetectionNamespace::Collison_Detector_IFace.

Definition at line 88 of file collision_detectors.cpp.

{
       CollisionReport collisionReport;

       Triangle* a = (Triangle*) pNode1;
       Triangle* b = (Triangle*) pNode2;
       
       VECTOR3 intersectionPoint1, intersectionPoint2, intersectionPoint3,intersectionPoint4, intersectionPoint5, intersectionPoint6;
       VECTOR3 finalIntersectionPoint;

       int bV1 = (int)intersectSegmentTriangle(a->v1, a->v2, b,intersectionPoint1);
       int bV2 = (int)intersectSegmentTriangle(a->v1, a->v3, b,intersectionPoint2);
       int bV3 = (int)intersectSegmentTriangle(a->v2, a->v3, b,intersectionPoint3);

       int bV4, bV5, bV6;

       int bV = bV1 + bV2 + bV3;

       switch (bV)
       {
       case 0:
              bV4 = (int)intersectSegmentTriangle(b->v1, b->v2, a,intersectionPoint4);
              bV5 = (int)intersectSegmentTriangle(b->v1, b->v3, a,intersectionPoint5);
              bV6 = (int)intersectSegmentTriangle(b->v2, b->v3, a,intersectionPoint6);
              bV = bV4 + bV5 + bV6;
              if (bV == 2)
              {
                     collisionReport.bCollide = true;

                     if (bV4 == 1 && bV5 == 1)
                     {
                            finalIntersectionPoint = intersectionPoint4 + (intersectionPoint5 - intersectionPoint4);
                     }
                     else if (bV4 == 1 && bV6 == 1)
                     {
                            finalIntersectionPoint = intersectionPoint4 + (intersectionPoint6 - intersectionPoint4);
                     }
                     else
                     {
                            finalIntersectionPoint = intersectionPoint6 + (intersectionPoint5 - intersectionPoint6);
                     }

              }
              break;
       case 1:
              bV4 = (int)intersectSegmentTriangle(b->v1, b->v2, a,intersectionPoint4);
              if (bV4 == 1)
              {
                     collisionReport.bCollide = true;
                     
                     if (bV1 == 1)
                     {
                            finalIntersectionPoint = intersectionPoint1 + (intersectionPoint4 - intersectionPoint1);
                     }
                     else if (bV2 == 1)
                     {
                            finalIntersectionPoint = intersectionPoint2 + (intersectionPoint4 - intersectionPoint2);
                     }
                     else
                     {
                            finalIntersectionPoint = intersectionPoint3 + (intersectionPoint4 - intersectionPoint3);
                     }

                     break;
              }

              bV5 = (int)intersectSegmentTriangle(b->v1, b->v3, a,intersectionPoint5);
              if (bV5 == 1)
              {
                     collisionReport.bCollide = true;
                     if (bV1 == 1)
                     {
                            finalIntersectionPoint = intersectionPoint1 + (intersectionPoint5 - intersectionPoint1);
                     }
                     else if (bV2 == 1)
                     {
                            finalIntersectionPoint = intersectionPoint2 + (intersectionPoint5 - intersectionPoint2);
                     }
                     else
                     {
                            finalIntersectionPoint = intersectionPoint3 + (intersectionPoint5 - intersectionPoint3);
                     }
                     break;
              }

              bV6 = (int)intersectSegmentTriangle(b->v2, b->v3, a,intersectionPoint6);
              if (bV6 == 1)
              {
                     collisionReport.bCollide = true;
                     if (bV1 == 1)
                     {
                            finalIntersectionPoint = intersectionPoint1 + (intersectionPoint6 - intersectionPoint1);
                     }
                     else if (bV2 == 1)
                     {
                            finalIntersectionPoint = intersectionPoint2 + (intersectionPoint6 - intersectionPoint2);
                     }
                     else
                     {
                            finalIntersectionPoint = intersectionPoint3 + (intersectionPoint6 - intersectionPoint3);
                     }
              }
              break;
       case 2:
              collisionReport.bCollide = true;
              if (bV1 == 1 && bV2 == 1)
              {
                     finalIntersectionPoint = intersectionPoint1 + (intersectionPoint2 - intersectionPoint1);
              }
              else if (bV1 == 1 && bV3 == 1)
              {
                     finalIntersectionPoint = intersectionPoint1 + (intersectionPoint3 - intersectionPoint1);
              }
              else
              {
                     finalIntersectionPoint = intersectionPoint2 + (intersectionPoint3 - intersectionPoint2);
              }


              break;
       default:
              break;
       }

       if (collisionReport.bCollide)
              collisionReport.collisionPoints.push_back(finalIntersectionPoint);

       return collisionReport;
}

bool Collision_detector_Triangles::intersectSegmentTriangle	(	VECTOR3	p,
		VECTOR3	q,
		Triangle *	triangle,
		VECTOR3 &	C
	)			[private]

Inetersection test for segment and triangle

Parameters:

[in]	start	point of segment
[in]	end	point of segment
[in]	pointer	to a triangle
[out]	point	of intersection if intersection exists

Returns:

true if intersection exists

Definition at line 218 of file collision_detectors.cpp.

{
       VECTOR3 ab = triangle->v2 - triangle->v1;
       VECTOR3 ac = triangle->v3 - triangle->v1;
       VECTOR3 qp = p - q;


       VECTOR3 n = ab.Cross(ac);

       float d =  qp.Dot(n);

       if (d <= 0.0f)
              return false;

       VECTOR3 ap = p - triangle->v1;

       float t = ap.Dot(n);
       if (t < 0.0f || t > d)
              return false;

       VECTOR3 e = qp.Cross(ap);
       float v = ac.Dot(e);
       if (v < 0.0f || v > d)
              return false;

       float w = -ab.Dot(e);
       if (w < 0.0f || v + w > d)
              return false;


       // Segment intersect triangle, compute intersetionPoint

       float ood = 1.0f / d;
       t *= ood;
       v *= ood;
       w *= ood;
       float u = 1.0f - v -w;

       C = p + t*(q-p);

       

       return true;
}

---

The documentation for this class was generated from the following files:

• /cygdrive/d/src/svn/vrut/trunk/modules/collision_detection/collision_detectors.h
• /cygdrive/d/src/svn/vrut/trunk/modules/collision_detection/collision_detectors.cpp