D:/CHAI3D/build-2-0-0/2.0.0/win32/src/graphics/CTriangle.h

Go to the documentation of this file.

//===========================================================================
/*
    This file is part of the CHAI 3D visualization and haptics libraries.
    Copyright (C) 2003-2009 by CHAI 3D. All rights reserved.

    This library is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License("GPL") version 2
    as published by the Free Software Foundation.

    For using the CHAI 3D libraries with software that can not be combined
    with the GNU GPL, and for taking advantage of the additional benefits
    of our support services, please contact CHAI 3D about acquiring a
    Professional Edition License.

    \author    <http://www.chai3d.org>
    \author    Francois Conti
    \version   2.0.0 $Rev: 270 $
*/
//===========================================================================

//---------------------------------------------------------------------------
#ifndef CTriangleH
#define CTriangleH
//---------------------------------------------------------------------------
#include "math/CMaths.h"
#include "graphics/CVertex.h"
#include "scenegraph/CMesh.h"
#include "collisions/CCollisionBasics.h"
//---------------------------------------------------------------------------

//===========================================================================
//===========================================================================

//===========================================================================
//===========================================================================
class cTriangle
{
  public:
    
    //-----------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //-----------------------------------------------------------------------

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    cTriangle(cMesh* a_parent, const unsigned int a_indexVertex0,
        const unsigned int a_indexVertex1, const unsigned int a_indexVertex2) :
        m_indexVertex0(a_indexVertex0), m_indexVertex1(a_indexVertex1),
        m_indexVertex2(a_indexVertex2), m_parent(a_parent), m_allocated(false),
        m_tag(0), m_neighbors(0), m_index(0)
    { }

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    cTriangle() : m_indexVertex0(0), m_indexVertex1(0), m_indexVertex2(0),
        m_index(0), m_parent(0), m_allocated(false), m_tag(0), m_neighbors(0)
    { }


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    ~cTriangle() {
      if (m_neighbors) {
        m_neighbors->clear();
        //delete m_neighbors;
        //m_neighbors = 0;
      }
    }


