CWE-ou-minkata/Sources/Plasma/PubUtilLib/plDrawable/plMorphSequence.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 "hsTypes.h"
#include "plMorphSequence.h"
#include "plMorphSequenceSDLMod.h"

#include "plAccessGeometry.h"
#include "plAccessVtxSpan.h"

#include "pnSceneObject/plSceneObject.h"
#include "pnSceneObject/plDrawInterface.h"
#include "pnSceneObject/plCoordinateInterface.h"

#include "plDrawableSpans.h"
#include "plInstanceDrawInterface.h"

#include "hsResMgr.h"
#include "plgDispatch.h"
#include "plMessage/plRenderMsg.h"

#include "plSharedMesh.h"

#include "plTweak.h"
#include "hsTimer.h"
#include "hsFastMath.h"

///////////////////////////////////////////////////////////////////////////

void plMorphDataSet::Read(hsStream* s, hsResMgr* mgr)
{
    hsKeyedObject::Read(s, mgr);
    
    int n = s->ReadSwap32();
    fMorphs.SetCount(n);
    int i;
    for( i = 0; i < n; i++ )
        fMorphs[i].Read(s, mgr);
}

void plMorphDataSet::Write(hsStream* s, hsResMgr* mgr)
{
    hsKeyedObject::Write(s, mgr);

    s->WriteSwap32(fMorphs.GetCount());
    int i;
    for( i = 0; i < fMorphs.GetCount(); i++ )
        fMorphs[i].Write(s, mgr);
}   

///////////////////////////////////////////////////////////////////////////

const UInt32 kChanMask = plAccessVtxSpan::kPositionMask
                        | plAccessVtxSpan::kNormalMask
                        | plAccessVtxSpan::kUVWMask;

// Probably want another type which is just initialize/override
// so we can set the mesh to whatever base set we want, as if
// that's what got loaded from disk.
// Use Access RW. That might already be handled in the customization stuff.

plConst(hsScalar)   kMorphTime(0.5);

class plMorphTarget
{
public:
    UInt16      fLayer;
    UInt16      fDelta;
    hsScalar    fWeight;
};

hsTArray<plMorphTarget> fTgtWgts;

plMorphSequence::plMorphSequence()
:   fMorphFlags(0),
    fMorphSDLMod(nil),
    fGlobalLayerRef(-1)
{
}

plMorphSequence::~plMorphSequence()
{
    DeInit();
}

hsBool plMorphSequence::MsgReceive(plMessage* msg)
{
    plRenderMsg* rend = plRenderMsg::ConvertNoRef(msg);
    if( rend )
    {
        // For now, I'm ignoring the target weight stuff for shared meshes.
        // Can always add it in later if desired.
        if( fTgtWgts.GetCount() )
        {
            hsScalar delWgt = hsTimer::GetDelSysSeconds() / (kMorphTime > 0 ? kMorphTime : 1.e-3f);
            int i;
            for( i = 0; i < fTgtWgts.GetCount(); i++ )
            {
                hsScalar currWgt = GetWeight(fTgtWgts[i].fLayer, fTgtWgts[i].fDelta);
                if( fTgtWgts[i].fWeight < currWgt )
                {
                    if( fTgtWgts[i].fWeight >= (currWgt -= delWgt) )
                        currWgt = fTgtWgts[i].fWeight;
                }
                else if( fTgtWgts[i].fWeight > currWgt )
                {
                    if( fTgtWgts[i].fWeight <= (currWgt += delWgt) )
                        currWgt = fTgtWgts[i].fWeight;
                }
                
                fMorphs[fTgtWgts[i].fLayer].SetWeight(fTgtWgts[i].fDelta, currWgt);

                if( fTgtWgts[i].fWeight == currWgt )
                {
                    fTgtWgts.Remove(i);
                    i--;
                }
            }
            ISetDirty(true);
        }

        if( !(fMorphFlags & kDirty) )
        {
            // We went a whole frame without getting dirty, 
            // we can stop refreshing now.
            plgDispatch::Dispatch()->UnRegisterForExactType(plRenderMsg::Index(), GetKey());

            return true;
        }
        ISetDirty(false);
        if( fMorphFlags & kDirtyIndices )
            IFindIndices();

        if( fMorphFlags & kHaveShared )
        {
            IApplyShared();
        }
        else
        {
            Apply();
        }
        return true;
    }

    plSharedMeshBCMsg *smMsg = plSharedMeshBCMsg::ConvertNoRef(msg);
    if (smMsg)
    {
        if (IGetDrawInterface()->GetKey() == smMsg->GetSender() || IIsUsingDrawable(smMsg->fDraw))
            fMorphFlags |= kDirtyIndices;
    }           

    plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef(msg);
    if (refMsg)
    {
        plSharedMesh *mesh = plSharedMesh::ConvertNoRef(refMsg->GetRef());
        if (mesh)
        {
            if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest) )
            {
                AddSharedMesh(mesh);
            }
            else if( refMsg->GetContext() & plRefMsg::kOnReplace)
            {
                plSharedMesh *oldMesh = plSharedMesh::ConvertNoRef(refMsg->GetOldRef());
                if (oldMesh)
                    RemoveSharedMesh(oldMesh);
                AddSharedMesh(mesh);
            }
            else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
                RemoveSharedMesh(mesh);             
            
            return true;
        }
    }
    
    return plSingleModifier::MsgReceive(msg);
}

