Simulator.h

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

#ifndef _SIMULATOR_H
#define _SIMULATOR_H

#include <list>
#include <map>
#include <set>
#include <boost/shared_ptr.hpp>
#include <Inventor/nodes/SoSeparator.h>
#include <Physsim/Base.h>
#include <Physsim/VectorN.h>

namespace Physsim {

class RigidBody;
class ArticulatedBody;
class Integrator;
class RecurrentForce;
class VisualizationData;
class DynamicBody;


class Simulator : public Base
{
        public:
                Simulator();
                virtual ~Simulator(); 
                virtual void determine_external_forces();
                virtual bool is_struct_identical(BaseConstPtr object) const;
                virtual void clone(BasePtr& cloned, bimap<BasePtr, BasePtr>* obj_map = NULL) 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 Real step(Real step_size);
                DynamicBodyPtr find_dynamic_body(const std::string& name) const;
                RigidBodyPtr find_rigid_body(const std::string& name) const;
                ArticulatedBodyPtr find_articulated_body(const std::string& name) const;
                std::list<RigidBodyPtr> get_all_rigid_bodies() const;
                void add_dynamic_body(DynamicBodyPtr body);
                void set_dynamic_bodies(const std::vector<DynamicBodyPtr>& bodies);
                void update_visualization();
                virtual void save_to_xml(XMLTreePtr node, std::list<BaseConstPtr>& shared_objects) const;
                virtual void load_from_xml(XMLTreeConstPtr node, std::map<std::string, BasePtr>& id_map);       
                void set_recurrent_forces(const std::vector<RecurrentForcePtr>& forces);
                void add_recurrent_force(RecurrentForcePtr force);
                void set_recurrent_forces_enabled(bool flag);
                        
                const std::vector<RecurrentForcePtr>& get_recurrent_forces() const { return _recurrent_forces; }

                // Gets whether a given recurrent force is individually disabled
                bool get_recurrent_force_enabled(RecurrentForcePtr force) { return _active_forces.find(force) != _active_forces.end(); }

                void set_recurrent_force_enabled(RecurrentForcePtr force, bool flag) { if (flag) _active_forces.insert(force); else _active_forces.erase(force); }
                

                const std::vector<DynamicBodyPtr>& get_dynamic_bodies() const { return _bodies; }

                IntegratorPtr get_integrator() { return _integrator; }
                
                Real get_time() const { return _current_time; }


                Real get_regression_factor() const { return _regression_factor; }
                
                void set_integrator(IntegratorPtr integrator) { _integrator = integrator; }
                
                void set_time(Real time) { assert(time >= 0.0); _current_time = time; }


                void set_regression_factor(Real regression_factor) { assert(regression_factor >= 1.0); _regression_factor = regression_factor; }

                void add_transient_vdata(SoNode* vdata) { _transient_vdata->addChild(vdata); } 
                
                SoSeparator* get_persistent_vdata() const { return _persistent_vdata; } 

                SoSeparator* get_transient_vdata() const { return _transient_vdata; } 

        protected:
                SoSeparator* _persistent_vdata;
                SoSeparator* _transient_vdata;
                std::vector<DynamicBodyPtr> _bodies;
                std::vector<RecurrentForcePtr> _recurrent_forces;
                std::set<RecurrentForcePtr> _active_forces;
                void integrate(Real step_size);
                Real _regression_factor;


                bool _external_forces_determined;

        private:
                Real _current_time;
                IntegratorPtr _integrator;
        
                static VectorN ode(const VectorN& x, Real t, void* data) { return *((VectorN*) data); }
                static void* set_dynamic_body_state(void* arg);
                static void* get_dynamic_body_state_deriv(void* arg);
}; // end class
} // end namespace 

#endif

---