//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
#include "cbase.h"

#include "physics_shadow.h"
#include "vphysics/player_controller.h"
#include "physics_friction.h"
#include "vphysics/friction.h"

// IsInContact
#include "ivp_mindist.hxx"
#include "ivp_core.hxx"
#include "ivp_friction.hxx"
#include "ivp_listener_object.hxx"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

struct vphysics_save_cshadowcontroller_t;
struct vphysics_save_shadowcontrolparams_t;


// UNDONE: Try this controller!
//damping is usually 1.0
//frequency is usually in the range 1..16
void ComputePDControllerCoefficients( float *coefficientsOut, const float frequency, const float damping, const float dt )
{
	const float ks = 9.0f * frequency * frequency;
	const float kd = 4.5f * frequency * damping;

	const float scale = 1.0f / ( 1.0f  + kd * dt + ks * dt * dt );

	coefficientsOut[0] = ks  *  scale;
	coefficientsOut[1] = ( kd + ks * dt ) * scale;

	// Use this controller like:
	// speed += (coefficientsOut[0] * (targetPos - currentPos) + coefficientsOut[1] * (targetSpeed - currentSpeed)) * dt
}

void ComputeController( IVP_U_Float_Point &currentSpeed, const IVP_U_Float_Point &delta, float maxSpeed, float maxDampSpeed, float scaleDelta, float damping, IVP_U_Float_Point *pOutImpulse = NULL )
{
	if ( currentSpeed.quad_length() < 1e-6 )
	{
		currentSpeed.set_to_zero();
	}

	// scale by timestep
	IVP_U_Float_Point acceleration;
	if ( maxSpeed > 0 )
	{
		acceleration.set_multiple( &delta, scaleDelta );
		float speed = acceleration.real_length();
		if ( speed > maxSpeed )
		{
			speed = maxSpeed / speed;
			acceleration.mult( speed );
		}
	}
	else
	{
		acceleration.set_to_zero();
	}

	IVP_U_Float_Point dampAccel;
	if ( maxDampSpeed > 0 )
	{
		dampAccel.set_multiple( &currentSpeed, -damping );
		float speed = dampAccel.real_length();
		if ( speed > maxDampSpeed )
		{
			speed = maxDampSpeed / speed;
			dampAccel.mult( speed );
		}
	}
	else
	{
		dampAccel.set_to_zero();
	}
	currentSpeed.add( &dampAccel );
	currentSpeed.add( &acceleration );
	if ( pOutImpulse )
	{
		*pOutImpulse = acceleration;
	}
}


void ComputeController( IVP_U_Float_Point &currentSpeed, const IVP_U_Float_Point &delta, const IVP_U_Float_Point &maxSpeed, float scaleDelta, float damping, IVP_U_Float_Point *pOutImpulse )
{
	// scale by timestep
	IVP_U_Float_Point acceleration;
	acceleration.set_multiple( &delta, scaleDelta );
	
	if ( currentSpeed.quad_length() < 1e-6 )
	{
		currentSpeed.set_to_zero();
	}

	acceleration.add_multiple( &currentSpeed, -damping );

	for(int i=2; i>=0; i--)
	{
		if(IVP_Inline_Math::fabsd(acceleration.k[i]) < maxSpeed.k[i]) 
			continue;
		
		// clip force
		acceleration.k[i] = (acceleration.k[i] < 0) ? -maxSpeed.k[i] : maxSpeed.k[i];
	}

	currentSpeed.add( &acceleration );
	if ( pOutImpulse )
	{
		*pOutImpulse = acceleration;
	}
}


static bool IsOnGround( IVP_Real_Object *pivp )
{
	IPhysicsFrictionSnapshot *pSnapshot = CreateFrictionSnapshot( pivp );
	bool bGround = false;
	while (pSnapshot->IsValid())
	{
		Vector normal;
		pSnapshot->GetSurfaceNormal( normal );
		if ( normal.z < -0.7f )
		{
			bGround = true;
			break;
		}
		
		pSnapshot->NextFrictionData();
	}
	DestroyFrictionSnapshot( pSnapshot );
	return bGround;
}

class CPlayerController : public IVP_Controller_Independent, public IPhysicsPlayerController, public IVP_Listener_Object
{
public:
	CPlayerController( CPhysicsObject *pObject );
	~CPlayerController( void );

	// ipion interfaces
    void do_simulation_controller( IVP_Event_Sim *es,IVP_U_Vector<IVP_Core> *cores);
    virtual IVP_CONTROLLER_PRIORITY get_controller_priority() { return (IVP_CONTROLLER_PRIORITY) (IVP_CP_MOTION+1); }
	virtual const char *get_controller_name() { return "vphysics:player"; }

	void SetObject( IPhysicsObject *pObject );
	void SetEventHandler( IPhysicsPlayerControllerEvent *handler );
	void Update( const Vector& position, const Vector& velocity, float secondsToArrival, bool onground, IPhysicsObject *ground );
	void MaxSpeed( const Vector &velocity );
	bool IsInContact( void );
	virtual bool WasFrozen() 
	{ 	
		IVP_Real_Object *pivp = m_pObject->GetObject();
		IVP_Core *pCore = pivp->get_core();
		return pCore->temporarily_unmovable ? true : false;
	}

	void ForceTeleportToCurrentPosition()
	{
		m_forceTeleport = true;
	}

	int GetShadowPosition( Vector *position, QAngle *angles )
	{
		IVP_U_Matrix matrix;
		
		IVP_Environment *pEnv = m_pObject->GetObject()->get_environment();

		double psi = pEnv->get_next_PSI_time().get_seconds();
		m_pObject->GetObject()->calc_at_matrix( psi, &matrix );
		if ( angles )
		{
			ConvertRotationToHL( matrix, *angles );
		}
		if ( position )
		{
			ConvertPositionToHL( matrix.vv, *position );
		}

		return 1;
	}
	void GetShadowVelocity( Vector *velocity );
	virtual void GetLastImpulse( Vector *pOut )
	{
		ConvertPositionToHL( m_lastImpulse, *pOut );
	}

	virtual void StepUp( float height );
	virtual void Jump();
	virtual IPhysicsObject *GetObject() { return m_pObject; }

	virtual void SetPushMassLimit( float maxPushMass )
	{
		m_pushableMassLimit = maxPushMass;
	}

	virtual void SetPushSpeedLimit( float maxPushSpeed )
	{
		m_pushableSpeedLimit = maxPushSpeed;
	}