int plMorphSequence::GetNumLayers(plKey meshKey /* = nil */) const
{
    int index = IFindSharedMeshIndex(meshKey);
    if (index < 0)
        return fMorphs.GetCount();
    else
        return fSharedMeshes[index].fMesh->fMorphSet->fMorphs.GetCount();
}

int plMorphSequence::GetNumDeltas(int iLay, plKey meshKey /* = nil */) const 
{ 
    int index = IFindSharedMeshIndex(meshKey);
    if (index < 0)
        return fMorphs[iLay].GetNumDeltas(); 
    else
        return fSharedMeshes[index].fMesh->fMorphSet->fMorphs[iLay].GetNumDeltas();
}

hsScalar plMorphSequence::GetWeight(int iLay, int iDel, plKey meshKey /* = nil */) const 
{ 
    int index = IFindSharedMeshIndex(meshKey);
    if (index == -1)
        return fMorphs[iLay].GetWeight(iDel); 
    else
        return fSharedMeshes[index].fArrayWeights[iLay].fDeltaWeights[iDel];
}

void plMorphSequence::SetWeight(int iLay, int iDel, hsScalar w, plKey meshKey /* = nil */)
{
    int index = IFindSharedMeshIndex(meshKey);

    // Only dirty if the weight isn't for a pending mesh
    if(meshKey == nil || index >= 0)
        ISetDirty(true);

    if (meshKey == nil)
    {
        if( iLay < fMorphs.GetCount() )
        {
            if( kMorphTime > 0 )
            {
                plMorphTarget tgt;
                tgt.fLayer = iLay;
                tgt.fDelta = iDel;
                tgt.fWeight = w;

                fTgtWgts.Append(tgt);
            }
            else
            {
                fMorphs[iLay].SetWeight(iDel, w);
            }
        }
    }
    else if (index >= 0)
    {
        fSharedMeshes[index].fArrayWeights[iLay].fDeltaWeights[iDel] = w;
        fSharedMeshes[index].fFlags |= plSharedMeshInfo::kInfoDirtyMesh;
        if (index == fGlobalLayerRef)
            ISetAllSharedToGlobal();
    }
    else
    {
        // Setting weight for a mesh we haven't added yet (loading state)
        index = IFindPendingStateIndex(meshKey);
        if (index < 0)
        {
            fPendingStates.Push();
            index = fPendingStates.GetCount() - 1;
            fPendingStates[index].fSharedMeshKey = meshKey;
        }
        if (fPendingStates[index].fArrayWeights.GetCount() <= iLay)
        {
            int had = fPendingStates[index].fArrayWeights.GetCount();
            hsTArray<plMorphArrayWeights> temp(iLay + 1);
            temp = fPendingStates[index].fArrayWeights;
            temp.SetCount(iLay + 1);

            fPendingStates[index].fArrayWeights.Swap(temp);
            int i;
            for( i = had; i < iLay+1; i++ )
                fPendingStates[index].fArrayWeights[i].fDeltaWeights.Reset();
        }
        if (fPendingStates[index].fArrayWeights[iLay].fDeltaWeights.GetCount() <= iDel)
            fPendingStates[index].fArrayWeights[iLay].fDeltaWeights.ExpandAndZero(iDel + 1);

        fPendingStates[index].fArrayWeights[iLay].fDeltaWeights[iDel] = w;
    }
}

