source: code/branches/physics/src/ogreode/OgreOdeCollision.h @ 2028

#ifndef _OGREODECOLLISION_H_
#define _OGREODECOLLISION_H_

#include "OgreOdePreReqs.h"
#include <OgreVector3.h>

namespace OgreOde 
{
        class _OgreOdeExport CollisionListener
        {
        public:
                CollisionListener();
                virtual ~CollisionListener();

                virtual bool collision(Contact* contact) = 0;
        };


        /** Using the default collisionCallbacks provided here will use the internal collisions setting of 
                of the space. 
                The space collide function now takes a bool useInternalCollisionFlag if you want internal collisions.
        */
        class _OgreOdeExport CollisionCallback : public CollisionListener
        {
        public:
        
                friend class Space;
                friend class Geometry;
        
                CollisionCallback();
                virtual ~CollisionCallback();
                
                /** handles the ode callback and passes on to pure virtual methods that inherited classes implement
                */
                static void collisionCallback(void *data, dGeomID geom_a, dGeomID geom_b);

                /** user impliemented
                */
                virtual void collisionCallback(OgreOde::Space* spaceFirst, OgreOde::Space* spaceSecond);
                
                virtual void collisionCallback(OgreOde::Space* space, OgreOde::Geometry* geometry);
                
                virtual void collisionCallback(OgreOde::Space* space);
                
                // This is down to a AABB level of the geometry, call collide() in here to go down further.
                virtual void collisionCallback(OgreOde::Geometry* geometryFirst, OgreOde::Geometry* geometrySecond);
        };


        class _OgreOdeExport Contact
        {
                friend class Geometry;
                friend class ContactMapCollisionListener;
        
        public:
                enum Flag
                {
                        Flag_UseAdditionalFriction                      = dContactMu2,
                        Flag_UseFirstFrictionDirection          = dContactFDir1,
                        Flag_SurfaceIsBouncy                            = dContactBounce,
                        Flag_UseERP                                                     = dContactSoftERP,
                        Flag_UseCFM                                                     = dContactSoftCFM,
                        Flag_IndependentMotion                          = dContactMotion1, 
                        Flag_AdditionalIndependentMotion        = dContactMotion2,
                        Flag_UseFDS                                                     = dContactSlip1,
                        Flag_UseAdditionalFDS                           = dContactSlip2,
                        Flag_FrictionPyramid                            = dContactApprox1_1,
                        Flag_AdditionalFrictionPyramid          = dContactApprox1_2,
                        Flag_BothFrictionPyramids                       = dContactApprox1 
                };

        public:
                Contact();
                ~Contact();

                const Ogre::Vector3& getPosition();
                const Ogre::Vector3& getNormal();
                Ogre::Real getPenetrationDepth();

        int getFirstSide();
        int getSecondSide();

                Geometry* getFirstGeometry();
                Geometry* getSecondGeometry();

                void setFirstFrictionDirection(const Ogre::Vector3& vector);
                void setFrictionMode(Contact::Flag flag);

                void setCoulombFriction(Ogre::Real mu, Ogre::Real additional_mu = -1.0);
                void setBouncyness(Ogre::Real bouncyness, Ogre::Real velocity_threshold = -1.0);
                void setSoftness(Ogre::Real ERP, Ogre::Real CFM);
                void setIndependentMotion(Ogre::Real velocity, Ogre::Real additional_velocity = -1.0);
                void setForceDependentSlip(Ogre::Real FDS);
                void setAdditionalFDS(Ogre::Real FDS);

                inline void setContact(dContact* contact)
                {
                        _contact = contact;
                        _contact->surface.mode = 0;
                }
        protected:
                inline Contact& operator=(dContact* contact)
                {
                        _contact = contact;
                        _contact->surface.mode = 0;
                        return *this;
                }

        protected:
                dContact* _contact;
                Ogre::Vector3 _position,_normal;
        };

        class _OgreOdeExport ContactMapCollisionListener:public CollisionListener
        {
        public:
                ContactMapCollisionListener();
                virtual ~ContactMapCollisionListener();

                virtual bool collision(Contact* contact);

                void createContact(MaterialID materialA,MaterialID materialB); 
                Contact *getContactPtr(MaterialID materialA,MaterialID materialB); 

        protected:
                std::map<MaterialID,MaterialMap* > _map;
        };
}

#endif