Collision.h

//***************************************************************************
//                       Collision Detection
//***************************************************************************

//  Copyright (C): Gabriel Zachmann, TU Clausthal, zach@tu-clausthal.de
//***************************************************************************


#ifndef Collision_H
#define Collision_H
#if defined(__sgi) || defined(_WIN32)
#pragma once
#endif


//---------------------------------------------------------------------------
//  Includes
//---------------------------------------------------------------------------

#include <vector>

#include <OpenSG/OSGConfig.h>
#include <OpenSG/OSGGeoProperty.h>
#include <OpenSG/OSGGeometry.h>

#include <col_import_export.h>

namespace col {

//---------------------------------------------------------------------------
//  Forward References
//---------------------------------------------------------------------------

struct Data;
struct Dop;
struct ColPipelineData;
struct SyncFun;

template<class T> class Queue;
struct Request;
class Matrix;
class ColObj;
struct Callback;
class Grid;

//---------------------------------------------------------------------------
//   Constants
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//   Types
//---------------------------------------------------------------------------

typedef bool (*PolyIntersectT)( Data *data );


typedef enum
{
    LEVEL_BOX,
    LEVEL_HULL,
    LEVEL_EXACT
} LevelOfDetectionE;


typedef enum
{
    ALGO_DEFAULT,                   
    ALGO_DOPTREE,
    ALGO_BOXTREE
} AlgoE;



//***************************************************************************
//  Callback
//***************************************************************************


struct COL_EXPORTIMPORT Callback
{
    virtual void operator () (const Data *data) throw () = 0;

    Callback( osg::NodePtr obj1, osg::NodePtr obj2,
              bool always = false,
              bool all_polygons_in = false,
              LevelOfDetectionE level_of_detection = LEVEL_EXACT );
    virtual ~Callback();

    osg::NodePtr obj1, obj2;

    bool collision;

    bool all_polygons;

    LevelOfDetectionE level;

};


//***************************************************************************
//  Data
//***************************************************************************

struct COL_EXPORTIMPORT PolygonIntersectionData
{

    const osg::Pnt3f   *points[2];
    const unsigned int *pgon[2];
    unsigned int        nvertices[2];

    osg::GeometryPtr    geom[2];
    unsigned int        pgon_index[2];

};


struct COL_EXPORTIMPORT Data
{
    // client data ----------------------------------------------------------

    std::vector<PolygonIntersectionData>     polisecdata;

    osg::NodePtr    node[2];

    osg::Matrix m12;

   // Tells whether or not all intersecting polygons are reported
    bool all_polygons;

    // Debgging -------------------------------------------------------------

    void*               client_data;

    PolyIntersectT      intersect_fun;

    // Internal -------------------------------------------------------------

    const Dop*          dop[2];

    Data( const osg::NodePtr &node1, const osg::NodePtr &node2 );

    // explicit Data( const Data &source );
    // virtual ~Data() throw();

    void addPolygonIntersectionData(  const osg::Pnt3f       *points1,
                                      const osg::Pnt3f       *points2,
                                      const unsigned int     *pgon1,
                                      const unsigned int     *pgon2,
                                      unsigned int           nvertices1,
                                      unsigned int           nvertices2,
                                      const osg::GeometryPtr &geom1,
                                      const osg::GeometryPtr &geom2,
                                      unsigned int           pgon_index1,
                                      unsigned int           pgon_index2 );

protected:
    Data( const Data &source );
    Data& operator = ( const Data &source );
};




//***************************************************************************
//  CollisionPipeline
//***************************************************************************

class COL_EXPORTIMPORT CollisionPipeline : public osg::Thread
{

 public:
    CollisionPipeline( const osg::Char8 *thread_name = NULL,
              unsigned int thread_id = 0 );

    void check( unsigned int *num_moved = NULL );

    static CollisionPipeline *runConcurrently( char* thread_name = NULL );

    static CollisionPipeline *get(char *name);

    static CollisionPipeline *find(char *name);

    void run(unsigned int number);

    void setSyncFun( SyncFun *fun );

    void useConvexHulls(bool useconvexhulls);

    void addCallback( Callback *callback );

    void addCycleCallback( Callback *callback );

    void makeCollidable( osg::NodePtr node );

    void deactivate( osg::NodePtr node );

    void activate( osg::NodePtr node );


    unsigned int getCycle( void );

    bool getUseGrid ();

    void useGrid( unsigned int size[3], float  min[3], float  max[3] );

    static AlgoE getAlgorithm();

    void verbose( bool verbPrint, bool verbShowHulls );

    bool getVerbPrint();

    bool getVerbShowHulls();

    unsigned int getNumObjs();

    void setUseHulls(bool useHulls);

    bool getUseHulls();



    static AlgoE M_PipelineAlgorithm; // = ALGO_DOPTREE, because this is the default algorithm

    unsigned int m_thread_id;

    static int m_Processor;

    unsigned int m_nonEmptyCycles;

    Queue<Request> *m_requests;

    Matrix *m_collmatrix;

    std::vector<ColObj> *m_colobjs;

    std::vector<Callback*> m_cycle_callbacks;

    ColPipelineData* m_pipelinedata;

    Grid *m_grid;

    virtual ~CollisionPipeline();

 protected:
    static osg::MPThreadType m_type;
    static osg::BaseThread* create( const osg::Char8 *thread_name, osg::UInt32 thread_id);
    virtual void workProc(void);

 private:
    unsigned int m_cycle;

    bool m_verb_print;

    bool m_verb_show_hulls;

    bool m_useHulls;

    unsigned int m_numObjs;

    const osg::Char8 *m_thread_name;

    SyncFun *m_syncfun;

    CollisionPipeline (const CollisionPipeline& source);

    void operator = (const CollisionPipeline &source);

    void request( const Request &request );


};  // class pipeline


//***************************************************************************
//  Sync
//***************************************************************************


struct COL_EXPORTIMPORT SyncFun
{
    virtual bool operator () () throw () = 0;

    SyncFun( );
    virtual ~SyncFun();
};




} // namespace col

#endif /* Collision_H */

---