ColObj.h

//***************************************************************************
//                           Various "small" classes
//***************************************************************************
//  Copyright (C):
//***************************************************************************
//CVSId: "@(#)$Id: ColObj.h,v 1.10 2004/06/09 12:23:18 weller Exp $"
//***************************************************************************


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

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

#include <vector>

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

#include <ColDopTree.h>
#include <ColBoxtree.h>
#include <ColConvexHull.h>
#include <ColGridObj.h>

#include <col_import_export.h>


namespace col {

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

class Matrix;
class MatrixCell;
class ColPair;


//***************************************************************************
//  ColObj
//***************************************************************************

class COL_EXPORTIMPORT ColObj
{

    friend class Matrix;
    friend class MatrixCell;
    friend class ColPair;

public:

    ColObj();
    ColObj( osg::GeometryPtr &geom, osg::NodePtr &node,
            bool flexible, bool stationary,
            bool compute_hull, AlgoE algo, Grid *grid,
            bool show_hull = false, char *name = NULL );
    virtual ~ColObj() throw();

    ColObj( const ColObj &source );
    void operator = ( const ColObj &source );

    void updateBBox( void );
    bool bboxIntersects( ColObj* other );
    bool hasMoved( unsigned int global_cycle );

    const char * getName( void ) const;

    void setActive( bool active );
    bool isActive();
    void setFlexible( bool flexible );
    void setStationary( bool stationary );

    static ColObj* find( vector<ColObj> *colobjs, osg::NodePtr obj );

    void SetGridObj( Grid *grid );
    GridObj * GetGridObj( void );
    void updateGrid ( void );

protected:

    bool m_active;

    bool m_flexible;

    bool m_stationary;

    const DopTree *m_doptree;

    const Boxtree *m_boxtree;

    osg::NodePtr m_node;                    // TODO: const machen, wenn OSG erlaubt

    osg::Matrix m_old_matr;

    osg::Matrix m_curr_matr;

    vector<const osg::MFPnt3f *> points;
    char *m_name;

    int m_col_matr_idx;

    bool m_has_moved;
    bool m_first_moved_check;
    unsigned int m_cycle;

    ConvexHull m_hull;

    //pointer to GridObj if grid is used, else NULL
    GridObj *m_gridobj;

};



//***************************************************************************
//  ColPair
//***************************************************************************

class COL_EXPORTIMPORT ColPair
{

public:

    ColPair();
    ColPair( ColObj* p, ColObj* q );
    ColPair( const ColPair &source );
    void operator = ( const ColPair &source );
    virtual ~ColPair() throw();

    ColObj* p( void ) const;
    ColObj* q( void ) const;

protected:

    ColObj *m_p, *m_q;

};



//**************************************************************************
// MatrixCell
//**************************************************************************

class COL_EXPORTIMPORT MatrixCell
{
public:

    MatrixCell( const ColObj *colobj1, const ColObj *colobj2 );

    void addCallback( Callback *callback );
    void callCallbacks( void ) const;

    bool check( bool use_hulls );

protected:

    vector<Callback*>   m_callback;

    ColObj const * const m_colobj1;
    ColObj const * const m_colobj2;

    LevelOfDetectionE m_level;

    SepPlane m_sep_plane;

    Data m_data;

    bool m_allpolygons;
};



//***************************************************************************
//  Matrix
//***************************************************************************

class COL_EXPORTIMPORT Matrix
{
public:

    Matrix( unsigned int numcolobjs = 50 );

    void addObj( ColObj *obj );
    void addCallback( Callback *callback, vector<ColObj> *colobjs );

    MatrixCell * getCell( const ColPair &pair ) const;
    MatrixCell * createCell( const ColObj *obj1, const ColObj *obj2 );

    bool check( const ColPair &pair, bool use_hulls, AlgoE algo ) const;
    void callCallbacks( const ColPair &pair ) const;

    bool isConsistent( vector<ColObj> *colobjs ) const;

protected:

    typedef vector<MatrixCell*> m_Row;

    vector<m_Row> m_m;

    explicit Matrix( const Matrix &source );
    Matrix& operator = ( const Matrix &source );

};


} // namespace col

#endif /* ColObj_H */

---