	virtual float GetPushMassLimit() { return m_pushableMassLimit; }
	virtual float GetPushSpeedLimit() { return m_pushableSpeedLimit; }

	// Object listener
	virtual void event_object_deleted( IVP_Event_Object *pEvent)
	{
		Assert( pEvent->real_object == m_pGround->GetObject() );
		m_pGround = NULL;
	}
	virtual void event_object_created( IVP_Event_Object *) {}
	virtual void event_object_revived( IVP_Event_Object *) {}
	virtual void event_object_frozen ( IVP_Event_Object *) {}

private:
	void AttachObject( void );
	void DetachObject( void );
	int TryTeleportObject( void );
	void SetGround( CPhysicsObject *pGroundObject );

	CPhysicsObject		*m_pObject;
	IVP_U_Float_Point	m_saveRot;
	CPhysicsObject		*m_pGround;	// Uses object listener to clear - so ok to hold over frames

	IPhysicsPlayerControllerEvent	*m_handler;
	float				m_maxDeltaPosition;
	float				m_dampFactor;
	float				m_secondsToArrival;
	float				m_pushableMassLimit;
	float				m_pushableSpeedLimit;
	IVP_U_Point			m_targetPosition;
	IVP_U_Float_Point	m_groundPosition;
	IVP_U_Float_Point	m_maxSpeed;
	IVP_U_Float_Point	m_currentSpeed;
	IVP_U_Float_Point	m_lastImpulse;
	bool				m_enable : 1;
	bool				m_onground : 1;
	bool				m_forceTeleport : 1;
	bool				m_updatedSinceLast : 5;
};


CPlayerController::CPlayerController( CPhysicsObject *pObject )
{
	m_pGround = NULL;
	m_pObject = pObject;
	m_handler = NULL;
	m_maxDeltaPosition = ConvertDistanceToIVP( 24 );
	m_dampFactor = 1.0f;
	m_targetPosition.k[0] = m_targetPosition.k[1] = m_targetPosition.k[2] = 0;
	m_pushableMassLimit = VPHYSICS_MAX_MASS;
	m_pushableSpeedLimit = 1e4f;
	m_forceTeleport = false;
	AttachObject();
}

CPlayerController::~CPlayerController( void ) 
{
	DetachObject();
}

void CPlayerController::SetGround( CPhysicsObject *pGroundObject )
{
	if ( m_pGround != pGroundObject )
	{
		if ( m_pGround && m_pGround->GetObject() )
		{
			m_pGround->GetObject()->remove_listener_object(this);
		}
		m_pGround = pGroundObject;
		if ( m_pGround && m_pGround->GetObject() )
		{
			m_pGround->GetObject()->add_listener_object(this);
		}
	}
}

void CPlayerController::AttachObject( void )
{
	m_pObject->EnableDrag( false );
	IVP_Real_Object *pivp = m_pObject->GetObject();
	IVP_Core *pCore = pivp->get_core();
	m_saveRot = pCore->rot_speed_damp_factor;
	pCore->rot_speed_damp_factor = IVP_U_Float_Point( 100, 100, 100 );
	pCore->calc_calc();
	BEGIN_IVP_ALLOCATION();
	pivp->get_environment()->get_controller_manager()->add_controller_to_core( this, pCore );
	END_IVP_ALLOCATION();
	m_pObject->AddCallbackFlags( CALLBACK_IS_PLAYER_CONTROLLER );
}

void CPlayerController::DetachObject( void )
{
	if ( !m_pObject )
		return;

	IVP_Real_Object *pivp = m_pObject->GetObject();
	IVP_Core *pCore = pivp->get_core();
	pCore->rot_speed_damp_factor = m_saveRot;
	pCore->calc_calc();
	m_pObject->RemoveCallbackFlags( CALLBACK_IS_PLAYER_CONTROLLER );
	m_pObject = NULL;
	pivp->get_environment()->get_controller_manager()->remove_controller_from_core( this, pCore );
	SetGround(NULL);
}

void CPlayerController::SetObject( IPhysicsObject *pObject )
{
	CPhysicsObject *obj = (CPhysicsObject *)pObject;
	if ( obj == m_pObject )
		return;

	DetachObject();
	m_pObject = obj;
	AttachObject();
}

int CPlayerController::TryTeleportObject( void )
{
	if ( m_handler && !m_forceTeleport )
	{
		Vector hlPosition;
		ConvertPositionToHL( m_targetPosition, hlPosition );
		if ( !m_handler->ShouldMoveTo( m_pObject, hlPosition ) )
			return 0;
	}

	IVP_Real_Object *pivp = m_pObject->GetObject();
	IVP_U_Quat targetOrientation;
	IVP_U_Point outPosition;

	pivp->get_quat_world_f_object_AT( &targetOrientation, &outPosition );

	if ( pivp->is_collision_detection_enabled() )
	{
		m_pObject->EnableCollisions( false );
		pivp->beam_object_to_new_position( &targetOrientation, &m_targetPosition, IVP_TRUE );
		m_pObject->EnableCollisions( true );
	}
	else
	{
		pivp->beam_object_to_new_position( &targetOrientation, &m_targetPosition, IVP_TRUE );
	}
	m_forceTeleport = false;
	return 1;
}

void CPlayerController::StepUp( float height )
{
	if ( height == 0.0f )
		return;

	Vector step( 0, 0, height );

	IVP_Real_Object *pIVP = m_pObject->GetObject();
	IVP_U_Quat world_f_object;
	IVP_U_Point positionIVP, deltaIVP;
	ConvertPositionToIVP( step, deltaIVP );
	pIVP->get_quat_world_f_object_AT( &world_f_object, &positionIVP );
	positionIVP.add( &deltaIVP );
	pIVP->beam_object_to_new_position( &world_f_object, &positionIVP, IVP_TRUE );
}

void CPlayerController::Jump()
{
#if 0
	// float for one tick to allow stepping and jumping to work properly
	IVP_Real_Object *pIVP = m_pObject->GetObject();
	const IVP_U_Point *pgrav = pIVP->get_environment()->get_gravity();
	IVP_U_Float_Point gravSpeed;
	gravSpeed.set_multiple( pgrav, pIVP->get_environment()->get_delta_PSI_time() );
	pIVP->get_core()->speed.subtract( &gravSpeed );
#endif
}

const int MAX_LIST_NORMALS = 8;
class CNormalList
{
public:
	bool IsFull() { return m_Normals.Count() == MAX_LIST_NORMALS; }
	void AddNormal( const Vector &normal )
	{
		if ( IsFull() )
			return;

		for ( int i = m_Normals.Count(); --i >= 0; )
		{
			if ( DotProduct( m_Normals[i], normal ) > 0.99f )
				return;
		}
		m_Normals.AddToTail( normal );
	}

