ivp_environment.cxx

hl2 source code. Do not use it illegal.

    this->draw_vectors=NULL;

}

IVP_Polygon *IVP_Environment::create_polygon(IVP_SurfaceManager *vic, const IVP_Template_Real_Object *templ,
					     IVP_U_Quat const *rotation, const IVP_U_Point *position)
{
    return new IVP_Polygon(get_root_cluster(), vic, templ, rotation, position);
}

IVP_Ball *IVP_Environment::create_ball( const IVP_Template_Ball *templ_ball, const IVP_Template_Real_Object *templ,
					     IVP_U_Quat const *rotation, const IVP_U_Point *position)
{
    return new IVP_Ball(get_root_cluster(), templ_ball, templ, rotation, position);
}

void IVP_Environment::add_listener_object_private(IVP_Real_Object *ro, IVP_Listener_Object *lo)
{
    this->get_cluster_manager()->add_listener_object(ro, lo);
}

void IVP_Environment::remove_listener_object_private(IVP_Real_Object *ro, IVP_Listener_Object *lo)
{
    this->get_cluster_manager()->remove_listener_object(ro, lo);
}

void IVP_Environment::add_listener_collision_private(IVP_Real_Object *ro, IVP_Listener_Collision *lo)
{
    this->get_cluster_manager()->add_listener_collision(ro, lo);
}

void IVP_Environment::remove_listener_collision_private(IVP_Real_Object *ro, IVP_Listener_Collision *lo)
{
    this->get_cluster_manager()->remove_listener_collision(ro, lo);
}



void IVP_Environment::add_listener_object_global(IVP_Listener_Object *listener)
{
    this->global_object_listeners.add(listener);
}

void IVP_Environment::install_listener_object_global(IVP_Listener_Object *listener)
{
    this->global_object_listeners.install(listener);
}

void IVP_Environment::remove_listener_object_global(IVP_Listener_Object *listener)
{
    this->global_object_listeners.remove(listener);
}

void IVP_Environment::fire_event_object_created(IVP_Event_Object *obj_event)
{
    int i;
    for (i=this->global_object_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_Object *lis = this->global_object_listeners.element_at(i);
		lis->event_object_created(obj_event);
    }
}

void IVP_Environment::fire_event_object_deleted(IVP_Event_Object *obj_event)
{
    int i;
    for (i=this->global_object_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_Object *lis = this->global_object_listeners.element_at(i);
		lis->event_object_deleted(obj_event);
    }
}


void IVP_Environment::fire_event_object_frozen(IVP_Event_Object *obj_event)
{
    int i;
    for (i=this->global_object_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_Object *lis = this->global_object_listeners.element_at(i);
		lis->event_object_frozen(obj_event);
    }
}

void IVP_Environment::fire_event_object_revived(IVP_Event_Object *obj_event)
{
    int i;
    for (i=this->global_object_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_Object *lis = this->global_object_listeners.element_at(i);
		lis->event_object_revived(obj_event);
    }
}

void IVP_Environment::fire_event_pre_collision( IVP_Event_Collision *coll)
{
    int i;
    for ( i = collision_listeners.len()-1; i>=0; i--){
		IVP_Listener_Collision *lis = collision_listeners.element_at(i);
        if (!(lis->get_enabled_callbacks() & IVP_LISTENER_COLLISION_CALLBACK_PRE_COLLISION)) 
			continue;
		lis->event_pre_collision(coll);
    }
}

void IVP_Environment::fire_event_post_collision( IVP_Event_Collision *coll)
{
    int i;
    for ( i = collision_listeners.len()-1; i>=0; i--){
		IVP_Listener_Collision *lis = collision_listeners.element_at(i);
        if (!(lis->get_enabled_callbacks() & IVP_LISTENER_COLLISION_CALLBACK_POST_COLLISION)) 
			continue;
		lis->event_post_collision(coll);
    }
}

void IVP_Environment::fire_event_friction_created( IVP_Event_Friction *coll)
{
    int i;
    for ( i = collision_listeners.len()-1; i>=0; i--){
		IVP_Listener_Collision *lis = collision_listeners.element_at(i);
        if (!(lis->get_enabled_callbacks() & IVP_LISTENER_COLLISION_CALLBACK_FRICTION)) 
			continue;
		lis->event_friction_created(coll);
    }
}

void IVP_Environment::fire_event_friction_deleted( IVP_Event_Friction *coll)
{
    int i;
    for ( i = collision_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_Collision *lis = collision_listeners.element_at(i);
		if (!(lis->get_enabled_callbacks() & IVP_LISTENER_COLLISION_CALLBACK_FRICTION)) 
			continue;
		lis->event_friction_deleted(coll);
    }
}

