CWE-ou-minkata/Sources/Plasma/PubUtilLib/plScene/plSceneNode.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 "plSceneNode.h"
#include "pnDispatch/plDispatch.h"
#include "plMessage/plNodeCleanupMsg.h"
#include "pnMessage/plNodeRefMsg.h"

#include "hsStream.h"
#include "hsResMgr.h"

#include "pnSceneObject/plSceneObject.h"
#include "plDrawable.h"
#include "plPhysical.h"
#include "plAudible.h"
#include "plGLight/plLightInfo.h"
#include "pnMessage/plRefMsg.h"
#include "plPipeline.h"
#include "pnKeyedObject/plKey.h"
#include "plDrawable/plSpaceTreeMaker.h"
#include "plDrawable/plSpaceTree.h"
#include "plPageTreeMgr.h"
#include "plOccluder.h"

//MFHORSE
//BLACK
// temp hack for debugging
#include "plDrawable/plDrawableSpans.h"
#include "pnKeyedObject/plKeyImp.h"

plSceneNode::plSceneNode()
:   fDepth(0),
    fSpaceTree(nil),
    fFilterGenerics(false)
{
}

plSceneNode::~plSceneNode()
{
    plgDispatch::Dispatch()->UnRegisterForExactType(plNodeCleanupMsg::Index(), GetKey());

    delete fSpaceTree;
}

//// Init ////////////////////////////////////////////////////////////////////
//  Because we can't register for messages on construction. Doh.

void plSceneNode::Init()
{
    ///  :P
    plgDispatch::Dispatch()->RegisterForExactType(plNodeCleanupMsg::Index(), GetKey());
}

void plSceneNode::Read(hsStream* s, hsResMgr* mgr)
{
    hsKeyedObject::Read(s, mgr);

    UInt32 n;
    int i;

    n = s->ReadSwap32();
    fSceneObjects.Reset();
    for( i = 0; i < n; i++ )
    {
        plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg(GetKey(), plRefMsg::kOnCreate, i, plNodeRefMsg::kObject);
        plKey key = mgr->ReadKeyNotifyMe(s, refMsg, plRefFlags::kActiveRef);
    }

    n = s->ReadSwap32();
    fGenericPool.Reset();
    for( i = 0; i < n; i++ )
    {
        plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg(GetKey(), plRefMsg::kOnCreate, -1, plNodeRefMsg::kGeneric);
        mgr->ReadKeyNotifyMe(s, refMsg, plRefFlags::kActiveRef);
    }
}

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

    int i;

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

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

void plSceneNode::Harvest(plVolumeIsect* isect, hsTArray<plDrawVisList>& levList)
{
    static hsTArray<Int16> visList;
    visList.SetCount(0);
    GetSpaceTree()->HarvestLeaves(isect, visList);
    static hsTArray<Int16> visSpans;
    visSpans.SetCount(0);

    int i;
    for( i = 0; i < visList.GetCount(); i++ )
    {
        int idx = visList[i];
        fDrawPool[idx]->GetSpaceTree()->HarvestLeaves(isect, visSpans);
        if( visSpans.GetCount() )
        {
            plDrawVisList* drawVis = levList.Push();
            drawVis->fDrawable = fDrawPool[idx];
            drawVis->fVisList.Swap(visSpans);
        }
    }
}

void plSceneNode::CollectForRender(plPipeline* pipe, hsTArray<plDrawVisList>& levList, plVisMgr* visMgr)
{
    static hsTArray<Int16> visList;
    visList.SetCount(0);
    pipe->HarvestVisible(GetSpaceTree(), visList);
    static hsTArray<Int16> visSpans;
    visSpans.SetCount(0);

    int i;
    for( i = 0; i < visList.GetCount(); i++ )
    {
        int idx = visList[i];
        if( pipe->PreRender(fDrawPool[idx], visSpans, visMgr) )
        {
            plDrawVisList* drawVis = levList.Push();
            drawVis->fDrawable = fDrawPool[idx];
            drawVis->fVisList.Swap(visSpans);
        }
    }
}

void plSceneNode::SubmitOccluders(plPageTreeMgr* pageMgr) const
{
    pageMgr->AddOccluderList(fOccluders);
}

plSpaceTree* plSceneNode::IBuildSpaceTree()
{
    plSpaceTreeMaker maker;
    maker.Reset();
    
    hsBounds3Ext bnd;
    bnd.Reset(&hsPoint3(0,0,0));
    
    int i;
    for( i = 0; i < fDrawPool.GetCount(); i++ )
    {
        if( fDrawPool[i] )
            maker.AddLeaf(fDrawPool[i]->GetSpaceTree()->GetWorldBounds());
        else
            maker.AddLeaf(bnd, true);
    }

    fSpaceTree = maker.MakeTree();
    fSpaceTree->MakeDirty();

    return fSpaceTree;
}

