//-----------------------------------------------------------------------------
//
// VTrack::onControllerEvent( pEvent );
//
// When the controller's state changes, this method is called. If the
// controller is reset the virtual method, onControllerReset is called.
//
// For a full list of possible events, see the 'eControllerEventType'
// declaration in VController.h.
//
//-----------------------------------------------------------------------------
bool VTrack::onControllerEvent( VController::eControllerEventType pEvent )
{
if ( !getController() )
{
AssertFatal( false, "VTrack::onControllerEvent() - Invalid Controller." );
return false;
}
// Enabled?
if ( !isEnabled() )
{
// Continue Processing Events.
return true;
}
switch( pEvent )
{
case VController::k_EventReset :
{
// Reset.
onControllerReset( getControllerTime(), isControllerPlayingForward() );
} break;
}
// Continue Processing Events.
return true;
}
//-----------------------------------------------------------------------------
//
// VEvent::setTriggerTime( pTime );
//
// Apply the given trigger time to the object.
//
// If the project was built using the VT_EDITOR preprocessor argument, then
// the validity of the passed value is verified. It also cannot be changed
// while the controller is playing.
//
//-----------------------------------------------------------------------------
void VEvent::setTriggerTime( const S32 &pTime )
{
#ifdef VT_EDITOR
VTrack *track = getTrack();
if ( !track )
{
// Apply Time.
mTriggerTime = pTime;
return;
}
if ( track->isControllerPlaying() )
{
// Don't Change While Playing.
return;
}
/*
// Check For Overlap.
for ( ITreeNode *node = mChildNode; node != NULL; node = node->mSiblingNextNode )
{
VEvent *event = ( VEvent* )node;
if ( event == this )
{
// Skip.
continue;
}
const U32 startTime = getStartTime();
const U32 finishTime = getFinishTime();
if ( ( pTime > startTime && pTime < finishTime )
|| ( ( pTime + mDuration ) > startTime && ( pTime + mDuration ) < finishTime )
|| ( pTime < startTime && ( pTime + mDuration ) > finishTime ) )
{
// Overlap!
return;
}
}
*/
// Apply Time.
mTriggerTime = mClamp( pTime, 0, getControllerDuration() );
// Sort Events.
track->sort();
// Reset Track.
track->onControllerReset( getControllerTime(), isControllerPlayingForward() );
#else
// Apply Time.
mTriggerTime = pTime;
#endif
}
//-----------------------------------------------------------------------------
//
// VTrack::calclateInterp( pTime );
//
// This method returns the interp time between or within events. If the given
// time is between two events, the return time is:
//
// ( pTime - last_event_finish_time )
// / ( next_event_start_time - last_event_finish_time )
//
// If the given time is within an event, the return time is:
//
// ( pTime - event_start_time ) / ( event_duration )
//
// The value returned here is between 0.0 and 1.0.
//
//-----------------------------------------------------------------------------
F32 VTrack::calculateInterp( S32 pTime )
{
if ( !isControllerPlayingForward() )
{
return ( 1.f - _calculateInterp( pTime ) );
}
return _calculateInterp( pTime );
}
//-----------------------------------------------------------------------------
//
// VFadeEvent::getFadeType();
//
// Returns the type of fade (in or out) that this event will use. Zero and Even
// indices will Fade Out, while Odd numbers will Fade In.
//
//-----------------------------------------------------------------------------
VFadeControl::eFadeType VFadeEvent::getFadeType( void )
{
if ( !isControllerPlayingForward() )
{
return ( getIndex() % 2 == 0 ) ? VFadeControl::k_TypeOut : VFadeControl::k_TypeIn;
}
return ( getIndex() % 2 == 0 ) ? VFadeControl::k_TypeIn : VFadeControl::k_TypeOut;
}
//-----------------------------------------------------------------------------
//
// VEvent::getPreviousEvent();
//
// Returns the previous event.
//
//-----------------------------------------------------------------------------
VEvent *VEvent::getPreviousEvent( void )
{
if ( !isControllerPlayingForward() )
{
return dynamic_cast<VEvent*>( mSiblingNextNode );
}
return dynamic_cast<VEvent*>( mSiblingPrevNode );
}
//-----------------------------------------------------------------------------
//
// VTrack::getPreviousEvent();
//
// Returns the Event that the Track was last intergrating.
//
//-----------------------------------------------------------------------------
VEvent *VTrack::getPreviousEvent( void )
{
if ( mNextEvent )
{
return mNextEvent->getPreviousEvent();
}
if ( !isControllerPlayingForward() )
{
return dynamic_cast<VEvent*>( getChild() );
}
return dynamic_cast<VEvent*>( getLastChild() );
}
//-----------------------------------------------------------------------------
//
// VMotionTrack::getObjectSpeed();
//
// Determine the Speed that an object must move at to travel over the segment
// length of the Path.
//
//-----------------------------------------------------------------------------
F32 VMotionEvent::getObjectSpeed( void )
{
// Fetch Parent Track.
VMotionTrack *track;
if ( !getTrack( track ) )
{
// Invalid Track.
return 0.f;
}
// Fetch Path & Reference Object.
VTorque::PathObjectType *path = track->getPath();
VTorque::SceneObjectType *object = getSceneObject();
if ( !path || !object )
{
// Invalid Object(s).
return 0.f;
}
// Fetch Node Index.
const S32 &srcNodeIndex = getNodeIndex( ( isControllerPlayingForward() ) ? 0 : -1 );
// Fetch the Next Event.
VEvent *nextEvent = getNextEvent();
// Valid Destination Node?
if ( !isControllerLooping() && !nextEvent )
{
// No Next Node.
return 0.f;
}
// Valid Next Node?
if ( nextEvent )
{
// Fetch Segment Length & Duration.
const F32 &length = VTorque::getPathNodeLength( path, srcNodeIndex );
const F32 &duration = mAbs( getTriggerTime() - nextEvent->getTriggerTime() );
// Speed = Distance / Duration.
return ( length / ( duration / 1000.f ) );
}
// Playing Forwards?
if ( isControllerPlayingForward() )
{
// Fetch the First Event.
VEvent *firstEvent = dynamic_cast<VEvent*>( track->getChild() );
// Fetch Segment Length & Duration.
const F32 &length = VTorque::getPathNodeLength( path, srcNodeIndex );
const F32 &duration = ( getControllerDuration() - getTriggerTime() ) + firstEvent->getTriggerTime();
// Speed = Distance / Duration.
return ( length / ( duration / 1000.f ) );
}
// Fetch the Last Event.
VEvent *lastEvent = dynamic_cast<VEvent*>( track->getLastChild() );
// Fetch Segment Length & Duration.
const F32 &length = VTorque::getPathNodeLength( path, srcNodeIndex );
const F32 &duration = ( getControllerDuration() - lastEvent->getTriggerTime() ) + getTriggerTime();
// Speed = Distance / Duration.
return ( length / ( duration / 1000.f ) );
}
//-----------------------------------------------------------------------------
//
// VEvent::getFinishTime();
//
// Returns the time, in milliseconds, that the event will cease updating.
//
//-----------------------------------------------------------------------------
S32 VEvent::getFinishTime( void )
{
return ( mTriggerTime + ( isControllerPlayingForward() * mDuration ) );
}
