ivp_environment.hxx

hl2 source code. Do not use it illegal.

    //some PSI grid dependent constants
    IVP_DOUBLE integrated_energy_damp;
    IVP_DOUBLE get_integrated_energy_damp() { return integrated_energy_damp; };
    /***********************************************************************************
     *			Internal public functions, handle with care:
     ***********************************************************************************/
public:
    void set_event_function();
    IVP_U_Vector<IVP_Listener_Object> global_object_listeners;
    IVP_U_Vector<class IVP_Collision_Delegator_Root> collision_delegator_roots;
    
    void fire_event_object_created(IVP_Event_Object *);
    void fire_event_object_deleted(IVP_Event_Object *);
    void fire_event_object_frozen (IVP_Event_Object *);
    void fire_event_object_revived(IVP_Event_Object *);
    void fire_object_is_removed_from_collision_detection(IVP_Real_Object *o);
	void fire_event_constraint_broken(IVP_Constraint *);
#ifdef HAVANA_CONSTRAINTS
	void fire_event_constraint_broken(class hk_Breakable_Constraint*);
#endif // HAVANA_CONSTRAINTS

    ////////// debugging
    IVP_Debug_Manager *debug_information;
    IVP_BOOL delete_debug_information;

    IVP_Draw_Vector_Debug *draw_vectors;
    void add_draw_vector(const IVP_U_Point *start_ws,const IVP_U_Float_Point *vec,const char *debug_text,int color);
    void delete_draw_vector_debug();    
    
    //////////// time management
    IVP_Time get_next_PSI_time(){ return time_of_next_psi; }
    IVP_Time get_old_time_of_last_PSI() { return time_of_last_psi; };

    IVP_FLOAT get_delta_PSI_time() { return delta_PSI_time; }
    IVP_FLOAT get_inv_delta_PSI_time() { return inv_delta_PSI_time; }

    IVP_Time_CODE get_current_time_code(){ return current_time_code; }
    
    IVP_ENV_STATE get_env_state() { return state; };	// return state;

    //////// private managers
    IVP_Time_Manager		 *get_time_manager() const	        { return time_manager;};
    IVP_Controller_Manager       *get_controller_manager() const        { return controller_manager; }; 
    IVP_Mindist_Manager		 *get_mindist_manager() const	        { return mindist_manager; };
    IVP_Sim_Units_Manager        *get_sim_units_manager() const         { return sim_units_manager; };

    IVP_Cache_Object_Manager	 *get_cache_object_manager() const      { return cache_object_manager; };
    IVP_OV_Tree_Manager          *get_ov_tree_manager() const           { return ov_tree_manager; };
    IVP_Cluster_Manager          *get_cluster_manager() const           { return cluster_manager; };
    IVP_Debug_Manager		 *get_debug_manager() const             { return debug_information; };
    IVP_U_Memory		 *get_memory_manager() const	        { return short_term_mem; };
    IVP_Cluster                  *get_root_cluster();
    IVP_PerformanceCounter	*get_performancecounter()  		{ return performancecounter; };

    IVP_U_Memory *get_sim_unit_mem(){ return sim_unit_mem; };
    IVP_U_Memory *get_short_term_mem(){ return short_term_mem; };






    /***********************************************************************************
     *			real public functions:
     ***********************************************************************************/

    //////////// public managers
    IVP_Range_Manager		 *get_range_manager() const 			{ return range_manager; };
    IVP_Material_Manager 	 *get_material_manager() const			{ return l_material_manager; };
    IVP_Collision_Filter	 *get_collision_filter() const			{ return collision_filter; };
    IVP_Statistic_Manager	 *get_statistic_manager()			{ return &statistic_manager; };
    IVP_BetterStatisticsmanager	 *get_betterstatisticsmanager()			{ return better_statisticsmanager; };
    IVP_U_Active_Value_Manager	 *get_active_value_manager() const		{ return l_active_value_manager; };
    IVP_Universe_Manager 	 *get_universe_manager() const			{ return universe_manager; };
    IVP_Anomaly_Manager		 *get_anomaly_manager() const                   { return anomaly_manager; }
    IVP_Anomaly_Limits		 *get_anomaly_limits() const                   { return anomaly_limits; }

    IVP_Real_Object	         *get_static_object() const                     { return static_object; }; // a env. global static ball
    IVP_Freeze_Manager           *get_freeze_manager()                          { return &freeze_manager; };
    //////////// time management
    IVP_Time get_current_time(){ return current_time; }
    void 	set_delta_PSI_time( IVP_DOUBLE new_delta_PSI_time );		// range: IVP_MIN_DELTA_PSI_TIME - IVP_MAX_DELTA_PSI_TIME
    
    static void set_global_collision_tolerance( IVP_DOUBLE tolerance = 0.01f);   // set the collision tolerance (try to go for higher values if possible)
    
    ////////// world creation

    // this is preleminary: allows to define breakable objects.
    // to create fixed complex objects, see the IVP_SurfaceBuilder_Ledge_Soup classes
    // Note: merge objects before collision detection is enabled and objects are revived !!!
    //       you may use IVP_Object_Attach::xxxx()  instead
    void merge_objects(IVP_U_Vector<IVP_Real_Object> *obj_to_merge);


    /********************************************************************************
     *	Name:	  	create_polygon /    create_ball 	
     *	Description:	Creates objects
     *	Note:		Objects are not collision detection enabled:
     *				to enable collision detection call
     *				IVP_Real_Object::enable_collision_detection
     *			Objects are not simulated when created. Simulation is started
     *			when objects collide or IVP_Real_Object::ensure_in_simulation() is called
     ********************************************************************************/
    IVP_Polygon *create_polygon(IVP_SurfaceManager *surface_manager,	// a surface_manager manager
				const IVP_Template_Real_Object *templ_obj,	// used to set mass center and rotation inertia directly (no automatism)
				const IVP_U_Quat *quat_world_f_object,	// the rotation of the object
				const IVP_U_Point *position);		// the position
    
    IVP_Ball *create_ball(	const IVP_Template_Ball *templ_ball,		// the radius
				const IVP_Template_Real_Object *templ_obj,	// used to set mass center and rotation inertia directly (no automatism)
				const IVP_U_Quat *quat_world_f_object,	// the rotation of the object
				const IVP_U_Point *position);		// the position
    

    // simple (predefined) actuators
    IVP_Actuator_Spring  *create_spring(IVP_Template_Spring *templ);     // creates a damped spring, Note IVP_Controller_Stiff_Spring are better
    IVP_Actuator_Suspension *create_suspension(IVP_Template_Suspension *templ); // creates a special vehicle spring
 
    IVP_Actuator_Force   *create_force(IVP_Template_Force *templ);       // creates a force actuator
    IVP_Actuator_Torque  *create_torque(IVP_Template_Torque *templ);     // creates a torque actuator
    IVP_Actuator_Rot_Mot *create_rotmot(IVP_Template_Rot_Mot *templ);    // creates a motor

    IVP_Actuator_Stabilizer   *create_stabilizer(IVP_Template_Stabilizer *templ);       // used for cars
    IVP_Actuator_Check_Dist   *create_check_dist(IVP_Template_Check_Dist *templ);       // creates a distance checker

    ////////// create constraints
    // for mor info on constraints look at ivp_template_constraint.hxx
    IVP_Constraint *create_constraint(const IVP_Template_Constraint *template_constraint);

    IVP_Controller_Motion *create_controller_motion(IVP_Real_Object *, const class IVP_Template_Controller_Motion *);

    const IVP_U_Point *get_gravity(){ return &gravity; };		// current gravity vector, default (0,9.83f,0);
    void set_gravity(IVP_U_Point *gravity);				// sets gravity vector (can be changed at any time)
	class IVP_Standard_Gravity_Controller *get_gravity_controller( void ) { return standard_gravity_controller; }
    
    /////////// global listening (private listening: see IVP_Real_Object)
    void add_listener_object_global(IVP_Listener_Object *); // adds a callback which listens to events of all objects
    void install_listener_object_global(IVP_Listener_Object *); // adds a callback which listens to events of all objects if its not in the list already
    void remove_listener_object_global(IVP_Listener_Object *);
    
    void add_listener_object_private(IVP_Real_Object *, IVP_Listener_Object *);		// adds a callback which listens to object events of one object
    void remove_listener_object_private(IVP_Real_Object *, IVP_Listener_Object *);	// (same as IVP_Real_Object::add_listener_object())

    void add_listener_collision_global(IVP_Listener_Collision *);	// adds a callback which listens to all collisions
    void remove_listener_collision_global(IVP_Listener_Collision *);

    void add_listener_collision_private(IVP_Real_Object *, IVP_Listener_Collision *);	// adds a callback which listens to just one object
    void remove_listener_collision_private(IVP_Real_Object *, IVP_Listener_Collision *);// (note: same as IVP_Real_Object::add_listener_collision())

    void add_listener_PSI(IVP_Listener_PSI *);			// adds a callback called at the beginning of every PSI
    void remove_listener_PSI(IVP_Listener_PSI *);

	void add_listener_constraint_global(IVP_Listener_Constraint *);
	void remove_listener_constraint_global(IVP_Listener_Constraint *);

    /////////// simulation
    void simulate_until(IVP_Time time);				// the MAIN function: simulates the entire physical environment until 'time'
    void simulate_dtime(IVP_DOUBLE deta_time);			// the MAIN function: simulates the entire physical for a given time
    void simulate_time_step( IVP_FLOAT sub_psi_pos = 1.99 );    // simulate exactly one time step (for synchronous use of the physics engine (e.g. playstation 2).

    void simulate_variable_time_step( IVP_FLOAT delta_time );    // simulate exactly one time step with a variable length
                                                                 // delta_time has to be in between 0.1 and 0.005 

    void reset_time();                                          // resets the time to zero

    void *client_data; //store pointer to custom datastructure

    /////////// construct/destruct: constructor see: IVP_Environment_Manager
    ~IVP_Environment();

    int environment_magic_number; //to detect if environment is valid (debug reasons)    
};