void IVP_Environment::fire_event_friction_pair_created( class IVP_Friction_Core_Pair *pair )
{
    int i;
    for ( i = collision_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_Collision *lis = collision_listeners.element_at(i);
		if (!(lis->get_enabled_callbacks() & IVP_LISTENER_COLLISION_CALLBACK_FRICTION)) 
			continue;
		lis->event_friction_pair_created(pair);
    }
}

void IVP_Environment::fire_event_friction_pair_deleted( class IVP_Friction_Core_Pair *pair  )
{
    int i;
    for ( i = collision_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_Collision *lis = collision_listeners.element_at(i);
		if (!(lis->get_enabled_callbacks() & IVP_LISTENER_COLLISION_CALLBACK_FRICTION)) 
			continue;
		lis->event_friction_pair_deleted(pair);
    }
}

void IVP_Environment::fire_event_PSI()
{
    int i;
    IVP_Event_PSI event;
    event.environment = this;
    for ( i = psi_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_PSI *lis = psi_listeners.element_at(i);
		lis->event_PSI(&event);
    }
}

// begin: Constraint listeners
void IVP_Environment::fire_event_constraint_broken(IVP_Constraint *constraint)
{
    int i;
    for (i=this->constraint_listeners.len()-1; i>=0; i--)
	{
		IVP_Listener_Constraint *lis = this->constraint_listeners.element_at(i);
		lis->event_constraint_broken(constraint);
    }
}

#ifdef HAVANA_CONSTRAINTS
void IVP_Environment::fire_event_constraint_broken(hk_Breakable_Constraint* constraint)
{
	int i;
	
	for(i = constraint_listeners.len() - 1; i >= 0; i--)
	{
		IVP_Listener_Constraint *lis = constraint_listeners.element_at(i);
		lis->event_constraint_broken(constraint);
	}
}
#endif // HAVANA_CONSTRAINTS

// end: Constraint listeners

void IVP_Environment::add_listener_collision_global(IVP_Listener_Collision *listener)
{
    collision_listeners.add(listener);
}

void IVP_Environment::remove_listener_collision_global(IVP_Listener_Collision *listener)
{
    collision_listeners.remove(listener);
}

void IVP_Environment::add_listener_PSI(IVP_Listener_PSI *listener)
{
    psi_listeners.add(listener);
}

void IVP_Environment::remove_listener_PSI(IVP_Listener_PSI *listener)
{
    psi_listeners.remove(listener);
}

// Constraint listener
void IVP_Environment::add_listener_constraint_global(IVP_Listener_Constraint *listener)
{
	constraint_listeners.add(listener);
}
void IVP_Environment::remove_listener_constraint_global(IVP_Listener_Constraint *listener)
{
	constraint_listeners.remove(listener);
}

void IVP_Environment::merge_objects(IVP_U_Vector<IVP_Real_Object> *objs_to_merge) 
{
	IVP_Merge_Core merge_all_objs;
	int obj_num=objs_to_merge->len();
	merge_all_objs.n_cores=obj_num;
	IVP_Real_Object *my_obj=objs_to_merge->element_at(0);
	IVP_Core_Merged *merged_core_for_all=new IVP_Core_Merged(my_obj);
	merge_all_objs.mcore=merged_core_for_all;
	merge_all_objs.cores=(IVP_Core **)p_malloc(obj_num*sizeof(IVP_Core*));
	int i;
	for(i=0; i< objs_to_merge->len(); i++) {
		my_obj = objs_to_merge->element_at(i);
		IVP_Core *old_core = my_obj->get_core();
		if (IVP_MTIS_SIMULATED(old_core->movement_state)){
			//	        old_core->stop_physical_movement();
			//		this->core_sim_manager->remove_sim_core(old_core);
		}
		
		merge_all_objs.cores[i]=my_obj->physical_core;
		merge_all_objs.core_stack[i]=my_obj->physical_core;
		my_obj->physical_core=merged_core_for_all;
		my_obj->friction_core=merged_core_for_all;
		my_obj->original_core=merged_core_for_all;
		merged_core_for_all->core_add_link_to_obj(my_obj);
	}
	
	merge_all_objs.calc_calc(); //now the merged core is valid
	
	IVP_Event_Sim es(this, get_next_PSI_time() - get_current_time());
	if (!IVP_MTIS_SIMULATED(merge_all_objs.movement_type) ){
		merged_core_for_all->calc_next_PSI_matrix_zero_speed( &es);
	}else{
		//	    this->core_sim_manager->add_sim_core(merged_core_for_all,0);
		merged_core_for_all->init_core_for_simulation();
		IVP_Calc_Next_PSI_Solver nps(merged_core_for_all);
		
		IVP_Vector_of_Hull_Managers_1 active_hull_managers;
		nps.calc_next_PSI_matrix( &es, &active_hull_managers );
		nps.commit_one_hull_manager( this, &active_hull_managers);
	}
	
	for(i=0;i<obj_num;i++) {
		delete merge_all_objs.cores[i];
	}
	P_FREE( merge_all_objs.cores );
}
// needed for sun to initialize templates classes
void ivp_dummy_func(){
    IVP_U_Set_Active<IVP_Core> ivp_class_dummy1(16);
    IVP_U_Set_Active<IVP_Real_Object> ivp_class_dummy2(16);
    IVP_U_Set_Active<IVP_Mindist_Base> ivp_class_dummy3(16);
    IVP_Attacher_To_Cores<IVP_Controller_Buoyancy> *ivp_class_dummy8 = new IVP_Attacher_To_Cores<IVP_Controller_Buoyancy>(NULL);
    ivp_class_dummy8 = ivp_class_dummy8;
}

