colmodel.h

Go to the documentation of this file.

/* MAINTAINER: Petko CURRENT EDITOR: Bernard */
#ifndef _COLMODEL_H
#define _COLMODEL_H

#include "GLVector.h"
#include "GLQuaternion.h"


inline double absD(double d)
{
        return (d >=0)? d : -d;
}


 /*@{ */

const int BOTTOM_FRONT_LEFT     = 0;
const int BOTTOM_FRONT_RIGHT= 1;
const int BOTTOM_BACK_RIGHT     = 2;
const int BOTTOM_BACK_LEFT      = 3;
const int TOP_FRONT_LEFT        = 4;
const int TOP_FRONT_RIGHT       = 5;
const int TOP_BACK_RIGHT        = 6;
const int TOP_BACK_LEFT         = 7;


class CDBox
{
public:
        CDBox(){};
        virtual ~CDBox(){};

        GLVector3d mVertex[8];

        void zeroize()
        {
                for (int i = 0; i < 8; i++ ) mVertex[i].set( 0, 0, 0 );
        }

        void translate( const GLVector3d translation )
        {
                for (int i = 0; i < 8; i++ ) mVertex[i]+= translation;
        }

        void rotate( GLQuaterniond rotation )
        {
                for (int i = 0; i < 8; i++ ) mVertex[i] = rotation.rotateVector( mVertex[i] );
        }

        
        double getMin(int cordinate) const
        {
                double min = mVertex[0].val[cordinate];
                for (int i = 1; i < 8; i++) if (mVertex[i].val[cordinate] < min) min = mVertex[i].val[cordinate];
                return min;
        }
                
        double getMax(int cordinate) const
        {
                double max = mVertex[0].val[cordinate];
                for (int i = 1; i < 8; i++) if (mVertex[i].val[cordinate] > max) max = mVertex[i].val[cordinate];
                return max;
        }

        bool quickCheckCollision( const CDBox & box ) const
        {
                for (int i = 0; i < 3; i++)
                {
                        if (getMax(i) <= box.getMin(i) ||
                                getMin(i) >= box.getMax(i)) return false;
                }
                return true;
        }

        void project(const GLVector3d &normal, double &min, double &max) const
        {
                min = max = normal.dot(mVertex[0]);
                for (int i = 1; i < 8; i++)
                {
                        double d = normal.dot(mVertex[i]);
                        if (d < min) min = d;
                        if (d > max) max = d;
                }
        }

        double trySepparatingAxis(const CDBox & box, int a1, int a2, int b1, int b2, GLVector3d &normal) const
        {
                // compute normal vector of seprarating plane
                normal = mVertex[a1]-mVertex[a2];
                normal.cross(box.mVertex[b1]-box.mVertex[b2]);
                
                // Test for zero vector. The normalization
                // isn't needed to decide the collision but it isn't possible
                // to directly comprare values returned by this function without
                // normalization.
                // The length test is needed to avoid divison by zero :-)
                if (normal.length() == 0) 
                {
                        return 100000000;               
                }
                normal.normalize();
        
                return projectAndCompare(*this, box, normal);
        }

        double trySepparatingAxisSelf(const CDBox & box, int a1, int a2, int b1, int b2, GLVector3d &normal) const
        {
                // compute normal vector of seprarating plane
                normal = mVertex[a1]-mVertex[a2];
                normal.cross(mVertex[b1]-mVertex[b2]);
                
                // Test for zero vector. The normalization
                // isn't needed to decide the collision but it isn't possible
                // to directly comprare values returned by this function without
                // normalization.
                // The length test is needed to avoid divison by zero :-)
                if (normal.length() == 0) 
                {
                        return 100000000;               
                }
                normal.normalize();
        
                return projectAndCompare(*this, box, normal);
        }

        static double projectAndCompare(const CDBox & box1, const CDBox & box2, const GLVector3d &normal)
        {               
                // Get min / max for first box
                double min1, max1;
                box1.project(normal, min1, max1);
                
                // Get min / max for second box
                double min2, max2;
                box2.project(normal, min2, max2);
        
                // Decide the colision
                if (min2 >= max1 || min1 >= max2) 
                {
                        return 0; // No collision
                }
                
                if ( max1 - min2 > max2 - min1 ) return max2 - min1;
                return min2 - max1;
        }

};


class CollisionModel
{
public:
        CollisionModel();
        virtual ~CollisionModel(){};

        bool checkCollision( const CollisionModel & model )
        {
                return computeMinimalAvoidVector(model, mAvoidVector);
        }
        
        const GLVector3d & getAvoidVector()
        {
                return mAvoidVector;
        }

        bool computeMinimalAvoidVector( const CollisionModel & model, GLVector3d & result );

        double computeMinimalAvoidDistance( const CollisionModel & model, GLVector3d & direction);
        
        void setTranslation( const GLVector3d &translation )
        {
                mTranslation = translation;
        }
        
        void addTranslation( const GLVector3d &translation )
        {
                mTranslation += translation;
        }

        void setRotation( const GLQuaterniond &rotation )
        {
                mRotation = rotation;
        }
        
        void addRotation( const GLQuaterniond &rotation )
        {
                mRotation *= rotation;
        }

        void finishTransformations()
        {
                mTransBox = mBox;
                mTransBox.rotate( mRotation );
                mTransBox.translate( mTranslation );
                mReseted = false;
        }

        void resetTransformations()
        {
                mTranslation.set( 0, 0, 0 );
                mRotation.set( 0, 0, 0, 0 );
                mTransBox.zeroize();
                mReseted = true;
        }

        bool isReseted() const
        {
                return mReseted;
        }

        CDBox& getModel()
        {
                return mBox;
        }

        CDBox& getTransModel()
        {
                return mTransBox;
        }

        void setModel( const CDBox & model )
        {
                mBox = model;
        }

private:

        CDBox                   mBox;                   

        CDBox                   mTransBox;              

        bool                    mReseted;               

        GLVector3d              mTranslation;   

        GLQuaterniond   mRotation;              

        GLVector3d              mAvoidVector;   
};

#endif

---