	bool HasPositiveProjection( const Vector &vec )
	{
		for ( int i = m_Normals.Count(); --i >= 0; )
		{
			if ( DotProduct( m_Normals[i], vec ) > 0 )
				return true;
		}
		return false;
	}

	// UNDONE: Handle the case better where we clamp to multiple planes
	// and still have a projection, but don't exceed limitVel.  Currently that will stop.
	// when this is done, remove the ground exception below.
	Vector ClampVector( const Vector &inVector, float limitVel )
	{
		if ( m_Normals.Count() > 2 )
		{
			for ( int i = 0; i < m_Normals.Count(); i++ )
			{
				if ( DotProduct(inVector, m_Normals[i]) > 0 )
				{
					return vec3_origin;
				}
			}
		}
		else
		{
			if ( m_Normals.Count() == 2 )
			{
				Vector crease;
				CrossProduct( m_Normals[0], m_Normals[1], crease );
				float dot = DotProduct( inVector, crease );
				return crease * dot;
			}
			else if (m_Normals.Count() == 1)
			{
				float dot = DotProduct( inVector, m_Normals[0] );
				if ( dot > limitVel )
				{
					return inVector + m_Normals[0]*(limitVel - dot);
				}
			}
		}
		return inVector;
	}
private:
	CUtlVectorFixed<Vector, MAX_LIST_NORMALS>	m_Normals;
};

void CPlayerController::do_simulation_controller( IVP_Event_Sim *es,IVP_U_Vector<IVP_Core> *)
{
	if ( !m_enable )
		return;
	IVP_Real_Object *pivp = m_pObject->GetObject();

	IVP_Core *pCore = pivp->get_core();
	Assert(!pCore->pinned && !pCore->physical_unmoveable);
	// current situation
	const IVP_U_Matrix *m_world_f_core = pCore->get_m_world_f_core_PSI();
	const IVP_U_Point *cur_pos_ws = m_world_f_core->get_position();

	IVP_U_Float_Point baseVelocity;
	baseVelocity.set_to_zero();
	// ---------------------------------------------------------
	// Translation
	// ---------------------------------------------------------

	if ( m_pGround )
	{
		const IVP_U_Matrix *pMatrix = m_pGround->GetObject()->get_core()->get_m_world_f_core_PSI();
		pMatrix->vmult4( &m_groundPosition, &m_targetPosition );
		m_pGround->GetObject()->get_core()->get_surface_speed( &m_groundPosition, &baseVelocity );
		pCore->speed.subtract( &baseVelocity );
	}

	IVP_U_Float_Point delta_position;  delta_position.subtract( &m_targetPosition, cur_pos_ws);

	if (!pivp->flags.shift_core_f_object_is_zero)
	{
		IVP_U_Float_Point shift_cs_os_ws;
		m_world_f_core->vmult3( pivp->get_shift_core_f_object(), &shift_cs_os_ws);
		delta_position.subtract( &shift_cs_os_ws );
	}


	IVP_DOUBLE qdist = delta_position.quad_length();

	// UNDONE: This is totally bogus!  Measure error using last known estimate
	// not current position!
	if ( m_forceTeleport || qdist > m_maxDeltaPosition * m_maxDeltaPosition )
	{
		if ( TryTeleportObject() )
			return;
	}

	// float to allow stepping
	const IVP_U_Point *pgrav = es->environment->get_gravity();
	IVP_U_Float_Point gravSpeed;
	gravSpeed.set_multiple( pgrav, es->delta_time );
	if ( m_onground )
	{
		pCore->speed.subtract( &gravSpeed );
	}

	float fraction = 1.0;
	if ( m_secondsToArrival > 0 )
	{
		fraction = es->delta_time / m_secondsToArrival;
		if ( fraction > 1 )
		{
			fraction = 1;
		}
	}
	if ( !m_updatedSinceLast )
	{
		// we haven't received an update from the game code since the last controller step
		// This means we haven't gotten feedback integrated into the motion plan, so the error may be 
		// exaggerated.  Assume that the first updated tick had valid information, and limit
		// all subsequent ticks to the same size impulses.
		// NOTE: Don't update the saved impulse - so any subsequent ticks will still have the last
		// known good information.
		float len = m_lastImpulse.real_length();
		// cap the max speed to the length of the last known good impulse
		IVP_U_Float_Point tmp;
		tmp.set( len, len, len );
		ComputeController( pCore->speed, delta_position, tmp, fraction / es->delta_time, m_dampFactor, NULL );
	}
	else
	{
		ComputeController( pCore->speed, delta_position, m_maxSpeed, fraction / es->delta_time, m_dampFactor, &m_lastImpulse );
	}
	pCore->speed.add( &baseVelocity );
	m_updatedSinceLast = false;

	// UNDONE: Assumes gravity points down
	Vector lastImpulseHL;
	ConvertPositionToHL( pCore->speed, lastImpulseHL );
	IPhysicsFrictionSnapshot *pSnapshot = CreateFrictionSnapshot( pivp );
	bool bGround = false;
	float invMass = pivp->get_core()->get_inv_mass();
	float limitVel = m_pushableSpeedLimit;
	CNormalList normalList;
	while (pSnapshot->IsValid())
	{
		Vector normal;
		pSnapshot->GetSurfaceNormal( normal );
		if ( normal.z < -0.7f )
		{
			bGround = true;
		}
		// remove this when clamp works better
		if ( normal.z > -0.99f )
		{
			IPhysicsObject *pOther = pSnapshot->GetObject(1);
			if ( !pOther->IsMoveable() || pOther->GetMass() > m_pushableMassLimit )
			{
				limitVel = 0.0f;
			}
			float pushSpeed = DotProduct( lastImpulseHL, normal );
			float contactVel = pSnapshot->GetNormalForce() * invMass;
			float pushTotal = pushSpeed + contactVel;
			if ( pushTotal > limitVel )
			{
				normalList.AddNormal( normal );
			}
		}
		
		pSnapshot->NextFrictionData();
	}
	DestroyFrictionSnapshot( pSnapshot );

	Vector clamped = normalList.ClampVector( lastImpulseHL, limitVel );
	Vector limit = clamped - lastImpulseHL;
	IVP_U_Float_Point limitIVP;
	ConvertPositionToIVP( limit, limitIVP );
	pivp->get_core()->speed.add( &limitIVP );
	m_lastImpulse.add( &limitIVP );

	if ( bGround )
	{
		float gravDt = gravSpeed.real_length();
		// moving down?  Press down with full gravity and no more
		if ( m_lastImpulse.k[1] >= 0 )
		{
			float delta = gravDt - m_lastImpulse.k[1];
			pivp->get_core()->speed.k[1] += delta;
			m_lastImpulse.k[1] += delta;
		}
	}

	// if we have time left, subtract it off
	m_secondsToArrival -= es->delta_time;
	if ( m_secondsToArrival < 0 )
	{
		m_secondsToArrival = 0;
	}
}