void IVP_Time_Event_D::simulate_time_event(IVP_Environment *env) {
#if 1
	int nr=number_of_sons;
    int i;
    for(i=0;i<=nr;i++) {
        IVP_Time_Event_D *delay_event=new IVP_Time_Event_D(env->get_current_time());
        delay_event->number_of_sons=nr-1;
        env->get_time_manager()->insert_event(delay_event,env->get_current_time());
    }
    P_DELETE_THIS(this);
#else
    P_DELETE_THIS(this);    
#endif
}

void IVP_Time_Event_N::simulate_time_event(IVP_Environment *env) {
    //env->get_time_manager()->event_function=time_man_sim_until;
    P_DELETE(env->get_time_manager()->event_manager);
    env->get_time_manager()->event_manager=new IVP_Event_Manager_Standard();
    env->get_time_manager()->event_manager->mode=0;
    P_DELETE_THIS(this);
}


void IVP_Environment::do_d_events() {
#ifdef PSXII
    for(int i=0;i<20;i++) {
	IVP_Time_Event_D *delay_event=new IVP_Time_Event_D(this->get_current_time());
	delay_event->number_of_sons=7;
	this->get_time_manager()->insert_event(delay_event,this->get_current_time());
    }
#else
    for(int i=0;i<5;i++) {
	IVP_Time_Event_D *delay_event=new IVP_Time_Event_D(this->get_current_time());
	delay_event->number_of_sons=8;
	this->get_time_manager()->insert_event(delay_event,this->get_current_time());
    }
#endif    
}


IVP_Time_Event_D::IVP_Time_Event_D(IVP_Time time) {
    IVP_USE(time);
}

IVP_Time_Event_N::IVP_Time_Event_N(IVP_Time time) {
    IVP_USE(time);
}


 
void IVP_Environment::add_draw_vector(const IVP_U_Point *start_p, const IVP_U_Float_Point *dir_vec,const char *debug_text_in,int v_color)
{
	IVP_IF(1){
    IVP_Draw_Vector_Debug *draw_vector=new IVP_Draw_Vector_Debug();
    draw_vector->first_point=*start_p;
    draw_vector->direction_vec=*dir_vec;
    draw_vector->debug_text=p_strdup(debug_text_in);
    draw_vector->color=v_color;
    draw_vector->next=this->draw_vectors;
    this->draw_vectors=draw_vector;
	}
}

#ifdef PSXII
	int ivp_bcd2dec(int bcd)
	{
		int dec = 0;
		int sign = (bcd < 0 ? -1 : 1);
		for (int order = 1; bcd; order*=10)
		{
			int i = bcd % 16;
			IVP_ASSERT(i >= 0 && i <= 9);
			bcd /= 16;
			dec += order * i;
		}
		return dec*sign;
	}

	tm ivp_ps2_getTime()
	{
		sceCdCLOCK rtc;
		int success = sceCdReadClock(&rtc);
		IVP_ASSERT(success);
		tm mytime;
		mytime.tm_sec  = ivp_bcd2dec(rtc.second);
		mytime.tm_min  = ivp_bcd2dec(rtc.minute);
		mytime.tm_hour = ivp_bcd2dec(rtc.hour);
		mytime.tm_mday = ivp_bcd2dec(rtc.day);
		mytime.tm_mon  = ivp_bcd2dec(rtc.month)-1;
		int year       = ivp_bcd2dec(rtc.year);
		mytime.tm_year = (year < 70 ? year + 100 : year);
		mytime.tm_isdst = -1;
		return mytime;
	}

	int ivp_ps2_sec_since_1970() {
		tm mytime = ivp_ps2_getTime();
		return (int)mktime(&mytime);		
	}