        //-----------------------------------------------------------------------
    // METHODS:
    //-----------------------------------------------------------------------

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline void setVertices(const unsigned int a_indexVertex0,
                                                        const unsigned int a_indexVertex1, 
                                                        const unsigned int a_indexVertex2)
    {
        m_indexVertex0 = a_indexVertex0;
        m_indexVertex1 = a_indexVertex1;
        m_indexVertex2 = a_indexVertex2;
    }


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline cVertex* getVertex0() const
    {
        // Where does the vertex array live?
        vector<cVertex>* vertex_vector = m_parent->pVertices();
        cVertex* vertex_array = (cVertex*) &((*vertex_vector)[0]);
        return vertex_array+m_indexVertex0;
    };


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline cVertex* getVertex1() const
    {
        // Where does the vertex array live?
        vector<cVertex>* vertex_vector = m_parent->pVertices();
        cVertex* vertex_array = (cVertex*) &((*vertex_vector)[0]);
        return vertex_array+m_indexVertex1;
    };


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline cVertex* getVertex2() const
    {
        // Where does the vertex array live?
        vector<cVertex>* vertex_vector = m_parent->pVertices();
        cVertex* vertex_array = (cVertex*) &((*vertex_vector)[0]);
        return vertex_array+m_indexVertex2;
    };


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline cVertex* getVertex(int vi) const
    {

        // Where does the vertex array live?
        vector<cVertex>* vertex_vector = m_parent->pVertices();
        cVertex* vertex_array = (cVertex*) &((*vertex_vector)[0]);

        switch (vi)
        {
          case 0 : return vertex_array+m_indexVertex0;
          case 1 : return vertex_array+m_indexVertex1;
          case 2 : return vertex_array+m_indexVertex2;
        }
        return NULL;
    }


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline unsigned int getVertexIndex(int vi) const
    {
                switch (vi)
                {
                        case 0 : return m_indexVertex0;
                        case 1 : return m_indexVertex1;
                        case 2 : return m_indexVertex2;
                }
                return 0;
    }

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline unsigned int getIndexVertex0() const
    {
        return (m_indexVertex0);
    };


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline unsigned int getIndexVertex1() const
    {
        return (m_indexVertex1);
    };


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline unsigned int getIndexVertex2() const
    {
        return (m_indexVertex2);
    };


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline unsigned int getIndex() const
    {
        return (m_index);
    };


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline cMesh* getParent() const
    {
        return (m_parent);
    };

    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline void setParent(cMesh* parent)
    {
        m_parent = parent;
    };


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline bool allocated() const
    {
        return (m_allocated);
    };



    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    inline bool computeCollision(cVector3d& a_segmentPointA,
                                 cVector3d& a_segmentPointB,
                                 cCollisionRecorder& a_recorder,
                                 cCollisionSettings& a_settings) const
    {
        // temp variables
        bool hit = false;
        cVector3d collisionPoint;
        cVector3d collisionNormal;
        double collisionDistanceSq = CHAI_LARGE;

        // Get the position of the triangle's vertices
        vector<cVertex>* vertex_vector = m_parent->pVertices();
        cVertex* vertex_array = (cVertex*) &((*vertex_vector)[0]);
        cVector3d vertex0 = vertex_array[m_indexVertex0].getPos();
        cVector3d vertex1 = vertex_array[m_indexVertex1].getPos();
        cVector3d vertex2 = vertex_array[m_indexVertex2].getPos();

        // If m_collisionRadius == 0, we search for a possible intersection between
        // the segment AB and the triangle defined by its three vertices V0, V1, V2.
        if (a_settings.m_collisionRadius == 0)
        {
            // check for collision between segment and triangle only
            if (cIntersectionSegmentTriangle(a_segmentPointA,
                                            a_segmentPointB,
                                            vertex0,
                                            vertex1,
                                            vertex2,
                                            collisionPoint,
                                            collisionNormal))
            {
                hit = true;
                collisionDistanceSq = cDistanceSq(a_segmentPointA, collisionPoint);
            }
        }


        // If m_collisionRadius > 0, we search for a possible intersection between
        // the segment AB and the shell of the current triangle which is described
        // by its three vertices and m_collisionRadius.
        else
        {
            cVector3d t_collisionPoint, t_collisionNormal;
            double t_collisionDistanceSq;
            cVector3d normal = cComputeSurfaceNormal(vertex0, vertex1, vertex2);
            cVector3d offset; normal.mulr(a_settings.m_collisionRadius, offset);
            cVector3d t_vertex0, t_vertex1, t_vertex2;

            // check for collision between segment and triangle upper shell
            vertex0.addr(offset, t_vertex0);
            vertex1.addr(offset, t_vertex1);
            vertex2.addr(offset, t_vertex2);
            if (cIntersectionSegmentTriangle(a_segmentPointA,
                                            a_segmentPointB,
                                            t_vertex0,
                                            t_vertex1,
                                            t_vertex2,
                                            collisionPoint,
                                            collisionNormal))
            {
                hit = true;
                collisionDistanceSq = cDistanceSq(a_segmentPointA, collisionPoint);
            }

            // check for collision between segment and triangle lower shell
            vertex0.subr(offset, t_vertex0);
            vertex1.subr(offset, t_vertex1);
            vertex2.subr(offset, t_vertex2);
            if (cIntersectionSegmentTriangle(a_segmentPointA,
                                            a_segmentPointB,
                                            t_vertex0,
                                            t_vertex1,
                                            t_vertex2,
                                            t_collisionPoint,
                                            t_collisionNormal))
            {
                hit = true;
                t_collisionDistanceSq = cDistanceSq(a_segmentPointA, t_collisionPoint);
                if (t_collisionDistanceSq < collisionDistanceSq)
                {
                    collisionPoint = t_collisionPoint;
                    collisionNormal = t_collisionNormal;
                    collisionDistanceSq = t_collisionDistanceSq;
                }
            }

            // check for collision between sphere located at vertex 0
            cVector3d t_p, t_n;
            if (cIntersectionSegmentSphere(a_segmentPointA,
                                           a_segmentPointB,
                                           vertex0,
                                           a_settings.m_collisionRadius,
                                           t_collisionPoint,
                                           t_collisionNormal,
                                           t_p,
                                           t_n) > 0)
            {
                hit = true;
                t_collisionDistanceSq = cDistanceSq(a_segmentPointA, t_collisionPoint);
                if (t_collisionDistanceSq < collisionDistanceSq)
                {
                    collisionPoint = t_collisionPoint;
                    collisionNormal = t_collisionNormal;
                    collisionDistanceSq = t_collisionDistanceSq;
                }
            }

            // check for collision between sphere located at vertex 1
            if (cIntersectionSegmentSphere(a_segmentPointA,
                                           a_segmentPointB,
                                           vertex1,
                                           a_settings.m_collisionRadius,
                                           t_collisionPoint,
                                           t_collisionNormal,
                                           t_p,
                                           t_n) > 0)
            {
                hit = true;
                t_collisionDistanceSq = cDistanceSq(a_segmentPointA, t_collisionPoint);
                if (t_collisionDistanceSq < collisionDistanceSq)
                {
                    collisionPoint = t_collisionPoint;
                    collisionNormal = t_collisionNormal;
                    collisionDistanceSq = t_collisionDistanceSq;
                }
            }

            // check for collision between sphere located at vertex 2
            if (cIntersectionSegmentSphere(a_segmentPointA,
                                           a_segmentPointB,
                                           vertex2,
                                           a_settings.m_collisionRadius,
                                           t_collisionPoint,
                                           t_collisionNormal,
                                           t_p,
                                           t_n) > 0)
            {
                hit = true;
                t_collisionDistanceSq = cDistanceSq(a_segmentPointA, t_collisionPoint);
                if (t_collisionDistanceSq < collisionDistanceSq)
                {
                    collisionPoint = t_collisionPoint;
                    collisionNormal = t_collisionNormal;
                    collisionDistanceSq = t_collisionDistanceSq;
                }
            }

            // check for collision between segment and triangle edge01 shell
            if (cIntersectionSegmentToplessCylinder(a_segmentPointA,
                                           a_segmentPointB,
                                           vertex0,
                                           vertex1,
                                           a_settings.m_collisionRadius,
                                           t_collisionPoint,
                                           t_collisionNormal,
                                           t_p,
                                           t_n) > 0)
            {
                hit = true;
                t_collisionDistanceSq = cDistanceSq(a_segmentPointA, t_collisionPoint);
                if (t_collisionDistanceSq < collisionDistanceSq)
                {
                    collisionPoint = t_collisionPoint;
                    collisionNormal = t_collisionNormal;
                    collisionDistanceSq = t_collisionDistanceSq;
                }
            }

            // check for collision between segment and triangle edge02 shell
            if (cIntersectionSegmentToplessCylinder(a_segmentPointA,
                                           a_segmentPointB,
                                           vertex0,
                                           vertex2,
                                           a_settings.m_collisionRadius,
                                           t_collisionPoint,
                                           t_collisionNormal,
                                           t_p,
                                           t_n) > 0)
            {
                hit = true;
                t_collisionDistanceSq = cDistanceSq(a_segmentPointA, t_collisionPoint);
                if (t_collisionDistanceSq < collisionDistanceSq)
                {
                    collisionPoint = t_collisionPoint;
                    collisionNormal = t_collisionNormal;
                    collisionDistanceSq = t_collisionDistanceSq;
                }
            }

            // check for collision between segment and triangle edge12 shell
            if (cIntersectionSegmentToplessCylinder(a_segmentPointA,
                                           a_segmentPointB,
                                           vertex1,
                                           vertex2,
                                           a_settings.m_collisionRadius,
                                           t_collisionPoint,
                                           t_collisionNormal,
                                           t_p,
                                           t_n) > 0)
            {
                hit = true;
                t_collisionDistanceSq = cDistanceSq(a_segmentPointA, t_collisionPoint);
                if (t_collisionDistanceSq < collisionDistanceSq)
                {
                    collisionPoint = t_collisionPoint;
                    collisionNormal = t_collisionNormal;
                    collisionDistanceSq = t_collisionDistanceSq;
                }
            }
        }

        // report collision
        if (hit)
        {
            // before reporting the new collision, we need to check if
            // the collision settings require us to verify the side of the
            // triangle which has been hit.
            bool hit_confirmed;
            if (a_settings.m_checkBothSidesOfTriangles)
            {
                // settings specify that a collision can occur on both sides
                // of the triangle, so the new collision is reported.
                hit_confirmed = true;
            }
            else
            {
                // we need check on which side of the triangle the collision occurred
                // and see it needs to be reported.
                cVector3d segmentAB;
                a_segmentPointB.subr(a_segmentPointA, segmentAB);

                cVector3d v01, v02, triangleNormal;
                vertex2.subr(vertex0, v02);
                vertex1.subr(vertex0, v01);
                v01.crossr(v02, triangleNormal);

                double value = cCosAngle(segmentAB, triangleNormal);
                if (value <= 0.0)
                {
                    hit_confirmed = true;
                }
                else
                {
                    hit_confirmed = false;
                }
            }


            // here we finally report the new collision to the collision event handler.
            if (hit_confirmed)
            {
                // we verify if anew collision needs to be created or if we simply
                // need to update the nearest collision.
                if (a_settings.m_checkForNearestCollisionOnly)
                {
                    // no new collision event is create. We just check if we need
                    // to update the nearest collision
                    if(collisionDistanceSq < a_recorder.m_nearestCollision.m_squareDistance)
                    {
                        // report basic collision data
                        a_recorder.m_nearestCollision.m_object = m_parent;
                        a_recorder.m_nearestCollision.m_triangle = (cTriangle*)this;
                        a_recorder.m_nearestCollision.m_localPos = collisionPoint;
                        a_recorder.m_nearestCollision.m_localNormal = collisionNormal;
                        a_recorder.m_nearestCollision.m_squareDistance = collisionDistanceSq;
                        a_recorder.m_nearestCollision.m_adjustedSegmentAPoint = a_segmentPointA;

                        // report advanced collision data
                        if (!a_settings.m_returnMinimalCollisionData)
                        {
                            a_recorder.m_nearestCollision.m_globalPos = cAdd(m_parent->getGlobalPos(),
                                                                        cMul(m_parent->getGlobalRot(),
                                                                        a_recorder.m_nearestCollision.m_localPos));
                            a_recorder.m_nearestCollision.m_globalNormal = cMul(m_parent->getGlobalRot(),
                            a_recorder.m_nearestCollision.m_localNormal);
                        }

                    }
                }
                else
                {
                    cCollisionEvent newCollisionEvent;

                    // report basic collision data
                    newCollisionEvent.m_object = m_parent;
                    newCollisionEvent.m_triangle = (cTriangle*)this;
                    newCollisionEvent.m_localPos = collisionPoint;
                    newCollisionEvent.m_localNormal = collisionNormal;
                    newCollisionEvent.m_squareDistance = collisionDistanceSq;
                    newCollisionEvent.m_adjustedSegmentAPoint = a_segmentPointA;

                    // report advanced collision data
                    if (!a_settings.m_returnMinimalCollisionData)
                    {
                        newCollisionEvent.m_globalPos = cAdd(m_parent->getGlobalPos(),
                                                        cMul(m_parent->getGlobalRot(),
                                                        newCollisionEvent.m_localPos));
                        newCollisionEvent.m_globalNormal = cMul(m_parent->getGlobalRot(),
                        newCollisionEvent.m_localNormal);
                    }

                    // add new collision even to collision list
                    a_recorder.m_collisions.push_back(newCollisionEvent);

                    // check if this new collision is a candidate for "nearest one"
                    if(collisionDistanceSq < a_recorder.m_nearestCollision.m_squareDistance)
                    {
                        a_recorder.m_nearestCollision = newCollisionEvent;
                    }
                }
            }

            // return result
            return (hit_confirmed);
        }
        else
        {
            return (false);
        }
    }


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    double computeArea()
    {
        // A = 0.5 * | u x v |
        cVector3d u = cSub(getVertex(1)->getPos(),getVertex(0)->getPos());
        cVector3d v = cSub(getVertex(2)->getPos(),getVertex(0)->getPos());
        return (0.5 * (cCross(u,v).length()));
    }


  public:
    
    //-----------------------------------------------------------------------
    // MEMBERS:
    //-----------------------------------------------------------------------
      
    unsigned int m_indexVertex0;

    unsigned int m_indexVertex1;

    unsigned int m_indexVertex2;

    unsigned int m_index;

    cMesh* m_parent;

    bool m_allocated;

    int m_tag;

    std::vector<cTriangle*>* m_neighbors;
};

//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------

---

CHAI3D 2.0.0 documentation
Please address any questions to support@chai3d.org
(C) 2003-2009 - CHAI 3D
All Rights Reserved.