void CPlayerController::SetEventHandler( IPhysicsPlayerControllerEvent *handler ) 
{
	m_handler = handler;
}

void CPlayerController::Update( const Vector& position, const Vector& velocity, float secondsToArrival, bool onground, IPhysicsObject *ground )
{
	IVP_U_Point	targetPositionIVP;
	IVP_U_Float_Point targetSpeedIVP;

	ConvertPositionToIVP( position, targetPositionIVP );
	ConvertPositionToIVP( velocity, targetSpeedIVP );
	
	m_updatedSinceLast = true;
	// if the object hasn't moved, abort
	if ( targetSpeedIVP.quad_distance_to( &m_currentSpeed ) < 1e-6 )
	{
		if ( targetPositionIVP.quad_distance_to( &m_targetPosition ) < 1e-6 )
		{
			return;
		}
	}

	m_targetPosition.set( &targetPositionIVP );
	m_secondsToArrival = secondsToArrival < 0 ? 0 : secondsToArrival;
	// Sanity check to make sure the position is good.
#ifdef _DEBUG
	float large = 1024 * 512;
	Assert( m_targetPosition.k[0] >= -large && m_targetPosition.k[0] <= large );
	Assert( m_targetPosition.k[1] >= -large && m_targetPosition.k[1] <= large );
	Assert( m_targetPosition.k[2] >= -large && m_targetPosition.k[2] <= large );
#endif

	m_currentSpeed.set( &targetSpeedIVP );

	IVP_Real_Object *pivp = m_pObject->GetObject();
	IVP_Core *pCore = pivp->get_core();
	IVP_Environment *pEnv = pivp->get_environment();
	pEnv->get_controller_manager()->ensure_core_in_simulation(pCore);

	m_enable = true;
	// m_onground makes this object anti-grav
	// UNDONE: Re-evaluate this
	m_onground = false;//onground;
	if ( velocity.LengthSqr() <= 0.1f )
	{
		// no input velocity, just go where physics takes you.
		m_enable = false;
		ground = NULL;
	}
	else
	{
		MaxSpeed( velocity );
	}

	CPhysicsObject *pGroundObject = static_cast<CPhysicsObject *>(ground);
	SetGround( pGroundObject );
	if ( m_pGround )
	{
		const IVP_U_Matrix *pMatrix = m_pGround->GetObject()->get_core()->get_m_world_f_core_PSI();
		pMatrix->vimult4( &m_targetPosition, &m_groundPosition );
	}
}

void CPlayerController::MaxSpeed( const Vector &velocity )
{
	IVP_Core *pCore = m_pObject->GetObject()->get_core();
	IVP_U_Float_Point ivpVel;
	ConvertPositionToIVP( velocity, ivpVel );
	IVP_U_Float_Point available = ivpVel;
	
	// normalize and save length
	float length = ivpVel.real_length_plus_normize();

	IVP_U_Float_Point baseVelocity;
	baseVelocity.set_to_zero();

	float dot = ivpVel.dot_product( &pCore->speed );
	if ( dot > 0 )
	{
		ivpVel.mult( dot * length );
		available.subtract( &ivpVel );
	}

	pCore->speed.add( &baseVelocity );
	IVP_Float_PointAbs( m_maxSpeed, available );
}


void CPlayerController::GetShadowVelocity( Vector *velocity )
{
	IVP_Core *core = m_pObject->GetObject()->get_core();
	if ( velocity )
	{
		IVP_U_Float_Point speed;
		speed.add( &core->speed, &core->speed_change );
		if ( m_pGround )
		{
			IVP_U_Float_Point baseVelocity;
			m_pGround->GetObject()->get_core()->get_surface_speed( &m_groundPosition, &baseVelocity );
			speed.subtract( &baseVelocity );
		}
		ConvertPositionToHL( speed, *velocity );
	}
}


bool CPlayerController::IsInContact( void )
{
	IVP_Real_Object *pivp = m_pObject->GetObject();
	if ( !pivp->flags.collision_detection_enabled )
		return false;

	IVP_Synapse_Friction *pfriction = pivp->get_first_friction_synapse();
	while ( pfriction )
	{
		extern IVP_Real_Object *GetOppositeSynapseObject( IVP_Synapse_Friction *pfriction );

		IVP_Real_Object *pobj = GetOppositeSynapseObject( pfriction );
		if ( pobj->flags.collision_detection_enabled )
		{
			// skip if this is a static object
			if ( !pobj->get_core()->physical_unmoveable && !pobj->get_core()->pinned )
			{
				CPhysicsObject *pPhys = static_cast<CPhysicsObject *>(pobj->client_data);
				// If this is a game-controlled shadow object, then skip it.
				// otherwise, we're in contact with something physically simulated
				if ( !pPhys->IsControlledByGame() )
					return true;
			}
		}

		pfriction = pfriction->get_next();
	}

	return false;
}


IPhysicsPlayerController *CreatePlayerController( CPhysicsObject *pObject )
{
	return new CPlayerController( pObject );
}

void DestroyPlayerController( IPhysicsPlayerController *pController )
{
	delete pController;
}

void QuaternionDiff( const IVP_U_Quat &p, const IVP_U_Quat &q, IVP_U_Quat &qt )
{
	IVP_U_Quat q2;

	// decide if one of the quaternions is backwards
	q2.set_invert_unit_quat( &q );
	qt.set_mult_quat( &q2, &p );
	qt.normize_quat();
}


void QuaternionAxisAngle( const IVP_U_Quat &q, Vector &axis, float &angle )
{
	angle = 2 * acos(q.w);
	if ( angle > M_PI )
	{
		angle -= 2*M_PI;
	}

	axis.Init( q.x, q.y, q.z );
	VectorNormalize( axis );
}


