//****************************************************************************
//* MODULE:         Gel/Components
//* FILENAME:       SkaterCameraComponent.cpp
//* OWNER:          Dave Cowling
//* CREATION DATE:  02/21/03
//****************************************************************************

#include <gel/components/skatercameracomponent.h>

#include <gel/object/compositeobjectmanager.h>
#include <gel/object/compositeobject.h>
#include <gel/components/cameracomponent.h>
#include <gel/components/inputcomponent.h>
#include <gel/components/camerautil.h>
#include <gel/components/cameralookaroundcomponent.h>
#include <gel/components/movablecontactcomponent.h>
#include <gel/scripting/checksum.h>
#include <gel/scripting/script.h>
#include <gel/scripting/struct.h>
#include <gel/scripting/symboltable.h>

#include <gfx/nxviewman.h>

#include <sk/objects/proxim.h>
#include <sk/components/skaterphysicscontrolcomponent.h>
#include <sk/components/skatercorephysicscomponent.h>
#include <sk/components/skaterbalancetrickcomponent.h>
#include <sk/components/skaterstatecomponent.h>


namespace Obj
{

const float SKATERCAMERACOMPONENT_LEAN_TO_SKATERCAM_LEAN	= (( Mth::PI / 6.0f ) / -4096.0f );
	
const float	SKATERCAMERACOMPONENT_INTERPOLATOR_TIMESTEP		= ( 1.0f / 60.0f );

// This is the value that mAbove should tend to when the behind value is closer than mBehind.

const float VERT_AIR_LANDED_TIME	= 10.0f / 60.0f;
const float TILT_MAX				= 0.34907f;						// 20 degees.
const float TILT_MIN				= -0.34907f;					// -20 degees.
const float TILT_INCREMENT			= 2.0f * ( TILT_MAX / 60.0f );	// 40 degrees/second.
const float TILT_DECREMENT			= 2.0f * ( TILT_MAX / 60.0f );	// 40 degrees/second.
const float TILT_RESTORE			= 8.0f * ( TILT_MAX / 60.0f );	// 160 degrees/second.
	
	
/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
static void _xrotlocal ( Mth::Matrix& m, float a )
{
	m.RotateXLocal( a );
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
CBaseComponent* CSkaterCameraComponent::s_create()
{
	return static_cast< CBaseComponent* >( new CSkaterCameraComponent );	
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
CSkaterCameraComponent::CSkaterCameraComponent() : CBaseComponent()
{
	SetType( CRC_SKATERCAMERA );
	
	mMode = SKATERCAM_MODE_UNDEFINED;
				  
	// Create the SLERP interpolator here.
	mpSlerp				= new Mth::SlerpInterpolator;

	// Set current zoom and LERP rates.
	mCurrentZoom		= 1.0f;
	mZoomLerp			= 0.0625f;
	mLastDot			= 1.0f;

	mLerpXZ				= 0.25f;
	mLerpY				= 0.5f;
	mVertAirLerpXZ		= 1.0f;
	mVertAirLerpY		= 1.0f;
	mGrindLerp			= 0.1f;
	
	mpSkater= NULL;
	mpSkaterStateComponent = NULL;
	mpSkaterPhysicsControlComponent = NULL;
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
CSkaterCameraComponent::~CSkaterCameraComponent()
{
	delete mpSlerp;
}


/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::Finalize (   )
{
	mp_lookaround_component = GetCameraLookAroundComponentFromObject(GetObject());
	
	Dbg_Assert(mp_lookaround_component);
}


/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::Enable( bool enable )
{
	CCameraComponent *p_cam_comp = GetCameraComponentFromObject( GetObject());
	Dbg_MsgAssert( p_cam_comp, ( "SkaterCameraComponent requires CameraComponent attached to parent" ));
	p_cam_comp->Enable( enable );
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
Gfx::Camera* CSkaterCameraComponent::GetCamera( void )
{
	CCameraComponent *p_cam_comp = GetCameraComponentFromObject( GetObject());
	Dbg_MsgAssert( p_cam_comp, ( "SkaterCameraComponent requires CameraComponent attached to parent" ));
	return p_cam_comp->GetCamera();
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
const Mth::Vector& CSkaterCameraComponent::GetPosition( void ) const 
{
	CCameraComponent *p_cam_comp = GetCameraComponentFromObject( GetObject());
	Dbg_MsgAssert( p_cam_comp, ( "SkaterCameraComponent requires CameraComponent attached to parent" ));
	return p_cam_comp->GetPosition();
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::SetPosition( Mth::Vector& pos )
{
	CCameraComponent *p_cam_comp = GetCameraComponentFromObject( GetObject());
	Dbg_MsgAssert( p_cam_comp, ( "SkaterCameraComponent requires CameraComponent attached to parent" ));
	p_cam_comp->SetPosition( pos );
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
const Mth::Matrix& CSkaterCameraComponent::GetMatrix( void ) const
{
	CCameraComponent *p_cam_comp = GetCameraComponentFromObject( GetObject());
	Dbg_MsgAssert( p_cam_comp, ( "SkaterCameraComponent requires CameraComponent attached to parent" ));
	return p_cam_comp->GetMatrix();
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::InitFromStructure( Script::CStruct* pParams )
{

// NOT We need a CCameraComponent attached in order to get camera details.
//	CCameraComponent *p_cam_comp	= GetCameraComponentFromObject( GetObject());
//	Dbg_MsgAssert( p_cam_comp, ( "CSkaterCameraComponent needs CCameraComponent attached to parent" ));

	// Clear the frame matrix, so that future slerps make sense.
	//Mth::Matrix& frame_matrix		= p_cam_comp->GetMatrix();
	Mth::Matrix& frame_matrix		= GetObject()->GetMatrix();
	frame_matrix.Ident();

	mLastActualRight 				= frame_matrix[X];
	mLastActualUp 					= frame_matrix[Y];
	mLastActualAt 					= frame_matrix[Z];


	// The camera requires a "CameraTarget" checksum parameter
	uint32	target_id = 0 ;
	pParams->GetChecksum("CameraTarget", &target_id, true);

	Dbg_MsgAssert(target_id >=0 && target_id <= 15,("Bad CameraTarget 0x%x in SkaterCameraComponent",target_id));

	CSkater* p_skater = static_cast<CSkater*>(CCompositeObjectManager::Instance()->GetObjectByID(target_id)); 
	Dbg_MsgAssert(p_skater,("Can't find skater %d in SkaterCameraComponent",target_id));

		
	SetSkater(p_skater);
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::RefreshFromStructure( Script::CStruct* pParams )
{
	// Reinitialise.
	InitFromStructure( pParams );
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::Commit( void )
{
	// Under the normal operation of components, the CSkaterCameraComponent updates the values
	// in CCameraComponent during its Update() function. The CCameraComponent in turn will set
	// the Gfx::CCamera values during it's Update() function.
	// In some cases however, we need the camera changes to be committed to the Gfx::Camera
	// immediately, usually when logic is paused, and the component Update()'s are not taking place.
	CCameraComponent *p_cam_component = GetCameraComponentFromObject( GetObject());
	if( p_cam_component )
	{
		p_cam_component->Update();
	}
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void CSkaterCameraComponent::ReadyForActivation ( const SCameraState& state )
{
	Dbg_MsgAssert(mpSkater, ("Skater camera (%s) has NULL target", Script::FindChecksumName(GetObject()->GetID())));
	
	mLastActualRight = state.lastActualMatrix[X];
	mLastActualUp = state.lastActualMatrix[Y];
	mLastActualAt = state.lastActualMatrix[Z];
	mLastTripodPos = state.lastTripodPos;
	mLastDot = state.lastDot;
	mCurrentZoom = state.lastZoom;
	mVertAirLandedTimer = 0.0f;
	mInstantCount = 0;
	
	mp_lookaround_component->mLookaroundHeading = 0.0f;
	mp_lookaround_component->mLookaroundLock = false;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void CSkaterCameraComponent::Update( void )
{
	if( mpSkater == NULL )
	{
		return;
	}
	
	// optimization KLUDGE
	if (mpSkaterPhysicsControlComponent && mpSkaterPhysicsControlComponent->IsDriving())
	{
		GetObject()->Pause(true);
		return;
	}
	
	// We need a CCameraComponent attached in order to get camera details.
	CCameraComponent *p_cam_comp = GetCameraComponentFromObject( GetObject());
	Dbg_MsgAssert( p_cam_comp, ( "CSkaterCameraComponent needs CCameraComponent attached to parent" ));

	// This used to be passed in as a param for the old CSkaterCam::Update().
	// Now we get it from a flag in the skater
	bool instantly = false;
	
	Dbg_Assert( mpSkater );
	if (mpSkater->HasTeleported())
	{
		instantly = true;
	}

	if( instantly )
	{
		mInstantCount = 3;
	}

	if( mInstantCount > 0 )
	{
		--mInstantCount;
		instantly = true;
	}

		
//	if (instantly)
//	{
//		printf ("%d: Instantly!\n",(int)Tmr::GetRenderFrame());
//	}
		
	// Length of last frame in seconds.
	float delta_time = Tmr::FrameLength();

	// Update any values we are currently interpolating.
	UpdateInterpolators();

	// Would have used a SetPos() function, but the camera update in rwviewer.cpp is spread out all over the place,
	// so it's not easy to do. We'll just store the old position before updating anything...
//	Gfx::Camera::StoreOldPos();
	p_cam_comp->StoreOldPosition();

//	Mth::Matrix& frame_matrix	= Gfx::Camera::GetMatrix();
	Mth::Matrix& frame_matrix	= p_cam_comp->GetMatrix();

	frame_matrix[X]   		= mLastActualRight;
	frame_matrix[Y]			= mLastActualUp;
	frame_matrix[Z]			= mLastActualAt;

	Mth::Vector	current_at_vector( frame_matrix[Z][X], frame_matrix[Z][Y], frame_matrix[Z][Z] ); 

	// Obtain skater state.
	EStateType	state			= mpSkaterStateComponent->GetState();
	Mth::Matrix target;

	if( state == WALL )
	{
#		ifdef	DEBUG_CAMERA
		printf ("SkaterCam Using mLastPreWallSkaterMatrix, as wallriding\n");
#		endif
		target						= mLastPreWallSkaterMatrix;
	}
	else
	{
#		ifdef	DEBUG_CAMERA
		printf ("SkaterCam Using GetCameraDisplayMatrix\n");
#		endif
		// target						= static_cast< CCompositeObject* >(mpSkater)->GetDisplayMatrix();
		if (mpSkater->IsLocalClient())
		{
			target						= mpSkater->GetDisplayMatrix();
		}
		else
		{
			target						= static_cast< CCompositeObject* >(mpSkater)->GetDisplayMatrix();
		}
		mLastPreWallSkaterMatrix	= target;
	}

	// Lerp towards the required lean.
	float cam_lean = 0.0f;
	if( state == RAIL && mpSkater->IsLocalClient())
	{		
		// Need to translate the lean value [-4096, 4096] into a reasonable camera lean angle.
		cam_lean = GetSkaterBalanceTrickComponentFromObject(mpSkater)->mGrind.mManualLean * SKATERCAMERACOMPONENT_LEAN_TO_SKATERCAM_LEAN;
	}

	if( cam_lean != mLean )
	{
		if( instantly )
		{
			mLean = cam_lean;
		}
		else
		{
			mLean += (( cam_lean - mLean ) * mGrindLerp );
		}
	}
		
	Mth::Vector skater_up;
					
	if (state != GROUND)
	{
		skater_up	= target[Y];
	}
	else
	{
		skater_up	= mpSkaterStateComponent->GetCameraDisplayNormal();
	}

//	Gfx::AddDebugLine( p_skater->m_pos, ( target[X] * 72.0f ) + p_skater->m_pos, MAKE_RGB( 128, 0, 0 ), MAKE_RGB( 128, 0, 0 ), 4 );
//	Gfx::AddDebugLine( p_skater->m_pos, ( target[Y] * 72.0f ) + p_skater->m_pos, MAKE_RGB( 0, 128, 0 ), MAKE_RGB( 0, 128, 0 ), 4 );
//	Gfx::AddDebugLine( p_skater->m_pos, ( target[Z] * 72.0f ) + p_skater->m_pos, MAKE_RGB( 0, 0, 128 ), MAKE_RGB( 0, 0, 128 ), 4 );
		
	// Use vel for forward facing, if moving in xz plane.
	Mth::Vector vel_xz( mpSkater->GetVel().GetX(), 0.0f, mpSkater->GetVel().GetZ());

	bool use_vert_cam = UseVertCam();
	
	// use velocity if physics not paused, and if we are moving fast enough, or if we are doing vert cam
	// or if we are doing spine physics
	if(
		!(mpSkaterPhysicsControlComponent && mpSkaterPhysicsControlComponent->IsPhysicsSuspended()) && (vel_xz.Length() > 0.1f || use_vert_cam  || mpSkaterStateComponent->GetFlag( SPINE_PHYSICS ))
	   )
	{
		if( use_vert_cam )
		{
			// If it's vert, then set target direction to near straight down.
			target[Z].Set( 0.0f, -1.0f, 0.0f );

			// Zero lookaround when in vert air (and not in lookaround locked or override mode, or doing a lip trick).
			if( !mp_lookaround_component->mLookaroundLock && !mp_lookaround_component->mLookaroundOverride && ( state != LIP ))
			{
				mp_lookaround_component->mLookaroundTilt		= 0.0f;
				mp_lookaround_component->mLookaroundHeading	= 0.0f;
			}
		}
		else
		{
			target[Z]		= mpSkater->GetVel();
			
#			if 1	// for use with non-straight spine transfer physics
			if( mpSkaterStateComponent->GetFlag( SPINE_PHYSICS ))
			{
				// Just use the up velocity, plus the velocity over the spine will be straight down when coming down the other side.
				target[Z][X] = 0.0f;
				target[Z][Z] = 0.0f;
				target[Z] += mpSkaterStateComponent->GetSpineVel();
			}
#			endif

			target[Z].Normalize();

//			printf ("Using Velocity (%f, %f, %f)\n", target[Z][X],target[Z][Y], target[Z][Z]);

//			Gfx::AddDebugLine( mpSkater->m_pos, ( target[Z] * 72.0f ) + mpSkater->m_pos, MAKE_RGB( 128, 128, 128 ), MAKE_RGB( 128, 128, 128 ), 4 );

			// Flatten out the velocity component perpendicular to the ground. However, if the skater is in the air, the
			// m_last_normal will contain the last ground normal, which we don't want, so set it to be 'up'.
			float			dot;
			Mth::Vector		normal;

			if( state == AIR )
			{
				// Patch for spine physics
				// only reduce component perpendicular to plane by 60%
				// so we still get some up/down camera movmeent 
				// only do this when moving down though, otherwise it looks poo
				if (mpSkaterStateComponent->GetFlag(SPINE_PHYSICS) && target[Z][Y] < 0.0f)
				{
					normal.Set( 0.0f, 1.0f, 0.0f );
					dot =  0.7f * Mth::DotProduct(target[Z],normal);	// change this to 0.8 to look down when coming down other side of a spine
				}
				else
				{
					normal.Set( 0.0f, 1.0f, 0.0f );
					dot		= target[Z].GetY();
				}
				// Set world up as the target vector.
				target[Y].Set( 0.0f, 1.0f, 0.0f );
			}
			else if( state == WALL )
			{
				normal.Set( 0.0f, 1.0f, 0.0f );
				dot		= target[Z].GetY();
			}
			else
			{
				normal	= mpSkaterStateComponent->GetCameraCurrentNormal();
				dot =  0.8f * Mth::DotProduct(target[Z],normal);
			}
			
			target[Z] -= normal * dot;
			target[Z].Normalize();
			
//			Gfx::AddDebugLine( mpSkater->m_pos, ( target[Z] * 72.0f ) + mpSkater->m_pos, MAKE_RGB( 256, 256, 256 ), MAKE_RGB( 256, 256, 256 ), 4 );
		}

		// We need to orthonormalize in a specific order, as when the velocity is going backwards, then 
		// the X orient will be wrong, and so plonk the skater upside down.
		target[X]			= Mth::CrossProduct( target[Y], target[Z] );
		target[X].Normalize();
		
		target[Y]			= Mth::CrossProduct( target[Z], target[X] );
		target[Y].Normalize();

//		Gfx::AddDebugLine( mpSkater->m_pos, ( target[X] * 72.0f ) + mpSkater->m_pos, MAKE_RGB( 128, 0, 0 ), MAKE_RGB( 128, 0, 0 ), 4 );
//		Gfx::AddDebugLine( mpSkater->m_pos, ( target[Y] * 72.0f ) + mpSkater->m_pos, MAKE_RGB( 0, 128, 0 ), MAKE_RGB( 0, 128, 0 ), 4 );
//		Gfx::AddDebugLine( mpSkater->m_pos, ( target[Z] * 72.0f ) + mpSkater->m_pos, MAKE_RGB( 0, 0, 128 ), MAKE_RGB( 0, 0, 128 ), 4 );
	}
	
	if (mpSkater->IsLocalClient() && mpSkaterStateComponent->GetFlag(IN_ACID_DROP))
	{
		CSkaterCorePhysicsComponent* pSkaterPhysicsComponent = GetSkaterCorePhysicsComponentFromObject(mpSkater);
		Dbg_Assert(pSkaterPhysicsComponent);
		
		target = pSkaterPhysicsComponent->m_acid_drop_camera_matrix;
	}
							
	// Tilt further if in regular air (going off a big jump, for example), or doing a lip trick.
	if( state == AIR )
	{
		mTiltAddition += TILT_INCREMENT * Tmr::FrameRatio();
		if( mTiltAddition > TILT_MAX )
		{
			mTiltAddition = TILT_MAX;
		}				
	}
	else if( mTiltAddition > 0.0f )
	{
		mTiltAddition -= TILT_RESTORE * Tmr::FrameRatio();
		if( mTiltAddition < 0.0f )
		{
			mTiltAddition = 0.0f;
		}				
	}
	else if( mTiltAddition < 0.0f )
	{
		mTiltAddition += TILT_RESTORE * Tmr::FrameRatio();
		if( mTiltAddition > 0.0f )
		{
			mTiltAddition = 0.0f;
		}				
	}

	// PJR: Needed to do this to fix a compiler crash on NGC. Hopefully SN will
	// fix this & I can revert this hack...
	target.RotateYLocal( mp_lookaround_component->mLookaroundHeading + mp_lookaround_component->mLookaroundHeadingStartingPoint );

	// Now tilt the matrix down a bit.
	if( state == LIP )
	{
//		target.RotateYLocal( 0.8f );
//		target.RotateXLocal( mLipTrickTilt + mTiltAddition );
		_xrotlocal ( target, mLipTrickTilt + mTiltAddition );
	}					
	else if( !(mpSkaterStateComponent->GetFlag( VERT_AIR ) && !mpSkaterStateComponent->GetFlag( CAN_BREAK_VERT )  && !mpSkaterStateComponent->GetFlag(SPINE_PHYSICS) ) /*|| !mpSkaterStateComponent->GetFlag(IN_ACID_DROP)*/)
	{
//		target.RotateXLocal( mTilt + mTiltAddition );
		_xrotlocal ( target, mTilt + mTiltAddition );
	}
	
	// Now adjust for 'lookaround'.
//	target.RotateXLocal( mLookaroundTilt );
	_xrotlocal( target, mp_lookaround_component->mLookaroundTilt );
	
	static float lip_rotate = 0.0f;

	if( state == LIP )
	{
		lip_rotate = Mth::PI / 2.0f;

		if( mLipSideDecided == 0 )
		{
			target.RotateY( lip_rotate );

			// Do collision check.
			CFeeler feeler;

			Mth::Vector horiz_z( target[Z][X], 0.0f, target[Z][Z] );
			horiz_z.Normalize();
			Mth::Vector a = mpSkater->m_pos - ( target[Z] * 3.0f );
			Mth::Vector b = a - ( horiz_z * 72.0f );

			feeler.SetIgnore(IGNORE_FACE_FLAGS_1, IGNORE_FACE_FLAGS_0);
			bool collision = feeler.GetCollision(a, b, true);
			if( !collision )
			{
				// Side 1 is fine.
				mLipSideDecided = 1;
			}
			else
			{
				float dist = feeler.GetDist();
				target.RotateY( -lip_rotate * 2.0f );
				horiz_z.Set( target[Z][X], 0.0f, target[Z][Z] );
				horiz_z.Normalize();
				a = mpSkater->m_pos - ( target[Z] * 3.0f );
				b = a - ( horiz_z * 72.0f );

				collision = feeler.GetCollision(a, b, true);
				if( !collision )
				{
					// Side 2 is fine.
					mLipSideDecided = 2;
				}
				else
				{
					if( feeler.GetDist() < dist )
					{
						// Side 2 is better than side 1.
						mLipSideDecided = 2;
					}
					else
					{
						// Side 1 is better than side 2.
						target.RotateY( lip_rotate * 2.0f );
						mLipSideDecided = 1;
					}
				}
			}
		}
		else
		{
			if( mLipSideDecided == 1 )
			{
				target.RotateY( lip_rotate );
			}
			else
			{
				target.RotateY( -lip_rotate );
			}
		}
	}
	else
	{
		mLipSideDecided = 0;
	}					

	// Set skater flag to indicate when the liptrick camera has spun to the opposite side.
	if( mpSkater && ( mLipSideDecided == 2 ))
	{
		mpSkater->mScriptFlags |= ( 1 << Script::GetInteger( 0x16b8e4cb /* "FLAG_SKATER_LIPTRICK_CAM_REVERSED" */ ));
	}
	else
	{
		mpSkater->mScriptFlags &= ~( 1 << Script::GetInteger( 0x16b8e4cb /* "FLAG_SKATER_LIPTRICK_CAM_REVERSED" */ ));
	}
	
//	Gfx::AddDebugLine( mpSkater->m_pos, ( target[X] * 72.0f ) + mpSkater->m_pos, MAKE_RGB( 128, 0, 0 ), MAKE_RGB( 128, 0, 0 ), 4 );
//	Gfx::AddDebugLine( mpSkater->m_pos, ( target[Y] * 72.0f ) + mpSkater->m_pos, MAKE_RGB( 0, 128, 0 ), MAKE_RGB( 0, 128, 0 ), 4 );
//	Gfx::AddDebugLine( mpSkater->m_pos, ( target[Z] * 72.0f ) + mpSkater->m_pos, MAKE_RGB( 0, 0, 128 ), MAKE_RGB( 0, 0, 128 ), 4 );
	
	// Why doing this, when setting below?
	Mth::Matrix t_matrix(0.0f, 0.0f, 0.0f);
	
	// Since camera points in -Z, but player in +Z, we must negate the X and Z axes
	t_matrix[X][X]		= -target[0][0];
	t_matrix[X][Y]		= -target[0][1];
	t_matrix[X][Z]		= -target[0][2];
	t_matrix[X][W]		= 0.0f;
	
	t_matrix[Y][X]		= target[1][0];
	t_matrix[Y][Y]		= target[1][1];
	t_matrix[Y][Z]		= target[1][2];
	t_matrix[Y][W]		= 0.0f;
	
	t_matrix[Z][X]		= -target[2][0];
	t_matrix[Z][Y]		= -target[2][1];
	t_matrix[Z][Z]		= -target[2][2];
	t_matrix[Z][W]		= 0.0f;
			
	t_matrix[W][X]		= 0.0f;
	t_matrix[W][Y]		= 0.0f;
	t_matrix[W][Z]		= 0.0f;
	t_matrix[W][W]		= 1.0f;
        
	frame_matrix[W][X]	= 0.0f;
	frame_matrix[W][Y]	= 0.0f;
	frame_matrix[W][Z]	= 0.0f;
	frame_matrix[W][W]	= 1.0f;

	// if we want an instant update, then just move it
	if (instantly)
	{
		frame_matrix = t_matrix;
	}

	float dotx = Mth::DotProduct( t_matrix[X], frame_matrix[X] );
	float doty = Mth::DotProduct( t_matrix[Y], frame_matrix[Y] );
	float dotz = Mth::DotProduct( t_matrix[Z], frame_matrix[Z] );

	if( dotx > CAMERA_SLERP_STOP && doty > CAMERA_SLERP_STOP && dotz > CAMERA_SLERP_STOP )
	{
		// Do nothing, camera has reached the target so we just leave the frame matrix exactly where it is.
//	    frame_matrix = t_matrix;
	}
	else
	{
		// Initialise the SLERP interpolator, with the current matrix as the start, and the ideal
		// matrix as the end (target).

		// GARY:  is this right?  i assume p_matrix = &t_matrix
		mpSlerp->setMatrices( &frame_matrix, &t_matrix );

		// Copy flags and shit (why copying all this when most of the values will be overwritten?)
		Mth::Matrix stored_frame;
		stored_frame = frame_matrix;
		frame_matrix = t_matrix;			

		// Continue to slerp towards the target, updating frame_matrix with the slerped values.
		if( !(mpSkaterStateComponent->GetFlag( VERT_AIR ) && !mpSkaterStateComponent->GetFlag( CAN_BREAK_VERT ) && !mpSkaterStateComponent->GetFlag(SPINE_PHYSICS)))
		{
			// If the skater has just landed from big air, use the big air land slerp value.
			if(( mpSkaterStateComponent->GetState() == GROUND ) && ( mVertAirLandedTimer >= delta_time ))
			{
				mVertAirLandedTimer -= delta_time;
				mpSlerp->getMatrix( &frame_matrix, GetTimeAdjustedSlerp( mVertAirLandedSlerp, delta_time ));
			}
			else
			{
				// Clear the vert air landed timer.
				mVertAirLandedTimer = 0.0f;
				
				mpSlerp->getMatrix( &frame_matrix, GetTimeAdjustedSlerp( mSlerp, delta_time ));

				// At this point we can check to see the angle that the camera's 'at' vector moved through this frame.
				// If this angle is too large, we need to limit it, regardless of the slerp. (This is primarily to avoid
				// the nasty jerk when transitioning rails etc.
				float this_dot = ( current_at_vector.GetX() * frame_matrix[Mth::AT][X] ) 
                       + ( current_at_vector.GetY() * frame_matrix[Mth::AT][Y] ) 
                       + ( current_at_vector.GetZ() * frame_matrix[Mth::AT][Z] ); 

				// Dot values will be in the range [0,1], with 1 being no change.
				if( this_dot < ( mLastDot * 0.9998f ))
				{
					// The angular change this frame is too big. Need to recalculate with an adjusted slerp value.
					float new_slerp = mSlerp * ( this_dot / ( mLastDot * 0.9998f ));
					mpSlerp->setMatrices( &stored_frame, &t_matrix );
					mpSlerp->getMatrix( &frame_matrix, GetTimeAdjustedSlerp( new_slerp, delta_time ));

					this_dot = mLastDot * 0.9998f;
				}
				mLastDot = this_dot;
			}
		}
		else
		{
			mpSlerp->getMatrix( &frame_matrix, GetTimeAdjustedSlerp( mVertAirSlerp, delta_time ));

			// Set the vert air landed timer to the max, since the skater is in vert air.
			mVertAirLandedTimer = VERT_AIR_LANDED_TIME;
		}						
	}		

	// Mick:  This is a patch to allow the walk camera to override the updating of the camera frame	
	// At this point, frame_matrix is valid to store.
	mLastActualRight	= frame_matrix[X];
	mLastActualUp		= frame_matrix[Y];
	mLastActualAt		= frame_matrix[Z];
	
	// Set camera position to be the same as the skater.
	Mth::Vector	cam_pos = GetTripodPos( instantly );
	
	// If in the air doing a trick, we slowly reduce the behind value to 'zoom' in on the skater.
	float above, behind;
	if( instantly )
	{
		float temp = mZoomLerp;
		mZoomLerp = 1.0f;					// fully lerp instantly
		CalculateZoom( &above, &behind );
		mZoomLerp = temp;
	}
	else
	{
		CalculateZoom( &above, &behind );
	}
	
	// Note we use the camera's at vector, as this will keep the skater in the middle of the frame.
	//cam_pos -= frame_matrix[Z] * behind;
	cam_pos += frame_matrix[Z] * behind;
		
	// Move camera along the Skater's up vector.
	cam_pos += skater_up * above;
	
	Mth::Vector	actual_focus_pos = mpSkater->m_pos + ( skater_up * above );
	
//	Gfx::AddDebugLine( mpSkater->m_pos, actual_focus_pos, MAKE_RGB( 0, 0, 128 ), MAKE_RGB( 0, 0, 128 ), 4 );
													  
//	Dbg_Message("Matrix Z  (%5.4f,%5.4f,%5.4f)", frame_matrix[Z][X], frame_matrix[Z][Y], frame_matrix[Z][Z]);
//	Dbg_Message("Matrix UP (%5.4f,%5.4f,%5.4f)", skater_up[X], skater_up[Y], skater_up[Z]);
//	Dbg_Message("Above %f Behind %f", above, behind);
//	Dbg_Message("focus pos (%5.1f,%5.1f,%5.1f)", actual_focus_pos[X], actual_focus_pos[Y], actual_focus_pos[Z]);
//	Dbg_Message("Camera after: pos (%5.1f,%5.1f,%5.1f)", cam_pos[X], cam_pos[Y], cam_pos[Z]);

	// Reorient the camera to look directly at the skater. We don't want to look at the interpolated position,
	// since this can lead to nasty jerkiness, especially on rails etc.
	target[Z].Set( actual_focus_pos.GetX() - cam_pos.GetX(), actual_focus_pos.GetY() - cam_pos.GetY(), actual_focus_pos.GetZ() - cam_pos.GetZ());
	target[Z].Normalize();

	// Read back the Y from the current matrix.
	target[Y][0]	= frame_matrix[Y][X];
	target[Y][1]	= frame_matrix[Y][Y];
	target[Y][2]	= frame_matrix[Y][Z];

	// Generate new orthonormal X and Y axes.
	target[X]		= Mth::CrossProduct( target[Y], target[Z] );
	target[X].Normalize();
	target[Y]		= Mth::CrossProduct( target[Z], target[X] );
	target[Y].Normalize();

	// Here is where lean may safely be applied without moving the focus position on screen.
	if( mLean != 0.0f )
	{
		target[Y].Rotate( target[Z], mLean );
		target[X].Rotate( target[Z], mLean );
	}
	
	// Write back into camera matrix.
	// Since camera points in -Z, but player in +Z, we must negate the X and Z axes
	frame_matrix[X][X]		= -target[0][0];
	frame_matrix[X][Y]		= -target[0][1];
	frame_matrix[X][Z]		= -target[0][2];
	frame_matrix[X][W]		= 0.0f;

	frame_matrix[Y][X]		= target[1][0];
	frame_matrix[Y][Y]		= target[1][1];
	frame_matrix[Y][Z]		= target[1][2];
	frame_matrix[Y][W]		= 0.0f;

	frame_matrix[Z][X]		= -target[2][0];
	frame_matrix[Z][Y]		= -target[2][1];
	frame_matrix[Z][Z]		= -target[2][2];
	frame_matrix[Z][W]		= 0.0f;

	// Update the position if there is a shake active.
	if(	mShakeDuration > 0.0f )
	{
		addShake( cam_pos, frame_matrix );
	}
		
	// Now do collision detection.
	
	bool no_camera_collision;
	if (mpSkater->IsLocalClient())
	{
		CSkaterCorePhysicsComponent* pSkaterPhysicsComponent = GetSkaterCorePhysicsComponentFromObject(mpSkater);
		Dbg_Assert(pSkaterPhysicsComponent);
		
		no_camera_collision = pSkaterPhysicsComponent->mp_movable_contact_component->GetContact() && state == LIP;
	}
	else
	{
		no_camera_collision = false;
	}
	
	if (no_camera_collision)
	{
		// no camera collision if doing a lip trick on a moving object
		//printf ("Lip trick on moving object\n");
	}
	else
	{
		ApplyCameraCollisionDetection(cam_pos, frame_matrix, cam_pos - ((Mth::Vector)( frame_matrix[Z] )) * behind, actual_focus_pos);
	}
	
	cam_pos[W] = 1.0f;
//	Gfx::Camera::SetPos( cam_pos );
	p_cam_comp->SetPosition( cam_pos );
	
	// reset old position if in instant update
	if (instantly)
	{
		p_cam_comp->StoreOldPosition();
	}
	
//	Dbg_Message("Camera Final: pos (%5.1f,%5.1f,%5.1f)", cam_pos[X], cam_pos[Y], cam_pos[Z]);

	// Store the position of the camera in CSkaterCam also (used for proximity nodes).

	// Dave - there is no m_pos anymore...
//	m_pos = cam_pos;

	// Dave - this used to return the value below when it was CSkaterCam::Update()
//	Mth::Vector	to_target = at_pos - cam_pos;
//	return to_target.Length();
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

CBaseComponent::EMemberFunctionResult CSkaterCameraComponent::CallMemberFunction( uint32 Checksum, Script::CStruct* pParams, Script::CScript* pScript )
{
	switch ( Checksum )
	{
		// @script | SC_ShakeCamera | shake the skater camera
        // @parm float | duration | duration of the shake (0 clears the shake)
        // @parm float | vert_amp | maximum vertical amplidtude of the shake
        // @parm float | horiz_amp | maximum horizontal amplidtude of the shake
        // @parm float | vert_vel | vertical velocity factor (how many full cycles of movement in 1 second) 
        // @parm float | horiz_vel | horizontal velocity factor (how many full cycles of movement in 1 second) 
		case CRCC(0x75a516d3,"SC_ShakeCamera"):
		{
			float duration	= 0.0f;
			float vert_amp	= 0.0f;
			float horiz_amp	= 0.0f;
			float vert_vel	= 0.0f;
			float horiz_vel	= 0.0f;

			pParams->GetFloat( "duration",	&duration );
			pParams->GetFloat( "vert_amp",	&vert_amp );
			pParams->GetFloat( "horiz_amp",	&horiz_amp );
			pParams->GetFloat( "vert_vel",	&vert_vel );
			pParams->GetFloat( "horiz_vel",	&horiz_vel );

			SetShake( duration, vert_amp, horiz_amp, vert_vel, horiz_vel );
			
			break;
		}
		
				 
		// @script | SC_SetMode | Set the mode of a skater camera
        // @parm integer | mode | mode number 1-4, start out at 2 (normal_medium)
		case CRCC(0xd7867ffe,"SC_SetMode"):
		{
		
			int mode = 0;
			pParams->GetInteger(CRCD(0x6835b854,"mode"),&mode, true);
			SetMode((ESkaterCamMode)mode);	   
			break; 	
		}

	
		default:
			return CBaseComponent::MF_NOT_EXECUTED;
	}

	// the "default" case of the switch statement handles
	// unrecognized functions;  if we make it down here,
	// that means that the component already handled it
	// somehow
    return CBaseComponent::MF_TRUE;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void CSkaterCameraComponent::GetDebugInfo(Script::CStruct *p_info)
{
#ifdef	__DEBUG_CODE__
	Dbg_MsgAssert(p_info,("NULL p_info sent to CSkaterCameraComponent::GetDebugInfo"));

	// Add any script components to the p_info structure,
	// and they will be displayed in the script debugger (qdebug.exe)
	// you will need to add the names to debugger_names.q, if they are not existing checksums

	/*	Example:
	p_info->AddInteger("m_never_suspend",m_never_suspend);
	p_info->AddFloat("m_suspend_distance",m_suspend_distance);
	*/
	
	// We call the base component's GetDebugInfo, so we can add info from the common base component.
	CBaseComponent::GetDebugInfo( p_info );
#endif				 
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void CSkaterCameraComponent::ResetLookAround( void )
{
	mp_lookaround_component->mLookaroundTilt		= 0.0f;
	mp_lookaround_component->mLookaroundHeading	= 0.0f;
	SetNoLerpUpdate( true );
	Update();
	Commit();
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void CSkaterCameraComponent::ResetMode( )
{
	// Just call SetMode() again with the current mode
	SetMode(mMode);
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void CSkaterCameraComponent::SetMode( ESkaterCamMode mode, float time )
{
	// We need a CCameraComponent attached in order to set camera details.
	CCameraComponent *p_cam_comp = GetCameraComponentFromObject(GetObject());
	Dbg_MsgAssert( p_cam_comp, ( "CSkaterCameraComponent needs CCameraComponent attached to parent" ));

	Dbg_MsgAssert( mode < SKATERCAM_NUM_MODES,( "Bad mode" ));

	// Obtain details for this mode.
	float h_fov, behind, above, tilt, origin_offset, zoom_lerp;
	const char* p_name;

	// Obtain a pointer to the array entry for the desired mode. The array is now dependent
	// on which game mode is currently being played, 1 player, 2 player vert, or 2 player horiz.
	Nx::ScreenMode screen_mode = Nx::CViewportManager::sGetScreenMode();

	Script::CArray* p_array;

	switch( screen_mode )
	{
		case Nx::vSPLIT_V:
		{
			p_array = Script::GetArray( "Skater_Camera_2P_Vert_Array" );
			break;
		}

		case Nx::vSPLIT_H:
		{
			p_array = Script::GetArray( "Skater_Camera_2P_Horiz_Array" );
			break;
		}

		default:
		{			
			p_array = Script::GetArray( "Skater_Camera_Array" );
			break;
		}
	}


	// Extra check here, since the array in physics.q may change.
	Dbg_MsgAssert( mode < (int)p_array->GetSize(), ( "Bad mode" ));

	uint32 cs = p_array->GetNameChecksum( mode );
	Script::CScriptStructure* p_struct = Script::GetStructure( cs );

	mMode = mode;

	mLipTrickTilt = 0.0f;

	// Read the values from the array.
	p_struct->GetFloat( CRCD(0x94df1603,"horiz_fov"),				&h_fov );
	p_struct->GetFloat( CRCD(0x52e6c41b,"behind"),					&behind );
	p_struct->GetFloat( CRCD(0xb96ae2d,"above"),					&above );
	p_struct->GetFloat( CRCD(0xe3c07609,"tilt"),						&tilt );
	p_struct->GetFloat( CRCD(0x12f6992,"origin_offset"),			&origin_offset );
	p_struct->GetFloat( CRCD(0x7f0032ac,"lip_trick_tilt"),			&mLipTrickTilt );
	p_struct->GetFloat( CRCD(0xadb6390e,"lip_trick_above"),			&mLipTrickAbove );

	// Get SLERP values.
	p_struct->GetFloat( CRCD(0xf54fb9c5,"slerp"),					&mSlerp );
	p_struct->GetFloat( CRCD(0x2fa11029,"vert_air_slerp"),			&mVertAirSlerp );
	p_struct->GetFloat( CRCD(0x42fd4a0,"vert_air_landed_slerp"),	&mVertAirLandedSlerp );

	// Get LERP values.
	p_struct->GetFloat( CRCD(0xae47899b,"lerp_xz"),					&mLerpXZ );
	p_struct->GetFloat( CRCD(0xe1e4e104,"lerp_y"),					&mLerpY );
	p_struct->GetFloat( CRCD(0xf386f4d9,"vert_air_lerp_xz"),			&mVertAirLerpXZ );
	p_struct->GetFloat( CRCD(0x4882a1fe,"vert_air_lerp_y"),			&mVertAirLerpY );
	p_struct->GetFloat( CRCD(0xbef0d195,"grind_lerp"),				&mGrindLerp );

	// Get zoom values.
	mGrindZoom			= 1.0f;
	mLipTrickZoom		= 1.0f;
	mBigAirTrickZoom	= 1.0f;

	p_struct->GetFloat( CRCD(0x748743a7,"zoom_lerp"),			&zoom_lerp );
	p_struct->GetFloat( CRCD(0x5a7f5cc5,"grind_zoom"),			&mGrindZoom );
	p_struct->GetFloat( CRCD(0xd790b83d,"big_air_trick_zoom"),	&mBigAirTrickZoom );
	p_struct->GetFloat( CRCD(0xd414c22e,"lip_trick_zoom"),		&mLipTrickZoom );
	mZoomLerp			= zoom_lerp;

	// Get camera style name.
	p_struct->GetText( CRCD(0xa1dc81f9,"name"), &p_name );

	// Send the new camera mode to console line 1.
	//HUD::PanelMgr* panelMgr = HUD::PanelMgr::Instance();
	//panelMgr->SendConsoleMessage( p_name, 1 );

	// Need to calculate interpolate timers here.
	mHorizFOV		= h_fov;
	mTilt			= tilt;
	mOriginOffset	= FEET( origin_offset );		// Convert to inches.

	// Set up interpolators for those values that require it.
	if( time > 0.0f )
	{
		behind						= FEET( behind );				// Convert to inches.
		above						= FEET( above );				// Convert to inches.
		mBehindInterpolatorTime		= time;
		mBehindInterpolatorDelta	= (( behind - mBehind ) * ( SKATERCAMERACOMPONENT_INTERPOLATOR_TIMESTEP	/ time ));
		mAboveInterpolatorTime		= time;
		mAboveInterpolatorDelta		= (( above - mAbove ) * ( SKATERCAMERACOMPONENT_INTERPOLATOR_TIMESTEP / time ));
	}
	else
	{
		mBehind						= FEET( behind );
		mAbove						= FEET( above );
		mBehindInterpolatorTime		= 0.0f;
		mAboveInterpolatorTime		= 0.0f;
	}
	
	// Set focal length immediately.
	switch( screen_mode )
	{
		case Nx::vSPLIT_V:
		{
#			ifdef __PLAT_NGC__
			p_cam_comp->SetHFOV( Script::GetFloat( "Skater_Cam_Horiz_FOV" ) / 2.0f );
#			else
			p_cam_comp->SetHFOV( mHorizFOV / 2.0f );
#			endif
			break;
		}

		case Nx::vSPLIT_H:
		{
			p_cam_comp->SetHFOV( mHorizFOV );
			break;
		}

		default:
		{			
			p_cam_comp->SetHFOV( mHorizFOV );
			break;
		}
	}

	switch( mode )
	{
		case ( SKATERCAM_MODE_REPLAY_FRONT ):
		case ( SKATERCAM_MODE_REPLAY_FRONT_ZOOM ):
			mp_lookaround_component->mLookaroundHeadingStartingPoint = Mth::PI;
			break;
		case ( SKATERCAM_MODE_REPLAY_LEFT ):
		case ( SKATERCAM_MODE_REPLAY_LEFT_ZOOM ):
			mp_lookaround_component->mLookaroundHeadingStartingPoint = Mth::PI / 2.0f;
			break;
		case ( SKATERCAM_MODE_REPLAY_BEHIND ):
		case ( SKATERCAM_MODE_REPLAY_BEHIND_ZOOM ):
			mp_lookaround_component->mLookaroundHeadingStartingPoint = 0;
			break;
		case ( SKATERCAM_MODE_REPLAY_RIGHT ):
		case ( SKATERCAM_MODE_REPLAY_RIGHT_ZOOM ):
			mp_lookaround_component->mLookaroundHeadingStartingPoint = -( Mth::PI / 2.0f );
			break;
		default:
			mp_lookaround_component->mLookaroundHeadingStartingPoint = 0;
			break;
	}   
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

void CSkaterCameraComponent::ToggleMode()
{
	if ( mMode >= SKATERCAM_NUM_NORMAL_MODES )
	{
		return;
	}
	
	mMode = (ESkaterCamMode)( mMode + 1);
	if( mMode >= SKATERCAM_NUM_NORMAL_MODES )
	{
		mMode = SKATERCAM_MODE_FIRST_VALID;
	}

	ResetMode();
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::SetShake( float duration, float vert_amp, float horiz_amp, float vert_vel, float horiz_vel )
{
	mShakeDuration			= duration;
	mShakeInitialDuration	= duration;
	mShakeMaxVertAmp		= vert_amp;
	mShakeMaxHorizAmp		= horiz_amp;
	mShakeVertVel			= vert_vel;
	mShakeHorizVel			= horiz_vel;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
bool CSkaterCameraComponent::UseVertCam( void )
{   
	if( mpSkater == NULL )
	{
		return false;
	}
	
	// this logic is used only by cameras observing non-local clients; in all other cases, skating camera logic in suspended when viewing a walking
	// skater; when observing, skater camera logic is always used; this prevents the "birds-eye-view" issue when observing a skater who transitioned to
	// walking during vert air
	if( mpSkaterStateComponent->GetPhysicsState() == WALKING )
	{
		return false;
	}
	
	// Use vert cam when in the lip state.
	if( mpSkaterStateComponent->GetState() == LIP )
	{
#		ifdef DEBUG_CAMERA
		printf ("SkaterCam Using Vert Cam as LIP\n");
#		endif
		return true;
	}
	
	if( mpSkaterStateComponent->GetFlag( VERT_AIR ) && !mpSkaterStateComponent->GetFlag( CAN_BREAK_VERT )  && !mpSkaterStateComponent->GetFlag(SPINE_PHYSICS))
	{
#		ifdef DEBUG_CAMERA
		printf ("SkaterCam Using Vert Cam as VERT_AIR\n");
#		endif
		return true;
	}
	
	if( mpSkaterStateComponent->GetJumpedOutOfLipTrick())
	{
#		ifdef DEBUG_CAMERA
		printf ("SkaterCam Using Vert Cam as Jumped out of lip trick\n");
#		endif
		return true;
	}

#	ifdef DEBUG_CAMERA
	printf ("Skatecam NOT using vert cam\n");
#	endif

	return false;	
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::addShake( Mth::Vector& cam, Mth::Matrix& frame )
{
	float damping		= mShakeDuration / mShakeInitialDuration;
	float vert_angle	= mShakeDuration * mShakeVertVel * Mth::PI * 2.0f;
	float horiz_angle	= mShakeDuration * mShakeHorizVel * Mth::PI * 2.0f;
	float vert_offset	= mShakeMaxVertAmp * sinf( vert_angle ) * damping;
	float horiz_offset	= mShakeMaxHorizAmp * sinf( horiz_angle ) * damping;

	cam += frame[X] * horiz_offset;
	cam += frame[Y] * vert_offset;

	mShakeDuration		-= Tmr::FrameLength();
	if( mShakeDuration < 0.0f )
		mShakeDuration = 0.0f;
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/

Mth::Vector CSkaterCameraComponent::GetTripodPos( bool instantly )
{
	float		lerp_xz;
	float		lerp_y;
	float		delta		= Tmr::FrameLength();

	if( mpSkater == NULL )
	{
		return Mth::Vector( 0.0f, 0.0f, 0.0f );
	}

	Mth::Vector now			= mpSkater->m_pos;

	// The tripod pos is always *tending* towards the skater position, but the rate at which it does so is
	// definable, to allow for some lag, which improves the feeling of speed.
	if( mLerpReductionTimer > 0.0f )
	{
		mLerpReductionTimer -= delta;
		if( mLerpReductionTimer > 0.0f )
		{
			mLerpReductionMult += ( mLerpReductionDelta * delta );
		}
		else
		{
			mLerpReductionMult	= 1.0f;
			mLerpReductionTimer	= 0.0f;
		}
	}
	else
	{
		mLerpReductionMult	= 1.0f;
	}

	Dbg_Assert( mpSkaterStateComponent );
	if(( mpSkaterStateComponent->GetFlag( VERT_AIR ) && !mpSkaterStateComponent->GetFlag( CAN_BREAK_VERT ) && !mpSkaterStateComponent->GetFlag( SPINE_PHYSICS )))
	{
		#ifdef	DEBUG_CAMERA
		printf ("Skatercam using mVertAirLerp\n");
		#endif

		lerp_xz	= GetTimeAdjustedSlerp( mVertAirLerpXZ * mLerpReductionMult, delta );
		lerp_y	= GetTimeAdjustedSlerp( mVertAirLerpY * mLerpReductionMult, delta );
	}
	else
	{
		lerp_xz	= GetTimeAdjustedSlerp( mLerpXZ * mLerpReductionMult, delta );
		lerp_y	= GetTimeAdjustedSlerp( mLerpY * mLerpReductionMult, delta );

		// Added the following check (Dave 7/16/02) to help eliminate the camera rattle when snapping on/off a curb.
		// The flag is set for one frame only.
		if( mpSkaterStateComponent->GetFlag( SNAPPED_OVER_CURB ))
		{
			lerp_y = 1.0f;
		}
		
		if( mpSkaterStateComponent->GetFlag( SNAPPED ))
		{
			instantly = true;
		}
	}

	if( instantly )
	{
		mLastTripodPos = now;
	}
	else
	{
		mLastTripodPos.Set( mLastTripodPos.GetX() + (( now.GetX() - mLastTripodPos.GetX() ) * lerp_xz ),
							mLastTripodPos.GetY() + (( now.GetY() - mLastTripodPos.GetY() ) * lerp_y ),
							mLastTripodPos.GetZ() + (( now.GetZ() - mLastTripodPos.GetZ() ) * lerp_xz ));
	}

	return mLastTripodPos;
}


/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::CalculateZoom( float* p_above, float* p_behind )
{
	if( mpSkater == NULL )
	{
		return;
	}

	mTargetZoom = 1.0f;

	// Deal with zoom for Big Air. Set the flag only when a trick is started.
	if( !mBigAirTrickZoomActive && ( mpSkaterStateComponent->GetFlag( VERT_AIR ) && !mpSkaterStateComponent->GetFlag( CAN_BREAK_VERT ) && !mpSkaterStateComponent->GetFlag(SPINE_PHYSICS)) && mpSkaterStateComponent->DoingTrick() )
	{
		mBigAirTrickZoomActive = true;
	}
	else if( !( mpSkaterStateComponent->GetFlag( VERT_AIR ) && !mpSkaterStateComponent->GetFlag( CAN_BREAK_VERT ) && !mpSkaterStateComponent->GetFlag( SPINE_PHYSICS )))
	{
		// Must have landed.
		mBigAirTrickZoomActive = false;
	}

	if( mBigAirTrickZoomActive )
	{
		mTargetZoom = mBigAirTrickZoom;
	}
	else
	{
		EStateType state = mpSkaterStateComponent->GetState();

		// If the skater is grinding, zoom also.
		if( state == RAIL )
		{
			mTargetZoom = mGrindZoom;
		}
		else if( state == LIP )
		{
			mTargetZoom = mLipTrickZoom;
		}
		else if( state == LIP )
		{
			mTargetZoom = mLipTrickZoom;
		}
	}

	
	#if 0
	// If lookaround override is set, factor in the lookaround override zoom.
	if( mp_lookaround_component->mLookaroundOverride && ( mp_lookaround_component->mLookaroundZoom != 1.0f ))
	{
		mCurrentZoom = mTargetZoom;
		mCurrentZoom *= mp_lookaround_component->mLookaroundZoom;
	}
	else
	{
		mCurrentZoom += (( mTargetZoom - mCurrentZoom ) * mZoomLerp );
	}
	#else
	// If lookaround override is set, factor in the lookaround override zoom.
	if( mp_lookaround_component->mLookaroundOverride && ( mp_lookaround_component->mLookaroundZoom != 1.0f ))
	{
		mTargetZoom *= mp_lookaround_component->mLookaroundZoom;
	}
	
	mCurrentZoom += (( mTargetZoom - mCurrentZoom ) * mZoomLerp );
	#endif
	
	*p_behind = mBehind * mCurrentZoom;

	// Behind is also shortened when the lookaround camera is tilting upwards.
	if( mp_lookaround_component->mLookaroundTilt < 0.0f )
	{
		float max_tilt = 3.14f * 0.2f;
		*p_behind = *p_behind * ( 0.4f + ( 0.6f * (( max_tilt + mp_lookaround_component->mLookaroundTilt ) / max_tilt )));
	}

	// Use lip_trick_above when doing a lip trick.
	float above_val = mAbove;
	if( mpSkaterStateComponent->GetState() == LIP )
	{
		above_val = mLipTrickAbove;
	}
	
	// Figure above tending towards the perfect above, if zoom is < 1.0.
	if( mCurrentZoom < 1.0f )
	{
		*p_above = SKATERCAMERACOMPONENT_PERFECT_ABOVE + (( above_val - SKATERCAMERACOMPONENT_PERFECT_ABOVE ) * mCurrentZoom );
	}
	else
	{
		*p_above = above_val;
	}
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::UpdateInterpolators(   )
{
	if( mBehindInterpolatorTime > 0.0f )
	{
		mBehindInterpolatorTime -= SKATERCAMERACOMPONENT_INTERPOLATOR_TIMESTEP;
		mBehind += mBehindInterpolatorDelta;		
	}
	else
	{
		mBehindInterpolatorTime = 0.0f;
	}

	if( mAboveInterpolatorTime > 0.0f )
	{
		mAboveInterpolatorTime -= SKATERCAMERACOMPONENT_INTERPOLATOR_TIMESTEP;
		mAbove += mAboveInterpolatorDelta;		
	}
	else
	{
		mAboveInterpolatorTime = 0.0f;
	}
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::SetLerpReductionTimer( float time )
{
	if( time > 0.0f )
	{
		mLerpReductionTimer	= time;
		mLerpReductionDelta	= 1.0f / time;
		mLerpReductionMult	= 0.0f;
	}
	else
	{
		mLerpReductionTimer	= 0.0f;
		mLerpReductionDelta	= 0.0f;
		mLerpReductionMult	= 1.0f;
	}
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::SetSkater( CSkater* p_skater )
{
	mpSkater = p_skater;
	
	if( p_skater == NULL )
	{
		mpSkaterStateComponent = NULL;
		mpSkaterPhysicsControlComponent = NULL;
	}
	else
	{
		mpSkaterStateComponent = GetSkaterStateComponentFromObject(mpSkater);
		Dbg_Assert(mpSkaterStateComponent);
		
		// non-local clients will not have a CSkaterPhysicsControlComponent
		mpSkaterPhysicsControlComponent = GetSkaterPhysicsControlComponentFromObject(mpSkater);
		
		SetNoLerpUpdate(true);
	}
}



/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
CSkater* CSkaterCameraComponent::GetSkater( void )
{
	return mpSkater;
}

/******************************************************************/
/*                                                                */
/*                                                                */
/******************************************************************/
void CSkaterCameraComponent::GetCameraState ( SCameraState& state )
{
	state.lastActualMatrix[X] = mLastActualRight;
	state.lastActualMatrix[Y] = mLastActualUp;
	state.lastActualMatrix[Z] = mLastActualAt;
	state.lastActualMatrix[W].Set( 0.0f, 0.0f, 0.0f, 1.0f );
	state.lastTripodPos = mLastTripodPos;
	state.lastDot = mLastDot;
	state.lastZoom = mCurrentZoom;
}
	
}