/********************************************************************************
 *	Name:	     	IVP_Application_Environment  	
 *	Description:	The Ipion Virtual Physics Engine users should provide
 *			an instance of IVP_Application_Environment to
 *			handle different events during simulation.
 *	Attention:	All values have to be set.
 ********************************************************************************/
class IVP_Application_Environment {
public:
    int	n_cache_object;		  // == 2**x number of caches for moving objects, should be larger than typical number of moving objects

    char *scratchpad_addr;        // scratch pad: a fast area which is temporarily used and is already cached in
    int scratchpad_size;

    /********************************************************************************
     *	Name:	     	Several custom managers  	
     *	Description:	To override basic functionality of the Ipion Physics Engine
     *               	you may replace some of it's internal managers by your
     *                	own version
     ********************************************************************************/
    IVP_Material_Manager     *material_manager; 	// a manager which serves friction and elasticity coefficients
    IVP_Collision_Filter     *collision_filter;		// a filter that checks which objects should be watched for collisions
    IVP_Universe_Manager     *universe_manager;		// see IVP_Universe_Manager
    IVP_PerformanceCounter   *performancecounter;       //
    IVP_Anomaly_Manager	     *anomaly_manager;
    IVP_Anomaly_Limits	     *anomaly_limits;

    IVP_Collision_Delegator_Root *default_collision_delegator_root; // an optional user defined default root collision delegator

