659 lines
18 KiB
C++
659 lines
18 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: MOVEMENT ENTITIES TEST
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "entitylist.h"
|
|
#include "entityoutput.h"
|
|
#include "keyframe/keyframe.h" // BUG: this needs to move if keyframe is a standard thing
|
|
|
|
#include "mathlib/mathlib.h" // FIXME: why do we still need this?
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
// Hack, sort of. These interpolators don't get to hold state, but the ones
|
|
// that need state (like the rope simulator) should NOT be used as paths here.
|
|
IPositionInterpolator *g_pPositionInterpolators[8] = {0,0,0,0,0,0,0,0};
|
|
|
|
IPositionInterpolator* GetPositionInterpolator( int iInterp )
|
|
{
|
|
if( !g_pPositionInterpolators[iInterp] )
|
|
g_pPositionInterpolators[iInterp] = Motion_GetPositionInterpolator( iInterp );
|
|
|
|
return g_pPositionInterpolators[iInterp];
|
|
}
|
|
|
|
|
|
static float Fix( float angle )
|
|
{
|
|
while ( angle < 0 )
|
|
angle += 360;
|
|
while ( angle > 360 )
|
|
angle -= 360;
|
|
|
|
return angle;
|
|
}
|
|
|
|
void FixupAngles( QAngle &v )
|
|
{
|
|
v.x = Fix( v.x );
|
|
v.y = Fix( v.y );
|
|
v.z = Fix( v.z );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Purpose: Contains a description of a keyframe
|
|
// has no networked representation, so has to store origin, etc. itself
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CPathKeyFrame : public CLogicalEntity
|
|
{
|
|
public:
|
|
DECLARE_CLASS( CPathKeyFrame, CLogicalEntity );
|
|
|
|
void Spawn( void );
|
|
void Activate( void );
|
|
void Link( void );
|
|
|
|
Vector m_Origin;
|
|
QAngle m_Angles; // euler angles PITCH YAW ROLL (Y Z X)
|
|
Quaternion m_qAngle; // quaternion angle (generated from m_Angles)
|
|
|
|
string_t m_iNextKey;
|
|
float m_flNextTime;
|
|
|
|
CPathKeyFrame *NextKey( int direction );
|
|
CPathKeyFrame *PrevKey( int direction );
|
|
|
|
float Speed( void ) { return m_flSpeed; }
|
|
void SetKeyAngles( QAngle angles );
|
|
|
|
CPathKeyFrame *InsertNewKey( Vector newPos, QAngle newAngles );
|
|
void CalculateFrameDuration( void );
|
|
|
|
protected:
|
|
CPathKeyFrame *m_pNextKey;
|
|
CPathKeyFrame *m_pPrevKey;
|
|
|
|
float m_flSpeed;
|
|
|
|
DECLARE_DATADESC();
|
|
};
|
|
|
|
LINK_ENTITY_TO_CLASS( keyframe_track, CPathKeyFrame );
|
|
|
|
BEGIN_DATADESC( CPathKeyFrame )
|
|
|
|
DEFINE_FIELD( m_Origin, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_Angles, FIELD_VECTOR ),
|
|
DEFINE_FIELD( m_qAngle, FIELD_QUATERNION ),
|
|
|
|
DEFINE_KEYFIELD( m_iNextKey, FIELD_STRING, "NextKey" ),
|
|
DEFINE_FIELD( m_flNextTime, FIELD_FLOAT ), // derived from speed
|
|
DEFINE_KEYFIELD( m_flSpeed, FIELD_FLOAT, "MoveSpeed" ),
|
|
DEFINE_FIELD( m_pNextKey, FIELD_CLASSPTR ),
|
|
DEFINE_FIELD( m_pPrevKey, FIELD_CLASSPTR ),
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Converts inputed euler angles to internal angle format (quaternions)
|
|
//-----------------------------------------------------------------------------
|
|
void CPathKeyFrame::Spawn( void )
|
|
{
|
|
m_Origin = GetLocalOrigin();
|
|
m_Angles = GetLocalAngles();
|
|
|
|
SetKeyAngles( m_Angles );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds the keyframe into the path after all the other keys have spawned
|
|
//-----------------------------------------------------------------------------
|
|
void CPathKeyFrame::Activate( void )
|
|
{
|
|
BaseClass::Activate();
|
|
|
|
Link();
|
|
|
|
CalculateFrameDuration();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CPathKeyFrame::CalculateFrameDuration( void )
|
|
{
|
|
// calculate time from speed
|
|
if ( m_pNextKey && m_flSpeed > 0 )
|
|
{
|
|
m_flNextTime = (m_Origin - m_pNextKey->m_Origin).Length() / m_flSpeed;
|
|
|
|
// couldn't get time from distance, get it from rotation instead
|
|
if ( !m_flNextTime )
|
|
{
|
|
// speed is in degrees per second
|
|
// find the largest rotation component and use that
|
|
QAngle ang = m_Angles - m_pNextKey->m_Angles;
|
|
FixupAngles( ang );
|
|
float x = 0;
|
|
for ( int i = 0; i < 3; i++ )
|
|
{
|
|
if ( abs(ang[i]) > x )
|
|
{
|
|
x = abs(ang[i]);
|
|
}
|
|
}
|
|
|
|
m_flNextTime = x / m_flSpeed;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Links the key frame into the key frame list
|
|
//-----------------------------------------------------------------------------
|
|
void CPathKeyFrame::Link( void )
|
|
{
|
|
m_pNextKey = dynamic_cast<CPathKeyFrame*>( gEntList.FindEntityByName(NULL, m_iNextKey ) );
|
|
|
|
if ( m_pNextKey )
|
|
{
|
|
m_pNextKey->m_pPrevKey = this;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : angles -
|
|
//-----------------------------------------------------------------------------
|
|
void CPathKeyFrame::SetKeyAngles( QAngle angles )
|
|
{
|
|
m_Angles = angles;
|
|
AngleQuaternion( m_Angles, m_qAngle );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : direction -
|
|
// Output : CPathKeyFrame
|
|
//-----------------------------------------------------------------------------
|
|
CPathKeyFrame* CPathKeyFrame::NextKey( int direction )
|
|
{
|
|
if ( direction == 1 )
|
|
{
|
|
return m_pNextKey;
|
|
}
|
|
else if ( direction == -1 )
|
|
{
|
|
return m_pPrevKey;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : direction -
|
|
// Output : CPathKeyFrame
|
|
//-----------------------------------------------------------------------------
|
|
CPathKeyFrame *CPathKeyFrame::PrevKey( int direction )
|
|
{
|
|
if ( direction == 1 )
|
|
{
|
|
return m_pPrevKey;
|
|
}
|
|
else if ( direction == -1 )
|
|
{
|
|
return m_pNextKey;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Creates and insterts a new keyframe into the sequence
|
|
// Input : newPos -
|
|
// newAngles -
|
|
// Output : CPathKeyFrame
|
|
//-----------------------------------------------------------------------------
|
|
CPathKeyFrame *CPathKeyFrame::InsertNewKey( Vector newPos, QAngle newAngles )
|
|
{
|
|
CPathKeyFrame *newKey = CREATE_ENTITY( CPathKeyFrame, "keyframe_track" );
|
|
|
|
// copy data across
|
|
newKey->SetKeyAngles( newAngles );
|
|
newKey->m_Origin = newPos;
|
|
newKey->m_flSpeed = m_flSpeed;
|
|
newKey->SetEFlags( GetEFlags() );
|
|
if ( m_iParent != NULL_STRING )
|
|
{
|
|
newKey->SetParent( m_iParent, NULL );
|
|
}
|
|
|
|
// link forward
|
|
newKey->m_pNextKey = m_pNextKey;
|
|
m_pNextKey->m_pPrevKey = newKey;
|
|
|
|
// link back
|
|
m_pNextKey = newKey;
|
|
newKey->m_pPrevKey = this;
|
|
|
|
// calculate new times
|
|
CalculateFrameDuration();
|
|
newKey->CalculateFrameDuration();
|
|
|
|
return newKey;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Purpose: Basic keyframed movement behavior
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CBaseMoveBehavior : public CPathKeyFrame
|
|
{
|
|
public:
|
|
DECLARE_CLASS( CBaseMoveBehavior, CPathKeyFrame );
|
|
|
|
void Spawn( void );
|
|
void Activate( void );
|
|
void MoveDone( void );
|
|
float SetObjectPhysicsVelocity( float moveTime );
|
|
|
|
// methods
|
|
virtual bool StartMoving( int direction );
|
|
virtual void StopMoving( void );
|
|
virtual bool IsMoving( void );
|
|
|
|
// derived classes should override this to get notification of arriving at new keyframes
|
|
// virtual void ArrivedAtKeyFrame( CPathKeyFrame * ) {}
|
|
|
|
bool IsAtSequenceStart( void );
|
|
bool IsAtSequenceEnd( void );
|
|
|
|
// interpolation functions
|
|
// int m_iTimeModifier;
|
|
int m_iPositionInterpolator;
|
|
int m_iRotationInterpolator;
|
|
|
|
// animation vars
|
|
float m_flAnimStartTime;
|
|
float m_flAnimEndTime;
|
|
float m_flAverageSpeedAcrossFrame; // for advancing time with speed (not the normal visa-versa)
|
|
CPathKeyFrame *m_pCurrentKeyFrame; // keyframe currently moving from
|
|
CPathKeyFrame *m_pTargetKeyFrame; // keyframe being moved to
|
|
CPathKeyFrame *m_pPreKeyFrame, *m_pPostKeyFrame; // pre- and post-keyframe's for spline interpolation
|
|
float m_flTimeIntoFrame;
|
|
|
|
int m_iDirection; // 1 for forward, -1 for backward, and 0 for at rest
|
|
|
|
float CalculateTimeAdvancementForSpeed( float moveTime, float speed );
|
|
|
|
DECLARE_DATADESC();
|
|
};
|
|
|
|
LINK_ENTITY_TO_CLASS( move_keyframed, CBaseMoveBehavior );
|
|
|
|
BEGIN_DATADESC( CBaseMoveBehavior )
|
|
|
|
// DEFINE_KEYFIELD( m_iTimeModifier, FIELD_INTEGER, "TimeModifier" ),
|
|
DEFINE_KEYFIELD( m_iPositionInterpolator, FIELD_INTEGER, "PositionInterpolator" ),
|
|
DEFINE_KEYFIELD( m_iRotationInterpolator, FIELD_INTEGER, "RotationInterpolator" ),
|
|
|
|
DEFINE_FIELD( m_pCurrentKeyFrame, FIELD_CLASSPTR ),
|
|
DEFINE_FIELD( m_pTargetKeyFrame, FIELD_CLASSPTR ),
|
|
DEFINE_FIELD( m_pPreKeyFrame, FIELD_CLASSPTR ),
|
|
DEFINE_FIELD( m_pPostKeyFrame, FIELD_CLASSPTR ),
|
|
|
|
DEFINE_FIELD( m_flAnimStartTime, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_flAnimEndTime, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_flAverageSpeedAcrossFrame, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_flTimeIntoFrame, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_iDirection, FIELD_INTEGER ),
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
void CBaseMoveBehavior::Spawn( void )
|
|
{
|
|
m_pCurrentKeyFrame = this;
|
|
m_flTimeIntoFrame = 0;
|
|
SetMoveType( MOVETYPE_PUSH );
|
|
|
|
// a move behavior is also it's first keyframe
|
|
m_Origin = GetLocalOrigin();
|
|
m_Angles = GetLocalAngles();
|
|
|
|
BaseClass::Spawn();
|
|
}
|
|
|
|
void CBaseMoveBehavior::Activate( void )
|
|
{
|
|
BaseClass::Activate();
|
|
|
|
SetMoveDoneTime( 0.5 ); // start moving in 0.2 seconds time
|
|
|
|
// if we are just the basic keyframed entity, cycle our animation
|
|
if ( !stricmp(GetClassname(), "move_keyframed") )
|
|
{
|
|
StartMoving( 1 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks to see if the we're at the start of the keyframe sequence
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseMoveBehavior::IsAtSequenceStart( void )
|
|
{
|
|
if ( !m_pCurrentKeyFrame )
|
|
return true;
|
|
|
|
if ( m_flAnimStartTime && m_flAnimStartTime >= GetLocalTime() )
|
|
{
|
|
if ( !m_pCurrentKeyFrame->PrevKey(1) && !m_pTargetKeyFrame )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks to see if we're at the end of the keyframe sequence
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseMoveBehavior::IsAtSequenceEnd( void )
|
|
{
|
|
if ( !m_pCurrentKeyFrame )
|
|
return false;
|
|
|
|
if ( !m_pCurrentKeyFrame->NextKey(1) && !m_pTargetKeyFrame )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseMoveBehavior::IsMoving( void )
|
|
{
|
|
if ( m_iDirection != 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Starts the object moving from it's current position, in the direction indicated
|
|
// Input : direction - 1 is forward through the sequence, -1 is backwards, and 0 is stop
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseMoveBehavior::StartMoving( int direction )
|
|
{
|
|
// 0 direction is to stop moving
|
|
if ( direction == 0 )
|
|
{
|
|
StopMoving();
|
|
return false;
|
|
}
|
|
|
|
// check to see if we should keep moving in the current direction
|
|
if ( m_iDirection == direction )
|
|
{
|
|
// if we're at the end of the current anim key, move to the next one
|
|
if ( GetLocalTime() >= m_flAnimEndTime )
|
|
{
|
|
m_pCurrentKeyFrame = m_pTargetKeyFrame;
|
|
m_flTimeIntoFrame = 0;
|
|
|
|
if ( !m_pTargetKeyFrame->NextKey(direction) )
|
|
{
|
|
// we've hit the end of the sequence
|
|
m_flAnimEndTime = 0;
|
|
m_flAnimStartTime = 0;
|
|
StopMoving();
|
|
return false;
|
|
}
|
|
|
|
// advance the target keyframe
|
|
m_pTargetKeyFrame = m_pTargetKeyFrame->NextKey(direction);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we're changing direction
|
|
|
|
// need to calculate current position in the frame
|
|
// stop first, then start again
|
|
if ( m_iDirection != 0 )
|
|
{
|
|
StopMoving();
|
|
}
|
|
|
|
m_iDirection = direction;
|
|
|
|
// if we're going in reverse, swap the currentkey and targetkey (since we're going opposite dir)
|
|
if ( direction == 1 )
|
|
{
|
|
m_pTargetKeyFrame = m_pCurrentKeyFrame->NextKey( direction );
|
|
}
|
|
else if ( direction == -1 )
|
|
{
|
|
if ( m_flTimeIntoFrame > 0 )
|
|
{
|
|
m_pTargetKeyFrame = m_pCurrentKeyFrame;
|
|
m_pCurrentKeyFrame = m_pCurrentKeyFrame->NextKey( 1 );
|
|
}
|
|
else
|
|
{
|
|
m_pTargetKeyFrame = m_pCurrentKeyFrame->PrevKey( 1 );
|
|
}
|
|
}
|
|
|
|
// recalculate our movement from the stored data
|
|
if ( !m_pTargetKeyFrame )
|
|
{
|
|
StopMoving();
|
|
return false;
|
|
}
|
|
|
|
// calculate the keyframes before and after the keyframes we're interpolating between
|
|
m_pPostKeyFrame = m_pTargetKeyFrame->NextKey( direction );
|
|
if ( !m_pPostKeyFrame )
|
|
{
|
|
m_pPostKeyFrame = m_pTargetKeyFrame;
|
|
}
|
|
m_pPreKeyFrame = m_pCurrentKeyFrame->PrevKey( direction );
|
|
if ( !m_pPreKeyFrame )
|
|
{
|
|
m_pPreKeyFrame = m_pCurrentKeyFrame;
|
|
}
|
|
}
|
|
|
|
// no target, can't move
|
|
if ( !m_pTargetKeyFrame )
|
|
return false;
|
|
|
|
// calculate start/end time
|
|
// ->m_flNextTime is the time to traverse to the NEXT key, so we need the opposite if travelling backwards
|
|
if ( m_iDirection == 1 )
|
|
{
|
|
m_flAnimStartTime = GetLocalTime() - m_flTimeIntoFrame;
|
|
m_flAnimEndTime = GetLocalTime() + m_pCurrentKeyFrame->m_flNextTime - m_flTimeIntoFrame;
|
|
}
|
|
else
|
|
{
|
|
// flip the timing, since we're in reverse
|
|
if ( m_flTimeIntoFrame )
|
|
m_flTimeIntoFrame = m_pTargetKeyFrame->m_flNextTime - m_flTimeIntoFrame;
|
|
|
|
m_flAnimStartTime = GetLocalTime() - m_flTimeIntoFrame;
|
|
m_flAnimEndTime = GetLocalTime() + m_pTargetKeyFrame->m_flNextTime - m_flTimeIntoFrame;
|
|
}
|
|
|
|
// calculate the average speed at which we cross
|
|
float animDuration = (m_flAnimEndTime - m_flAnimStartTime);
|
|
float dist = (m_pCurrentKeyFrame->m_Origin - m_pTargetKeyFrame->m_Origin).Length();
|
|
m_flAverageSpeedAcrossFrame = animDuration / dist;
|
|
|
|
SetMoveDoneTime( m_flAnimEndTime - GetLocalTime() );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: stops the object from moving
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseMoveBehavior::StopMoving( void )
|
|
{
|
|
// remember exactly where we are in the frame
|
|
m_flTimeIntoFrame = 0;
|
|
|
|
if ( m_iDirection == 1 )
|
|
{
|
|
// record the time if we're not at the end of the frame
|
|
if ( GetLocalTime() < m_flAnimEndTime )
|
|
{
|
|
m_flTimeIntoFrame = GetLocalTime() - m_flAnimStartTime;
|
|
}
|
|
else
|
|
{
|
|
// we're actually at the end
|
|
if ( m_pTargetKeyFrame )
|
|
{
|
|
m_pCurrentKeyFrame = m_pTargetKeyFrame;
|
|
}
|
|
}
|
|
}
|
|
else if ( m_iDirection == -1 )
|
|
{
|
|
// store it only as a forward movement
|
|
m_pCurrentKeyFrame = m_pTargetKeyFrame;
|
|
|
|
if ( GetLocalTime() < m_flAnimEndTime )
|
|
{
|
|
m_flTimeIntoFrame = m_flAnimEndTime - GetLocalTime();
|
|
}
|
|
}
|
|
|
|
// stop moving totally
|
|
SetMoveDoneTime( -1 );
|
|
m_iDirection = 0;
|
|
m_flAnimStartTime = 0;
|
|
m_flAnimEndTime = 0;
|
|
m_pTargetKeyFrame = NULL;
|
|
SetAbsVelocity(vec3_origin);
|
|
SetLocalAngularVelocity( vec3_angle );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: We have just arrived at a key, move onto the next keyframe
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseMoveBehavior::MoveDone( void )
|
|
{
|
|
// if we're just a base then keep playing the anim
|
|
if ( !stricmp(STRING(m_iClassname), "move_keyframed") )
|
|
{
|
|
int direction = m_iDirection;
|
|
// start moving from the keyframe we've just reached
|
|
if ( !StartMoving(direction) )
|
|
{
|
|
// try moving in the other direction
|
|
StartMoving( -direction );
|
|
}
|
|
}
|
|
|
|
BaseClass::MoveDone();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Calculates a new moveTime based on the speed and the current point
|
|
// in the animation.
|
|
// used to advance keyframed objects that have dynamic speeds.
|
|
// Input : moveTime -
|
|
// Output : float - the new time in the keyframing sequence
|
|
//-----------------------------------------------------------------------------
|
|
float CBaseMoveBehavior::CalculateTimeAdvancementForSpeed( float moveTime, float speed )
|
|
{
|
|
return (moveTime * speed * m_flAverageSpeedAcrossFrame);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// GetLocalTime() is the objects local current time
|
|
// Input : destTime - new time that is being moved to
|
|
// moveTime - amount of time to be advanced this frame
|
|
// Output : float - the actual amount of time to move (usually moveTime)
|
|
//-----------------------------------------------------------------------------
|
|
float CBaseMoveBehavior::SetObjectPhysicsVelocity( float moveTime )
|
|
{
|
|
// make sure we have a valid set up
|
|
if ( !m_pCurrentKeyFrame || !m_pTargetKeyFrame )
|
|
return moveTime;
|
|
|
|
// if we're not moving, we're not moving
|
|
if ( !IsMoving() )
|
|
return moveTime;
|
|
|
|
float destTime = moveTime + GetLocalTime();
|
|
|
|
// work out where we want to be, using destTime
|
|
m_flTimeIntoFrame = destTime - m_flAnimStartTime;
|
|
float newTime = (destTime - m_flAnimStartTime) / (m_flAnimEndTime - m_flAnimStartTime);
|
|
Vector newPos;
|
|
QAngle newAngles;
|
|
|
|
IPositionInterpolator *pInterp = GetPositionInterpolator( m_iPositionInterpolator );
|
|
if( pInterp )
|
|
{
|
|
// setup key frames
|
|
pInterp->SetKeyPosition( -1, m_pPreKeyFrame->m_Origin );
|
|
Motion_SetKeyAngles( -1, m_pPreKeyFrame->m_qAngle );
|
|
|
|
pInterp->SetKeyPosition( 0, m_pCurrentKeyFrame->m_Origin );
|
|
Motion_SetKeyAngles( 0, m_pCurrentKeyFrame->m_qAngle );
|
|
|
|
pInterp->SetKeyPosition( 1, m_pTargetKeyFrame->m_Origin );
|
|
Motion_SetKeyAngles( 1, m_pTargetKeyFrame->m_qAngle );
|
|
|
|
pInterp->SetKeyPosition( 2, m_pPostKeyFrame->m_Origin );
|
|
Motion_SetKeyAngles( 2, m_pPostKeyFrame->m_qAngle );
|
|
|
|
// find new interpolated position & rotation
|
|
pInterp->InterpolatePosition( newTime, newPos );
|
|
}
|
|
else
|
|
{
|
|
newPos.Init();
|
|
}
|
|
|
|
Quaternion qRot;
|
|
Motion_InterpolateRotation( newTime, m_iRotationInterpolator, qRot );
|
|
QuaternionAngles( qRot, newAngles );
|
|
|
|
// find our velocity vector (newPos - currentPos) and scale velocity vector according to the movetime
|
|
float oneOnMoveTime = 1 / moveTime;
|
|
SetAbsVelocity( (newPos - GetLocalOrigin()) * oneOnMoveTime );
|
|
SetLocalAngularVelocity( (newAngles - GetLocalAngles()) * oneOnMoveTime );
|
|
|
|
return moveTime;
|
|
}
|
|
|