void GetObjectPosition_IVP( IVP_U_Point &origin, IVP_Real_Object *pivp )
{
	const IVP_U_Matrix *m_world_f_core = pivp->get_core()->get_m_world_f_core_PSI();
	origin.set( m_world_f_core->get_position() );
	if (!pivp->flags.shift_core_f_object_is_zero)
	{
		IVP_U_Float_Point shift_cs_os_ws;
		m_world_f_core->vmult3( pivp->get_shift_core_f_object(), &shift_cs_os_ws );
		origin.add(&shift_cs_os_ws);
	}
}


bool IsZeroVector( const IVP_U_Point &vec )
{
	return (vec.k[0] == 0.0 && vec.k[1] == 0.0 && vec.k[2] == 0.0 ) ? true : false;
}

float ComputeShadowControllerIVP( IVP_Real_Object *pivp, shadowcontrol_params_t &params, float secondsToArrival, float dt )
{
	// resample fraction
	// This allows us to arrive at the target at the requested time
	float fraction = 1.0;
	if ( secondsToArrival > 0 )
	{
		fraction = dt / secondsToArrival;
		if ( fraction > 1 )
		{
			fraction = 1;
		}
	}

	secondsToArrival -= dt;
	if ( secondsToArrival < 0 )
	{
		secondsToArrival = 0;
	}

	if ( fraction <= 0 )
		return secondsToArrival;

	// ---------------------------------------------------------
	// Translation
	// ---------------------------------------------------------

	IVP_U_Point positionIVP;
	GetObjectPosition_IVP( positionIVP, pivp );

	IVP_U_Float_Point delta_position;
	delta_position.subtract( &params.targetPosition, &positionIVP);

	// BUGBUG: Save off velocities and estimate final positions
	// measure error against these final sets
	// also, damp out 100% saved velocity, use max additional impulses
	// to correct error and damp out error velocity
	// extrapolate position
	if ( params.teleportDistance > 0 )
	{
		IVP_DOUBLE qdist;
		if ( !IsZeroVector(params.lastPosition) )
		{
			IVP_U_Float_Point tmpDelta;
			tmpDelta.subtract( &positionIVP, &params.lastPosition );
			qdist = tmpDelta.quad_length();
		}
		else
		{
			// UNDONE: This is totally bogus!  Measure error using last known estimate
			// not current position!
			qdist = delta_position.quad_length();
		}

		if ( qdist > params.teleportDistance * params.teleportDistance )
		{
			if ( pivp->is_collision_detection_enabled() )
			{
				pivp->enable_collision_detection( IVP_FALSE );
				pivp->beam_object_to_new_position( &params.targetRotation, &params.targetPosition, IVP_TRUE );
				pivp->enable_collision_detection( IVP_TRUE );
			}
			else
			{
				pivp->beam_object_to_new_position( &params.targetRotation, &params.targetPosition, IVP_TRUE );
			}
			delta_position.set_to_zero();
		}
	}

	float invDt = 1.0f / dt;
	IVP_Core *pCore = pivp->get_core();
	ComputeController( pCore->speed, delta_position, params.maxSpeed, params.maxDampSpeed, fraction * invDt, params.dampFactor, &params.lastImpulse );

	params.lastPosition.add_multiple( &positionIVP, &pCore->speed, dt );

	IVP_U_Float_Point deltaAngles;
	// compute rotation offset
	IVP_U_Quat deltaRotation;
	QuaternionDiff( params.targetRotation, pCore->q_world_f_core_next_psi, deltaRotation );

	// convert offset to angular impulse
	Vector axis;
	float angle;
	QuaternionAxisAngle( deltaRotation, axis, angle );
	VectorNormalize(axis);

	deltaAngles.k[0] = axis.x * angle;
	deltaAngles.k[1] = axis.y * angle;
	deltaAngles.k[2] = axis.z * angle;

	ComputeController( pCore->rot_speed, deltaAngles, params.maxAngular, params.maxDampAngular, fraction * invDt, params.dampFactor, NULL );

	return secondsToArrival;
}

void ConvertShadowControllerToIVP( const hlshadowcontrol_params_t &in, shadowcontrol_params_t &out )
{
	ConvertPositionToIVP( in.targetPosition, out.targetPosition );
	ConvertRotationToIVP( in.targetRotation, out.targetRotation );
	out.teleportDistance = ConvertDistanceToIVP( in.teleportDistance );

	out.maxSpeed = ConvertDistanceToIVP( in.maxSpeed );
	out.maxDampSpeed = ConvertDistanceToIVP( in.maxDampSpeed );
	out.maxAngular = ConvertAngleToIVP( in.maxAngular );
	out.maxDampAngular = ConvertAngleToIVP( in.maxDampAngular );

	out.dampFactor = in.dampFactor;
}

void ConvertShadowControllerToHL( const shadowcontrol_params_t &in, hlshadowcontrol_params_t &out )
{
	ConvertPositionToHL( in.targetPosition, out.targetPosition );
	ConvertRotationToHL( in.targetRotation, out.targetRotation );
	out.teleportDistance = ConvertDistanceToHL( in.teleportDistance );

	out.maxSpeed = ConvertDistanceToHL( in.maxSpeed );
	out.maxDampSpeed = ConvertDistanceToHL( in.maxDampSpeed );
	out.maxAngular = ConvertAngleToHL( in.maxAngular );
	out.maxDampAngular = ConvertAngleToHL( in.maxDampAngular );

	out.dampFactor = in.dampFactor;
}

float ComputeShadowControllerHL( CPhysicsObject *pObject, const hlshadowcontrol_params_t &params, float secondsToArrival, float dt )
{
	shadowcontrol_params_t ivpParams;
	ConvertShadowControllerToIVP( params, ivpParams );
	return ComputeShadowControllerIVP( pObject->GetObject(), ivpParams, secondsToArrival, dt );
}

class CShadowController : public IVP_Controller_Independent, public IPhysicsShadowController, public CAlignedNewDelete<16>
{
public:
	CShadowController();
	CShadowController( CPhysicsObject *pObject, bool allowTranslation, bool allowRotation );
	~CShadowController( void );

	// ipion interfaces
    void do_simulation_controller( IVP_Event_Sim *es,IVP_U_Vector<IVP_Core> *cores);
    virtual IVP_CONTROLLER_PRIORITY get_controller_priority() { return IVP_CP_MOTION; }
	virtual const char *get_controller_name() { return "vphysics:shadow"; }