    IVP_U_Active_Value_Manager *env_active_float_manager;	// a hash of active_values
    IVP_Range_Manager *range_manager;			// optional custom range_manager

    
    IVP_Application_Environment();
};

class IVP_Vector_of_Hulls_128: public IVP_U_Vector<IVP_Hull_Manager_Base> {
    IVP_Hull_Manager_Base *elem_buffer[128];
public:
    IVP_Vector_of_Hulls_128(): IVP_U_Vector<IVP_Hull_Manager_Base>((void **)&elem_buffer[0], 128){;};
};

class IVP_Vector_of_Cores_128: public IVP_U_Vector<IVP_Core> {
    void *elem_buffer[128];
public:
    IVP_Vector_of_Cores_128(): IVP_U_Vector<IVP_Core>(&elem_buffer[0], 128){;};
};


/********************************************************************************
 *	Name:	    	IVP_Environment_Manager  	
 *	Description:	Factory for IVP_Environments
 *	Note:		When creating an environment, create a fully initialized
 *			IVP_Application_Environment first.
 ********************************************************************************/
class IVP_Environment_Manager {
    friend class IVP_Environment;
private:
    static IVP_Environment_Manager static_environment_manager;
    IVP_Environment_Manager();
public:
    ~IVP_Environment_Manager();
    int ivp_willamette_optimization;


    IVP_U_Vector<IVP_Environment> environments;
    IVP_Environment *create_environment(IVP_Application_Environment *appl_env,const char *costumer_name,unsigned int auth_code);
    static IVP_Environment_Manager* IVP_CDECL get_environment_manager();			
};

#endif