PQPCollisionDetection.h

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

#ifndef _PQP_COLLISION_DETECTION_H
#define _PQP_COLLISION_DETECTION_H

#include <list>
#include <set>
#include <map>
#include <boost/shared_ptr.hpp>
#include "PQP.h"
#include <Physsim/Polyhedron.h>
#include <Physsim/CollisionDetection.h>

struct PQP_CollideResult;

namespace Physsim {

class RigidBody;
class ArticulatedBody;
class CollisionGeometry;        
struct InsideEdge;

class PQPCollisionDetection : public CollisionDetection
{
        public:
                PQPCollisionDetection();
                PQPCollisionDetection(const std::vector<DynamicBodyPtr>& bodies);
                PQPCollisionDetection(const std::vector<DynamicBodyPtr>& bodies, bool disable_adjacent);
                ~PQPCollisionDetection() {}
                void reconstruct();
                void reconstruct(CollisionGeometryPtr geom);
                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;
                virtual bool is_collision(Real epsilon = 0.0);
                virtual Real calc_distances();
                virtual std::list<ContactPtr> find_contacts(CollisionGeometryPtr g1, CollisionGeometryPtr g2);
                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 add_collision_geometry(CollisionGeometryPtr geom);
                virtual void remove_collision_geometry(CollisionGeometryPtr geom);
                virtual void remove_all_collision_geometries();


                void set_distance_query_rerr(Real err) { _dquery_rerr = err; }


                void set_distance_query_aerr(Real err) { _dquery_aerr = err; }


                bool get_geoms_interpenetrate() const { return _geoms_interpenetrate; }


                void set_geoms_interpenetrate(bool flag) { _geoms_interpenetrate = flag; }


        protected:
                boost::shared_ptr<std::list<std::pair<TriangleConstPtr, TriangleConstPtr> > > get_colliding_tris(CollisionGeometryPtr g1, boost::shared_ptr<CollisionGeometry> g2) const;
                virtual void clone_query_results(BasePtr& cloned, bimap<BasePtr, BasePtr>* object_map) const;
                virtual void save_query_results(BasePtr object, bimap<BasePtr, BasePtr>* correspondence) const;
                virtual void load_query_results(BaseConstPtr object, bimap<BasePtr, BasePtr>* correspondence);

                std::map<Vector3ConstPtr, std::list<TriangleConstPtr> > _adj_facets;

        private:
                std::list<ContactPtr> form_contacts(CollisionGeometryPtr g1, CollisionGeometryPtr g2, const std::list<std::pair<TriangleConstPtr, TriangleConstPtr> >& colliding_tris) const;
                ContactPtr det_contact_geometry(CollisionGeometryPtr g1, CollisionGeometryPtr g2, std::list<std::pair<TriangleConstPtr, TriangleConstPtr> >& colliding_tris) const;
                void det_contact_normal(CollisionGeometryPtr g2, CollisionGeometryPtr g2, Contact& c, std::list<std::pair<TriangleConstPtr, TriangleConstPtr> >& colliding_tris) const;
                Real det_d(const std::list<Vector3ConstPtr>& p_vertices, const std::list<Vector3ConstPtr>& q_vertices, const Polyhedron& isect, const Vector3& normal) const;
                Vector3 det_polygon_normal(const std::list<Vector3>& polygon) const;
                boost::shared_ptr<std::list<Vector3> > get_contact_vertices(CollisionGeometryPtr g2, CollisionGeometryPtr g2, const std::list<std::pair<TriangleConstPtr, TriangleConstPtr> >& colliding_tris) const;
                static void to_PQP(const Matrix4& m, PQP_REAL R[3][3], PQP_REAL T[3]);
                static boost::shared_ptr<PQP_CollideResult> clone_collide_result(const PQP_CollideResult& cr);
                static boost::shared_ptr<PQP_DistanceResult> clone_distance_result(const PQP_DistanceResult& dr);
                Real _dquery_rerr;
                Real _dquery_aerr;
        
                std::map<CollisionGeometryPtr, boost::shared_ptr<PQP_Model> > _model_map;

        protected:
                bool _geoms_interpenetrate;

                std::map<CollisionGeometryPtr, std::list<TriangleConstPtr> > _non_coplanar_facets;
};

} // end namespace

#endif

---