ivp_environment.cxx

hl2 source code. Do not use it illegal.

// Copyright (C) Ipion Software GmbH 1999-2000. All rights reserved.


#ifndef WIN32
#	pragma implementation "ivp_environment.hxx"
#endif

#include <ivp_physics.hxx>

#if defined(WIN32) || defined(PSXII)
//#	include <sys\types.h>
//#	include <sys\stat.h>
//#	include <windows.h>
#	include <time.h>
#endif

#if defined(PSXII)
#include <libcdvd.h>
#define NULL 0
#endif

#include <ivp_debug.hxx>
#include <ivp_debug_manager.hxx>
#include <ivp_physic_private.hxx>
#include <ivp_sim_unit.hxx>
#include <ivp_time.hxx>
#include <ivu_memory.hxx>
#include <ivu_active_value.hxx>
#include <ivp_actuator.hxx>
#include <ivp_templates.hxx>
#include <ivp_controller_motion.hxx>

#include <ivp_material.hxx>
#include <ivp_collision_filter.hxx>
#include <ivp_compact_ledge.hxx>
#include <ivp_clustering_longrange.hxx>
#include <ivp_cache_object.hxx>
#include <ivp_cache_ledge_point.hxx>
#include <ivp_range_manager.hxx>
#include <ivp_anomaly_manager.hxx>

#include <ivp_great_matrix.hxx>
#include <ivp_constraint_local.hxx>

#include <ivp_mindist_intern.hxx>
#include <ivp_mindist_minimize.hxx>
#include <ivp_mindist_event.hxx>
#include <ivp_friction.hxx>

#include <ivp_listener_collision.hxx>
#include <ivp_listener_object.hxx>
#include <ivp_listener_psi.hxx>
#include <ivp_calc_next_psi_solver.hxx>

#include <ivp_merge_core.hxx>
#include <ivu_set.hxx>
#include <ivp_controller_buoyancy.hxx>
#include <ivp_performancecounter.hxx>

#include <ivp_betterstatisticsmanager.hxx>

#include <ivp_authenticity.hxx>

#if !defined(IVP_VERSION_SDK) && !defined(IVP_VERSION_EVAL)
#   pragma error("You have to define IVP_VERSION_SDK or IVP_VERSION_EVAL")
#endif

IVP_Freeze_Manager::IVP_Freeze_Manager(){
    init_freeze_manager();
}

void IVP_Freeze_Manager::init_freeze_manager(){
    freeze_check_dtime = 0.3f;
}

