/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

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);
}