#endif

void IVP_Environment::simulate_psi(IVP_Time /*psi_time*/){

    IVP_IF(1 || this->debug_information->display_statistic)
    {
	if( get_current_time()- get_statistic_manager()->last_statistic_output >= 1.0f ) {
	    get_statistic_manager()->output_statistic();
	    get_statistic_manager()->last_statistic_output = get_current_time();
	}
    }
    IVP_IF(1) {
	get_debug_manager()->psi_counter += 1.0f;
        delete_draw_vector_debug();
    }


#ifdef IVP_ENABLE_PERFORMANCE_COUNTER
    get_performancecounter()->pcount(IVP_PE_PSI_UNIVERSE);
#endif
    
    state = IVP_ES_PSI;	
    if ( core_revive_list.len() ){
    	revive_cores_PSI();
    }

    IVP_Universe_Manager *um = this->get_universe_manager();
    if (um){
	    IVP_Cluster_Manager *cm = get_cluster_manager();
	    cm->check_for_unused_objects(um);
    }

    l_active_value_manager->refresh_psi_active_values(this);	// lots of side effects, bombs ....
    fire_event_PSI();		// inform psi listeners //???

	get_mindist_manager()->recalc_all_exact_wheel_mindist();    

#ifdef IVP_ENABLE_PERFORMANCE_COUNTER
    get_performancecounter()->pcount(IVP_PE_PSI_CONTROLLERS);
#endif
    IVP_Vector_of_Cores_128 touched_cores;
    get_sim_units_manager()->simulate_sim_units_psi(this, &touched_cores);


#ifdef IVP_ENABLE_PERFORMANCE_COUNTER
    get_performancecounter()->pcount(IVP_PE_PSI_INTEGRATORS);
#endif    
    IVP_Vector_of_Hulls_128 active_hulls;
    IVP_Calc_Next_PSI_Solver::commit_all_calc_next_PSI_matrix(this, &touched_cores, &active_hulls);



#ifdef IVP_ENABLE_PERFORMANCE_COUNTER
    get_performancecounter()->pcount(IVP_PE_PSI_HULL);
#endif
    state = IVP_ES_PSI_HULL;
    IVP_Calc_Next_PSI_Solver::commit_all_hull_managers( this, &active_hulls);

#ifdef IVP_ENABLE_PERFORMANCE_COUNTER
    get_performancecounter()->pcount(IVP_PE_PSI_SHORT_MINDISTS);
#endif
    state = IVP_ES_PSI_SHORT;
    get_mindist_manager()->recalc_all_exact_mindists();


#ifdef IVP_ENABLE_PERFORMANCE_COUNTER
    get_performancecounter()->pcount(IVP_PE_PSI_CRITICAL_MINDISTS);
#endif
    state = IVP_ES_PSI_CRITIC;
    get_mindist_manager()->recalc_all_exact_mindists_events();


#ifdef IVP_ENABLE_PERFORMANCE_COUNTER
	get_performancecounter()->pcount(IVP_PE_PSI_END);
#endif


#if (defined(WIN32) || defined(PSXII)) && defined(IVP_VERSION_EVAL)  /* blocking only if original ivp_authenticity.hxx is used */
    {
        // IVP_BLOCKING_EVERY_MIN    
	time_since_last_blocking += get_delta_PSI_time();
	//do some blocking from time to time
	if( time_since_last_blocking>121.1f) {
	    time_since_last_blocking=0.0f;

		int t;

#ifdef IVP_BLOCKING_ALWAYS
	    this->do_d_events();
#else

#ifdef WIN32
	    time_t tt = time(NULL);
		t = (int)tt;
#endif
#ifdef PSXII
		t = ivp_ps2_sec_since_1970();
#endif

	    if ( t > 983404800 // 1 Mar 01 @@CB
		+ 60*60*24* (
		31 + 30 + 31 ) ){ // expiration date 31 May 01 @@CB
		this->do_d_events();
	    }
#endif
	}
    }
#endif


    this->state = IVP_ES_AT;
    return;
}

void IVP_Environment::set_global_collision_tolerance( IVP_DOUBLE tolerance ){
    ivp_mindist_settings.set_collision_tolerance( tolerance );
}