IVP_Environment::IVP_Environment(IVP_Environment_Manager *manager,IVP_Application_Environment *appl_env,
				 const char *company_name,unsigned int auth_code)
{
  IVP_ASSERT( sizeof(IVP_Compact_Edge) == 4);
  IVP_ASSERT( sizeof(IVP_Compact_Triangle) == 16);
  
    P_MEM_CLEAR(this);
    get_freeze_manager()->init_freeze_manager();

    state=IVP_ES_AT;
    statistic_manager.l_environment=this;
    
    {
	l_material_manager = appl_env->material_manager;
	if (!l_material_manager){
	    l_material_manager = new IVP_Material_Manager(IVP_TRUE);
	}

	l_active_value_manager = appl_env->env_active_float_manager;
	if (!l_active_value_manager){
	    l_active_value_manager = new IVP_U_Active_Value_Manager(IVP_TRUE);
	}
	
	collision_filter = appl_env->collision_filter;
	if (!collision_filter){
	    collision_filter = new IVP_Collision_Filter_Coll_Group_Ident(IVP_TRUE);
	}

	anomaly_manager = appl_env->anomaly_manager;
	if (!anomaly_manager){
	    anomaly_manager = new IVP_Anomaly_Manager(IVP_TRUE);
	}

	anomaly_limits = appl_env->anomaly_limits;
	if (!anomaly_limits){
	    anomaly_limits = new IVP_Anomaly_Limits(IVP_TRUE);
	}
	
	if (!appl_env->default_collision_delegator_root){
	  collision_delegator_roots.add ( new IVP_Collision_Delegator_Root_Mindist() );
	}else{
	  collision_delegator_roots.add(appl_env->default_collision_delegator_root);
	}
	
	universe_manager = appl_env->universe_manager;
    }

    {
	standard_gravity_controller = new IVP_Standard_Gravity_Controller();
	IVP_U_Point temp_grav(0.0f,9.83f,0.0f);
	set_gravity(&temp_grav);
	standard_gravity_controller->grav_vec.set(&temp_grav);
	manager->environments.add(this);
    }
    
    controller_manager = new IVP_Controller_Manager(this);
    
    set_delta_PSI_time( 1.0f/66.0f );
    cluster_manager  = new IVP_Cluster_Manager(this);
    sim_units_manager= new IVP_Sim_Units_Manager(this);
    time_manager     = new IVP_Time_Manager();
    mindist_manager  = new IVP_Mindist_Manager(this);
    ov_tree_manager  = new IVP_OV_Tree_Manager();
    this->better_statisticsmanager = new IVP_BetterStatisticsmanager();

    this->range_manager = appl_env->range_manager;
    if(!appl_env->range_manager){
	this->range_manager = new IVP_Range_Manager(this, IVP_TRUE);
    }

    if (appl_env->performancecounter){
	this->performancecounter = appl_env->performancecounter;
    }else{
	this->performancecounter = new IVP_PerformanceCounter_Simple();
    }
    cache_object_manager = new IVP_Cache_Object_Manager(appl_env->n_cache_object );
    
    environment_manager = manager;
    current_time_code = 1;
    current_time = 0.0f;
    time_of_next_psi = get_delta_PSI_time();

    {
	short_term_mem = new IVP_U_Memory();
	sim_unit_mem = new IVP_U_Memory();
	
	int ssizeh = appl_env->scratchpad_size>>1;
	short_term_mem->init_mem_transaction_usage(appl_env->scratchpad_addr, ssizeh);
	sim_unit_mem->init_mem_transaction_usage  (ssizeh + appl_env->scratchpad_addr, ssizeh);
    }

    next_movement_check=IVP_MOVEMENT_CHECK_COUNT;
    
    IVP_IF( 1 ) {
	this->debug_information=new IVP_Debug_Manager();
	this->delete_debug_information = IVP_TRUE;
    }

    integrated_energy_damp = IVP_Inline_Math::ivp_expf ( IVP_FLOAT(log(0.9f)) * get_delta_PSI_time() );

    IVP_Mindist_Minimize_Solver::init_mms_function_table();
    IVP_Mindist_Event_Solver::init_mim_function_table();

    this->auth_costumer_name = p_strdup(company_name);
    this->auth_costumer_code = auth_code;
    this->pw_count = 10;
   
    { // create a static ball
	IVP_Template_Ball b;
	b.radius = 1.0f;
	IVP_Template_Real_Object t;
	t.set_name( "static_object");
	t.physical_unmoveable = IVP_TRUE;
	IVP_U_Matrix mco;
	mco.init();
	mco.vv.set_to_zero();
	t.mass_center_override = &mco;

	IVP_U_Point position; position.set_to_zero();
	this->static_object = this->create_ball( &b, &t, NULL, &position );
    }

	environment_magic_number=IVP_Environment_Magic_Number;
}

void IVP_Environment::set_delta_PSI_time(IVP_DOUBLE psi_time){
    IVP_ASSERT(psi_time >= IVP_MIN_DELTA_PSI_TIME);
    IVP_ASSERT(psi_time <= IVP_MAX_DELTA_PSI_TIME);
    delta_PSI_time = psi_time;
    inv_delta_PSI_time = 1.0f / delta_PSI_time;
}

IVP_Environment::~IVP_Environment(){
    // make shure that you have deleted first all IVP_Real_Object s

    if(environment_magic_number!=IVP_Environment_Magic_Number) {
        return;
	}

    {
	for (int i = psi_listeners.len()-1; i>=0; i--){
	    IVP_Listener_PSI *lis = psi_listeners.element_at(i);
	    lis->environment_will_be_deleted(this);
	}
    }
    
    static_object->delete_silently();
    static_object = NULL;
    P_DELETE(cluster_manager);   // deletes all objects recursively

    P_DELETE(standard_gravity_controller);
    P_DELETE(controller_manager);
    P_DELETE(time_manager);
    P_DELETE(sim_units_manager);
    P_DELETE(mindist_manager);
    P_DELETE(ov_tree_manager);
    P_DELETE(this->better_statisticsmanager);
    
    IVP_IF( delete_debug_information == IVP_TRUE ) {
	P_DELETE(this->debug_information);
    }
    
    performancecounter->environment_is_going_to_be_deleted(this);

    collision_filter->environment_will_be_deleted(this);
    collision_filter = NULL;

    anomaly_manager->environment_will_be_deleted(this);
    anomaly_manager = NULL;
    
    anomaly_limits->environment_will_be_deleted(this);
    anomaly_limits = NULL;
    
    l_active_value_manager->environment_will_be_deleted(this);
    l_active_value_manager = NULL;
    
    l_material_manager->environment_will_be_deleted(this);
    l_material_manager = NULL;
    
    range_manager->environment_will_be_deleted(this);
    range_manager = NULL;

    for (int k = collision_delegator_roots.len()-1;k>=0;k--){
      IVP_Collision_Delegator_Root *cdr = collision_delegator_roots.element_at(k);
      cdr->environment_is_going_to_be_deleted_event(this);
    }
    collision_delegator_roots.clear();
    
    P_DELETE(short_term_mem);
    P_DELETE(sim_unit_mem);
    P_DELETE(cache_object_manager);
    P_DELETE(auth_costumer_name);
    
    environment_manager->environments.remove(this);
    this->delete_draw_vector_debug();
} 

