/*
================
idThread::Event_AngToUp
================
*/
void idThread::Event_AngToUp( idAngles &ang )
{
    idVec3 vec;

    ang.ToVectors( NULL, NULL, &vec );
    ReturnVector( vec );
}

/*
================
sdClientScriptEntity::Event_SetAngles
================
*/
void sdClientScriptEntity::Event_SetAngles( const idAngles& ang ) {
	idMat3 axis = ang.ToMat3();

	SetAxis( axis );

	if ( GetPhysics() != NULL ) {
		GetPhysics()->SetAxis( axis );
	}
}

/*
================
idDict::GetAngles
================
*/
bool idDict::GetAngles( const char *key, const char *defaultString, idAngles &out ) const {
	bool		found;
	const char	*s;
	if( !defaultString ) {
		defaultString = "0 0 0";
	}
	found = GetString( key, defaultString, &s );
	out.Zero();
	sscanf( s, "%f %f %f", &out.pitch, &out.yaw, &out.roll );
	return found;
}

// RAVEN BEGIN
// jnewquist: Controller rumble
void idPlayerView::ShakeOffsets( idVec3 &shakeOffset, idAngles &shakeAngleOffset, const idBounds bounds ) const {
	float shakeVolume = 0.0f;
	shakeOffset.Zero();
	shakeAngleOffset.Zero();

	if( gameLocal.isMultiplayer ) {
		return;
	}

	shakeVolume = CalculateShake( shakeAngleOffset );

	if( gameLocal.time < shakeFinishTime ) {
		float offset = ( shakeFinishTime - gameLocal.time ) * shakeScale * 0.001f;

		shakeOffset[0] = idMath::ClampFloat( bounds[0][0] - 1.0f, bounds[1][0] + 1.0f, rvRandom::flrand( -offset, offset ) );
		shakeOffset[1] = idMath::ClampFloat( bounds[0][1] - 1.0f, bounds[1][1] + 1.0f, rvRandom::flrand( -offset, offset ) );
		shakeOffset[2] = idMath::ClampFloat( bounds[0][2] - 1.0f, bounds[1][2] + 1.0f, rvRandom::flrand( -offset, offset ) );

		shakeAngleOffset[0] = idMath::ClampFloat( -70.0f, 70.0f, rvRandom::flrand( -offset, offset ) );
		shakeAngleOffset[1] = idMath::ClampFloat( -70.0f, 70.0f, rvRandom::flrand( -offset, offset ) );
		shakeAngleOffset[2] = idMath::ClampFloat( -70.0f, 70.0f, rvRandom::flrand( -offset, offset ) );
	}
}

