CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAvatar/plAGAnim.cpp

/*==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==*/

/////////////////////////////////////////////////////////////////////////////////////////
//
// INCLUDES
//
/////////////////////////////////////////////////////////////////////////////////////////
// singular
#include "plAGAnim.h"

// local
#include "plMatrixChannel.h"

// global
#include "hsResMgr.h"

// other
#include "plMessage/plAnimCmdMsg.h"

/////////////////////////////////////////////////////////////////////////////////////////
//
// STATICS
//
/////////////////////////////////////////////////////////////////////////////////////////

plAGAnim::plAnimMap plAGAnim::fAllAnims;

/////////////////////////////////////////////////////////////////////////////////////////
//
// plAGAnim
//
/////////////////////////////////////////////////////////////////////////////////////////

// ctor ------------
// -----
plAGAnim::plAGAnim()
: plSynchedObject()
{
    fName = nil;
}

// ctor ------------------------------------------------------
// -----
plAGAnim::plAGAnim(const char *name, double start, double end)
: fStart((hsScalar)start),
  fEnd((hsScalar)end)
{
    if (name == nil)
        name = "";

    fName = TRACKED_NEW char[strlen(name) + 1];
    strcpy(fName, name);
}

// dtor -------------
// -----
plAGAnim::~plAGAnim()
{
    if (fName)
    {
        RemoveAnim(fName);
        delete[] fName;
        fName = nil;
    }

    //int numChannels = fChannels.size();
    int numApps = fApps.size();

    for (int i = 0; i < numApps; i++)
    {
        plAGApplicator *app = fApps[i];
        if (app)
        {
            plAGChannel *channel = app->GetChannel();
            if(channel)
                delete channel;
            
            delete app;
        }
    }
}

// GetChannelCount ------------------
// ----------------
int plAGAnim::GetChannelCount() const
{
    return fApps.size();
}

// GetChannel -------------------------------------
// -----------
plAGChannel * plAGAnim::GetChannel(int index) const
{
    plAGApplicator *app = fApps[index];
    return (app ? app->GetChannel() : nil);
}

// GetChannel --------------------------------------------
// -----------
plAGChannel * plAGAnim::GetChannel(const char *name) const
{
    int appCount = fApps.size();

    for(int i = 0; i < appCount; i++)
    {
        plAGApplicator *app = fApps[i];
        plAGChannel *channel = app->GetChannel();
        const char *channelName = app->GetChannelName();

        if(stricmp(name, channelName) == 0)
        {
            return channel;
        }
    }
    return nil;
}

// GetApplicatorCount ------------------
// -------------------
int plAGAnim::GetApplicatorCount() const
{
    return fApps.size();
}

// GetApplicator -----------------------------------
// --------------
plAGApplicator *plAGAnim::GetApplicator(int i) const
{
    return fApps[i];
}

// AddApplicator -------------------------------
// --------------
int plAGAnim::AddApplicator(plAGApplicator *app)
{
    hsAssert(app->GetChannel(), "Adding an applicator with no channel");
    fApps.push_back(app);

    // return the index of the channel
    return(fApps.size() - 1);
}

// RemoveApplicator ------------------------
// -----------------
hsBool plAGAnim::RemoveApplicator(int index)
{
    hsAssert(index < fApps.size(), "Out of range index for plAGAnim::RemoveApp()");

    if(index < fApps.size())
    {
        fApps.erase(fApps.begin() + index);
        return true;
    } else {
        return false;
    }
}

// ExtendToLength ----------------------------
// ---------------
void plAGAnim::ExtendToLength(hsScalar length)
{
    if (length > GetEnd())
        SetEnd(length);
}

// GetChannelName ------------------------------
// ---------------
const char * plAGAnim::GetChannelName(int index)
{
    hsAssert(index < fApps.size(), "Out of range index for plAGAnim::GetChannelName()");

    if(index < fApps.size())
    {
        return fApps[index]->GetChannel()->GetName();
    } else {
        return nil;
    }
}

