D:/CHAI3D/build-2-0-0/2.0.0/win32/src/collisions/CCollisionSpheresGeometry.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    Chris Sewell
    \author    Francois Conti
    \version   2.0.0 $Rev: 250 $
*/
//===========================================================================

//---------------------------------------------------------------------------
#ifndef CCollisionSpheresGeometryH
#define CCollisionSpheresGeometryH
//---------------------------------------------------------------------------
#include "math/CMaths.h"
#include "graphics/CTriangle.h"
#include <assert.h>
#include <list>
#include <map>
#include <math.h>
//---------------------------------------------------------------------------
using std::map;
using std::less;
using std::list;
//---------------------------------------------------------------------------
class cCollisionSpheresPoint;
class cCollisionSpheresEdge;
class cCollisionSpheresLeaf;
//---------------------------------------------------------------------------
typedef map<cCollisionSpheresPoint *, cCollisionSpheresEdge *,
        less<cCollisionSpheresPoint *> > PtEmap;
//---------------------------------------------------------------------------

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

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

    cCollisionSpheresPoint(double a_x = 0,
                           double a_y = 0,
                           double a_z = 0)
                           { m_pos.x = a_x;  m_pos.y = a_y;  m_pos.z = a_z; }


    //-----------------------------------------------------------------------
    // MEMBERS:
    //-----------------------------------------------------------------------
    
    cVector3d m_pos;

    PtEmap m_edgeMap;
};


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

    cCollisionSpheresEdge() { }

    cCollisionSpheresEdge(cCollisionSpheresPoint *a_a,
                          cCollisionSpheresPoint *a_b)
                          { initialize(a_a,a_b); }

    virtual ~cCollisionSpheresEdge() {}


    //-----------------------------------------------------------------------
    // METHODS:
    //-----------------------------------------------------------------------
    
    void initialize(cCollisionSpheresPoint *a_a, cCollisionSpheresPoint *a_b);

    inline const cVector3d &getCenter() const  {return m_center;}

    inline double getRadius() const
        { if (m_D <= 0.0) return 0.0; return sqrt(m_D)/2; }


  private:
    
    //-----------------------------------------------------------------------
    // MEMBERS:
    //-----------------------------------------------------------------------

    cCollisionSpheresPoint *m_end[2];

    cVector3d m_center;

    cVector3d m_d;

    double m_D;
};


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

    cCollisionSpheresGenericShape() : m_sphere(NULL) { }

    virtual ~cCollisionSpheresGenericShape() {}


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

    virtual const cVector3d &getCenter() const = 0;

    virtual double getRadius() const = 0;

    virtual bool computeCollision(cCollisionSpheresGenericShape *a_other,
                                  cCollisionRecorder& a_recorder,
                                  cCollisionSettings& a_settings) = 0;

    virtual cCollisionSpheresLeaf* getSphere()  { return m_sphere; }

    virtual void setSphere(cCollisionSpheresLeaf* a_sphere)
        { m_sphere = a_sphere; }

    bool operator<(cCollisionSpheresGenericShape* a_other)
        { return (getCenter().get(m_split) < a_other->getCenter().get(m_split)); }

    
    //-----------------------------------------------------------------------
    // MEMBERS:
    //-----------------------------------------------------------------------

    static int m_split;


  private:
    
    //-----------------------------------------------------------------------
    // MEMBERS:
    //-----------------------------------------------------------------------

    cCollisionSpheresLeaf *m_sphere;
};


//===========================================================================
//===========================================================================
class cCollisionSpheresTri : public cCollisionSpheresGenericShape
{
  public:
    
    //-----------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //-----------------------------------------------------------------------

    cCollisionSpheresTri(cVector3d a,
                         cVector3d b,
                         cVector3d c,
                         double a_extendedRadius);

    virtual ~cCollisionSpheresTri() {};


    //-----------------------------------------------------------------------
    // METHODS:
    //-----------------------------------------------------------------------
    
    bool computeCollision(cCollisionSpheresGenericShape *a_other,
                          cCollisionRecorder& a_recorder,
                          cCollisionSettings& a_settings);

    inline const cVector3d &getCenter() const  { return m_center; }

    inline double getRadius() const  { return m_radius; }

    cTriangle* getOriginal() { return m_original; }

    void setOriginal(cTriangle* a_original) { m_original = a_original; }


  protected:
        
    //-----------------------------------------------------------------------
    // MEMBERS:
    //-----------------------------------------------------------------------

    cCollisionSpheresPoint m_corner[3];

    cCollisionSpheresEdge m_side[3];

    cVector3d m_center;

    double m_radius;

    cTriangle* m_original;
};


//===========================================================================
//===========================================================================
class cCollisionSpheresLine : public cCollisionSpheresGenericShape
{
  public:
    
    //-----------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //-----------------------------------------------------------------------

    cCollisionSpheresLine(cVector3d& a_segmentPointA,
                          cVector3d& a_segmentPointB);

    virtual ~cCollisionSpheresLine() {}


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

    inline const cVector3d &getCenter() const  { return m_center; }

    inline double getRadius() const  { return m_radius; }

    bool computeCollision(cCollisionSpheresGenericShape *a_other,
                          cCollisionRecorder& a_recorder,
                          cCollisionSettings& a_settings);

    cVector3d getSegmentPointA() { return m_segmentPointA; }

    cVector3d getSegmentPointB() { return m_segmentPointB; }


  protected:
  
        //-----------------------------------------------------------------------
    // MEMBERS:
    //-----------------------------------------------------------------------

    cVector3d m_center;

    double m_radius;

    cVector3d m_segmentPointA;

    cVector3d m_segmentPointB;
};

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

---

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