C:/Projects/ngn/include/collision.h

/***************************************************************************
 *            collision.h
 *
 *  Sun Feb  1 12:12:39 2004
 *  Copyright  2004  thierry schartz
 *  thierry.schartz@bluebottle.com
 ****************************************************************************/
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef _COLLISION_H
#define _COLLISION_H

#ifdef WIN32
#include <windows.h>
#endif


#define TRACE_RAY 0
#define TRACE_SPHERE 1
#define TRACE_BOX 2

#include "vector3d.h"
#include "aabb.h"

namespace ngn {

        namespace core {
                class Bsp;
                struct tBSPBrush;


                namespace bsp {

                

                        class NGN_API BSPCollision
                        {
                        public:
                                BSPCollision();
                                BSPCollision( const BSPCollision& other );
                                BSPCollision operator=( const BSPCollision& other );
                                virtual ~BSPCollision();
                                
                                // set type of collision detection ( point, sphere or box )
                                void setTraceType( int trace_type );
                                // get collision detection type
                                int getTraceType() const;
                                // set radius of the sphere to check against bsp
                                void setSphereRadius( float radius );
                                // get sphere radius
                                float getSphereRadius() const;
                                // set AAB box to check collision against
                                void setBox( core::AABB& box );
                                // get AABB
                                AABB& getAABB();
                                // true if collision occured
                                bool collided() const;
                                // true if ground was hit
                                bool hitGround() const;
                                // true if small obstacle was hit
                                bool hitStep() const;
                                // trace and check collision
                                core::Vector3df checkCollision( core::Bsp* bsp, core::Vector3df start, core::Vector3df end );
                                // check collision with small objects, return new position and
                                // set 'stepHeight' to obstacle height
                                core::Vector3df checkStep( core::Bsp* bsp, core::Vector3df start, core::Vector3df end, float& stepHeight );
                                

                        protected:
                                // trace for collision
                                core::Vector3df trace( core::Bsp* bsp, core::Vector3df start, core::Vector3df end );
                                // checks all the nodes until find leafs that store the brushes
                                void checkNode(core::Bsp* bsp, int nodeIndex, float startRatio, float endRatio, core::Vector3df start, core::Vector3df end );
                                // checks current movement vector against the brush and its sides
                                void checkBrush( core::Bsp* bsp, core::tBSPBrush *pBrush, core::Vector3df start, core::Vector3df end );

                        private:
                                bool m_collided;                // true if object collided with BSP tree
                                bool m_hitground;               // true if ground was hit
                                bool m_hitstep;                 // true if a small obstacle was encountered
                                const float m_epsilon;  // Quake 3 const for preventing float calculations errors
                                int m_trace_type;               // type of tracing
                                float m_trace_radius;   // collision offset
                                float m_trace_ratio;    // % of trace colliding solid
                                core::AABB m_box;               // box to check collision against
                                core::Vector3df m_collision_normal;     // normal vector to collision plane
                                static float m_max_step_height; // max height for stepping over obstacles


                        };




                }//bsp
        }//core

        class NGN_API Collision
        {
        public:
                Collision();

                core::Vector3df checkCollision( core::Vector3df start, core::Vector3df end );
                bool collided() const;
                void setTraceType( int trace_type );
                int getTraceType() const;
                void setSphereRadius( float radius );
                float getSphereRadius() const;
                void setBox( core::AABB& box );

        private:
                core::bsp::BSPCollision m_collision;
        
        };
                





}//ngn
#endif /* _COLLISION_H */

---