CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAvatar/plAGMasterSDLModifier.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==*/
#include "plAGMasterSDLModifier.h"
#include "plSDL/plSDL.h"
#include "plInterp/plAnimTimeConvert.h"
#include "pnSceneObject/plSceneObject.h"
#include "plAGMasterMod.h"
#include "plAGAnimInstance.h"
#include "plgDispatch.h"
#include "pnMessage/plTimeMsg.h"
#include "hsTimer.h"
#include "plMessage/plAnimCmdMsg.h"

// static vars
char plAGMasterSDLModifier::AGMasterVarNames::kStrAtcs[]="atcs";
char plAGMasterSDLModifier::AGMasterVarNames::kStrBlends[]="blends";

UInt32 plAGMasterSDLModifier::IApplyModFlags(UInt32 sendFlags)
{
    // ugly hack so bug light animation state isn't stored on the server
    if (stricmp(GetTarget()->GetKeyName(), "RTOmni-BugLightTest") == 0)
        return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState);
    // ditto for the KI light
    if (stricmp(GetTarget()->GetKeyName(), "RTOmniKILight") == 0)
        return (sendFlags | plSynchedObject::kDontPersistOnServer | plSynchedObject::kIsAvatarState);

    return sendFlags;
}

//
// copy blends values from current state into sdl
//
void plAGMasterSDLModifier::IPutBlends(plStateDataRecord* state, plAGMasterMod* agMaster)
{
    int numBlends = agMaster->GetNumPrivateAnimations();    // each private anim has a blend value
    plSimpleStateVariable* blendsVar = state->FindVar(AGMasterVarNames::kStrBlends);
    if (blendsVar->GetCount() != numBlends)
        blendsVar->Alloc(numBlends);

    // sdl copy
    int i;
    for(i=0;i<numBlends; i++)
    {
        blendsVar->Set((UInt8)(agMaster->GetAnimInstance(i)->GetBlend() * 255), i);
    }
}


//
// Copy atcs from current state into sdl
//
void plAGMasterSDLModifier::IPutCurrentStateIn(plStateDataRecord* dstState)
{
    plSceneObject* sobj=GetTarget();
    hsAssert(sobj, "plAGMasterSDLModifier, nil target");
    
    plAGMasterMod* agMaster=IGetObjectsAGMasterMod(sobj);
    hsAssert(agMaster, "nil AGMasterMod");

    if (agMaster)
    {
        IPutBlends(dstState, agMaster);

        int numAnims = agMaster->GetNumATCAnimations();     
        plSDStateVariable* atcsVar = dstState->FindSDVar(AGMasterVarNames::kStrAtcs);
        if (atcsVar->GetCount() != numAnims)
            atcsVar->Resize(numAnims);

        // copy atcs to sdl 
        int i;
        for(i=0;i<numAnims; i++)
        {
            plStateDataRecord* atcStateDataRec = atcsVar->GetStateDataRecord(i);
            plAnimTimeConvert* animTimeConvert = agMaster->GetATCAnimInstance(i)->GetTimeConvert();

            IPutATC(atcStateDataRec, animTimeConvert);
        }
    }
}

//
// Given a scene object, find and return it's AGMasterMod
//
plAGMasterMod* plAGMasterSDLModifier::IGetObjectsAGMasterMod(plSceneObject* obj)
{
    int count = obj->GetNumModifiers();

    for (int i = 0; i < count; i++)
    {
        plAGMasterMod * avMod = const_cast<plAGMasterMod*>(plAGMasterMod::ConvertNoRef(obj->GetModifier(i)));
        if(avMod)
            return avMod;
    }

    return nil;
}

//
// Apply state in SDL record to current animation state 
//
void plAGMasterSDLModifier::ISetCurrentBlends(const plStateDataRecord* state, plAGMasterMod* objAGMaster)
{
    // Check Blends
    plSimpleStateVariable* blendsVar = state->FindVar(AGMasterVarNames::kStrBlends);
    if (blendsVar->IsUsed())
    {       
        int i;
        if (blendsVar->GetCount() != objAGMaster->GetNumPrivateAnimations())
            return; // bogus state

        for (i=0;i<blendsVar->GetCount();i++)
        {
            UInt8 blend;
            blendsVar->Get(&blend, i);
            objAGMaster->GetAnimInstance(i)->SetBlend(blend / 255.f);
        }
    }
}

//
// Change the object's animation state to reflect what is specified in the 
// stateDataRecord.
//
void plAGMasterSDLModifier::ISetCurrentStateFrom(const plStateDataRecord* srcState)
{
    plSceneObject* sobj=GetTarget();
    hsAssert(sobj, "plAGMasterSDLModifier, nil target");
    
    plAGMasterMod* objAGMaster=IGetObjectsAGMasterMod(sobj);
    hsAssert(objAGMaster, "can't find object's AGMasterSDLState");
    
    ISetCurrentBlends(srcState, objAGMaster);

    plSDStateVariable* atcsVar = srcState->FindSDVar(AGMasterVarNames::kStrAtcs);
    if (atcsVar->IsUsed())
    {
        if (objAGMaster->GetNumATCAnimations() != atcsVar->GetCount())
            return;

        int i;
        for(i=0;i<atcsVar->GetCount(); i++)
        {
            plStateDataRecord* atcStateDataRec = atcsVar->GetStateDataRecord(i);
            plAnimTimeConvert* objAtc = objAGMaster->GetATCAnimInstance(i)->GetTimeConvert();   // dst                  
            ISetCurrentATC(atcStateDataRec, objAtc);
            objAtc->EnableCallbacks(false);
        }
        objAGMaster->IRegForEval(objAGMaster->HasRunningAnims());

        // Force one eval, then re-enable all the callbacks
        double time = (hsTimer::GetSysSeconds() - hsTimer::GetDelSysSeconds());

        if (objAGMaster->fIsGrouped && objAGMaster->fMsgForwarder)
        {
            hsScalar animTimeFromWorldTime = (objAGMaster->GetNumATCAnimations() > 0) ? objAGMaster->GetATCAnimInstance(0)->GetTimeConvert()->WorldToAnimTimeNoUpdate(time) : 0.0f;

            plAGCmdMsg *msg = TRACKED_NEW plAGCmdMsg();
            msg->SetCmd(plAGCmdMsg::kSetAnimTime);
            msg->fAnimTime = animTimeFromWorldTime;
            msg->AddReceiver(objAGMaster->fMsgForwarder->GetKey());
            plgDispatch::MsgSend(msg);
        }
        else
        {
            objAGMaster->AdvanceAnimsToTime(time);
        }

        for (i = 0; i < objAGMaster->GetNumATCAnimations(); i++)
            objAGMaster->GetATCAnimInstance(i)->GetTimeConvert()->EnableCallbacks(true);
    }
}