wmlspatial.cpp

3D Game Engine Design Source Code非常棒

        // pop states at this node
        for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
            pkStack->Pop(pkList->m_spkState);
    }
}
//----------------------------------------------------------------------------
void Spatial::OnDraw (Renderer& rkRenderer)
{
    if ( m_bForceCull )
        return;

    CameraPtr spCamera = rkRenderer.GetCamera();
    unsigned int uiState = spCamera->GetPlaneState();

    if ( !spCamera->Culled(m_kWorldBound) )
        Draw(rkRenderer);

    spCamera->SetPlaneState(uiState);
}
//----------------------------------------------------------------------------
Object* Spatial::GetObjectByName (const char* acName)
{
    Object* pkFound = Object::GetObjectByName(acName);
    if ( pkFound )
        return pkFound;

    RenderState::List* pkList;
    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
    {
        pkFound = pkList->m_spkState->GetObjectByName(acName);
        if ( pkFound )
            return pkFound;
    }

    // To avoid cycles in a recursive search of a scene graph for an object
    // with the specified name, the Node m_pkParent is not checked.
    return NULL;
}
//----------------------------------------------------------------------------
void Spatial::GetAllObjectsByName (const char* acName,
    std::vector<Object*>& rkObjects)
{
    Object::GetAllObjectsByName(acName,rkObjects);

    RenderState::List* pkList;
    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
        pkList->m_spkState->GetAllObjectsByName(acName,rkObjects);

    // To avoid cycles in a recursive search of a scene graph for an object
    // with the specified name, the Node m_pkParent is not checked.
}
//----------------------------------------------------------------------------
Spatial::PickRecord::PickRecord (Spatial* pkObject, float fRayT)
    :
    m_spkObject(pkObject)
{
    m_fRayT = fRayT;
}
//----------------------------------------------------------------------------
Spatial::PickRecord::~PickRecord ()
{
    // stub for derived classes
}
//----------------------------------------------------------------------------
void Spatial::DoPick (const Vector3f&, const Vector3f&, PickArray&)
{
    // stub for derived classes
}
//----------------------------------------------------------------------------
void Spatial::Sort (PickArray& rkResults)
{
    // sort in ascending order
    std::sort(rkResults.begin(),rkResults.end());
}
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// streaming
//----------------------------------------------------------------------------
Object* Spatial::Factory (Stream&)
{
    // Spatial is abstract, Factory never called
    return NULL;
}
//----------------------------------------------------------------------------
void Spatial::Load (Stream& rkStream, Stream::Link* pkLink)
{
    Object::Load(rkStream,pkLink);

    // native data
    StreamRead(rkStream,m_kRotate);
    StreamRead(rkStream,m_kTranslate);
    StreamRead(rkStream,m_fScale);

    // world transforms and world bound are derived, no need to save

    // link data
    int iQuantity;
    StreamRead(rkStream,iQuantity);
    m_pkStateList = 0;
    for (int i = 0; i < iQuantity; i++)
    {
        RenderState* pkState;
        StreamRead(rkStream,pkState);
        pkLink->Add(pkState);

        // build render state list, to be filled in by Link
        RenderState::List* pkList = new RenderState::List;
        pkList->m_spkState = NULL;
        pkList->m_pkNext = m_pkStateList;
        m_pkStateList = pkList;
    }
}
//----------------------------------------------------------------------------
void Spatial::Link (Stream& rkStream, Stream::Link* pkLink)
{
    Object::Link(rkStream,pkLink);

    RenderState::List* pkList;
    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
    {
        Object* pkLinkID = pkLink->GetLinkID();
        pkList->m_spkState = (RenderState*)rkStream.GetFromMap(pkLinkID);
    }
}
//----------------------------------------------------------------------------
bool Spatial::Register (Stream& rkStream)
{
    if ( !Object::Register(rkStream) )
        return false;

    // m_pkParent need not be registered since the parent itself must have
    // initiated the Register call to its children, 'this' being one of them.

    RenderState::List* pkList;
    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
    {
        RenderState* pkState = pkList->m_spkState;
        if ( pkState )
            pkState->Register(rkStream);
    }

    return true;
}
//----------------------------------------------------------------------------
void Spatial::Save (Stream& rkStream)
{
    Object::Save(rkStream);

    // native data
    StreamWrite(rkStream,m_kRotate);
    StreamWrite(rkStream,m_kTranslate);
    StreamWrite(rkStream,m_fScale);

    // world transforms and world bound are derived, no need to save

    // link data

    // m_pkParent need not be saved since 'this' will be attached as a child
    // in Node::Link.

    RenderState::List* pkList;
    int iQuantity = 0;
    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
        iQuantity++;

    StreamWrite(rkStream,iQuantity);

    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
        StreamWrite(rkStream,pkList->m_spkState);
}
//----------------------------------------------------------------------------
StringTree* Spatial::SaveStrings ()
{
    int iChildQuantity = 1;
    RenderState::List* pkList;
    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
    {
        RenderState* pkState = pkList->m_spkState;
        if ( pkState )
            iChildQuantity++;
    }

    StringTree* pkTree = new StringTree(9,0,iChildQuantity,0);

    // strings
    pkTree->SetString(0,MakeString(&ms_kRTTI,GetName()));
    pkTree->SetString(1,MakeString("local rotate =",m_kRotate));
    pkTree->SetString(2,MakeString("local translate =",m_kTranslate));
    pkTree->SetString(3,MakeString("local scale =",m_fScale));
    pkTree->SetString(4,MakeString("world rotate =",m_kWorldRotate));
    pkTree->SetString(5,MakeString("world translate =",m_kWorldTranslate));
    pkTree->SetString(6,MakeString("world scale =",m_fWorldScale));
    pkTree->SetString(7,MakeString("world bound =",m_kWorldBound));
    pkTree->SetString(8,MakeString("force cull =",m_bForceCull));

    // children
    pkTree->SetChild(0,Object::SaveStrings());
    int iSlot = 1;
    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
    {
        RenderState* pkState = pkList->m_spkState;
        if ( pkState )
            pkTree->SetChild(iSlot++,pkState->SaveStrings());
    }

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

    int iDynaSize = 0;
    RenderState::List* pkList = m_pkStateList;
    while ( pkList )
    {
        iDynaSize += sizeof(RenderState::List);
        pkList = pkList->m_pkNext;
    }

    int iTotalSize = iBaseSize + iDynaSize + Object::GetMemoryUsed();
    return iTotalSize;
}
//----------------------------------------------------------------------------
int Spatial::GetDiskUsed () const
{
    int iSize = Object::GetDiskUsed() +
        sizeof(m_kRotate) +
        sizeof(m_kTranslate) +
        sizeof(m_fScale);

    RenderState::List* pkList;
    int iQuantity = 0;
    for (pkList = m_pkStateList; pkList; pkList = pkList->m_pkNext)
        iQuantity++;

    // List of states stored as 4-byte integer (quantity of state) and
    // array of pointers to states.
    iSize += sizeof(int) + iQuantity*sizeof(RenderStatePtr);

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