	void SetObject( IPhysicsObject *pObject );
	void Update( const Vector &position, const QAngle &angles, float secondsToArrival );
	void MaxSpeed( float maxSpeed, float maxAngularSpeed );
	virtual void StepUp( float height );
	virtual void SetTeleportDistance( float teleportDistance );
	virtual bool AllowsTranslation() { return m_allowsTranslation; }
	virtual bool AllowsRotation() { return m_allowsRotation; }

	virtual void GetLastImpulse( Vector *pOut )
	{
		ConvertPositionToHL( m_shadow.lastImpulse, *pOut );
	}
	bool IsEnabled() { return m_enabled; }
	void Enable( bool bEnable ) 
	{ 
		m_enabled = bEnable;
	}

	void WriteToTemplate( vphysics_save_cshadowcontroller_t &controllerTemplate );
	void InitFromTemplate( const vphysics_save_cshadowcontroller_t &controllerTemplate );
	
	virtual void SetPhysicallyControlled( bool isPhysicallyControlled ) { m_isPhysicallyControlled = isPhysicallyControlled; }
	virtual bool IsPhysicallyControlled() { return m_isPhysicallyControlled; }

	virtual void UseShadowMaterial( bool bUseShadowMaterial )
	{
		if ( !m_pObject )
			return;

		int current = m_pObject->GetMaterialIndexInternal();
		int target = bUseShadowMaterial ? MATERIAL_INDEX_SHADOW : m_savedMaterialIndex;
		if ( target != current )
		{
			m_pObject->SetMaterialIndex( target );
		}
	}

	virtual void ObjectMaterialChanged( int materialIndex )
	{
		if ( !m_pObject )
			return;
		m_savedMaterialIndex = materialIndex;
	}

	//Basically get the last inputs to IPhysicsShadowController::Update(), returns last input to timeOffset in Update()
	virtual float GetTargetPosition( Vector *pPositionOut, QAngle *pAnglesOut );

	virtual float GetTeleportDistance( void );
	virtual void GetMaxSpeed( float *pMaxSpeedOut, float *pMaxAngularSpeedOut );

private:
	void AttachObject( void );
	void DetachObject( void );

	shadowcontrol_params_t	m_shadow;
	IVP_U_Float_Point	m_saveRot;
	IVP_U_Float_Point	m_savedRI;
	CPhysicsObject		*m_pObject;
	float				m_secondsToArrival;
	float				m_savedMass;
	unsigned int		m_savedFlags;

	unsigned short		m_savedMaterialIndex;
	bool				m_enabled : 1;
	bool				m_allowsTranslation : 1;
	bool				m_allowsRotation : 1;
	bool				m_isPhysicallyControlled : 1;
};

CShadowController::CShadowController()
{ 
	m_shadow.targetPosition.set_to_zero(); 
	m_shadow.targetRotation.init(); 
}

CShadowController::CShadowController( CPhysicsObject *pObject, bool allowTranslation, bool allowRotation )
{
	m_pObject = pObject;
	m_shadow.dampFactor = 1.0f;
	m_shadow.teleportDistance = 0;
	m_shadow.maxDampSpeed = 0;
	m_shadow.maxDampAngular = 0;
	m_shadow.targetPosition.set_to_zero(); 
	m_shadow.targetRotation.init(); 

	m_allowsTranslation = allowTranslation;
	m_allowsRotation = allowRotation;

	m_isPhysicallyControlled = false;
	m_enabled = false;

	AttachObject();
}

CShadowController::~CShadowController( void ) 
{
	DetachObject();
}

void CShadowController::AttachObject( void )
{
	IVP_Real_Object *pivp = m_pObject->GetObject();
	IVP_Core *pCore = pivp->get_core();
	m_saveRot = pCore->rot_speed_damp_factor;
	m_savedRI = *pCore->get_rot_inertia();
	m_savedMass = pCore->get_mass();
	m_savedMaterialIndex = m_pObject->GetMaterialIndexInternal();

	Vector position;
	QAngle angles;
	m_pObject->GetPosition( &position, &angles );
	ConvertPositionToIVP( position, m_shadow.targetPosition );
	ConvertRotationToIVP( angles, m_shadow.targetRotation );

	UseShadowMaterial( true );

	pCore->rot_speed_damp_factor = IVP_U_Float_Point( 100, 100, 100 );

	if ( !m_allowsRotation )
	{
		IVP_U_Float_Point ri( 1e15f, 1e15f, 1e15f );
		pCore->set_rotation_inertia( &ri );
	}
	if ( !m_allowsTranslation )
	{
		m_pObject->SetMass( VPHYSICS_MAX_MASS );
		//pCore->inv_rot_inertia.hesse_val = 0.0f;
		m_pObject->EnableGravity( false );
	}

	m_savedFlags = m_pObject->CallbackFlags();
	unsigned int flags = m_savedFlags | CALLBACK_SHADOW_COLLISION;
	flags &= ~CALLBACK_GLOBAL_FRICTION;
	flags &= ~CALLBACK_GLOBAL_COLLIDE_STATIC;
	m_pObject->SetCallbackFlags( flags );
	m_pObject->EnableDrag( false );

	pCore->calc_calc();
	pivp->get_environment()->get_controller_manager()->add_controller_to_core( this, pCore );
	m_shadow.lastPosition.set_to_zero();
}

void CShadowController::DetachObject( void )
{
	IVP_Real_Object *pivp = m_pObject->GetObject();
	IVP_Core *pCore = pivp->get_core();
	// don't bother if we're just doing this to delete the object
	if ( !(m_pObject->GetCallbackFlags() & CALLBACK_MARKED_FOR_DELETE) )
	{
		pCore->rot_speed_damp_factor = m_saveRot;
		pCore->set_mass( m_savedMass );
		m_pObject->SetCallbackFlags( m_savedFlags );
		m_pObject->EnableDrag( true );
		m_pObject->EnableGravity( true );
		UseShadowMaterial( false );
		pCore->set_rotation_inertia( &m_savedRI ); // this calls calc_calc()
	}
	m_pObject = NULL;
	pivp->get_environment()->get_controller_manager()->remove_controller_from_core( this, pCore );
}

void CShadowController::SetObject( IPhysicsObject *pObject )
{
	CPhysicsObject *obj = (CPhysicsObject *)pObject;
	if ( obj == m_pObject )
		return;

	DetachObject();
	m_pObject = obj;
	AttachObject();
}