// Read --------------------------------------------
// -----
void plAGAnim::Read(hsStream *stream, hsResMgr *mgr)
{
    plSynchedObject::Read(stream, mgr);

    // read in the name of the animation itself
    fName = stream->ReadSafeString();

    fStart = stream->ReadSwapScalar();
    fEnd = stream->ReadSwapScalar();

    int numApps = stream->ReadSwap32();

    fApps.reserve(numApps);             // pre-allocate for performance
    int i;
    for (i = 0; i < numApps; i++)
    {
        plAGApplicator * app = plAGApplicator::ConvertNoRef(mgr->ReadCreatable(stream));
        app->SetChannel(plAGChannel::ConvertNoRef(mgr->ReadCreatable(stream)));
        fApps.push_back(app);
    }
    plAGAnim::AddAnim(fName, this);
}

// Write --------------------------------------------
// ------
void plAGAnim::Write(hsStream *stream, hsResMgr *mgr)
{
    plSynchedObject::Write(stream, mgr);

    stream->WriteSafeString(fName);

    stream->WriteSwapScalar(fStart);
    stream->WriteSwapScalar(fEnd);

    int numApps = fApps.size();

    stream->WriteSwap32(numApps);

    int i;
    for (i = 0; i < numApps; i++)
    {
        plAGApplicator *app = fApps[i];
        hsAssert(app, "Missing applicator during write.");
        plAGChannel *channel = nil;
        if (app)
            channel = app->GetChannel();
    
        hsAssert(channel, "Missing channel during write.");
        mgr->WriteCreatable(stream, app);
        mgr->WriteCreatable(stream, channel);
    }
}

void plAGAnim::ClearAnimationRegistry()
{
    fAllAnims.clear();
}

// AddAnim ----------------------------------------------
// --------
void plAGAnim::AddAnim(const char * name, plAGAnim *anim)
{
    // Only register the animation if it's got a "real" name. Unnamed animations
    // all get the same standard name.
    if(strcmp(name, ENTIRE_ANIMATION_NAME) != 0)
    {
        hsAssert(anim, "registering nil anim");
        fAllAnims[name] = anim;
    }
}

// FindAnim -----------------------------------
// ---------
plAGAnim * plAGAnim::FindAnim(const char *name)
{
    plAnimMap::iterator i = fAllAnims.find(name);

    if(i != fAllAnims.end())
    {
        return (*i).second;
    } else {
        return nil;
    }
}

// RemoveAnim -------------------------------
// -----------
hsBool plAGAnim::RemoveAnim(const char *name)
{
    plAnimMap::iterator i = fAllAnims.find(name);

    if(i != fAllAnims.end())
    {
        fAllAnims.erase(i);
        return true;
    } else {
        return false;
    }
}

// DumpAnimationRegistry -------------
// ----------------------
void plAGAnim::DumpAnimationRegistry()
{
    plAnimMap::iterator i = fAllAnims.begin();
    int j = 0;

    do {
        plAGAnim *anim = (*i).second;
        const char *name = anim->GetName();
        hsStatusMessageF("GLOBAL ANIMS [%d]: <%s>", j++, name);
    } while(++i != fAllAnims.end());
}

