ivp_mindist_intern.hxx

hl2 source code. Do not use it illegal.

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

//IVP_EXPORT_PROTECTED

#ifndef _IVP_MINDIST_INTERN_INCLUDED
#define _IVP_MINDIST_INTERN_INCLUDED

#ifndef WIN32
#	pragma interface
#endif


class IVP_Compact_Edge;

#ifndef IVP_FVECTOR_INCLUDED
#	include  "ivu_fvector.hxx"
#endif

#ifndef _IVP_MINDIST_INCLUDED
#	include <ivp_mindist.hxx>
#endif

//#define IVP_MINDIST_BEHAVIOUR_DEBUG	// do core as soon as possible

#if defined(DEBUG) && defined(IVP_MINDIST_BEHAVIOUR_DEBUG)
#	define DEBUG_CHECK_LEN
#endif

#define IVP_MAX_MINIMIZE_BEFORE_HASH_CHECK 20
#define IVP_MAX_PIERCINGS 2
#define IVP_LOOP_HASH_SIZE 20
#define IVP_MAX_PIERCE_CNT 0xFFFE

#define IVP_MIN_TERMINATION_QDLEN 1E-3f		// generates core
#define IVP_MIN_TERMINATION_QDLEN_EPS 1E-6f	// generates warning

class IVP_Compact_Edge;
class IVP_Environment;
class IVP_Collision;

class IVP_Synapse_Real;
class IVP_Contact_Point;
class IVP_Actuator;
class IVP_Compact_Ledge;
class IVP_Mindist_OO_Watcher;
class IVP_Mindist;

#define IVP_MAX_STEPS_FOR_COLLDIST_DECREASE 64

extern class IVP_Mindist_Settings{
public:
    // mindist
    IVP_FLOAT real_coll_dist;		   // very absolute bound of distance
    IVP_FLOAT min_coll_dists;              // the minimum of all call dists
    IVP_FLOAT coll_dists[IVP_MAX_STEPS_FOR_COLLDIST_DECREASE];			// Minimal distance between objects before collision occurs [meter]

    // friction
    IVP_FLOAT minimum_friction_dist;       // for friction checks for impact
    IVP_FLOAT friction_dist;		   // distance for friction
    IVP_FLOAT keeper_dist;		   // try to hold objects with a simple spring
    IVP_FLOAT speed_after_keeper_dist;     // speed when falling from keeper_dist to coll_dist
    IVP_FLOAT distance_keepers_safety;     // safety gap, when surpassed mindist doesnt appear in complex
    IVP_FLOAT max_distance_for_friction;	// when to through away friction mindist
    IVP_FLOAT max_distance_for_impact_system; //check friction mindinst for impact when in this range

    // collision
    IVP_FLOAT mindist_change_force_dist;	// in [meter]
    IVP_FLOAT min_vertical_speed_at_collision;  //
    // collision is assumed when distance is < coll_dist + mindist_change_force_dist

	// spawned mindists for recursive hulls @@CB
	int max_spawned_mindist_count;

	// base size for event queue delta time stepping @@CB
	IVP_DOUBLE event_queue_min_delta_time_base;

    void set_collision_tolerance(IVP_DOUBLE);
	void set_event_queue_min_delta_time_base(IVP_DOUBLE); //@@CB
    IVP_Mindist_Settings();
} ivp_mindist_settings;



/********************************************************************************
 *	Name:	  	IVP_Collision_Delegator_Root_Sphere     	
 *	Description:	Simple root collision delegator which generates functions
 *			useable for convex subparts
 ********************************************************************************/
class IVP_Collision_Delegator_Root_Mindist : public IVP_Collision_Delegator_Root {
public:
  virtual void object_is_removed_from_collision_detection(IVP_Real_Object *);
  virtual IVP_Collision *delegate_collisions_for_object(IVP_Real_Object *base_object, IVP_Real_Object *colliding_element);

  virtual void environment_is_going_to_be_deleted_event(IVP_Environment *env);
  virtual void collision_is_going_to_be_deleted_event(class IVP_Collision *t);
  ~IVP_Collision_Delegator_Root_Mindist();
  IVP_Collision_Delegator_Root_Mindist();
};



/********************************************************************************
 *	Name:	  	IVP_Synapse_OO     	
 *	Description:	Synapses for the IVP_OO_Watcher
 ********************************************************************************/