void plMorphSequence::ISetDirty(hsBool on) 
{ 
    if( on )
    {
        if( !(fMorphFlags & kDirty) )
            plgDispatch::Dispatch()->RegisterForExactType(plRenderMsg::Index(), GetKey());
        fMorphFlags |= kDirty; 

        // Even if we know we're already dirty, there could be new info this frame.
        // Need to tell our scene object
        //
        // Actually, in the case of the avatar, this sends an insane flurry of messages to the server 
        // when we drag (or even just hold the mouse button down on) the morph scrollbars. 
        // These messages are completely unneccessary. We broadcast our state when we join a new age, and that's enough.
        // Non-avatar related morphs (if they ever exist) will need to call DirtySynchState some special
        // way. Not here.
        //
        //if (GetTarget(0))
        //  GetTarget(0)->DirtySynchState(kSDLMorphSequence, 0);
    }
    else
    {
        fMorphFlags &= ~kDirty; 
    }
}

// MorphSequence - Init
void plMorphSequence::Init()
{
    if( fMorphFlags & kHaveShared )
    {
        IFindIndices();
    }
    else
    {
        if( !GetHaveSnap() )
        {
            // Take an access snapshot of all our spans
            const plDrawInterface* di = IGetDrawInterface();

            plAccessGeometry::Instance()->TakeSnapShot(di, kChanMask);

            ISetHaveSnap(true);
        }
    }
}

void plMorphSequence::Activate()
{
    Init();
    ISetDirty(true);
}

void plMorphSequence::DeActivate()
{
    if( fMorphFlags & kHaveShared )
    {
        IReleaseIndices();
    }
    plgDispatch::Dispatch()->UnRegisterForExactType(plRenderMsg::Index(), GetKey());
}

// MorphSequence - DeInit
void plMorphSequence::DeInit()
{
    if( fMorphFlags & kHaveShared )
    {
        IReleaseIndices();
    }
    else
    {
        if( GetHaveSnap() )
        {
            // Release all our snapshot data
            const plDrawInterface* di = IGetDrawInterface();

            if( di ) 
                plAccessGeometry::Instance()->ReleaseSnapShot(di);

            ISetHaveSnap(false);
        }
    }
}

void plMorphSequence::IRenormalize(hsTArray<plAccessSpan>& dst) const
{
    int i;
    for( i = 0; i < dst.GetCount(); i++ )
    {
        hsAssert(dst[i].HasAccessVtx(), "Come on, everyone has vertices");
        plAccessVtxSpan& accVtx = dst[i].AccessVtx();
        int j;
        for( j = 0; j < accVtx.VertCount(); j++ )
        {
            hsFastMath::Normalize(accVtx.Normal(j));
        }
    }
}

// MorphSequence - Apply
void plMorphSequence::Apply() const
{
    const plDrawInterface* di = IGetDrawInterface();
    if( !di )
        return;

    // Reset to initial.
    Reset(di);

    // We'll be accumulating into the buffer, so open RW
    hsTArray<plAccessSpan> dst;
    plAccessGeometry::Instance()->OpenRW(di, dst);

    // For each MorphArray
    int i;
    for( i = 0; i < fMorphs.GetCount(); i++ )
    {
        // Apply Delta
        fMorphs[i].Apply(dst);
    }

    IRenormalize(dst);

    // Close up the access spans
    plAccessGeometry::Instance()->Close(dst);
}

// MorphSequence - Reset to initial
void plMorphSequence::Reset(const plDrawInterface* di) const
{
    if( !di )
    {
        di = IGetDrawInterface();
    }

    // Use access span RestoreSnapshot
    if( di )
        plAccessGeometry::Instance()->RestoreSnapShot(di, kChanMask);
}

const plDrawInterface* plMorphSequence::IGetDrawInterface() const
{
    plSceneObject* so = GetTarget();
    if( !so )
        return nil;

    const plDrawInterface* di = so->GetDrawInterface();

    return di;
}

