D:/CHAI3D/build-2-0-0/2.0.0/win32/src/collisions/CCollisionSpheres.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 CCollisionSpheresH
#define CCollisionSpheresH
//---------------------------------------------------------------------------
#include "math/CMaths.h"
#include "collisions/CGenericCollision.h"
#include "collisions/CCollisionSpheresGeometry.h"
#include "graphics/CVertex.h"
#include "graphics/CTriangle.h"
#include "graphics/CDraw3D.h"
#include "graphics/CColor.h"
#include "scenegraph/CMesh.h"
#include <assert.h>
#include <list>
#include <queue>
#include <vector>

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

//---------------------------------------------------------------------------
typedef vector<cCollisionSpheresGenericShape*> Plist;

class cCollisionSpheresSphere;

class cCollisionSpheresLeaf;
//---------------------------------------------------------------------------

//===========================================================================
//===========================================================================
class cCollisionSpheres : public cGenericCollision
{
  public:
    
    //-----------------------------------------------------------------------
    // CONSTRUCTORS AND DESTRUCTOR:
    //-----------------------------------------------------------------------

    cCollisionSpheres(vector<cTriangle> *a_triangles, bool a_useNeighbors);

    virtual ~cCollisionSpheres();


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

    void initialize(double a_radius = 0);

    void render();

    bool computeCollision(cVector3d& a_segmentPointA,
                          cVector3d& a_segmentPointB,
                          cCollisionRecorder& a_recorder,
                          cCollisionSettings& a_settings);


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

    cCollisionSpheresSphere *m_root;

    vector<cTriangle> *m_trigs;

    cTriangle *m_lastCollision;

    bool m_useNeighbors;

    cCollisionSpheresLeaf *m_firstLeaf;

        cTriangle* secret;
};


//===========================================================================
//===========================================================================
class cCollisionSpheresSphere
{
    //-----------------------------------------------------------------------
    // FRIENDS:
    //-----------------------------------------------------------------------

    friend class cCollisionSpheresNode;

    friend class cCollisionSpheresLeaf;


  public:
    
    //-----------------------------------------------------------------------
    // CONSTRUCTORS AND DESTRUCTOR:
    //-----------------------------------------------------------------------

    cCollisionSpheresSphere(cCollisionSpheresSphere *a_parent);

    cCollisionSpheresSphere() : m_center(0,0,0), m_parent(0), m_depth(0) { };

    virtual ~cCollisionSpheresSphere() {};


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

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

    inline double getRadius() { return m_radius; }

    virtual int isLeaf() = 0;

    virtual void draw(int a_depth = -1) = 0;

    static bool computeCollision(cCollisionSpheresSphere *a_sa,
                                 cCollisionSpheresSphere *a_sb,
                                 cCollisionRecorder& a_recorder,
                                 cCollisionSettings& a_settings);

  protected:

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

    cCollisionSpheresSphere *m_parent;

    cVector3d m_center;

    double m_radius;

    int m_depth;

        int m_num;
};


//===========================================================================
//===========================================================================
class cCollisionSpheresNode : public cCollisionSpheresSphere
{
  public:

    //-----------------------------------------------------------------------
    // CONSTRUCTORS AND DESTRUCTOR:
    //-----------------------------------------------------------------------

    cCollisionSpheresNode(Plist &a_primList,
            cCollisionSpheresSphere *a_parent = NULL);

    cCollisionSpheresNode(std::vector<cTriangle> *a_tris,
            cCollisionSpheresSphere *a_parent = NULL,
            double a_extendedRadius = 0);

    cCollisionSpheresNode() : cCollisionSpheresSphere(), m_left(0), m_right(0) { };

    virtual ~cCollisionSpheresNode() {};


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

    void ConstructChildren(Plist &a_primList);

    int isLeaf()  { return 0; }

    void draw(int a_depth);

    static bool computeCollision(cCollisionSpheresNode *a_sa,
                                 cCollisionSpheresSphere *a_sb,
                                 cCollisionRecorder& a_recorder,
                                 cCollisionSettings& a_settings);

    static void swapptr(void **a_a, void **a_b);


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

    cCollisionSpheresSphere *m_left;

    cCollisionSpheresSphere *m_right;
};


//===========================================================================
//===========================================================================
class cCollisionSpheresLeaf : public cCollisionSpheresSphere
{
  public:
    
    //-----------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //-----------------------------------------------------------------------

    cCollisionSpheresLeaf(cCollisionSpheresGenericShape *a_prim,
            cCollisionSpheresSphere *a_parent = NULL);

    cCollisionSpheresLeaf(cTriangle *a_tri,
            cCollisionSpheresSphere *a_parent = NULL,
            double a_extendedRadius = 0);

    cCollisionSpheresLeaf() : cCollisionSpheresSphere() { m_prim = 0; }

    virtual ~cCollisionSpheresLeaf() { if (m_prim) delete m_prim; }


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

    int isLeaf()  { return 1; }

    void draw(int a_depth);

    static bool computeCollision(cCollisionSpheresLeaf *a_sa,
                                 cCollisionSpheresLeaf *a_sb,
                                 cCollisionRecorder& a_recorder,
                                 cCollisionSettings& a_settings);


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

    cCollisionSpheresGenericShape *m_prim;
};

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

---

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