class IVP_Synapse_OO: public IVP_Listener_Hull {
    friend class IVP_OO_Watcher;
    IVP_Real_Object *object;
    IVP_OO_Watcher *watcher;
    virtual ~IVP_Synapse_OO();
    IVP_Synapse_OO(){;};
  void init_synapse_oo(IVP_OO_Watcher *, IVP_Real_Object *);
public:
    IVP_HULL_ELEM_TYPE get_type(){ return IVP_HULL_ELEM_OO_WATCHER; };
    void hull_limit_exceeded_event(IVP_Hull_Manager *hull_manager, IVP_HTIME);
    void hull_manager_is_going_to_be_deleted_event(IVP_Hull_Manager *);		// function have to remove itself from hull manager
};



/********************************************************************************
 *	Name:	  	IVP_OO_Watcher     	
 *	Description:	Manages a hash of IVP_Mindist_OO_Watcher
 ********************************************************************************/
class IVP_OO_Watcher : public IVP_Collision, public IVP_Collision_Delegator {
    IVP_Synapse_OO  synapses[2];
    IVP_U_FVector<IVP_Collision>  mindists;
protected:
    void get_objects( IVP_Real_Object *objects_out[2] );
    void get_ledges( const IVP_Compact_Ledge *ledges_out[2] );

    IVP_Synapse_OO *get_synapse(int i){ return &synapses[i]; };
public:
    // IVP_Collision_Delegator
    void collision_is_going_to_be_deleted_event(class IVP_Collision *t);
    
    void hull_limit_exceeded_event();
    void hull_manager_is_going_to_be_deleted_event ();
    virtual ~IVP_OO_Watcher();	    
    IVP_OO_Watcher(IVP_Collision_Delegator *del, IVP_Real_Object *obj0, IVP_Real_Object *obj1);
};

/********************************************************************************
 *	Name:	  	IVP_Synapse_Real     	
 *	Description:	Adds additional functionality to IVP_Synapse,
 *	Attention:	No additional storage elements allowed in IVP_Synapse_Real
 ********************************************************************************/
class IVP_Synapse_Real: public IVP_Synapse {
protected:
  friend class IVP_Mindist;
  friend class IVP_Mindist_Manager;
  friend class IVP_Contact_Point;
public:

protected:

  // debug
  void check_consistency_of_ledge(const IVP_Compact_Edge *edge) const;

  inline void remove_exact_synapse_from_object();
  inline void insert_exact_synapse_in_object();

  inline void remove_invalid_synapse_from_object();
  inline void insert_invalid_synapse_in_object(); 

  virtual ~IVP_Synapse_Real(){;};
public:
  inline void  update_synapse(const IVP_Compact_Edge *e, IVP_SYNAPSE_POLYGON_STATUS s){
    IVP_IF(s!=IVP_ST_BALL){	check_consistency_of_ledge(e);    }
    edge = e;
    status = s;
}
protected:
    IVP_Synapse_Real(){};
    void init_synapse( IVP_Mindist *min, IVP_Real_Object *object_to_link, const IVP_Compact_Edge *e, IVP_SYNAPSE_POLYGON_STATUS s ){
	IVP_Synapse::init_synapse_real((IVP_Mindist_Base *)min, object_to_link);
	update_synapse(e,s);};
public:
  inline IVP_Core *get_core()const{ return l_obj->physical_core; };

  virtual void print();

  IVP_Hull_Manager *get_hull_manager(){ return get_object()->get_hull_manager();};
  inline IVP_DOUBLE insert_in_hull_manager(IVP_DOUBLE rel_hull_time); // returns current center pos
  inline IVP_DOUBLE insert_lazy_in_hull_manager(IVP_DOUBLE rel_hull_time);
  
  IVP_Synapse_Real       *get_next(){ return (IVP_Synapse_Real *)next;};
  IVP_Synapse_Real       *get_prev(){ return (IVP_Synapse_Real *)prev;};
  IVP_Mindist            *get_mindist(){ return (IVP_Mindist *) get_synapse_mindist(); };
};


// Minimal Dist Recalc types
enum IVP_MRC_TYPE {
    IVP_MRC_UNINITIALIZED = 0,
    IVP_MRC_OK = 1,
    IVP_MRC_ENDLESS_LOOP=2,
    IVP_MRC_BACKSIDE=3,
    IVP_MRC_ALREADY_CALCULATED=4,	// see status for details
    IVP_MRC_ILLEGAL=5
};

enum IVP_MINDIST_EVENT_HINT {
    IVP_EH_NOW,
    IVP_EH_SMALL_DELAY,
    IVP_EH_BIG_DELAY
};