plSpaceTree* plSceneNode::ITrashSpaceTree()
{
    delete fSpaceTree;
    return fSpaceTree = nil;
}

void plSceneNode::IDirtySpaceTree()
{
    int i;
    for( i = 0; i < fDrawPool.GetCount(); i++ )
    {
        if( fDrawPool[i] && fDrawPool[i]->GetSpaceTree()->IsDirty() )
        {
            fDrawPool[i]->GetSpaceTree()->Refresh();
            fSpaceTree->MoveLeaf(i, fDrawPool[i]->GetSpaceTree()->GetWorldBounds());
        }
    }
}

plSpaceTree* plSceneNode::GetSpaceTree()
{
    if( !fSpaceTree )
    {
        IBuildSpaceTree();
    }
    IDirtySpaceTree();
    return fSpaceTree;
}

void plSceneNode::ISetDrawable(plDrawable* d)
{
    if( !d )
        return;

    if (fDrawPool.Find(d) == fDrawPool.kMissingIndex)
    {
        fDrawPool.Append(d);
    }

    ITrashSpaceTree();
}

void plSceneNode::ISetAudible(plAudible* a)
{
    if( !a )
        return;

    if( fAudioPool.kMissingIndex == fAudioPool.Find(a) )
    {
        fAudioPool.Append(a);
    }
}

void plSceneNode::ISetPhysical(plPhysical* p)
{
    if( !p )
        return;

    if( fSimulationPool.kMissingIndex == fSimulationPool.Find(p) )
    {
        fSimulationPool.Append(p);
    }
}

void plSceneNode::ISetObject(plSceneObject* o)
{
    if( o && (fSceneObjects.kMissingIndex == fSceneObjects.Find(o)) )
    {
        fSceneObjects.Append(o);

    // MF_NET_GROUPS_TEST
    // This will have no effect on members of NetGroupConstants
        o->SetNetGroup(o->SelectNetGroup(GetKey()));

        o->SetSceneNode(GetKey());
    }
}

void plSceneNode::ISetLight(plLightInfo* l)
{
    if( fLightPool.kMissingIndex == fLightPool.Find(l) )
        fLightPool.Append( l );

}

void plSceneNode::ISetOccluder(plOccluder* o)
{
    if( fOccluders.kMissingIndex == fOccluders.Find(o) )
    {
        fOccluders.Append(o);
    }
}

void plSceneNode::ISetGeneric(hsKeyedObject* k)
{
    if( fGenericPool.kMissingIndex == fGenericPool.Find(k) )
        fGenericPool.Append(k);
}

void plSceneNode::IRemoveDrawable(plDrawable* d)
{
    int idx = fDrawPool.Find(d);
    if( idx != fDrawPool.kMissingIndex )
        fDrawPool.Remove(idx);

    ITrashSpaceTree();
}

void plSceneNode::IRemoveAudible(plAudible* a)
{
    int idx = fAudioPool.Find(a);
    if( idx != fAudioPool.kMissingIndex )
        fAudioPool.Remove(idx);

}

void plSceneNode::IRemovePhysical(plPhysical* p)
{
    hsAssert(p, "Removing nil physical");

#ifdef HS_DEBUGGING
    if (p)
    {
        plKey oldNodeKey = p->GetSceneNode();
        if (oldNodeKey && oldNodeKey != GetKey())
        {
            char buf[256];
            sprintf(buf, "Trying to remove physical %s from scenenode %s,\nbut it's actually in %s",
                p->GetKeyName(), GetKeyName(), oldNodeKey->GetName());
            hsAssert(0, buf);
        }
    }
#endif

    int idx = fSimulationPool.Find(p);
    if( idx != fSimulationPool.kMissingIndex )
        fSimulationPool.Remove(idx);
}

void plSceneNode::IRemoveObject(plSceneObject* o)
{
    int idx = fSceneObjects.Find(o);
    if( idx != fSceneObjects.kMissingIndex )
        fSceneObjects.Remove(idx);
}

void plSceneNode::IRemoveLight(plLightInfo* l)
{
    hsAssert(l, "Removing nil light");

    int idx = fLightPool.Find(l);
    if( idx != fLightPool.kMissingIndex )
    {
        fLightPool.Remove(idx);
    }
}

void plSceneNode::IRemoveOccluder(plOccluder* o)
{
    int idx = fOccluders.Find(o);
    if( idx != fOccluders.kMissingIndex )
        fOccluders.Remove(idx);
}

void plSceneNode::IRemoveGeneric(hsKeyedObject* k)
{
    int idx = fGenericPool.Find(k);
    if( idx != fGenericPool.kMissingIndex )
        fGenericPool.Remove(idx);
}

