CollisionDetection.h

/****************************************************************************
 * Copyright 2005 Evan Drumwright
 * This library is distributed under the terms of the GNU General Public 
 * License (found in COPYING).
 ****************************************************************************/

#ifndef _COLLISION_DETECTION_H
#define _COLLISION_DETECTION_H

#include <map>
#include <set>
#include <Physsim/sorted_pair>
#include <Physsim/Base.h>
#include <Physsim/Contact.h>
#include <Physsim/VectorN.h>
#include <Physsim/Matrix4.h>

namespace Physsim {

class DynamicBody;
class RigidBody;
class ArticulatedBody;
class CollisionGeometry;
class Triangle;

struct Query
{
        public:
                boost::shared_ptr<void> result;
                CollisionGeometryPtr g1, g2;
                std::list<ContactPtr> c;
};

typedef boost::shared_ptr<Query> QueryPtr;

class CollisionDetection : public Base
{
        public:
                CollisionDetection();
                virtual ~CollisionDetection() {}
                virtual void clone(BasePtr& cloned, bimap<BasePtr, BasePtr>* obj_map = NULL) const;
                virtual bool is_struct_identical(BaseConstPtr object) const;
                virtual void load_state(BaseConstPtr object, bimap<BasePtr, BasePtr>* correspondence = NULL);
                virtual void save_state(BasePtr object, bimap<BasePtr, BasePtr>* correspondence = NULL) const;
                void add_dynamic_body(DynamicBodyPtr body);
                void operator=(const CollisionDetection* source);
                virtual void load_from_xml(XMLTreeConstPtr node, std::map<std::string, BasePtr>& id_map);
                virtual void save_to_xml(XMLTreePtr node, std::list<BaseConstPtr>& shared_objects) const;
                virtual void remove_collision_geometry(CollisionGeometryPtr geom);
                virtual void remove_all_collision_geometries();
                virtual void add_rigid_body(RigidBodyPtr body); 
                virtual void add_articulated_body(ArticulatedBodyPtr abody, bool disable_adjacent);
                virtual void output_object_state(std::ostream& out) const;
                void set_enabled(BasePtr b1, BasePtr b2, bool enabled);
                void set_enabled(BasePtr b, bool enabled);
                bool is_checked(CollisionGeometryPtr cg1, CollisionGeometryPtr cg2) const;


                virtual void add_collision_geometry(CollisionGeometryPtr geom) { _geoms.insert(geom); } 

                const std::set<CollisionGeometryPtr>& get_collision_geometries() const { return _geoms; }
                
                bool is_enabled(CollisionGeometryPtr g1, CollisionGeometryPtr g2) const { return _disabled_pairs.find(make_sorted_pair(g1, g2)) == _disabled_pairs.end(); }
                        
                bool is_enabled(CollisionGeometryPtr g) const { return _disabled.find(g) == _disabled.end(); }


                virtual bool is_collision(Real epsilon = 0.0) = 0;

                virtual Real calc_distances() = 0;

                
                const std::map<sorted_pair<CollisionGeometryPtr>, QueryPtr>& get_colliding_pairs() const { return _colliding_pairs; }

                const std::map<sorted_pair<CollisionGeometryPtr>, QueryPtr>& get_distances() const { return _distances; }

                const std::set<sorted_pair<CollisionGeometryPtr> >& get_disabled_pairs() const { return _disabled_pairs; }

                const std::set<CollisionGeometryPtr>& get_disabled() const { return _disabled; }

                void add_articulated_body(ArticulatedBodyPtr abody) { add_articulated_body(abody, _disable_adjacent_default); }

                virtual std::list<ContactPtr> find_contacts(CollisionGeometryPtr g1, CollisionGeometryPtr g2) = 0;
                
                bool _disable_adjacent_default;

        protected:
                virtual void save_query_results(BasePtr object, bimap<BasePtr, BasePtr>* correspondence) const { }

                virtual void clone_query_results(BasePtr& cloned, bimap<BasePtr, BasePtr>* object_map) const { }

                virtual void load_query_results(BaseConstPtr object, bimap<BasePtr, BasePtr>* correspondence) { }

                bool collinear(const std::list<Vector3>& points) const;
        
                std::set<sorted_pair<CollisionGeometryPtr> > _disabled_pairs;

                std::set<CollisionGeometryPtr> _disabled;

                std::map<sorted_pair<CollisionGeometryPtr>, QueryPtr> _colliding_pairs;

                std::map<sorted_pair<CollisionGeometryPtr>, QueryPtr> _distances;

        protected:

                std::set<CollisionGeometryPtr> _geoms;
}; // end class

} // end namespace Physsim

#endif

---