/*
================
sdDeliveryVehicle::Magog_DoMove
================
*/
void sdDeliveryVehicle::Magog_DoMove( const idVec3& aheadPointIdeal, const idVec3& aheadPointDir, const idVec3& endPoint, float itemRotation, float maxYawScale, bool orientToEnd, bool clampRoll, bool slowNearEnd, float pathSpeed ) {
	float frameTime = MS2SEC( gameLocal.msec );

	idVec3 aheadPoint = aheadPointIdeal;
	const idVec3& origin = GetPhysics()->GetOrigin();
	const idVec3& velocity = GetPhysics()->GetLinearVelocity();
	const idMat3& axis = GetPhysics()->GetAxis();
	const idAngles angles = axis.ToAngles();
	const idVec3& angVel = GetPhysics()->GetAngularVelocity();
	
	const idVec3& currentFwd = axis[ 0 ];
	const idVec3& currentRight = axis[ 1 ];
	const idVec3& currentUp = axis[ 2 ];
	
	float rollVel = angVel * currentFwd;
	float pitchVel = angVel * currentRight;
	float yawVel = angVel * currentUp;

	// find the current height of the vehicle
	idVec3 futureContribution = velocity * 1.0f;
	futureContribution.z = 0.0f;
	float futureContributionLength = futureContribution.Length();
	if ( futureContributionLength > 2000.0f ) {
		futureContribution = futureContribution * ( 2000.0f / futureContributionLength );
	}

	idVec3 futureSpot = origin + futureContribution;
	futureSpot.z -= HOVER_DOWNCAST_LENGTH;

	trace_t trace;
	gameLocal.clip.TraceBounds( CLIP_DEBUG_PARMS trace, origin, futureSpot, GetPhysics()->GetBounds(), axis, MASK_SOLID | MASK_OPAQUE, this );
	futureSpot = trace.endpos;

	// shift the ahead point based on the trace
	float currentHeight = origin.z - futureSpot.z;
	if ( currentHeight < HOVER_DOWNCAST_LENGTH ) { 
		aheadPoint.z = origin.z - currentHeight + HOVER_HEIGHT_AIM;
	} else {
		aheadPoint.z = origin.z - HOVER_DOWNCAST_LENGTH + HOVER_HEIGHT_AIM;
	}

//	sys.debugCircle( g_colorRed, origin, '0 0 1', 16, 8, 0 );
//	sys.debugArrow( g_colorRed, origin, futureSpot, 256, 0 );
//	sys.debugCircle( g_colorRed, futureSpot, '0 0 1', 16, 8, 0 );
//	sys.debugCircle( '0 1 0', aheadPoint, '0 0 1', 256.0f, 16, 0 );


	idVec3 point;
	float lookaheadFactor;

	{
		// generate a cubic spline between the two points
		idVec3 x0 = origin;
		idVec3 x1 = aheadPoint;
		idVec3 dx0 = velocity * 3.0f;					// maintaining our current velocity is more important
		idVec3 dx1 = aheadPointDir * pathSpeed * 1.0f;	// than matching the destination vector
		
		// calculate coefficients
		idVec3 D = x0;
		idVec3 C = dx0;
		idVec3 B = 3*x1 - dx1 - 2*C - 3*D;
		idVec3 A = x1 - B - C - D;
		
		float distanceLeft = ( endPoint - origin ).Length();
		lookaheadFactor = ( distanceLeft / 6096.0f ) * 0.5f;
		lookaheadFactor = idMath::ClampFloat( 0.2f, 0.5f, lookaheadFactor );
		if ( !slowNearEnd ) {
			lookaheadFactor = 0.5f;
		}
		
		point = ( A * lookaheadFactor + B )*lookaheadFactor*lookaheadFactor + C*lookaheadFactor + D;
	}


	//
	// Follower logic
	//
	idVec3 delta = point - origin;
	idVec3 aheadDelta = aheadPoint - origin;

	idVec3 newVelocity = vec3_origin;

	//
	// Z axis
	//

	// figure out what Z velocity is needed to get where we want to go within a frame
	float Zvel = aheadDelta.z / frameTime;
	Zvel = idMath::ClampFloat( -maxZVel, maxZVel, Zvel );
	
	// figure out what Z acceleration is neccessary
	float ZAccel = ( Zvel - velocity.z ) / frameTime;
	ZAccel = idMath::ClampFloat( -maxZAccel, maxZAccel, ZAccel );
	
	// chop the Z acceleration when its nearing the end - helps to avoid settling issues
//.........这里部分代码省略.........

/*
================
idThread::Event_AngToForward
================
*/
void idThread::Event_AngToForward( idAngles &ang ) {
	ReturnVector( ang.ToForward() );
}

/*
================
sdClientAnimated::Event_SetJointAngle
================
*/
void sdClientAnimated::Event_SetJointAngle( jointHandle_t joint, jointModTransform_t transformType, const idAngles& angles ) {
	animator.SetJointAxis( joint, transformType, angles.ToMat3() );
}

/*
================
hhCameraInterpolator::UpdateViewAngles
================
*/
idAngles hhCameraInterpolator::UpdateViewAngles( const idAngles& viewAngles ) {
	return (viewAngles.ToMat3() * GetCurrentAxis()).ToAngles();
}