//IVP_BOOL IVP_Environment::must_perform_movement_check() {
//    next_movement_check--;
//    if(next_movement_check==0) {
//#ifdef IVP_ENCRYPT_EXISTS
//        pw_count--;
//        if(pw_count==0) {
//	    IVP_UINT32 crypt_val = IVP_Encrypt::encrypt_strings(auth_costumer_name,IVP_IPION_AUTH_CHECK);
//	    if(auth_costumer_code != crypt_val) {
//	        mindist_manager=NULL;
//	    }
//	    }
//
//	    time_t t, e;
//		t = time(NULL);
//		e = 3181552896; // october 26th 2000, on a Mac
//		printf(" Now: %.1f   Target: %.1f\n\n", (float)t, (float)e);
//		if (t > e)
//	        mindist_manager=NULL;
//#endif	
//	next_movement_check=IVP_MOVEMENT_CHECK_COUNT*3/2 + (short)(ivp_rand()* (IVP_MOVEMENT_CHECK_COUNT/2));
//	return IVP_TRUE;
//    } else {
//	return IVP_FALSE;
//    }
//}

void IVP_Environment::fire_object_is_removed_from_collision_detection(IVP_Real_Object *obj){
    for (int k = collision_delegator_roots.len()-1;k>=0;k--){
      IVP_Collision_Delegator_Root *cdr = collision_delegator_roots.element_at(k);
      cdr->object_is_removed_from_collision_detection(obj);
    }
}

void IVP_Environment::set_gravity(IVP_U_Point *gravity_){
    this->gravity.set(gravity_);
    this->gravity_scalar=gravity_->real_length();
    this->standard_gravity_controller->set_standard_gravity(gravity_);
}

 
IVP_Environment_Manager::IVP_Environment_Manager()
{
    environments.elems=NULL;
	ivp_willamette_optimization=0;
    //    static_environment_manager=this;
}


IVP_Environment_Manager::~IVP_Environment_Manager()
{
/*
    for (int i = environments.len()-1; i>=0; i--){
	IVP_Environment *env = environments.element_at(i);
	//delete(env);
    }
*/
}


IVP_Actuator_Rot_Mot *IVP_Environment::create_rotmot(IVP_Template_Rot_Mot *templ)
{
    if (templ->active_float_max_torque ||
	templ->active_float_max_rotation_speed ||
	templ->active_float_power){
	return new IVP_Actuator_Rot_Mot_Active(this, templ);
    }
    return new IVP_Actuator_Rot_Mot(this, templ);
}

IVP_Actuator_Torque *IVP_Environment::create_torque(IVP_Template_Torque *templ)
{
    if (templ->active_float_torque || templ->active_float_max_rotation_speed){
			return new IVP_Actuator_Torque_Active(this, templ);
    }
    return new IVP_Actuator_Torque(this, templ);
}

IVP_Controller_Motion *IVP_Environment::create_controller_motion(IVP_Real_Object *obj,const IVP_Template_Controller_Motion *templ){
    return new IVP_Controller_Motion( obj, templ);
}

IVP_Actuator_Force *IVP_Environment::create_force(IVP_Template_Force *templ)
{
    if (templ->active_float_force){
	return new IVP_Actuator_Force_Active(this, templ);
    }else{
	return new IVP_Actuator_Force(this,templ);
    }
}

IVP_Actuator_Spring *IVP_Environment::create_spring(IVP_Template_Spring *templ)
{
    if (templ->active_float_spring_len
	|| templ->active_float_spring_constant
	|| templ->active_float_spring_damp
	|| templ->active_float_spring_rel_pos_damp){
	return new IVP_Actuator_Spring_Active(this,templ);
    }else{
	return new IVP_Actuator_Spring(this, templ, IVP_ACTUATOR_TYPE_SPRING);
    }
}