hsBool plSceneNode::IOnRemove(plNodeRefMsg* refMsg)
{

    switch( refMsg->fType )
    {
    case plNodeRefMsg::kDrawable:
        IRemoveDrawable(plDrawable::ConvertNoRef(refMsg->GetRef()));
        break;
    case plNodeRefMsg::kPhysical:
        IRemovePhysical(plPhysical::ConvertNoRef(refMsg->GetRef()));
        break;
    case plNodeRefMsg::kAudible:
        IRemoveAudible(plAudible::ConvertNoRef(refMsg->GetRef()));
        break;
    case plNodeRefMsg::kObject:
        IRemoveObject(plSceneObject::ConvertNoRef(refMsg->GetRef()));
        break;
    case plNodeRefMsg::kLight:
        IRemoveLight(plLightInfo::ConvertNoRef(refMsg->GetRef()));
        break;
    case plNodeRefMsg::kOccluder:
        IRemoveOccluder(plOccluder::ConvertNoRef(refMsg->GetRef()));
        break;
    case plNodeRefMsg::kGeneric:
        IRemoveGeneric(refMsg->GetRef());
        break;
    }
    if( refMsg->GetRef() && (refMsg->GetContext() & plRefMsg::kOnRemove) )
        GetKey()->Release(refMsg->GetRef()->GetKey());
        
    return true;
}

hsBool plSceneNode::IOnAdd(plNodeRefMsg* refMsg)
{
    int which = refMsg->fWhich;

    switch( refMsg->fType )
    {
    case plNodeRefMsg::kDrawable:
        ISetDrawable(plDrawable::ConvertNoRef(refMsg->GetRef()));
        return true;
    case plNodeRefMsg::kPhysical:
        ISetPhysical(plPhysical::ConvertNoRef(refMsg->GetRef()));
        return true;
    case plNodeRefMsg::kAudible:
        ISetAudible(plAudible::ConvertNoRef(refMsg->GetRef()));
        return true;
    case plNodeRefMsg::kObject:
        ISetObject(plSceneObject::ConvertNoRef(refMsg->GetRef()));
        return true;
    case plNodeRefMsg::kLight:
        ISetLight(plLightInfo::ConvertNoRef(refMsg->GetRef()));
        return true;
    case plNodeRefMsg::kOccluder:
        ISetOccluder(plOccluder::ConvertNoRef(refMsg->GetRef()));
        return true;
    case plNodeRefMsg::kGeneric:
        ISetGeneric(refMsg->GetRef());
    }
    return true;
}

hsBool plSceneNode::MsgReceive(plMessage* msg)
{
    plNodeCleanupMsg    *cleanMsg = plNodeCleanupMsg::ConvertNoRef( msg );

    if( cleanMsg )
    {
        ICleanUp();
        return true;
    }

    plNodeRefMsg* refMsg = plNodeRefMsg::ConvertNoRef(msg);
    
    if( refMsg )
    {
        if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
            return IOnAdd(refMsg);
        else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
            return IOnRemove(refMsg);

    }

    return hsKeyedObject::MsgReceive(msg);
}

//// ICleanUp ////////////////////////////////////////////////////////////////
//  Export only: Clean up the scene node (i.e. make sure drawables optimize)

void    plSceneNode::ICleanUp( void )
{
    int     i;


    /// Go find drawables to delete
    for( i = 0; i < fDrawPool.GetCount(); i++ )
        fDrawPool[ i ]->Optimize();

    if (fFilterGenerics)
    {
        for( i = fSceneObjects.GetCount() - 1; i >= 0; i--)
            GetKey()->Release(fSceneObjects[i]->GetKey());
        for( i = fDrawPool.GetCount() - 1; i >= 0; i--)
            GetKey()->Release(fDrawPool[i]->GetKey());
        for( i = fSimulationPool.GetCount() - 1; i >= 0; i--)
            GetKey()->Release(fSimulationPool[i]->GetKey());
        for( i = fAudioPool.GetCount() - 1; i >= 0; i--)
            GetKey()->Release(fAudioPool[i]->GetKey());
        for( i = fOccluders.GetCount() - 1; i >= 0; i--)
            GetKey()->Release(fOccluders[i]->GetKey());
        for( i = fLightPool.GetCount() - 1; i >= 0; i--)
            GetKey()->Release(fLightPool[i]->GetKey());
    }

    ITrashSpaceTree();
}

//// GetMatchingDrawable /////////////////////////////////////////////////////
//  Export only: Query for a given drawable.

plDrawable  *plSceneNode::GetMatchingDrawable( const plDrawableCriteria& crit )
{
    int     i;


    for( i = 0; i < fDrawPool.GetCount(); i++ )
    {
        if( fDrawPool[ i ]->DoIMatch( crit ) )
            return fDrawPool[ i ];
    }

    return nil;
}

//// OptimizeDrawables ///////////////////////////////////////////////////////
//  Loops through all the drawables and calls Optimize on each one. For the
//  export side, to be called right before writing the drawables to disk.

void    plSceneNode::OptimizeDrawables( void )
{
    int     i;


    for( i = 0; i < fDrawPool.GetCount(); i++ )
        fDrawPool[ i ]->Optimize();
}