void plMorphSequence::AddTarget(plSceneObject* so)
{
    plSingleModifier::AddTarget(so);

    if (!fMorphSDLMod)
    {
        fMorphSDLMod = TRACKED_NEW plMorphSequenceSDLMod;
        so->AddModifier(fMorphSDLMod);
    }
}

void plMorphSequence::RemoveTarget(plSceneObject *so)
{
    plSingleModifier::RemoveTarget(so);

    if (so)
        if (fMorphSDLMod)
            so->RemoveModifier(fMorphSDLMod);

    delete fMorphSDLMod;
    fMorphSDLMod = nil;     
}
    
void plMorphSequence::Read(hsStream* s, hsResMgr* mgr)
{
    plSingleModifier::Read(s, mgr);

    fMorphFlags = 0;

    int n = s->ReadSwap32();
    fMorphs.SetCount(n);
    int i;
    for( i = 0; i < n; i++ )
        fMorphs[i].Read(s, mgr);
    
    n = s->ReadSwap32();
    for( i = 0; i < n; i++)
        mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef);
}

void plMorphSequence::Write(hsStream* s, hsResMgr* mgr)
{
    plSingleModifier::Write(s, mgr);

    s->WriteSwap32(fMorphs.GetCount());
    int i;
    for( i = 0; i < fMorphs.GetCount(); i++ )
        fMorphs[i].Write(s, mgr);

    s->WriteSwap32(fSharedMeshes.GetCount());
    for( i = 0; i < fSharedMeshes.GetCount(); i++ )
        mgr->WriteKey(s, fSharedMeshes[i].fMesh);
}

// Normal sequence of calls:
// 1) on notification that meshes have changed (or activate)
//      IFindIndices() - Sets up indices 
//      IApplyShared() - Find which mesh is active and
//          IResetShared(iActive);
//          IApplyShared(iActive);
//      go dormant
// 2) on weight change
//      SetWeight() - Register for render message and set the new weight
// 3) on render msg:
//      if dirty
//          IApplyShared() - Find which mesh is active and
//              IResetShared(iActive);
//              IApplyShared(iActive);
//      else
//          Unregister for render message.
// 4) on deinit
//      IReleaseIndices() - Just let's us know there's nothing much to be done.
//

void plMorphSequence::IResetShared()
{
    int i;
    for (i = 0; i < fSharedMeshes.GetCount(); i++)
        IResetShared(i);
}

void plMorphSequence::IApplyShared()
{
    int i;
    for (i = 0; i < fSharedMeshes.GetCount(); i++)
    {
        IResetShared(i);
        IApplyShared(i);
    }
}

void plMorphSequence::IFindIndices()
{
    fMorphFlags &= ~kDirtyIndices;

    int i;
    for( i = 0; i < fSharedMeshes.GetCount(); i++ )
        IFindIndices(i);
}

void plMorphSequence::IReleaseIndices()
{
    int i;
    for( i = 0; i < fSharedMeshes.GetCount(); i++ )
        IReleaseIndices(i);
}


void plMorphSequence::IApplyShared(int iShare)
{
    if( iShare >= fSharedMeshes.GetCount() || fSharedMeshes[iShare].fCurrDraw == nil)
        return;

    plSharedMeshInfo& mInfo = fSharedMeshes[iShare];

    hsTArray<plAccessSpan> dst;
    // Now copy each shared mesh geometryspan into the drawable
    // to get it back to it's pristine condition.
    int i;
    for( i = 0; i < mInfo.fMesh->fSpans.GetCount(); i++ )
    {
        plAccessSpan dstAcc;
        plAccessGeometry::Instance()->OpenRW(mInfo.fCurrDraw, mInfo.fCurrIdx[i], dstAcc);

        dst.Append(dstAcc);
    }

    // For each MorphArray
    for( i = 0; i < mInfo.fMesh->fMorphSet->fMorphs.GetCount(); i++ )
    {
        // Apply Delta
        mInfo.fMesh->fMorphSet->fMorphs[i].Apply(dst, &mInfo.fArrayWeights[i].fDeltaWeights);
    }

    IRenormalize(dst);

    // Close up the access spans
    plAccessGeometry::Instance()->Close(dst);
    mInfo.fFlags &= ~plSharedMeshInfo::kInfoDirtyMesh;
}