void CShadowController::StepUp( float height )
{
	Vector step( 0, 0, height );

	IVP_Real_Object *pIVP = m_pObject->GetObject();
	IVP_U_Quat world_f_object;
	IVP_U_Point positionIVP, deltaIVP;
	ConvertPositionToIVP( step, deltaIVP );
	pIVP->get_quat_world_f_object_AT( &world_f_object, &positionIVP );
	positionIVP.add( &deltaIVP );
	pIVP->beam_object_to_new_position( &world_f_object, &positionIVP, IVP_TRUE );
}

void CShadowController::SetTeleportDistance( float teleportDistance )
{
	m_shadow.teleportDistance = ConvertDistanceToIVP( teleportDistance );
}

float CShadowController::GetTeleportDistance( void )
{
	return ConvertDistanceToHL( m_shadow.teleportDistance );
}

void CShadowController::do_simulation_controller( IVP_Event_Sim *es,IVP_U_Vector<IVP_Core> *)
{
	if ( IsEnabled() )
	{
		IVP_Real_Object *pivp = m_pObject->GetObject();
		Assert(!pivp->get_core()->pinned && !pivp->get_core()->physical_unmoveable);

		ComputeShadowControllerIVP( pivp, m_shadow, m_secondsToArrival, es->delta_time );
		if ( m_allowsTranslation )
		{
			// UNDONE: Assumes gravity points down
			const IVP_U_Point *pgrav = pivp->get_environment()->get_gravity();
			float gravDt = pgrav->k[1] * es->delta_time;
			
			if ( m_shadow.lastImpulse.k[1] > gravDt )
			{
				if ( IsOnGround( pivp ) )
				{
					float delta = gravDt - m_shadow.lastImpulse.k[1];
					pivp->get_core()->speed.k[1] += delta;
					m_shadow.lastImpulse.k[1] += delta;
				}
			}
		}

		// if we have time left, subtract it off
		m_secondsToArrival -= es->delta_time;
		if ( m_secondsToArrival < 0 )
		{
			m_secondsToArrival = 0;
		}
	}
	else
	{
		m_shadow.lastPosition.set_to_zero();
	}
}

// NOTE: This isn't a test for equivalent orientations, it's a test for calling update
// with EXACTLY the same data repeatedly
static bool IsEqual( const IVP_U_Point &pt0, const IVP_U_Point &pt1 )
{
	return pt0.quad_distance_to( &pt1 ) < 1e-8f ? true : false;
}

// NOTE: This isn't a test for equivalent orientations, it's a test for calling update
// with EXACTLY the same data repeatedly
static bool IsEqual( const IVP_U_Quat &pt0, const IVP_U_Quat &pt1 )
{
	float delta = fabs(pt0.x - pt1.x);
	delta += fabs(pt0.y - pt1.y);
	delta += fabs(pt0.z - pt1.z);
	delta += fabs(pt0.w - pt1.w);
	return delta < 1e-8f ? true : false;
}

void CShadowController::Update( const Vector &position, const QAngle &angles, float secondsToArrival )
{
	IVP_U_Point targetPosition = m_shadow.targetPosition;
	IVP_U_Quat targetRotation = m_shadow.targetRotation;

	ConvertPositionToIVP( position, m_shadow.targetPosition );
	m_secondsToArrival = secondsToArrival < 0 ? 0 : secondsToArrival;
	ConvertRotationToIVP( angles, m_shadow.targetRotation );

	Enable( true );

	if ( IsEqual( targetPosition, m_shadow.targetPosition ) && IsEqual( targetRotation, m_shadow.targetRotation ) )
		return;

	m_pObject->Wake();
}

float CShadowController::GetTargetPosition( Vector *pPositionOut, QAngle *pAnglesOut )
{
	if( pPositionOut )
		ConvertPositionToHL( m_shadow.targetPosition, *pPositionOut );

	if( pAnglesOut )
		ConvertRotationToHL( m_shadow.targetRotation, *pAnglesOut );

	return m_secondsToArrival;
}

void CShadowController::MaxSpeed( float maxSpeed, float maxAngularSpeed )
{
	// UNDONE: Turn this on when shadow controllers are having velocity updated per frame
	// right now this has the effect of making dampspeed zero by default.
#if 0
	IVP_Core *pCore = m_pObject->GetObject()->get_core();
	{
		// limit additional velocity to that which is not amplifying the current velocity
		float availableSpeed = ConvertDistanceToIVP( maxSpeed );
		float currentSpeed = pCore->speed.real_length();

		m_shadow.maxDampSpeed = min(currentSpeed, availableSpeed);
		m_shadow.maxSpeed = availableSpeed - m_shadow.maxDampSpeed;
	}

	{
		// limit additional velocity to that which is not amplifying the current velocity
		float availableAngularSpeed = ConvertAngleToIVP( maxAngularSpeed );
		float currentAngularSpeed = pCore->rot_speed.real_length();
		m_shadow.maxDampAngular = min(currentAngularSpeed, availableAngularSpeed);
		m_shadow.maxAngular = availableAngularSpeed - m_shadow.maxDampAngular;
	}
#else
	m_shadow.maxSpeed = maxSpeed;
	m_shadow.maxDampSpeed = maxSpeed;
	m_shadow.maxAngular = maxAngularSpeed;
	m_shadow.maxDampAngular = maxAngularSpeed;
#endif
}

void CShadowController::GetMaxSpeed( float *pMaxSpeedOut, float *pMaxAngularSpeedOut )
{
	if( pMaxSpeedOut )
		*pMaxSpeedOut = m_shadow.maxSpeed;

	if( pMaxAngularSpeedOut )
		*pMaxAngularSpeedOut = m_shadow.maxAngular;
}

struct vphysics_save_shadowcontrolparams_t : public hlshadowcontrol_params_t
{
	DECLARE_SIMPLE_DATADESC();
};

BEGIN_SIMPLE_DATADESC( vphysics_save_shadowcontrolparams_t )
	DEFINE_FIELD( targetPosition,		FIELD_POSITION_VECTOR	),
	DEFINE_FIELD( targetRotation,		FIELD_VECTOR	),
	DEFINE_FIELD( maxSpeed,			FIELD_FLOAT	),
	DEFINE_FIELD( maxDampSpeed,		FIELD_FLOAT	),
	DEFINE_FIELD( maxAngular,			FIELD_FLOAT	),
	DEFINE_FIELD( maxDampAngular,		FIELD_FLOAT	),
	DEFINE_FIELD( dampFactor,			FIELD_FLOAT	),
	DEFINE_FIELD( teleportDistance,	FIELD_FLOAT	),
END_DATADESC()