IVP_Actuator_Suspension *IVP_Environment::create_suspension(IVP_Template_Suspension *templ)
{
	return new IVP_Actuator_Suspension(this, templ);
}

IVP_Actuator_Stabilizer *IVP_Environment::create_stabilizer(IVP_Template_Stabilizer *templ)
{
    return new IVP_Actuator_Stabilizer(this, templ);
}

IVP_Actuator_Check_Dist *IVP_Environment::create_check_dist(IVP_Template_Check_Dist *templ)
{
    return new IVP_Actuator_Check_Dist(this, templ);
}


IVP_Cluster *IVP_Environment::get_root_cluster()
{
    return this->cluster_manager->get_root_cluster();
}


IVP_Environment *IVP_Environment_Manager::create_environment(IVP_Application_Environment *appl_env,
							     const char *costumer_name,unsigned int auth_code) {
#ifdef IVP_ENCRYPT_EXISTS
    IVP_UINT32 crypt_val = IVP_Encrypt::encrypt_strings(costumer_name,IVP_IPION_AUTH_CHECK);
    if(auth_code != crypt_val) {
	return NULL;
    }
#endif
    IVP_Environment *new_en=new IVP_Environment(this,appl_env,costumer_name,auth_code);
    return new_en;
}


IVP_Environment_Manager IVP_Environment_Manager::static_environment_manager;
IVP_Environment_Manager *IVP_Environment_Manager::get_environment_manager()
{
    //    if (static_environment_manager == NULL){
    //	static_environment_manager = new IVP_Environment_Manager();
    //    }
    
    return(&static_environment_manager);
}


void IVP_Environment::simulate_until(IVP_Time until_time){
    this->get_betterstatisticsmanager()->set_simulation_time(until_time.get_time());
    time_manager->event_loop(this,until_time);
    //time_manager->simulate_variable_time_step(this,until_time - get_current_time());
}

void IVP_Environment::simulate_variable_time_step(IVP_FLOAT delta_time){
    this->get_betterstatisticsmanager()->set_simulation_time(get_current_time().get_time() + delta_time);
    time_manager->simulate_variable_time_step(this,delta_time);
}

void IVP_Environment::reset_time(){
    time_manager->reset_time(this->get_old_time_of_last_PSI());
    sim_units_manager->reset_time(this->get_old_time_of_last_PSI());
    
    set_current_time( IVP_Time(get_current_time() - get_old_time_of_last_PSI()));
    time_of_last_psi = IVP_Time(0.0f);
    time_of_next_psi = IVP_Time(0.0f) + get_delta_PSI_time();
}

void IVP_Environment::simulate_dtime(IVP_DOUBLE dtime)
{
    IVP_Time new_time =  get_current_time();
    new_time += dtime;
    time_manager->event_loop(this,new_time);
}

void IVP_Environment::simulate_time_step( IVP_FLOAT sub_psi_time){
    IVP_Time new_time =  get_old_time_of_last_PSI();
    new_time += get_delta_PSI_time() * sub_psi_time;
    time_manager->event_loop(this,new_time);
}

void IVP_Environment::set_current_time(IVP_Time time){
    current_time_code++;
    current_time = time;
}

IVP_Draw_Vector_Debug::IVP_Draw_Vector_Debug(){
    P_MEM_CLEAR(this);
}

IVP_Draw_Vector_Debug::~IVP_Draw_Vector_Debug(){
    if (debug_text) P_FREE(debug_text);
}

void IVP_Debug_Manager::clear_debug_manager() {
#if !defined(PSXII)
    if(out_deb_file) {
      if(out_deb_file!=stdout) {
	fclose(out_deb_file);
      }
    }
#endif
}

IVP_Debug_Manager::~IVP_Debug_Manager() {
    clear_debug_manager();
}

void IVP_Debug_Manager::init_debug_manager() {
    P_MEM_CLEAR(this);
    //out_deb_file = fopen("debugout0","w");
    //file_nr=0;
    //file_out_impacts=IVP_TRUE;
    //check_fs=IVP_TRUE;
    //out_deb_file=stdout;
    revolve_deb_file=IVP_FALSE;
}

IVP_Debug_Manager::IVP_Debug_Manager()
{
    init_debug_manager();
}


void IVP_Environment::delete_draw_vector_debug(){
    IVP_Draw_Vector_Debug *dv,*next_dv;

    dv=this->draw_vectors;
    while(dv!=NULL)    {
	if(dv->debug_text)    P_FREE(dv->debug_text);
	next_dv=dv->next;
	P_DELETE(dv);
	dv=next_dv;
    }