hsBool plMorphSequence::IResetShared(int iShare)
{
    if( iShare >= fSharedMeshes.GetCount() || fSharedMeshes[iShare].fCurrDraw == nil)
        return false;

    plSharedMeshInfo& mInfo = fSharedMeshes[iShare];

    // Now copy each shared mesh geometryspan into the drawable
    // to get it back to it's pristine condition.
    int i;
    for( i = 0; i < mInfo.fMesh->fSpans.GetCount(); i++ )
    {
        plAccessSpan srcAcc;
        plAccessGeometry::Instance()->AccessSpanFromGeometrySpan(srcAcc, mInfo.fMesh->fSpans[i]);
        plAccessSpan dstAcc;
        plAccessGeometry::Instance()->OpenRW(mInfo.fCurrDraw, mInfo.fCurrIdx[i], dstAcc);
        
        plAccPosNormUVWIterator srcIter(&srcAcc.AccessVtx());
        plAccPosNormUVWIterator dstIter(&dstAcc.AccessVtx());

        const int numUVWs = srcAcc.AccessVtx().NumUVWs();

        for( srcIter.Begin(), dstIter.Begin(); srcIter.More(); srcIter.Advance(), dstIter.Advance() )
        {
            *dstIter.Position() = *srcIter.Position();
            *dstIter.Normal() = *srcIter.Normal();

            int j;
            for( j = 0; j < numUVWs; j++ )
                *dstIter.UVW(j) = *srcIter.UVW(j);
        }
    }

    return true;
}

hsBool plMorphSequence::IFindIndices(int iShare)
{
    plSharedMeshInfo& mInfo = fSharedMeshes[iShare];
    mInfo.fCurrDraw = nil; // In case we fail.

    const plInstanceDrawInterface* di = plInstanceDrawInterface::ConvertNoRef(IGetDrawInterface());
    if( !di )
        return false;

    Int32 meshIdx = di->GetSharedMeshIndex(mInfo.fMesh);
    if( meshIdx < 0 )
        return false;

    plDrawableSpans* dr = plDrawableSpans::ConvertNoRef(di->GetDrawable((UInt8)meshIdx));
    if( !dr )
        return false;

    mInfo.fCurrDraw = dr;

    plDISpanIndex& diIndex = dr->GetDISpans(di->GetDrawableMeshIndex((UInt8)meshIdx));

    hsAssert(mInfo.fMesh->fSpans.GetCount() == diIndex.GetCount(), "Mismatch between geometry and indices");

    mInfo.fCurrIdx.SetCount(diIndex.GetCount());

    int i;
    for( i = 0; i < diIndex.GetCount(); i++ )
        mInfo.fCurrIdx[i] = diIndex[i];

    return true;
}

void plMorphSequence::IReleaseIndices(int iShare)
{
    plSharedMeshInfo& mInfo = fSharedMeshes[iShare];
    mInfo.fCurrDraw = nil;
}

Int32 plMorphSequence::IFindSharedMeshIndex(plKey meshKey) const
{
    int i;
    for( i = 0; i < fSharedMeshes.GetCount(); i++ )
    {
        if (fSharedMeshes[i].fMesh->GetKey() == meshKey)
            return i;
    }

    return -1;
}

Int32 plMorphSequence::IFindPendingStateIndex(plKey meshKey) const
{
    int i;
    for( i = 0; i < fPendingStates.GetCount(); i++ )
    {
        if (fPendingStates[i].fSharedMeshKey == meshKey)
            return i;
    }
    
    return -1;
}

hsBool plMorphSequence::IIsUsingDrawable(plDrawable *draw)
{
    int i;
    for (i = 0; i < fSharedMeshes.GetCount(); i++)
    {
        if (fSharedMeshes[i].fCurrDraw == draw)
            return true;
    }

    return false;
}