struct vphysics_save_cshadowcontroller_t
{
	CPhysicsObject		*pObject;
	float				secondsToArrival;
	IVP_U_Float_Point	saveRot;
	IVP_U_Float_Point	savedRI;
	IVP_U_Float_Point	currentSpeed;

	float				savedMass;
	int					savedMaterial;
	unsigned int		savedFlags;
	bool				enable;
	bool				allowPhysicsMovement;
	bool				allowPhysicsRotation;
	bool				isPhysicallyControlled;

	hlshadowcontrol_params_t	shadowParams;

	DECLARE_SIMPLE_DATADESC();
};


BEGIN_SIMPLE_DATADESC( vphysics_save_cshadowcontroller_t )
	//DEFINE_VPHYSPTR( pObject ),
	DEFINE_FIELD( secondsToArrival,		FIELD_FLOAT	),
	DEFINE_ARRAY( saveRot.k,				FIELD_FLOAT, 3 ),
	DEFINE_ARRAY( savedRI.k,				FIELD_FLOAT, 3 ),
	DEFINE_ARRAY( currentSpeed.k,			FIELD_FLOAT, 3 ),
	DEFINE_FIELD( savedMass,				FIELD_FLOAT	),
	DEFINE_FIELD( savedFlags,				FIELD_INTEGER	),
	DEFINE_CUSTOM_FIELD( savedMaterial, MaterialIndexDataOps() ),
	DEFINE_FIELD( enable,						FIELD_BOOLEAN	),
	DEFINE_FIELD( allowPhysicsMovement,		FIELD_BOOLEAN	),
	DEFINE_FIELD( allowPhysicsRotation,		FIELD_BOOLEAN	),
	DEFINE_FIELD( isPhysicallyControlled,	FIELD_BOOLEAN	),

	DEFINE_EMBEDDED_OVERRIDE( shadowParams, vphysics_save_shadowcontrolparams_t ),
END_DATADESC()

void CShadowController::WriteToTemplate( vphysics_save_cshadowcontroller_t &controllerTemplate )
{
	controllerTemplate.pObject = m_pObject;
	controllerTemplate.secondsToArrival = m_secondsToArrival;
	controllerTemplate.saveRot = m_saveRot;
	controllerTemplate.savedRI = m_savedRI;
	controllerTemplate.savedMass = m_savedMass;
	controllerTemplate.savedFlags = m_savedFlags;

	controllerTemplate.savedMaterial = m_savedMaterialIndex;
	controllerTemplate.enable = IsEnabled();
	controllerTemplate.allowPhysicsMovement = m_allowsTranslation;
	controllerTemplate.allowPhysicsRotation = m_allowsRotation;
	controllerTemplate.isPhysicallyControlled = m_isPhysicallyControlled;

	ConvertShadowControllerToHL( m_shadow, controllerTemplate.shadowParams );
}

void CShadowController::InitFromTemplate( const vphysics_save_cshadowcontroller_t &controllerTemplate )
{
	m_pObject = controllerTemplate.pObject;
	m_secondsToArrival = controllerTemplate.secondsToArrival;
	m_saveRot = controllerTemplate.saveRot;
	m_savedRI = controllerTemplate.savedRI;
	m_savedMass = controllerTemplate.savedMass;
	m_savedFlags = controllerTemplate.savedFlags;
	m_savedMaterialIndex = controllerTemplate.savedMaterial;

	Enable( controllerTemplate.enable );
	m_allowsTranslation = controllerTemplate.allowPhysicsMovement;
	m_allowsRotation = controllerTemplate.allowPhysicsRotation;
	m_isPhysicallyControlled = controllerTemplate.isPhysicallyControlled;
	
	ConvertShadowControllerToIVP( controllerTemplate.shadowParams, m_shadow );
	m_pObject->GetObject()->get_environment()->get_controller_manager()->add_controller_to_core( this, m_pObject->GetObject()->get_core() );
}


IPhysicsShadowController *CreateShadowController( CPhysicsObject *pObject, bool allowTranslation, bool allowRotation )
{
	return new CShadowController( pObject, allowTranslation, allowRotation );
}



bool SavePhysicsShadowController( const physsaveparams_t &params, IPhysicsShadowController *pIShadow )
{
	vphysics_save_cshadowcontroller_t controllerTemplate;
	memset( &controllerTemplate, 0, sizeof(controllerTemplate) );

	CShadowController *pShadowController = (CShadowController *)pIShadow;
	pShadowController->WriteToTemplate( controllerTemplate );
	params.pSave->WriteAll( &controllerTemplate );
	return true;
}

bool RestorePhysicsShadowController( const physrestoreparams_t &params, IPhysicsShadowController **ppShadowController )
{
	return false;
}

bool RestorePhysicsShadowControllerInternal( const physrestoreparams_t &params, IPhysicsShadowController **ppShadowController, CPhysicsObject *pObject )
{
	vphysics_save_cshadowcontroller_t controllerTemplate;

	memset( &controllerTemplate, 0, sizeof(controllerTemplate) );
	params.pRestore->ReadAll( &controllerTemplate );
	
	// HACKHACK: pass this in
	controllerTemplate.pObject = pObject;

	CShadowController *pShadow = new CShadowController();
	pShadow->InitFromTemplate( controllerTemplate );

	*ppShadowController = pShadow;
	return true;
}

bool SavePhysicsPlayerController( const physsaveparams_t &params, CPlayerController *pPlayerController )
{
	return false;
}

bool RestorePhysicsPlayerController( const physrestoreparams_t &params, CPlayerController **ppPlayerController )
{
	return false;
}

//HACKHACK: The physics object transfer system needs to temporarily detach a shadow controller from an object, then reattach without other repercussions
void ControlPhysicsShadowControllerAttachment_Silent( IPhysicsShadowController *pController, IVP_Real_Object *pivp, bool bAttach )
{
	if( bAttach )
	{
		pivp->get_environment()->get_controller_manager()->add_controller_to_core( (CShadowController *)pController, pivp->get_core() );
	}
	else
	{
		pivp->get_environment()->get_controller_manager()->remove_controller_from_core( (CShadowController *)pController, pivp->get_core() );
	}
}

void ControlPhysicsPlayerControllerAttachment_Silent( IPhysicsPlayerController *pController, IVP_Real_Object *pivp, bool bAttach )
{
	if( bAttach )
	{
		pivp->get_environment()->get_controller_manager()->add_controller_to_core( (CPlayerController *)pController, pivp->get_core() );
	}
	else
	{
		pivp->get_environment()->get_controller_manager()->remove_controller_from_core( (CPlayerController *)pController, pivp->get_core() );
	}
}