// SharesPinsWith -----------------------------------------
// ---------------
hsBool plAGAnim::SharesPinsWith(const plAGAnim *anim) const
{
    int i, j;
    for (i = 0; i < fApps.size(); i++)
    {
        for (j = 0; j < anim->fApps.size(); j++)
        {
            if (!strcmp(fApps[i]->GetChannelName(), anim->fApps[j]->GetChannelName()) &&
                fApps[i]->CanBlend(anim->fApps[j]))
            {
                return true;
            }
        }
    }
    return false;
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// plATCAnim
//
/////////////////////////////////////////////////////////////////////////////////////////

// ctor --------------
// -----
plATCAnim::plATCAnim()
: plAGAnim()
{
}

// ctor --------------------------------------------------------
// -----
plATCAnim::plATCAnim(const char *name, double start, double end)
: plAGAnim(name, start, end),
  fInitial(-1),
  fAutoStart(true),
  fLoopStart((hsScalar)start),
  fLoopEnd((hsScalar)end),
  fLoop(false),
  fEaseInType(plAnimEaseTypes::kNoEase),
  fEaseOutType(plAnimEaseTypes::kNoEase),
  fEaseInLength(0),
  fEaseOutLength(0),
  fEaseInMin(0.f),
  fEaseInMax(0.f),
  fEaseOutMin(0.f),
  fEaseOutMax(0.f)
{
}

// dtor ---------------
// -----
plATCAnim::~plATCAnim()
{
    for (MarkerMap::iterator it = fMarkers.begin(); it != fMarkers.end(); it++)
        delete [] (char*)it->first;
    fMarkers.clear();
    for( LoopMap::iterator it2 = fLoops.begin(); it2 != fLoops.end(); it2++ )
        delete [] (char *)it2->first;
    fLoops.clear();
    fStopPoints.clear();
}

// Read ---------------------------------------------
// -----
void plATCAnim::Read(hsStream *stream, hsResMgr *mgr)
{
    plAGAnim::Read(stream, mgr);

    fInitial = stream->ReadSwapScalar();
    fAutoStart = stream->Readbool();
    fLoopStart = stream->ReadSwapScalar();
    fLoopEnd = stream->ReadSwapScalar();
    fLoop = stream->Readbool();

    fEaseInType = stream->ReadByte();
    fEaseInMin = stream->ReadSwapScalar();
    fEaseInMax = stream->ReadSwapScalar();
    fEaseInLength = stream->ReadSwapScalar();
    fEaseOutType = stream->ReadByte();
    fEaseOutMin = stream->ReadSwapScalar();
    fEaseOutMax = stream->ReadSwapScalar();
    fEaseOutLength = stream->ReadSwapScalar();

    int i;
    int numMarkers = stream->ReadSwap32();
    for (i = 0; i < numMarkers; i++)
    {
        char *name = stream->ReadSafeString();
        float time = stream->ReadSwapFloat();
        fMarkers[name] = time;
    }

    int numLoops = stream->ReadSwap32();
    for (i = 0; i < numLoops; i++)
    {
        char *name = stream->ReadSafeString();
        float begin = stream->ReadSwapScalar();
        float end = stream->ReadSwapScalar();
        fLoops[name] = std::pair<float,float>(begin,end);
    }

    int numStops = stream->ReadSwap32();
    for (i = 0; i < numStops; i++)
        fStopPoints.push_back(stream->ReadSwapScalar());
}

// Write ---------------------------------------------
// ------
void plATCAnim::Write(hsStream *stream, hsResMgr *mgr)
{
    plAGAnim::Write(stream, mgr);

    stream->WriteSwapScalar(fInitial);
    stream->Writebool(fAutoStart);
    stream->WriteSwapScalar(fLoopStart);
    stream->WriteSwapScalar(fLoopEnd);
    stream->Writebool(fLoop);

    stream->WriteByte(fEaseInType);
    stream->WriteSwapScalar(fEaseInMin);
    stream->WriteSwapScalar(fEaseInMax);
    stream->WriteSwapScalar(fEaseInLength);
    stream->WriteByte(fEaseOutType);
    stream->WriteSwapScalar(fEaseOutMin);
    stream->WriteSwapScalar(fEaseOutMax);
    stream->WriteSwapScalar(fEaseOutLength);

    stream->WriteSwap32(fMarkers.size());
    for (MarkerMap::iterator it = fMarkers.begin(); it != fMarkers.end(); it++)
    {
        stream->WriteSafeString(it->first);
        stream->WriteSwapFloat(it->second);
    }

    stream->WriteSwap32(fLoops.size());
    for (LoopMap::iterator loopIt = fLoops.begin(); loopIt != fLoops.end(); loopIt++)
    {
        stream->WriteSafeString(loopIt->first);
        std::pair<float,float>& loop = loopIt->second;
        stream->WriteSwapFloat(loop.first);
        stream->WriteSwapFloat(loop.second);
    }

    int i;
    stream->WriteSwap32(fStopPoints.size());
    for (i = 0; i < fStopPoints.size(); i++)
        stream->WriteSwapScalar(fStopPoints[i]);
}

// CheckLoop --------------
// ----------
void plATCAnim::CheckLoop()
{
    if (fLoopStart == fLoopEnd)
    {
        fLoopStart = fStart;
        fLoopEnd = fEnd;
    }
}

// AddLoop ------------------------------------------------------
// --------
void plATCAnim::AddLoop(const char *name, float start, float end)
{
    char *nameCpy = hsStrcpy(name);
    fLoops[nameCpy] = std::pair<float,float>(start, end);
}

// GetLoop --------------------------------------------------------------
// --------
bool plATCAnim::GetLoop(const char *name, float &start, float &end) const
{
    LoopMap::const_iterator it = fLoops.find(name);
    if (it != fLoops.end())
    {
        const std::pair<float,float>& loop = (*it).second;
        start = loop.first;
        end = loop.second;
        return true;
    }

    return false;
}

// GetLoop --------------------------------------------------------
// --------
bool plATCAnim::GetLoop(UInt32 num, float &start, float &end) const
{
    if (num >= fLoops.size())
        return false;

    LoopMap::const_iterator it = fLoops.begin();

    while (num > 0)
    {
        it++;
        num--;
    }
    const std::pair<float,float>& loop = (*it).second;
    start = loop.first;
    end = loop.second;
    return true;
}

// GetNumLoops ----------------------
// ------------
UInt32 plATCAnim::GetNumLoops() const
{
    return fLoops.size();
}

// AddMarker ------------------------------------------
// ----------
void plATCAnim::AddMarker(const char *name, float time)
{
    char *nameCpy = hsStrcpy(name);
    fMarkers[nameCpy] = time;
}

// GetMarker -------------------------------------
// ----------
float plATCAnim::GetMarker(const char *name) const
{
    if (fMarkers.find(name) != fMarkers.end())
        return (*fMarkers.find(name)).second;
    return -1;
}

// CopyMarkerNames -------------------------------------
// ----------------
void plATCAnim::CopyMarkerNames(std::vector<char*> &out)
{
    MarkerMap::iterator it = fMarkers.begin();

    for (; it != fMarkers.end(); it++)
    {
        out.push_back(hsStrcpy((*it).first));
    }
}

// AddStopPoint ---------------------------
// -------------
void plATCAnim::AddStopPoint(hsScalar time)
{
    fStopPoints.push_back(time);
}

// NumStopPoints ----------------
// --------------
UInt32 plATCAnim::NumStopPoints()
{
    return fStopPoints.size();
}

// GetStopPoint --------------------------
// -------------
hsScalar plATCAnim::GetStopPoint(UInt32 i)
{
    hsAssert(i < fStopPoints.size(), "Invalid index for GetStopPoint");
    return fStopPoints[i];
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// plEmoteAnim
//
/////////////////////////////////////////////////////////////////////////////////////////

// ctor ------------------
// -----
plEmoteAnim::plEmoteAnim()
: fBodyUsage(kBodyFull)
{
}

// ctor ------------------------------------------------------------------------------
// -----
plEmoteAnim::plEmoteAnim(const char *animName, double begin, double end, float fadeIn,
                         float fadeOut, BodyUsage bodyUsage)
: plATCAnim(animName, begin, end),
  fFadeIn(fadeIn),
  fFadeOut(fadeOut),
  fBodyUsage(bodyUsage)
{
}

// Read -----------------------------------------------
// -----
void plEmoteAnim::Read(hsStream *stream, hsResMgr *mgr)
{
    plATCAnim::Read(stream, mgr);

    // plAGAnim::RegisterEmote(fName, this);
    fFadeIn = stream->ReadSwapScalar();
    fFadeOut = stream->ReadSwapScalar();
    fBodyUsage = static_cast<BodyUsage>(stream->ReadByte());

}

// Write -----------------------------------------------
// ------
void plEmoteAnim::Write(hsStream *stream, hsResMgr *mgr)
{
    plATCAnim::Write(stream, mgr);
    stream->WriteSwapScalar(fFadeIn);
    stream->WriteSwapScalar(fFadeOut);
    stream->WriteByte(static_cast<UInt8>(fBodyUsage));
}

// GetBodyUsage ----------------------------------------
// -------------
plEmoteAnim::BodyUsage plEmoteAnim::GetBodyUsage() const
{
    return fBodyUsage;
}

// GetFadeIn -----------------------
// ----------
float plEmoteAnim::GetFadeIn() const
{
    return fFadeIn;
}

// GetFadeOut -----------------------
// -----------
float plEmoteAnim::GetFadeOut() const
{
    return fFadeOut;
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// plAgeGlobalAnim
//
/////////////////////////////////////////////////////////////////////////////////////////

// ctor --------------------------
// -----
plAgeGlobalAnim::plAgeGlobalAnim()
: plAGAnim()
{
    fGlobalVarName = nil;
}

// ctor --------------------------------------------------------------------
// -----
plAgeGlobalAnim::plAgeGlobalAnim(const char *name, double start, double end)
: plAGAnim(name, start, end),
  fGlobalVarName(nil)
{
}

// dtor ---------------------------
// -----
plAgeGlobalAnim::~plAgeGlobalAnim()
{
    delete [] fGlobalVarName;
}

void plAgeGlobalAnim::SetGlobalVarName(char *name) 
{ 
    delete [] fGlobalVarName; 
    fGlobalVarName = hsStrcpy(name); 
}


// Read ---------------------------------------------------
// -----
void plAgeGlobalAnim::Read(hsStream *stream, hsResMgr *mgr)
{
    plAGAnim::Read(stream, mgr);

    fGlobalVarName = stream->ReadSafeString();
}

// Write ---------------------------------------------------
// ------
void plAgeGlobalAnim::Write(hsStream *stream, hsResMgr *mgr)
{
    plAGAnim::Write(stream, mgr);

    stream->WriteSafeString(fGlobalVarName);
}


/////////////////////////////////////////////////////////////////////////////////////////
//
// UTILITIES
//
/////////////////////////////////////////////////////////////////////////////////////////

// GetStartToEndTransform -----------------------------------------------
bool GetStartToEndTransform(const plAGAnim *anim, hsMatrix44 *startToEnd,
                            hsMatrix44 *endToStart, const char *channelName)
{
    double start = 0.0f;    // assumed
    double end = anim->GetEnd();

    GetRelativeTransform(anim, start, end, startToEnd, endToStart, channelName);
    return true;
}

// GetRelativeTransform ---------------------------------------------------
bool GetRelativeTransform(const plAGAnim *anim, double timeA, double timeB,
                          hsMatrix44 *a2b, hsMatrix44 *b2a, const char *channelName)
{
    bool result = false;
    plAGChannel *maybeChannel = anim->GetChannel(channelName);
    hsAssert(maybeChannel, "Couldn't find channel with given name.");
    if(maybeChannel)
    {
        plMatrixChannel *channel = plMatrixChannel::ConvertNoRef(maybeChannel);
        hsAssert(channel, "Found channel, but it's not a matrix channel.");
        
        if(channel)
        {
            hsMatrix44 matA;
            hsMatrix44 matB;

            channel->Value(matA, timeA);
            channel->Value(matB, timeB);

            if(a2b)                 // requested a transform from point A to point B
            {
                hsMatrix44 invA;
                matA.GetInverse(&invA);
                *a2b = invA * matB;
            }
            if(b2a)                 // requested a transform from point B to point A
            {
                hsMatrix44 invB;
                matB.GetInverse(&invB);
                *b2a = invB * matA;
                
                if(a2b)
                {
                    hsMatrix44 invB2;
                    a2b->GetInverse(&invB2);
                }
            }
        }
    }
    return result;
}