void plMorphSequence::AddSharedMesh(plSharedMesh* mesh)
{
    // This happens if SDL state tells us to use a mesh without morph info
    // (Either because the object used to but no longer does, or because
    // the SDL is giving us the wrong key.)
    if (!mesh->fMorphSet)
        return;

    if (fSharedMeshes.GetCount() == 0)
        plgDispatch::Dispatch()->RegisterForExactType(plSharedMeshBCMsg::Index(), GetKey());

    if (IFindSharedMeshIndex(mesh->GetKey()) >= 0)
        return; // We already have it.

    hsAssert(fSharedMeshes.GetCount() < 127, "Too many meshes for one morph sequence.");
    SetUseSharedMesh(true); 
    int pendingIndex = IFindPendingStateIndex(mesh->GetKey());

    plSharedMeshInfo mInfo;
    mInfo.fMesh = mesh;
    mInfo.fCurrDraw = nil;

    // Intialize our weights to zero.
    mInfo.fArrayWeights.Reset();
    mInfo.fArrayWeights.SetCount(mesh->fMorphSet->fMorphs.GetCount());
    int i, j;
    for (i = 0; i < mesh->fMorphSet->fMorphs.GetCount(); i++)
        mInfo.fArrayWeights[i].fDeltaWeights.ExpandAndZero(mesh->fMorphSet->fMorphs[i].GetNumDeltas());
            
    // Aha, we have some pending weights. Copy them in!
    if (pendingIndex >= 0)
    {
        // Filter in any data that's valid
        for (i = 0; i < mInfo.fArrayWeights.GetCount() && i < fPendingStates[pendingIndex].fArrayWeights.GetCount(); i++)
        {
            for (j = 0; j < mInfo.fArrayWeights[i].fDeltaWeights.GetCount() && 
                        j < fPendingStates[pendingIndex].fArrayWeights[i].fDeltaWeights.GetCount(); j++)
            {
                mInfo.fArrayWeights[i].fDeltaWeights[j] = fPendingStates[pendingIndex].fArrayWeights[i].fDeltaWeights[j];
            }
        }
            
        fPendingStates.Remove(pendingIndex);

        mInfo.fFlags |= plSharedMeshInfo::kInfoDirtyMesh;
        ISetDirty(true);
    }

    fSharedMeshes.Append(mInfo);
    IFindIndices(fSharedMeshes.GetCount() - 1);

    if (mesh->fFlags & plSharedMesh::kLayer0GlobalToMod)
    {
        fGlobalLayerRef = fSharedMeshes.GetCount() - 1;
        ISetAllSharedToGlobal();
    }
    else 
        ISetSingleSharedToGlobal(fSharedMeshes.GetCount() - 1);
}

void plMorphSequence::RemoveSharedMesh(plSharedMesh* mesh)
{
    int idx = IFindSharedMeshIndex(mesh->GetKey());
    if (idx < 0)
        return; // Don't have it... can't remove it can we?
    
    fSharedMeshes.Remove(idx);

    fGlobalLayerRef = -1;
    int i;
    for (i = 0; i < fSharedMeshes.GetCount(); i++)
    {
        if (fSharedMeshes[i].fMesh->fFlags & plSharedMesh::kLayer0GlobalToMod)
        {
            fGlobalLayerRef = i;
            break;
        }
    }
    
    if (fSharedMeshes.GetCount() == 0)
        plgDispatch::Dispatch()->UnRegisterForExactType(plSharedMeshBCMsg::Index(), GetKey());
}

void plMorphSequence::FindMorphMods(const plSceneObject *so, hsTArray<const plMorphSequence*> &mods)
{
    const plMorphSequence *morph = plMorphSequence::ConvertNoRef(so->GetModifierByType(plMorphSequence::Index()));
    if (morph)
        mods.Append(morph);
    
    const plCoordinateInterface *ci = so->GetCoordinateInterface();
    int i;
    for (i = 0; i < ci->GetNumChildren(); i++)
        FindMorphMods(ci->GetChild(i)->GetOwner(), mods);
}

void plMorphSequence::ISetAllSharedToGlobal()
{
    int i;
    for (i = 0; i < fSharedMeshes.GetCount(); i++)
    {
        if (i != fGlobalLayerRef)
            ISetSingleSharedToGlobal(i);
    }
}

void plMorphSequence::ISetSingleSharedToGlobal(int idx)
{
    if (fGlobalLayerRef < 0)
        return;

    int i;
    for (i = 0; i < fSharedMeshes[fGlobalLayerRef].fArrayWeights[0].fDeltaWeights.GetCount(); i++)
        SetWeight(0, i, fSharedMeshes[fGlobalLayerRef].fArrayWeights[0].fDeltaWeights[i], fSharedMeshes[idx].fMesh->GetKey());
}