wmlkeyframecontroller.cpp

3D Game Engine Design Source Code非常棒

        StreamRead(rkStream,m_iSQuantity);
        if ( m_iSQuantity > 0 )
        {
            m_afSTime = new float[m_iSQuantity];
            m_afSData = new float[m_iSQuantity];
            StreamRead(rkStream,m_afSTime,m_iSQuantity);
            StreamRead(rkStream,m_afSData,m_iSQuantity);
        }
    }
}
//----------------------------------------------------------------------------
void KeyframeController::Link (Stream& rkStream,
    Stream::Link* pkLink)
{
    Controller::Link(rkStream,pkLink);
}
//----------------------------------------------------------------------------
bool KeyframeController::Register (Stream& rkStream)
{
    return Controller::Register(rkStream);
}
//----------------------------------------------------------------------------
void KeyframeController::Save (Stream& rkStream)
{
    Controller::Save(rkStream);

    bool bShared = m_iSharedQuantity > 0;
    StreamWriteBool(rkStream,bShared);

    if ( bShared  )
    {
        StreamWrite(rkStream,m_iSharedQuantity);
        StreamWrite(rkStream,m_afSharedTime,m_iSharedQuantity);
        StreamWrite(rkStream,m_akTData,m_iSharedQuantity);
        StreamWrite(rkStream,m_akRData,m_iSharedQuantity);
        StreamWrite(rkStream,m_afSData,m_iSharedQuantity);
    }
    else
    {
        StreamWrite(rkStream,m_iTQuantity);
        if ( m_iTQuantity > 0 )
        {
            StreamWrite(rkStream,m_afTTime,m_iTQuantity);
            StreamWrite(rkStream,m_akTData,m_iTQuantity);
        }

        StreamWrite(rkStream,m_iRQuantity);
        if ( m_iRQuantity > 0 )
        {
            StreamWrite(rkStream,m_afRTime,m_iRQuantity);
            StreamWrite(rkStream,m_akRData,m_iRQuantity);
        }

        StreamWrite(rkStream,m_iSQuantity);
        if ( m_iSQuantity > 0 )
        {
            StreamWrite(rkStream,m_afSTime,m_iSQuantity);
            StreamWrite(rkStream,m_afSData,m_iSQuantity);
        }
    }
}
//----------------------------------------------------------------------------
StringTree* KeyframeController::SaveStrings ()
{
    int iSQuantity, iCQuantity;
    if ( m_iSharedQuantity > 0 )
    {
        iSQuantity = 2;
        iCQuantity = 5;
    }
    else
    {
        iSQuantity = 4;
        iCQuantity = 7;
    }

    StringTree* pkTree = new StringTree(iSQuantity,0,iCQuantity,0);

    // strings
    pkTree->SetString(0,MakeString(&ms_kRTTI,GetName()));
    if ( m_iSharedQuantity > 0 )
    {
        pkTree->SetString(1,MakeString("quantity =",m_iSharedQuantity));
    }
    else
    {
        pkTree->SetString(1,MakeString("translate quantity =",m_iTQuantity));
        pkTree->SetString(2,MakeString("rotate quantity =",m_iRQuantity));
        pkTree->SetString(3,MakeString("scale quantity =",m_iSQuantity));
    }

    // children
    pkTree->SetChild(0,Controller::SaveStrings());

    StringTree* pkAttrTree;
    char acDummy[16];
    int i;

    if ( m_iSharedQuantity > 0 )
    {
        pkAttrTree = new StringTree(m_iSharedQuantity+1,0,0,0);
        pkTree->SetChild(1,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("times"));
        for (i = 0; i < m_iSharedQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_afSharedTime[i]));
        }

        pkAttrTree = new StringTree(m_iSharedQuantity+1,0,0,0);
        pkTree->SetChild(2,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("translate keys"));
        for (i = 0; i < m_iSharedQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_akTData[i]));
        }

        pkAttrTree = new StringTree(m_iSharedQuantity+1,0,0,0);
        pkTree->SetChild(3,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("rotate keys"));
        for (i = 0; i < m_iSharedQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_akRData[i]));
        }

        pkAttrTree = new StringTree(m_iSharedQuantity+1,0,0,0);
        pkTree->SetChild(4,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("scale keys"));
        for (i = 0; i < m_iSharedQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_afSData[i]));
        }
    }
    else
    {
        pkAttrTree = new StringTree(m_iTQuantity+1,0,0,0);
        pkTree->SetChild(1,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("translate times"));
        for (i = 0; i < m_iTQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_afTTime[i]));
        }
        pkAttrTree = new StringTree(m_iTQuantity+1,0,0,0);
        pkTree->SetChild(2,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("translate keys"));
        for (i = 0; i < m_iTQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_akTData[i]));
        }

        pkAttrTree = new StringTree(m_iRQuantity+1,0,0,0);
        pkTree->SetChild(3,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("rotate times"));
        for (i = 0; i < m_iRQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_afRTime[i]));
        }
        pkAttrTree = new StringTree(m_iRQuantity+1,0,0,0);
        pkTree->SetChild(4,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("rotate keys"));
        for (i = 0; i < m_iRQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_akRData[i]));
        }

        pkAttrTree = new StringTree(m_iSQuantity+1,0,0,0);
        pkTree->SetChild(5,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("scale times"));
        for (i = 0; i < m_iSQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,m_afSTime[i]));
        }
        pkAttrTree = new StringTree(m_iSQuantity+1,0,0,0);
        pkTree->SetChild(6,pkAttrTree);
        pkAttrTree->SetString(0,MakeString("scale keys"));
        for (i = 0; i < m_iSQuantity; i++)
        {
            sprintf(acDummy,"%d:",i);
            pkAttrTree->SetString(i+1,MakeString(acDummy,
                m_afSData[i]));
        }
    }

    return pkTree;
}
//----------------------------------------------------------------------------
int KeyframeController::GetMemoryUsed () const
{
    int iBaseSize = sizeof(KeyframeController) - sizeof(Controller);

    int iDynaSize = 0;
    if ( m_iSharedQuantity > 0 )
    {
        iDynaSize += m_iSharedQuantity*sizeof(m_afSharedTime[0]);
        iDynaSize += m_iSharedQuantity*sizeof(m_akTData[0]);
        iDynaSize += m_iSharedQuantity*sizeof(m_akRData[0]);
        iDynaSize += m_iSharedQuantity*sizeof(m_afSData[0]);
    }
    else
    {
        iDynaSize += m_iTQuantity*(sizeof(m_afTTime[0])+sizeof(m_akTData[0]));
        iDynaSize += m_iRQuantity*(sizeof(m_afRTime[0])+sizeof(m_akRData[0]));
        iDynaSize += m_iSQuantity*(sizeof(m_afSTime[0])+sizeof(m_afSData[0]));
    }

    int iTotalSize = iBaseSize + iDynaSize + Controller::GetMemoryUsed();
    return iTotalSize;
}
//----------------------------------------------------------------------------
int KeyframeController::GetDiskUsed () const
{
    int iSize = Controller::GetDiskUsed();

    bool bShared = m_iSharedQuantity > 0;
    iSize += StreamBytesBool(bShared);

    if ( bShared  )
    {
        iSize += sizeof(m_iSharedQuantity);
        iSize += m_iSharedQuantity*sizeof(m_afSharedTime[0]);
        iSize += m_iSharedQuantity*sizeof(m_akTData[0]);
        iSize += m_iSharedQuantity*sizeof(m_akRData[0]);
        iSize += m_iSharedQuantity*sizeof(m_afSData[0]);
    }
    else
    {
        iSize += sizeof(m_iTQuantity);
        if ( m_iTQuantity > 0 )
        {
            iSize += m_iTQuantity*sizeof(m_afTTime[0]);
            iSize += m_iTQuantity*sizeof(m_akTData[0]);
        }

        iSize += sizeof(m_iRQuantity);
        if ( m_iRQuantity > 0 )
        {
            iSize += m_iRQuantity*sizeof(m_afRTime[0]);
            iSize += m_iRQuantity*sizeof(m_akRData[0]);
        }

        iSize += sizeof(m_iSQuantity);
        if ( m_iSQuantity > 0 )
        {
            iSize += m_iSQuantity*sizeof(m_afSTime[0]);
            iSize += m_iSQuantity*sizeof(m_afSData[0]);
        }
    }

    return iSize;
}
//----------------------------------------------------------------------------