You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1403 lines
34 KiB
1403 lines
34 KiB
14 years ago
|
/*==LICENSE==*
|
||
|
|
||
|
CyanWorlds.com Engine - MMOG client, server and tools
|
||
13 years ago
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
||
14 years ago
|
|
||
|
This program is free software: you can redistribute it and/or modify
|
||
|
it under the terms of the GNU General Public License as published by
|
||
|
the Free Software Foundation, either version 3 of the License, or
|
||
|
(at your option) any later version.
|
||
|
|
||
|
This program is distributed in the hope that it will be useful,
|
||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
13 years ago
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
14 years ago
|
GNU General Public License for more details.
|
||
|
|
||
|
You should have received a copy of the GNU General Public License
|
||
13 years ago
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
||
|
Additional permissions under GNU GPL version 3 section 7
|
||
|
|
||
|
If you modify this Program, or any covered work, by linking or
|
||
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
|
||
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
|
||
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
|
||
|
(or a modified version of those libraries),
|
||
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
|
||
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
|
||
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
|
||
|
licensors of this Program grant you additional
|
||
|
permission to convey the resulting work. Corresponding Source for a
|
||
|
non-source form of such a combination shall include the source code for
|
||
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
|
||
|
work.
|
||
14 years ago
|
|
||
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
||
|
or by snail mail at:
|
||
|
Cyan Worlds, Inc.
|
||
|
14617 N Newport Hwy
|
||
|
Mead, WA 99021
|
||
|
|
||
|
*==LICENSE==*/
|
||
|
#include "hsTypes.h"
|
||
|
#include "plAnimEaseTypes.h"
|
||
|
#include "plAnimTimeConvert.h"
|
||
|
#include "../plAvatar/plAGAnim.h"
|
||
|
|
||
|
#include "hsTimer.h"
|
||
|
#include "hsStream.h"
|
||
|
|
||
|
#include "../pnMessage/plEventCallbackMsg.h"
|
||
|
#include "../plMessage/plAnimCmdMsg.h"
|
||
|
#include "../plAvatar/plAGMasterSDLModifier.h"
|
||
|
#include "../plAvatar/plAGMasterMod.h"
|
||
|
#include "../plModifier/plLayerSDLModifier.h"
|
||
|
#include "../plSurface/plLayerAnimation.h"
|
||
|
|
||
|
#include "hsResMgr.h"
|
||
|
#include "plgDispatch.h"
|
||
|
|
||
|
|
||
|
plAnimTimeConvert::plAnimTimeConvert()
|
||
|
: fCurrentAnimTime(0),
|
||
|
fLastEvalWorldTime(0),
|
||
|
fBegin(0),
|
||
|
fEnd(0),
|
||
|
fLoopEnd(0),
|
||
|
fLoopBegin(0),
|
||
|
fSpeed(1.f),
|
||
|
fFlags(0),
|
||
|
fOwner(nil),
|
||
|
fEaseInCurve(nil),
|
||
|
fEaseOutCurve(nil),
|
||
|
fSpeedEaseCurve(nil),
|
||
|
fCurrentEaseCurve(nil),
|
||
|
fInitialBegin(0),
|
||
|
fInitialEnd(0),
|
||
|
fWrapTime(0)
|
||
|
//fDirtyNotifier(nil)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert::~plAnimTimeConvert()
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < fCallbackMsgs.GetCount(); i++ )
|
||
|
hsRefCnt_SafeUnRef(fCallbackMsgs[i]);
|
||
|
|
||
|
delete fEaseInCurve;
|
||
|
delete fEaseOutCurve;
|
||
|
delete fSpeedEaseCurve;
|
||
|
//delete fDirtyNotifier;
|
||
|
|
||
|
IClearAllStates();
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::Init(plATCAnim *anim, plAGAnimInstance *instance, plAGMasterMod *master)
|
||
|
{
|
||
|
// Set up our eval callbacks
|
||
|
plAGInstanceCallbackMsg *instMsg;
|
||
|
instMsg = TRACKED_NEW plAGInstanceCallbackMsg(master->GetKey(), kStart);
|
||
|
instMsg->fInstance = instance;
|
||
|
AddCallback(instMsg);
|
||
|
hsRefCnt_SafeUnRef(instMsg);
|
||
|
instMsg = TRACKED_NEW plAGInstanceCallbackMsg(master->GetKey(), kStop);
|
||
|
instMsg->fInstance = instance;
|
||
|
AddCallback(instMsg);
|
||
|
hsRefCnt_SafeUnRef(instMsg);
|
||
|
instMsg = TRACKED_NEW plAGInstanceCallbackMsg(master->GetKey(), kSingleFrameAdjust);
|
||
|
instMsg->fInstance = instance;
|
||
|
AddCallback(instMsg);
|
||
|
hsRefCnt_SafeUnRef(instMsg);
|
||
|
|
||
|
SetOwner(master);
|
||
|
ClearFlags();
|
||
|
|
||
|
for (int i = 0; i < anim->NumStopPoints(); i++)
|
||
|
GetStopPoints().Append(anim->GetStopPoint(i));
|
||
|
|
||
|
SetBegin(anim->GetStart());
|
||
|
SetEnd(anim->GetEnd());
|
||
|
fInitialBegin = fBegin;
|
||
|
fInitialEnd = fEnd;
|
||
|
|
||
|
if (anim->GetInitial() != -1)
|
||
|
SetCurrentAnimTime(anim->GetInitial());
|
||
|
else
|
||
|
SetCurrentAnimTime(anim->GetStart());
|
||
|
SetLoopPoints(anim->GetLoopStart(), anim->GetLoopEnd());
|
||
|
Loop(anim->GetLoop());
|
||
|
SetSpeed(1.f);
|
||
|
SetEase(true, anim->GetEaseInType(), anim->GetEaseInMin(),
|
||
|
anim->GetEaseInMax(), anim->GetEaseInLength());
|
||
|
SetEase(false, anim->GetEaseOutType(), anim->GetEaseOutMin(),
|
||
|
anim->GetEaseOutMax(), anim->GetEaseOutLength());
|
||
|
|
||
|
// set up our time converter based on the animation's specs...
|
||
|
// ... after we've set all of its other state values.
|
||
|
if (anim->GetAutoStart())
|
||
|
{
|
||
|
plSynchEnabler ps(true); // enable dirty tracking so that autostart will send out a state update
|
||
|
Start();
|
||
|
}
|
||
|
else
|
||
|
InitStop();
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// 0=nil, 1=easeIn, 2=easeOut, 3=speed
|
||
|
//
|
||
|
void plAnimTimeConvert::SetCurrentEaseCurve(int x)
|
||
|
{
|
||
|
switch(x)
|
||
|
{
|
||
|
default:
|
||
|
hsAssert(false, "invalid arg to SetCurrentEaseCurve");
|
||
|
break;
|
||
|
case kEaseNone:
|
||
|
fCurrentEaseCurve=nil;
|
||
|
break;
|
||
|
case kEaseIn:
|
||
|
fCurrentEaseCurve=fEaseInCurve;
|
||
|
break;
|
||
|
case kEaseOut:
|
||
|
fCurrentEaseCurve=fEaseOutCurve;
|
||
|
break;
|
||
|
case kEaseSpeed:
|
||
|
fCurrentEaseCurve=fSpeedEaseCurve;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int plAnimTimeConvert::GetCurrentEaseCurve() const
|
||
|
{
|
||
|
if (fCurrentEaseCurve==nil)
|
||
|
return kEaseNone;
|
||
|
if (fCurrentEaseCurve==fEaseInCurve)
|
||
|
return kEaseIn;
|
||
|
if (fCurrentEaseCurve==fEaseOutCurve)
|
||
|
return kEaseOut;
|
||
|
if (fCurrentEaseCurve==fSpeedEaseCurve)
|
||
|
return kEaseSpeed;
|
||
|
|
||
|
hsAssert(false, "unknown ease curve");
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// set the number of ATCStates we have
|
||
|
//
|
||
|
void plAnimTimeConvert::ResizeStates(int cnt)
|
||
|
{
|
||
|
while (fStates.size() > cnt)
|
||
|
{
|
||
|
delete fStates.back();
|
||
|
fStates.pop_back();
|
||
|
}
|
||
|
|
||
|
while (cnt>fStates.size())
|
||
|
{
|
||
|
fStates.push_back(TRACKED_NEW plATCState);
|
||
|
}
|
||
|
|
||
|
hsAssert(fStates.size()==cnt, "state resize mismatch");
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::ResetWrap()
|
||
|
{
|
||
|
fBegin = fInitialBegin;
|
||
|
fEnd = fInitialEnd;
|
||
|
Forewards();
|
||
|
|
||
|
fFlags &= (~kWrap & ~kNeedsReset);
|
||
|
}
|
||
|
|
||
|
hsScalar plAnimTimeConvert::ICalcEaseTime(const plATCEaseCurve *curve, double start, double end)
|
||
|
{
|
||
|
start -= curve->fBeginWorldTime;
|
||
|
end -= curve->fBeginWorldTime;
|
||
|
|
||
|
// Clamp to the curve's range
|
||
|
if (start < 0)
|
||
|
start = 0;
|
||
|
if (end > curve->fLength)
|
||
|
end = curve->fLength;
|
||
|
|
||
|
|
||
|
hsScalar delSecs = 0;
|
||
|
|
||
|
if (start < curve->fLength)
|
||
|
{
|
||
|
// Redundant eval... but only when easing.
|
||
|
delSecs = curve->PositionGivenTime((hsScalar)end) - curve->PositionGivenTime((hsScalar)start);
|
||
|
}
|
||
|
return delSecs;
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::IClearSpeedEase()
|
||
|
{
|
||
|
|
||
|
if (fCurrentEaseCurve == fSpeedEaseCurve)
|
||
|
fCurrentEaseCurve = nil;
|
||
|
|
||
|
delete fSpeedEaseCurve;
|
||
|
fSpeedEaseCurve = nil;
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::ICheckTimeCallbacks(hsScalar frameStart, hsScalar frameStop)
|
||
|
{
|
||
|
int i;
|
||
|
for( i = fCallbackMsgs.GetCount()-1; i >= 0; --i )
|
||
|
{
|
||
|
if (fCallbackMsgs[i]->fEvent == kTime)
|
||
|
{
|
||
|
if( ITimeInFrame(fCallbackMsgs[i]->fEventTime, frameStart, frameStop) )
|
||
|
ISendCallback(i);
|
||
|
}
|
||
|
else if (fCallbackMsgs[i]->fEvent == kBegin && ITimeInFrame(fBegin, frameStart, frameStop) )
|
||
|
ISendCallback(i);
|
||
|
else if (fCallbackMsgs[i]->fEvent == kEnd && ITimeInFrame(fEnd, frameStart, frameStop) )
|
||
|
ISendCallback(i);
|
||
|
|
||
|
}
|
||
|
}
|
||
|
|
||
|
hsBool plAnimTimeConvert::ITimeInFrame(hsScalar secs, hsScalar start, hsScalar stop)
|
||
|
{
|
||
|
if (secs == start && secs == stop)
|
||
|
return true;
|
||
|
if( IsBackwards() )
|
||
|
{
|
||
|
if( start < stop )
|
||
|
{
|
||
|
// We've just wrapped. Careful to exclude markers outside current loop.
|
||
|
if( ((secs <= start) && (secs >= fLoopBegin))
|
||
|
|| ((secs >= stop) && (secs <= fLoopEnd)) )
|
||
|
return true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if( (secs <= start) && (secs >= stop) )
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if( start > stop )
|
||
|
{
|
||
|
// We've just wrapped. Careful to exclude markers outside current loop.
|
||
|
if( ((secs >= start) && (secs <= fLoopEnd))
|
||
|
|| ((secs <= stop) && (secs >= fLoopBegin)) )
|
||
|
return true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if( (secs >= start) && (secs <= stop) )
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::ISendCallback(int i)
|
||
|
{
|
||
|
// Check if callbacks are disabled this frame (i.e. when we're loading in state)
|
||
|
if (fFlags & kNoCallbacks)
|
||
|
return;
|
||
|
|
||
|
// send callback if msg is local or if we are the local master
|
||
|
if (!fCallbackMsgs[i]->HasBCastFlag(plMessage::kNetPropagate) ||
|
||
|
!fOwner || fOwner->IsLocallyOwned()==plSynchedObject::kYes)
|
||
|
{
|
||
|
plEventCallbackMsg *temp = fCallbackMsgs[i];
|
||
|
|
||
|
fCallbackMsgs[i]->SetSender(fOwner ? fOwner->GetKey() : nil);
|
||
|
|
||
|
hsRefCnt_SafeRef(fCallbackMsgs[i]);
|
||
|
plgDispatch::MsgSend(fCallbackMsgs[i]);
|
||
|
|
||
|
// No more repeats, remove this callback from our list
|
||
|
if (fCallbackMsgs[i]->fRepeats == 0)
|
||
|
{
|
||
|
hsRefCnt_SafeUnRef(fCallbackMsgs[i]);
|
||
|
fCallbackMsgs.Remove(i);
|
||
|
}
|
||
|
// If this isn't infinite, decrement the number of repeats
|
||
|
else if (fCallbackMsgs[i]->fRepeats > 0)
|
||
|
fCallbackMsgs[i]->fRepeats--;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::IStop(double time, hsScalar animTime)
|
||
|
{
|
||
|
if( IsStopped() )
|
||
|
return *this;
|
||
|
|
||
|
IClearSpeedEase(); // If we had one queued up, clear it. It will automatically take effect when we start
|
||
|
SetFlag(kEasingIn, false);
|
||
|
SetFlag(kStopped, true);
|
||
|
if (fFlags & kNeedsReset)
|
||
|
ResetWrap();
|
||
|
|
||
|
IProcessStateChange(time, animTime);
|
||
|
|
||
|
int i;
|
||
|
for( i = fCallbackMsgs.GetCount()-1; i >= 0; --i )
|
||
|
{
|
||
|
if (fCallbackMsgs[i]->fEvent == kStop)
|
||
|
{
|
||
|
ISendCallback(i);
|
||
|
}
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::IProcessStateChange(double worldTime, hsScalar animTime /* = -1 */)
|
||
|
{
|
||
|
if (fStates.size() > 0 && worldTime < fStates.front()->fStartWorldTime)
|
||
|
return *this; // Sorry... state saves only work in the forward direction
|
||
|
|
||
|
fLastStateChange = worldTime;
|
||
|
plATCState *state = TRACKED_NEW plATCState;
|
||
|
|
||
|
state->fStartWorldTime = fLastStateChange;
|
||
|
state->fStartAnimTime = (animTime < 0 ? WorldToAnimTimeNoUpdate(fLastStateChange) : animTime);
|
||
|
state->fFlags = (UInt8)fFlags;
|
||
|
state->fBegin = fBegin;
|
||
|
state->fEnd = fEnd;
|
||
|
state->fLoopBegin = fLoopBegin;
|
||
|
state->fLoopEnd = fLoopEnd;
|
||
|
state->fSpeed = fSpeed;
|
||
|
state->fWrapTime = fWrapTime;
|
||
|
state->fEaseCurve = (fCurrentEaseCurve == nil ? nil : fCurrentEaseCurve->Clone());
|
||
|
|
||
|
fStates.push_front(state);
|
||
|
IFlushOldStates();
|
||
|
|
||
|
const char* sdlName=nil;
|
||
|
if (plLayerAnimation::ConvertNoRef(fOwner))
|
||
|
sdlName=kSDLLayer;
|
||
|
else
|
||
|
if (plAGMasterMod::ConvertNoRef(fOwner))
|
||
|
sdlName=kSDLAGMaster;
|
||
|
else
|
||
|
{
|
||
|
hsAssert(false, "unknown sdl owner");
|
||
|
}
|
||
|
fOwner->DirtySynchState(sdlName, 0); // Send SDL state update to server
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
// Remove any out-of-date plATCStates
|
||
|
// Where "out-of-date" means, "More than 1 frame old"
|
||
|
void plAnimTimeConvert::IFlushOldStates()
|
||
|
{
|
||
|
plATCState *state;
|
||
|
plATCStateList::const_iterator i = fStates.begin();
|
||
|
UInt32 count = 0;
|
||
|
|
||
|
for (i; i != fStates.end(); i++)
|
||
|
{
|
||
|
count++;
|
||
|
state = *i;
|
||
|
if (fLastEvalWorldTime - hsTimer::GetDelSysSeconds() >= state->fStartWorldTime)
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
while (fStates.size() > count)
|
||
|
{
|
||
|
delete fStates.back();
|
||
|
fStates.pop_back();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::IClearAllStates()
|
||
|
{
|
||
|
while (fStates.size() > 0)
|
||
|
{
|
||
|
delete fStates.back();
|
||
|
fStates.pop_back();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
plATCState *plAnimTimeConvert::IGetState(double wSecs) const
|
||
|
{
|
||
|
plATCState *state;
|
||
|
plATCStateList::const_iterator i = fStates.begin();
|
||
|
|
||
|
for (i; i != fStates.end(); i++)
|
||
|
{
|
||
|
state = *i;
|
||
|
if (wSecs >= state->fStartWorldTime)
|
||
|
return state;
|
||
|
}
|
||
|
|
||
|
return nil;
|
||
|
}
|
||
|
|
||
|
plATCState *plAnimTimeConvert::IGetLatestState() const
|
||
|
{
|
||
|
return fStates.front();
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::SetOwner(plSynchedObject* o)
|
||
|
{
|
||
|
fOwner = o;
|
||
|
}
|
||
|
|
||
|
hsBool plAnimTimeConvert::IIsStoppedAt(const double &wSecs, const UInt32 &flags,
|
||
|
const plATCEaseCurve *curve) const
|
||
|
{
|
||
|
if (flags & kStopped)
|
||
|
return !(flags & kForcedMove); // If someone called SetCurrentAnimTime(), we need to say we moved.
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
hsBool plAnimTimeConvert::IsStoppedAt(double wSecs) const
|
||
|
{
|
||
|
if (wSecs > fLastStateChange)
|
||
|
return IIsStoppedAt(wSecs, fFlags, fCurrentEaseCurve);
|
||
|
|
||
|
plATCState *state = IGetState(wSecs);
|
||
|
|
||
|
if ( !state )
|
||
|
return true;
|
||
|
|
||
|
return IIsStoppedAt(wSecs, state->fFlags, state->fEaseCurve);
|
||
|
}
|
||
|
|
||
|
hsScalar plAnimTimeConvert::WorldToAnimTime(double wSecs)
|
||
|
{
|
||
|
//hsAssert(wSecs >= fLastEvalWorldTime, "Tried to eval a time that's earlier than the last eval time.");
|
||
|
double d = wSecs - fLastEvalWorldTime;
|
||
|
hsScalar f = fCurrentAnimTime;
|
||
|
|
||
|
if (wSecs < fLastStateChange)
|
||
|
{
|
||
|
fCurrentAnimTime = IWorldToAnimTimeBeforeState(wSecs);
|
||
|
fLastEvalWorldTime = wSecs;
|
||
|
return fCurrentAnimTime;
|
||
|
}
|
||
|
|
||
|
if (fLastEvalWorldTime <= fLastStateChange) // Crossing into the latest state
|
||
|
{
|
||
|
fLastEvalWorldTime = fLastStateChange;
|
||
|
fCurrentAnimTime = IGetLatestState()->fStartAnimTime;
|
||
|
}
|
||
|
|
||
|
if( (fFlags & kStopped) || (wSecs == fLastEvalWorldTime) )
|
||
|
{
|
||
|
if (fFlags & kForcedMove)
|
||
|
{
|
||
|
int i;
|
||
|
for( i = fCallbackMsgs.GetCount()-1; i >= 0; --i )
|
||
|
{
|
||
|
if (fCallbackMsgs[i]->fEvent == kSingleFrameEval)
|
||
|
{
|
||
|
ISendCallback(i);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
fFlags &= ~kForcedMove;
|
||
|
fLastEvalWorldTime = wSecs;
|
||
|
|
||
|
return fCurrentAnimTime;
|
||
|
}
|
||
|
hsScalar note = fCurrentAnimTime - f;
|
||
|
hsScalar secs = 0, delSecs = 0;
|
||
|
|
||
|
if (fCurrentEaseCurve != nil)
|
||
|
{
|
||
|
delSecs += ICalcEaseTime(fCurrentEaseCurve, fLastEvalWorldTime, wSecs);
|
||
|
if (wSecs > fCurrentEaseCurve->GetEndWorldTime())
|
||
|
{
|
||
|
if (fFlags & kEasingIn)
|
||
|
delSecs += hsScalar(wSecs - fCurrentEaseCurve->GetEndWorldTime()) * fSpeed;
|
||
|
|
||
|
IClearSpeedEase();
|
||
|
|
||
|
fCurrentEaseCurve = nil;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// The easy case... playing the animation at a constant speed.
|
||
|
delSecs = hsScalar(wSecs - fLastEvalWorldTime) * fSpeed;
|
||
|
}
|
||
|
|
||
|
if (fFlags & kBackwards)
|
||
|
delSecs = -delSecs;
|
||
|
|
||
|
secs = fCurrentAnimTime + delSecs;
|
||
|
// At this point, "secs" is the pre-wrapped (before looping) anim time.
|
||
|
// "delSecs" is the change in anim time
|
||
|
|
||
|
// if our speed is < 0, then checking for the kBackwards flag isn't enough
|
||
|
// so we base our decision on the direction of the actual change we've computed.
|
||
|
hsBool forewards = delSecs >= 0;
|
||
|
|
||
|
if (fFlags & kLoop)
|
||
|
{
|
||
|
hsBool wrapped = false;
|
||
|
|
||
|
if (forewards)
|
||
|
{
|
||
|
if (IGetLatestState()->fStartAnimTime > fLoopEnd)
|
||
|
{
|
||
|
// Our animation started past the loop. Play to the end.
|
||
|
if (secs > fEnd)
|
||
|
{
|
||
|
secs = fEnd;
|
||
|
IStop(wSecs, secs);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (secs > fLoopEnd)
|
||
|
{
|
||
|
secs = fmodf(secs - fLoopBegin, fLoopEnd - fLoopBegin) + fLoopBegin;
|
||
|
wrapped = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (IGetLatestState()->fStartAnimTime < fLoopBegin)
|
||
|
{
|
||
|
if (secs < fBegin)
|
||
|
{
|
||
|
secs = fBegin;
|
||
|
IStop(wSecs, secs);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (secs < fLoopBegin)
|
||
|
{
|
||
|
secs = fLoopEnd - fmodf(fLoopEnd - secs, fLoopEnd - fLoopBegin);
|
||
|
wrapped = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (fFlags & kWrap)
|
||
|
{
|
||
|
// possible options, representing each line:
|
||
|
// 1. We wrapped around the the beginning of the anim, so stop at the wrap point if we're past it.
|
||
|
// 2. Same as #1, but in the backwards case.
|
||
|
// 3. We started before the wrap point, now we're after it. Stop.
|
||
|
// 4. Same as #3, backwards.
|
||
|
if ((wrapped && (forewards && secs >= fWrapTime) ||
|
||
|
(!forewards && secs <= fWrapTime)) ||
|
||
|
(forewards && fCurrentAnimTime < fWrapTime && secs >= fWrapTime) ||
|
||
|
(!forewards && fCurrentAnimTime > fWrapTime && secs <= fWrapTime))
|
||
|
{
|
||
|
secs = fWrapTime;
|
||
|
IStop(wSecs, secs);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else // Not looping
|
||
|
{
|
||
|
if ((secs < fBegin) || (secs > fEnd))
|
||
|
{
|
||
|
secs = forewards ? fEnd : fBegin;
|
||
|
IStop(wSecs, secs);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
ICheckTimeCallbacks(fCurrentAnimTime, secs);
|
||
|
|
||
|
fLastEvalWorldTime = wSecs;
|
||
|
if (fEaseOutCurve != nil && !(fFlags & kEasingIn) && wSecs >= fEaseOutCurve->GetEndWorldTime())
|
||
|
IStop(wSecs, secs);
|
||
|
|
||
|
return fCurrentAnimTime = secs;
|
||
|
}
|
||
|
|
||
|
hsScalar plAnimTimeConvert::WorldToAnimTimeNoUpdate(double wSecs) const
|
||
|
{
|
||
|
return IWorldToAnimTimeNoUpdate(wSecs, IGetState(wSecs));
|
||
|
}
|
||
|
|
||
|
hsScalar plAnimTimeConvert::IWorldToAnimTimeNoUpdate(double wSecs, plATCState *state)
|
||
|
{
|
||
|
//hsAssert(wSecs >= fLastEvalWorldTime, "Tried to eval a time that's earlier than the last eval time.");
|
||
|
if (state == nil)
|
||
|
return 0;
|
||
|
|
||
|
if (state->fFlags & kStopped)
|
||
|
return state->fStartAnimTime;
|
||
|
|
||
|
hsScalar secs = 0, delSecs = 0;
|
||
|
|
||
|
if (state->fEaseCurve != nil)
|
||
|
{
|
||
|
delSecs += ICalcEaseTime(state->fEaseCurve, state->fStartWorldTime, wSecs);
|
||
|
if (wSecs > state->fEaseCurve->GetEndWorldTime())
|
||
|
{
|
||
|
if (state->fFlags & kEasingIn)
|
||
|
delSecs += hsScalar(wSecs - state->fEaseCurve->GetEndWorldTime()) * state->fSpeed;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// The easy case... playing the animation at a constant speed.
|
||
|
delSecs = hsScalar(wSecs - state->fStartWorldTime) * state->fSpeed;
|
||
|
}
|
||
|
|
||
|
if (state->fFlags & kBackwards)
|
||
|
delSecs = -delSecs;
|
||
|
|
||
|
secs = state->fStartAnimTime + delSecs;
|
||
|
// At this point, "secs" is the pre-wrapped (before looping) anim time.
|
||
|
// "delSecs" is the change in anim time
|
||
|
hsBool forewards = delSecs >= 0;
|
||
|
|
||
|
if (state->fFlags & kLoop)
|
||
|
{
|
||
|
hsBool wrapped = false;
|
||
|
|
||
|
if (forewards)
|
||
|
{
|
||
|
if (state->fStartAnimTime > state->fLoopEnd)
|
||
|
{
|
||
|
// Our animation started past the loop. Play to the end.
|
||
|
if (secs > state->fEnd)
|
||
|
{
|
||
|
secs = state->fEnd;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (secs > state->fLoopEnd)
|
||
|
{
|
||
|
secs = fmodf(secs - state->fLoopBegin, state->fLoopEnd - state->fLoopBegin) + state->fLoopBegin;
|
||
|
wrapped = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (state->fStartAnimTime < state->fLoopBegin)
|
||
|
{
|
||
|
if (secs < state->fBegin)
|
||
|
{
|
||
|
secs = state->fBegin;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (secs < state->fLoopBegin)
|
||
|
{
|
||
|
secs = state->fLoopEnd - fmodf(state->fLoopEnd - secs, state->fLoopEnd - state->fLoopBegin);
|
||
|
wrapped = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (state->fFlags & kWrap)
|
||
|
{
|
||
|
if ((wrapped && (forewards && secs >= state->fWrapTime) ||
|
||
|
(!forewards && secs <= state->fWrapTime)) ||
|
||
|
(forewards && state->fStartAnimTime < state->fWrapTime && secs >= state->fWrapTime) ||
|
||
|
(!forewards && state->fStartAnimTime > state->fWrapTime && secs <= state->fWrapTime))
|
||
|
{
|
||
|
secs = state->fWrapTime;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ((secs < state->fBegin) || (secs > state->fEnd))
|
||
|
{
|
||
|
secs = forewards ? state->fEnd : state->fBegin;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return secs;
|
||
|
}
|
||
|
|
||
|
hsScalar plAnimTimeConvert::IWorldToAnimTimeBeforeState(double wSecs) const
|
||
|
{
|
||
|
return IWorldToAnimTimeNoUpdate(wSecs, IGetState(wSecs));
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::SetCurrentAnimTime(hsScalar s, hsBool jump /* = false */)
|
||
|
{
|
||
|
// We're setting the anim value for whenever we last evaluated.
|
||
|
fFlags |= kForcedMove;
|
||
|
if (!jump)
|
||
|
ICheckTimeCallbacks(fCurrentAnimTime, s);
|
||
|
fCurrentAnimTime = s;
|
||
|
int i;
|
||
|
for( i = fCallbackMsgs.GetCount()-1; i >= 0; --i )
|
||
|
{
|
||
|
if (fCallbackMsgs[i]->fEvent == kSingleFrameAdjust)
|
||
|
{
|
||
|
ISendCallback(i);
|
||
|
}
|
||
|
}
|
||
|
IProcessStateChange(hsTimer::GetSysSeconds(), fCurrentAnimTime);
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::SetEase(hsBool easeIn, UInt8 type, hsScalar minLength, hsScalar maxLength, hsScalar normLength)
|
||
|
{
|
||
|
if (easeIn)
|
||
|
{
|
||
|
delete fEaseInCurve;
|
||
|
fEaseInCurve = plATCEaseCurve::CreateEaseCurve(type, minLength, maxLength, normLength, 0, fSpeed);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
delete fEaseOutCurve;
|
||
|
fEaseOutCurve = plATCEaseCurve::CreateEaseCurve(type, minLength, maxLength, normLength, fSpeed, 0);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
hsScalar plAnimTimeConvert::GetBestStopDist(hsScalar min, hsScalar max, hsScalar norm, hsScalar time) const
|
||
|
{
|
||
|
hsScalar bestTime = -1;
|
||
|
hsScalar bestDist = -1;
|
||
|
if (fStopPoints.GetCount() == 0)
|
||
|
return norm;
|
||
|
|
||
|
hsScalar curTime;
|
||
|
hsScalar curDist;
|
||
|
|
||
|
int i;
|
||
|
for (i = 0; i < fStopPoints.GetCount(); i++)
|
||
|
{
|
||
|
hsScalar stop = fStopPoints.Get(i);
|
||
|
|
||
|
if (IsLooped())
|
||
|
{
|
||
|
hsScalar loopDist;
|
||
|
if (IsBackwards())
|
||
|
{
|
||
|
if ((time >= fLoopBegin && stop < fLoopBegin) ||
|
||
|
(time < fLoopBegin && stop > fLoopBegin))
|
||
|
continue;
|
||
|
loopDist = -(fLoopEnd - fLoopBegin);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ((time <= fLoopEnd && stop > fLoopEnd) ||
|
||
|
(time > fLoopEnd && stop < fLoopEnd))
|
||
|
continue; // we'll never reach it.
|
||
|
loopDist = fLoopEnd - fLoopBegin;
|
||
|
}
|
||
|
if (stop <= fLoopEnd && stop >= fLoopBegin)
|
||
|
{
|
||
|
while (true)
|
||
|
{
|
||
|
curTime = stop - time;
|
||
|
if (IsBackwards())
|
||
|
curTime = -curTime;
|
||
|
|
||
|
if (curTime > max)
|
||
|
break;
|
||
|
|
||
|
curDist = curTime - norm;
|
||
|
if (curDist < 0)
|
||
|
curDist = -curDist;
|
||
|
|
||
|
if (curTime >= min && curTime <= max && (bestDist == -1 || bestDist > curDist))
|
||
|
{
|
||
|
bestDist = curDist;
|
||
|
bestTime = curTime;
|
||
|
}
|
||
|
stop += loopDist;
|
||
|
}
|
||
|
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
curTime = stop - time;
|
||
|
if (IsBackwards())
|
||
|
curTime = -curTime;
|
||
|
|
||
|
curDist = curTime - norm;
|
||
|
if (curDist < 0)
|
||
|
curDist = -curDist;
|
||
|
|
||
|
if (curTime >= min && curTime <= max && (bestDist == -1 || bestDist > curDist))
|
||
|
{
|
||
|
bestDist = curDist;
|
||
|
bestTime = curTime;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
hsStatusMessageF("found stop point %f\n", bestTime);
|
||
|
|
||
|
if (bestTime == -1)
|
||
|
bestTime = norm;
|
||
|
return bestTime;
|
||
|
}
|
||
|
|
||
|
// Passing in a rate of zero specifies an immediate change.
|
||
|
void plAnimTimeConvert::SetSpeed(hsScalar goal, hsScalar rate /* = 0 */)
|
||
|
{
|
||
|
hsScalar curSpeed = fSpeed;
|
||
|
fSpeed = goal;
|
||
|
|
||
|
|
||
|
if (rate == 0)
|
||
|
{
|
||
|
IClearSpeedEase();
|
||
|
fCurrentEaseCurve = nil;
|
||
|
|
||
|
}
|
||
|
// Skip if we're either stopped or stopping. We'll take the new speed into account next time we start up.
|
||
|
else if ((fFlags & kEasingIn))
|
||
|
{
|
||
|
double curTime = hsTimer::GetSysSeconds();
|
||
|
if (fCurrentEaseCurve != nil)
|
||
|
{
|
||
|
double easeTime = curTime - fCurrentEaseCurve->fBeginWorldTime;
|
||
|
curSpeed = fCurrentEaseCurve->VelocityGivenTime((hsScalar)easeTime);
|
||
|
}
|
||
|
if (fSpeedEaseCurve != nil)
|
||
|
{
|
||
|
fSpeedEaseCurve->RecalcToSpeed(curSpeed, goal);
|
||
|
fSpeedEaseCurve->SetLengthOnRate(rate);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
hsScalar length;
|
||
|
length = (goal - curSpeed) / rate;
|
||
|
if (length < 0)
|
||
|
length = -length;
|
||
|
|
||
|
fSpeedEaseCurve = plATCEaseCurve::CreateEaseCurve(plAnimEaseTypes::kConstAccel, length, length, length,
|
||
|
curSpeed, goal);
|
||
|
}
|
||
|
|
||
|
fSpeedEaseCurve->fBeginWorldTime = curTime;
|
||
|
fCurrentEaseCurve = fSpeedEaseCurve;
|
||
|
}
|
||
|
|
||
|
IProcessStateChange(hsTimer::GetSysSeconds());
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::Read(hsStream* s, hsResMgr* mgr)
|
||
|
{
|
||
|
plCreatable::Read(s, mgr);
|
||
|
|
||
|
fFlags = (UInt16)(s->ReadSwap32());
|
||
|
|
||
|
fBegin = fInitialBegin = s->ReadSwapScalar();
|
||
|
fEnd = fInitialEnd = s->ReadSwapScalar();
|
||
|
fLoopEnd = s->ReadSwapScalar();
|
||
|
fLoopBegin = s->ReadSwapScalar();
|
||
|
fSpeed = s->ReadSwapScalar();
|
||
|
|
||
|
fEaseInCurve = plATCEaseCurve::ConvertNoRef(mgr->ReadCreatable(s));
|
||
|
fEaseOutCurve = plATCEaseCurve::ConvertNoRef(mgr->ReadCreatable(s));
|
||
|
fSpeedEaseCurve = plATCEaseCurve::ConvertNoRef(mgr->ReadCreatable(s));
|
||
|
|
||
|
fCurrentAnimTime = s->ReadSwapScalar();
|
||
|
fLastEvalWorldTime = s->ReadSwapDouble();
|
||
|
|
||
|
// load other non-synched data;
|
||
|
int count = s->ReadSwap32();
|
||
|
fCallbackMsgs.SetCountAndZero(count);
|
||
|
|
||
|
int i;
|
||
|
for (i = 0; i < count; i++)
|
||
|
{
|
||
|
plEventCallbackMsg* msg = plEventCallbackMsg::ConvertNoRef(mgr->ReadCreatable(s));
|
||
|
fCallbackMsgs[i] = msg;
|
||
|
}
|
||
|
|
||
|
count = s->ReadSwap32();
|
||
|
for (i = 0; i < count; i++)
|
||
|
{
|
||
|
fStopPoints.Append(s->ReadSwapScalar());
|
||
|
}
|
||
|
IProcessStateChange(0, fBegin);
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::Write(hsStream* s, hsResMgr* mgr)
|
||
|
{
|
||
|
plCreatable::Write(s, mgr);
|
||
|
|
||
|
s->WriteSwap32(fFlags);
|
||
|
|
||
|
s->WriteSwapScalar(fBegin);
|
||
|
s->WriteSwapScalar(fEnd);
|
||
|
s->WriteSwapScalar(fLoopEnd);
|
||
|
s->WriteSwapScalar(fLoopBegin);
|
||
|
s->WriteSwapScalar(fSpeed);
|
||
|
|
||
|
mgr->WriteCreatable(s, fEaseInCurve);
|
||
|
mgr->WriteCreatable(s, fEaseOutCurve);
|
||
|
mgr->WriteCreatable(s, fSpeedEaseCurve);
|
||
|
|
||
|
s->WriteSwapScalar(fCurrentAnimTime);
|
||
|
s->WriteSwapDouble(fLastEvalWorldTime);
|
||
|
|
||
|
// save out other non-synched important data
|
||
|
s->WriteSwap32(fCallbackMsgs.Count());
|
||
|
int i;
|
||
|
for (i = 0; i < fCallbackMsgs.Count(); i++)
|
||
|
mgr->WriteCreatable(s, fCallbackMsgs[i]);
|
||
|
|
||
|
s->WriteSwap32(fStopPoints.GetCount());
|
||
|
for (i = 0; i < fStopPoints.GetCount(); i++)
|
||
|
{
|
||
|
s->WriteSwapScalar(fStopPoints.Get(i));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::InitStop()
|
||
|
{
|
||
|
return IStop(hsTimer::GetSysSeconds(), fCurrentAnimTime);
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::Stop(hsBool on)
|
||
|
{
|
||
|
if( on )
|
||
|
return Stop();
|
||
|
else
|
||
|
return Start();
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::Stop(double stopTime)
|
||
|
{
|
||
|
if( IsStopped() || (fEaseOutCurve != nil && !(fFlags & kEasingIn)) )
|
||
|
return *this;
|
||
|
|
||
|
if (stopTime < 0)
|
||
|
stopTime = hsTimer::GetSysSeconds();
|
||
|
hsScalar stopAnimTime = WorldToAnimTimeNoUpdate(stopTime);
|
||
|
|
||
|
SetFlag(kEasingIn, false);
|
||
|
|
||
|
if( fEaseOutCurve == nil )
|
||
|
{
|
||
|
return IStop(stopTime, fCurrentAnimTime);
|
||
|
}
|
||
|
|
||
|
hsScalar currSpeed;
|
||
|
if (fCurrentEaseCurve == nil || stopTime >= fCurrentEaseCurve->GetEndWorldTime())
|
||
|
currSpeed = fSpeed;
|
||
|
else
|
||
|
currSpeed = fCurrentEaseCurve->VelocityGivenTime((hsScalar)(stopTime - fCurrentEaseCurve->fBeginWorldTime));
|
||
|
|
||
|
fEaseOutCurve->RecalcToSpeed(currSpeed > fSpeed ? currSpeed : fSpeed, 0);
|
||
|
fEaseOutCurve->SetLengthOnDistance(GetBestStopDist(fEaseOutCurve->GetMinDistance(), fEaseOutCurve->GetMaxDistance(),
|
||
|
fEaseOutCurve->GetNormDistance(), stopAnimTime));
|
||
|
fEaseOutCurve->fBeginWorldTime = stopTime - fEaseOutCurve->TimeGivenVelocity(currSpeed);
|
||
|
|
||
|
fCurrentEaseCurve = fEaseOutCurve;
|
||
|
|
||
|
return IProcessStateChange(stopTime);
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::Start(double startTime)
|
||
|
{
|
||
|
// If start has not been called since the last stop, kEasingIn will not be set
|
||
|
if( (fFlags & kEasingIn) && (startTime == fLastStateChange) )
|
||
|
return *this;
|
||
|
|
||
|
SetFlag(kEasingIn, true);
|
||
|
|
||
|
if (startTime < 0)
|
||
|
startTime = hsTimer::GetSysSeconds();
|
||
|
|
||
|
if (fEaseInCurve != nil)
|
||
|
{
|
||
|
hsScalar currSpeed;
|
||
|
if (fCurrentEaseCurve == nil || startTime >= fCurrentEaseCurve->GetEndWorldTime())
|
||
|
currSpeed = 0;
|
||
|
else
|
||
|
currSpeed = fCurrentEaseCurve->VelocityGivenTime((hsScalar)(startTime - fCurrentEaseCurve->fBeginWorldTime));
|
||
|
|
||
|
if (currSpeed <= fSpeed)
|
||
|
{
|
||
|
fEaseInCurve->RecalcToSpeed(0, fSpeed);
|
||
|
fEaseInCurve->fBeginWorldTime = startTime - fEaseInCurve->TimeGivenVelocity(currSpeed);
|
||
|
|
||
|
fCurrentEaseCurve = fEaseInCurve;
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{ // We eased out in the middle of a speed change, but were told to start again before slowing past
|
||
|
// the target speed, so the "ease in" is really a slow down.
|
||
|
SetSpeed(fSpeed, fEaseInCurve->fSpeed / fEaseInCurve->fLength);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// check for a start callback
|
||
|
int i;
|
||
|
for( i = fCallbackMsgs.GetCount()-1; i >= 0; --i )
|
||
|
{
|
||
|
if (fCallbackMsgs[i]->fEvent == kStart)
|
||
|
{
|
||
|
ISendCallback(i);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
SetFlag(kStopped, false);
|
||
|
if (fFlags & kBackwards)
|
||
|
{
|
||
|
if (fCurrentAnimTime == fBegin)
|
||
|
return IProcessStateChange(startTime, fEnd);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (fCurrentAnimTime == fEnd)
|
||
|
return IProcessStateChange(startTime, fBegin);
|
||
|
}
|
||
|
return IProcessStateChange(startTime);
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::Backwards(hsBool on)
|
||
|
{
|
||
|
return on ? Backwards() : Forewards();
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::Backwards()
|
||
|
{
|
||
|
if( IsBackwards() )
|
||
|
return *this;
|
||
|
|
||
|
// check for a reverse callback
|
||
|
int i;
|
||
|
for( i = fCallbackMsgs.GetCount()-1; i >= 0; --i )
|
||
|
{
|
||
|
if (fCallbackMsgs[i]->fEvent == kReverse)
|
||
|
{
|
||
|
ISendCallback(i);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
SetFlag(kBackwards, true);
|
||
|
|
||
|
// Record state changes
|
||
|
IProcessStateChange(hsTimer::GetSysSeconds(), fCurrentAnimTime);
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::Forewards()
|
||
|
{
|
||
|
if( !IsBackwards() )
|
||
|
return *this;
|
||
|
|
||
|
// check for a reverse callback
|
||
|
int i;
|
||
|
for( i = fCallbackMsgs.GetCount()-1; i >= 0; --i )
|
||
|
{
|
||
|
if (fCallbackMsgs[i]->fEvent == kReverse)
|
||
|
{
|
||
|
ISendCallback(i);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
SetFlag(kBackwards, false);
|
||
|
|
||
|
// Record state changes
|
||
|
IProcessStateChange(hsTimer::GetSysSeconds(), fCurrentAnimTime);
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::Loop(hsBool on)
|
||
|
{
|
||
|
SetFlag(kLoop, on);
|
||
|
|
||
|
// Record state changes
|
||
|
IProcessStateChange(hsTimer::GetSysSeconds(), fCurrentAnimTime);
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::PlayToTime(hsScalar time)
|
||
|
{
|
||
|
fFlags |= kNeedsReset;
|
||
|
if (fCurrentAnimTime > time)
|
||
|
{
|
||
|
if (fFlags & kLoop)
|
||
|
{
|
||
|
fWrapTime = time;
|
||
|
fFlags |= kWrap;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
fBegin = time;
|
||
|
Backwards();
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
fEnd = time;
|
||
|
}
|
||
|
Start();
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
plAnimTimeConvert& plAnimTimeConvert::PlayToPercentage(hsScalar percent)
|
||
|
{
|
||
|
return PlayToTime(fBegin + (fEnd - fBegin) * percent);
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::RemoveCallback(plEventCallbackMsg* pMsg)
|
||
|
{
|
||
|
int idx = fCallbackMsgs.Find(pMsg);
|
||
|
if( idx != fCallbackMsgs.kMissingIndex )
|
||
|
{
|
||
|
hsRefCnt_SafeUnRef(fCallbackMsgs[idx]);
|
||
|
fCallbackMsgs.Remove(idx);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
hsBool plAnimTimeConvert::HandleCmd(plAnimCmdMsg* modMsg)
|
||
|
{
|
||
|
if (fFlags & kNeedsReset)
|
||
|
ResetWrap();
|
||
|
|
||
|
// The net msg screener is already checking for callbacks,
|
||
|
// I'm just being extra safe.
|
||
|
if (!modMsg->HasBCastFlag(plMessage::kNetCreatedRemotely))
|
||
|
{
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kAddCallbacks) )
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < modMsg->GetNumCallbacks(); i++ )
|
||
|
{
|
||
|
AddCallback(plEventCallbackMsg::ConvertNoRef(modMsg->GetEventCallback(i)));
|
||
|
}
|
||
|
}
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kRemoveCallbacks) )
|
||
|
{
|
||
|
int i;
|
||
|
for( i = 0; i < modMsg->GetNumCallbacks(); i++ )
|
||
|
{
|
||
|
RemoveCallback(modMsg->GetEventCallback(i));
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kSetBackwards) )
|
||
|
{
|
||
|
Backwards();
|
||
|
}
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kSetForewards) )
|
||
|
{
|
||
|
Forewards();
|
||
|
}
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kStop) )
|
||
|
Stop();
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kSetLooping) )
|
||
|
Loop();
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kUnSetLooping) )
|
||
|
NoLoop();
|
||
|
|
||
|
if (modMsg->Cmd(plAnimCmdMsg::kSetBegin))
|
||
|
{
|
||
|
if (modMsg->fBegin >= fInitialBegin)
|
||
|
SetBegin(modMsg->fBegin);
|
||
|
else
|
||
|
SetBegin(fInitialBegin);
|
||
|
}
|
||
|
|
||
|
if (modMsg->Cmd(plAnimCmdMsg::kSetEnd))
|
||
|
{
|
||
|
if (modMsg->fEnd <= fInitialEnd)
|
||
|
SetEnd(modMsg->fEnd);
|
||
|
else
|
||
|
SetEnd(fInitialEnd);
|
||
|
}
|
||
|
|
||
|
if (fBegin > fEnd)
|
||
|
{
|
||
|
fBegin = fInitialBegin;
|
||
|
fEnd = fInitialEnd;
|
||
|
}
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kSetLoopEnd) )
|
||
|
SetLoopEnd(modMsg->fLoopEnd);
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kSetLoopBegin) )
|
||
|
SetLoopBegin(modMsg->fLoopBegin);
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kSetSpeed) )
|
||
|
SetSpeed(modMsg->fSpeed, modMsg->fSpeedChangeRate);
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kGoToTime) )
|
||
|
{
|
||
|
if (modMsg->fTime < fBegin)
|
||
|
SetCurrentAnimTime(fBegin, true);
|
||
|
else if (modMsg->fTime > fEnd)
|
||
|
SetCurrentAnimTime(fEnd, true);
|
||
|
else
|
||
|
SetCurrentAnimTime(modMsg->fTime, true);
|
||
|
}
|
||
|
|
||
|
if ( modMsg->Cmd(plAnimCmdMsg::kGoToPercent) )
|
||
|
SetCurrentAnimTime(fBegin + (fEnd - fBegin) * modMsg->fTime);
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kGoToBegin) )
|
||
|
SetCurrentAnimTime(fBegin, true);
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kGoToEnd) )
|
||
|
SetCurrentAnimTime(fEnd, true);
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kGoToLoopBegin) )
|
||
|
SetCurrentAnimTime(fLoopBegin, true);
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kGoToLoopEnd) )
|
||
|
SetCurrentAnimTime(fLoopEnd, true);
|
||
|
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kToggleState) )
|
||
|
{
|
||
|
if( IsStopped() )
|
||
|
{
|
||
|
Start();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Stop();
|
||
|
}
|
||
|
}
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kContinue) )
|
||
|
{
|
||
|
Start();
|
||
|
}
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kIncrementForward) )
|
||
|
{
|
||
|
if (fCurrentAnimTime == fEnd)
|
||
|
return true;
|
||
|
double currTime = hsTimer::GetSysSeconds();
|
||
|
hsScalar newTime = fCurrentAnimTime + hsTimer::GetDelSysSeconds();
|
||
|
if (newTime > fEnd)
|
||
|
{
|
||
|
newTime = fEnd;
|
||
|
}
|
||
|
Forewards();
|
||
|
SetCurrentAnimTime(newTime);
|
||
|
}
|
||
|
if( modMsg->Cmd(plAnimCmdMsg::kIncrementBackward) )
|
||
|
{
|
||
|
if (fCurrentAnimTime == fBegin)
|
||
|
return true;
|
||
|
double currTime = hsTimer::GetSysSeconds();
|
||
|
hsScalar newTime = fCurrentAnimTime - hsTimer::GetDelSysSeconds();
|
||
|
if (newTime < fBegin)
|
||
|
{
|
||
|
newTime = fBegin;
|
||
|
}
|
||
|
Backwards();
|
||
|
SetCurrentAnimTime(newTime);
|
||
|
}
|
||
|
|
||
|
if (modMsg->Cmd(plAnimCmdMsg::kPlayToTime))
|
||
|
PlayToTime(modMsg->fTime);
|
||
|
|
||
|
if (modMsg->Cmd(plAnimCmdMsg::kPlayToPercentage))
|
||
|
PlayToPercentage(modMsg->fTime);
|
||
|
|
||
|
// Basically, simulate what would happen if we played the animation
|
||
|
if (modMsg->Cmd(plAnimCmdMsg::kFastForward))
|
||
|
{
|
||
|
if (IsForewards())
|
||
|
SetCurrentAnimTime(fEnd, true);
|
||
|
else
|
||
|
SetCurrentAnimTime(fBegin, true);
|
||
|
// but if it should continue to play, statr it.
|
||
|
if (IsLooped())
|
||
|
Start();
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::AddCallback(plEventCallbackMsg* pMsg)
|
||
|
{
|
||
|
hsRefCnt_SafeRef(pMsg);
|
||
|
fCallbackMsgs.Append(pMsg);
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::ClearCallbacks()
|
||
|
{
|
||
|
for (int i = 0; i<fCallbackMsgs.Count(); i++)
|
||
|
{
|
||
|
hsRefCnt_SafeUnRef(fCallbackMsgs[i]);
|
||
|
}
|
||
|
fCallbackMsgs.Reset();
|
||
|
}
|
||
|
|
||
|
void plAnimTimeConvert::EnableCallbacks(hsBool val)
|
||
|
{
|
||
|
SetFlag(kNoCallbacks, !val);
|
||
|
}
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
void plATCState::Read(hsStream *s, hsResMgr *mgr)
|
||
|
{
|
||
|
fStartWorldTime = s->ReadSwapDouble();
|
||
|
fStartAnimTime = s->ReadSwapScalar();
|
||
|
|
||
|
fFlags = (UInt8)(s->ReadSwap32());
|
||
|
fEnd = s->ReadSwapScalar();
|
||
|
fLoopBegin = s->ReadSwapScalar();
|
||
|
fLoopEnd = s->ReadSwapScalar();
|
||
|
fSpeed = s->ReadSwapScalar();
|
||
|
fWrapTime = s->ReadSwapScalar();
|
||
|
if (s->ReadBool())
|
||
|
fEaseCurve = plATCEaseCurve::ConvertNoRef(mgr->ReadCreatable(s));
|
||
|
}
|
||
|
|
||
|
void plATCState::Write(hsStream *s, hsResMgr *mgr)
|
||
|
{
|
||
|
s->WriteSwapDouble(fStartWorldTime);
|
||
|
s->WriteSwapScalar(fStartAnimTime);
|
||
|
|
||
|
s->WriteSwap32(fFlags);
|
||
|
s->WriteSwapScalar(fEnd);
|
||
|
s->WriteSwapScalar(fLoopBegin);
|
||
|
s->WriteSwapScalar(fLoopEnd);
|
||
|
s->WriteSwapScalar(fSpeed);
|
||
|
s->WriteSwapScalar(fWrapTime);
|
||
|
if (fEaseCurve != nil)
|
||
|
{
|
||
|
s->WriteBool(true);
|
||
|
mgr->WriteCreatable(s, fEaseCurve);
|
||
|
}
|
||
|
else
|
||
|
s->WriteBool(false);
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|