CWE-ou-minkata/Sources/Plasma/PubUtilLib/plScene/plPageTreeMgr.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 "plPageTreeMgr.h"
#include "plDrawable/plSpaceTreeMaker.h"
#include "plDrawable/plSpaceTree.h"
#include "plDrawable.h"
#include "plScene/plSceneNode.h"
#include "plPipeline.h"
#include "plMath/hsRadixSort.h"
#include "plCullPoly.h"
#include "plOccluder.h"
#include "hsFastMath.h"
#include "plProfile.h"
#include "plVisMgr.h"

#include "plTweak.h"

static hsTArray<hsRadixSortElem> scratchList;

hsBool plPageTreeMgr::fDisableVisMgr = 0;

plProfile_CreateTimer("Object Sort", "Draw", DrawObjSort);
plProfile_CreateCounter("Objects Sorted", "Draw", DrawObjSorted);
plProfile_CreateTimer("Occluder Sort", "Draw", DrawOccSort);
plProfile_CreateCounter("Occluders Used", "Draw", DrawOccUsed);
plProfile_CreateTimer("Occluder Build", "Draw", DrawOccBuild);
plProfile_CreateCounter("Occluder Polys Processed", "Draw", DrawOccPolyProc);
plProfile_CreateTimer("Occluder Poly Sort", "Draw", DrawOccPolySort);

plPageTreeMgr::plPageTreeMgr()
:   fSpaceTree(nil)
{
    fVisMgr = plGlobalVisMgr::Instance();
}

plPageTreeMgr::~plPageTreeMgr()
{
    delete fSpaceTree;
}

void plPageTreeMgr::AddNode(plSceneNode* node)
{
    ITrashSpaceTree();

    node->Init();

    fNodes.Append(node);
}

void plPageTreeMgr::RemoveNode(plSceneNode* node)
{
    ITrashSpaceTree();

    int idx = fNodes.Find(node);
    if( idx != fNodes.kMissingIndex )
        fNodes.Remove(idx);
}

void plPageTreeMgr::Reset()
{
    fNodes.Reset();

    ITrashSpaceTree();
}

void plPageTreeMgr::ITrashSpaceTree()
{
    delete fSpaceTree;
    fSpaceTree = nil;
}

hsBool plPageTreeMgr::Harvest(plVolumeIsect* isect, hsTArray<plDrawVisList>& levList)
{
    levList.SetCount(0);
    if( !(GetSpaceTree() || IBuildSpaceTree()) )
        return false;

    static hsTArray<Int16> list;

    GetSpaceTree()->HarvestLeaves(isect, list);

    int i;
    for( i = 0; i < list.GetCount(); i++ )
    {
        fNodes[list[i]]->Harvest(isect, levList);
    }

    return levList.GetCount() > 0;
}

#include "plProfile.h"
plProfile_CreateTimer("DrawableTime", "Draw", DrawableTime);
plProfile_Extern(RenderScene);

int plPageTreeMgr::Render(plPipeline* pipe)
{
    // If we don't have a space tree and can't make one, just bail
    if( !(GetSpaceTree() || IBuildSpaceTree()) )
        return 0;

    static hsTArray<Int16> list;
    list.SetCount(0);

    plProfile_BeginTiming(RenderScene);

    plVisMgr* visMgr = fDisableVisMgr ? nil : fVisMgr;

    if( visMgr )
    {
        plProfile_Extern(VisEval);
        plProfile_BeginTiming(VisEval);
        visMgr->Eval(pipe->GetViewPositionWorld());
        plProfile_EndTiming(VisEval);
    }

    pipe->BeginVisMgr(visMgr);

    IRefreshTree(pipe);

    IGetOcclusion(pipe, list);
    pipe->HarvestVisible(GetSpaceTree(), list);

    static hsTArray<plDrawVisList> levList;
    levList.SetCount(0);
    int i;
    for( i = 0; i < list.GetCount(); i++ )
    {
        fNodes[list[i]]->CollectForRender(pipe, levList, visMgr);
    }
    
    int numDrawn = IRenderVisList(pipe, levList);

    IResetOcclusion(pipe);

    pipe->EndVisMgr(visMgr);

    plProfile_EndTiming(RenderScene);

    return numDrawn;

}

int plPageTreeMgr::IRenderVisList(plPipeline* pipe, hsTArray<plDrawVisList>& levList)
{
    // Sort levList into sortedDrawList, which is just a list
    // of drawable/visList pairs in ascending render priority order.
    // visLists are just lists of span indices, but only of the
    // spans which are visible (on screen and non-occluded and non-disabled).
    static hsTArray<plDrawVisList> sortedDrawList;
    if( !ISortByLevel(pipe, levList, sortedDrawList) )
    {
        return 0;
    }

    int numDrawn = 0;

    plVisMgr* visMgr = fDisableVisMgr ? nil : fVisMgr;

    // Going through the list in order, if we hit a drawable which doesn't need
    // its spans sorted, we can just draw it.
    // If we hit a drawable which does need its spans sorted, we could just draw
    // it, but that precludes sorting spans between drawables (like the player avatar
    // sorting with normal scene objects). So when we hit a drawable which needs
    // span sorting, we sort its spans with the spans of the next N drawables in
    // the sorted list which have the same render priority and which also want their
    // spans sorted.
    int i;
    for( i = 0; i < sortedDrawList.GetCount(); i++ )
    {
        plDrawable* p = sortedDrawList[i].fDrawable;


        plProfile_BeginLap(DrawableTime, p->GetKey()->GetUoid().GetObjectName());
    
        if( sortedDrawList[i].fDrawable->GetNativeProperty(plDrawable::kPropSortSpans) )
        {
            // IPrepForRenderSortingSpans increments "i" to the next index to be drawn (-1 so the i++
            // at the top of the loop is correct.
            numDrawn += IPrepForRenderSortingSpans(pipe, sortedDrawList, i);
        }
        else
        {
            pipe->PrepForRender(sortedDrawList[i].fDrawable, sortedDrawList[i].fVisList, visMgr);

            pipe->Render(sortedDrawList[i].fDrawable, sortedDrawList[i].fVisList);

            numDrawn += sortedDrawList[i].fVisList.GetCount();

        }

        plProfile_EndLap(DrawableTime, p->GetKey()->GetUoid().GetObjectName());
    }

    return numDrawn;
}

hsBool plPageTreeMgr::ISortByLevel(plPipeline* pipe, hsTArray<plDrawVisList>& drawList, hsTArray<plDrawVisList>& sortedDrawList)
{
    sortedDrawList.SetCount(0);

    if( !drawList.GetCount() )
        return false;

    scratchList.SetCount(drawList.GetCount());

    hsRadixSort::Elem* listTrav = nil;
    int i;
    for( i = 0; i < drawList.GetCount(); i++ )
    {
        listTrav = &scratchList[i];
        listTrav->fBody = (void*)&drawList[i];
        listTrav->fNext = listTrav+1;
        listTrav->fKey.fULong = drawList[i].fDrawable->GetRenderLevel().Level();
    }
    listTrav->fNext = nil;

    hsRadixSort rad;
    hsRadixSort::Elem* sortedList = rad.Sort(scratchList.AcquireArray(), hsRadixSort::kUnsigned);

    listTrav = sortedList;

    while( listTrav )
    {
        plDrawVisList& drawVis = *(plDrawVisList*)listTrav->fBody;
        sortedDrawList.Append(drawVis);
        
        listTrav = listTrav->fNext;
    }

    return true;
}

// Render from iDrawStart in drawVis list all drawables with the sort by spans property, well, sorting
// by spans.
// Returns the index of the last one drawn.
int plPageTreeMgr::IPrepForRenderSortingSpans(plPipeline* pipe, hsTArray<plDrawVisList>& drawVis, int& iDrawStart)
{
    UInt32 renderLevel = drawVis[iDrawStart].fDrawable->GetRenderLevel().Level();

    int i;

    static hsTArray<plDrawVisList*> drawables;
    static hsTArray<plDrawSpanPair> pairs;

    // Given the input drawVisList (list of drawable/visList pairs), we make two new
    // lists. The list "drawables" is just the excerpted sub-list from drawVis starting
    // from the input index and going through all compatible drawables (drawables which
    // are appropriate to sort (and hence intermix) with the first drawable in the list.
    // The second list is the drawableIndex/spanIndex pairs convenient for sorting (where
    // drawIndex indexes into drawables and spanIndex indexes into drawVis[iDraw].fVisList.
    // So pairs[i] resolves into 
    // drawables[pairs[i].fDrawable].fDrawable->GetSpan(pairs[i].fSpan)

    drawables.Append(&drawVis[iDrawStart]);
    for( i = 0; i < drawVis[iDrawStart].fVisList.GetCount(); i++ )
    {
        plDrawSpanPair* pair = pairs.Push();
        pair->fDrawable = 0;
        pair->fSpan = drawVis[iDrawStart].fVisList[i];
    }

    int iDraw;
    for( iDraw = iDrawStart+1; 
        (iDraw < drawVis.GetCount())
        && (drawVis[iDraw].fDrawable->GetRenderLevel().Level() == renderLevel)
        && drawVis[iDraw].fDrawable->GetNativeProperty(plDrawable::kPropSortSpans);
        iDraw++ )
    {
        plDrawable* drawable = drawVis[iDraw].fDrawable;
        hsTArray<Int16>& visList = drawVis[iDraw].fVisList;
        for( i = 0; i < visList.GetCount(); i++ )
        {
            plDrawSpanPair* pair = pairs.Push();
            pair->fDrawable = drawables.GetCount();
            pair->fSpan = visList[i];
        }
        drawables.Append(&drawVis[iDraw]);
    }

    // Now that we have them in a more convenient format, sort them and render.
    IRenderSortingSpans(pipe, drawables, pairs);

    int numDrawn = pairs.GetCount();

    drawables.SetCount(0);
    pairs.SetCount(0);

    iDrawStart = iDraw - 1;

    return numDrawn;
}

hsBool plPageTreeMgr::IRenderSortingSpans(plPipeline* pipe, hsTArray<plDrawVisList*>& drawList, hsTArray<plDrawSpanPair>& pairs)
{

    if( !pairs.GetCount() )
        return false;

    hsPoint3 viewPos = pipe->GetViewPositionWorld();

    plProfile_BeginTiming(DrawObjSort);
    plProfile_IncCount(DrawObjSorted, pairs.GetCount());

    hsRadixSort::Elem* listTrav;
    scratchList.SetCount(pairs.GetCount());

    // First, sort on distance to the camera (squared).
    listTrav = nil;
    int iSort = 0;
    int i;
    for( i = 0; i < pairs.GetCount(); i++ )
    {
        plDrawable* drawable = drawList[pairs[i].fDrawable]->fDrawable;

        listTrav = &scratchList[iSort++];
        listTrav->fBody = (void*)*(UInt32*)&pairs[i];
        listTrav->fNext = listTrav + 1;

        if( drawable->GetNativeProperty(plDrawable::kPropSortAsOne) )
        {
            const hsBounds3Ext& bnd = drawable->GetSpaceTree()->GetNode(drawable->GetSpaceTree()->GetRoot()).fWorldBounds;
            plConst(hsScalar) kDistFudge(1.e-1f);
            listTrav->fKey.fFloat = -(bnd.GetCenter() - viewPos).MagnitudeSquared() + hsScalar(pairs[i].fSpan) * kDistFudge;
        }
        else
        {
            const hsBounds3Ext& bnd = drawable->GetSpaceTree()->GetNode(pairs[i].fSpan).fWorldBounds;
            listTrav->fKey.fFloat = -(bnd.GetCenter() - viewPos).MagnitudeSquared();
        }
    }
    if( !listTrav )
    {
        plProfile_EndTiming(DrawObjSort);
        return false;
    }
    listTrav->fNext = nil;

    hsRadixSort rad;
    hsRadixSort::Elem* sortedList = rad.Sort(scratchList.AcquireArray(), 0);

    plProfile_EndTiming(DrawObjSort);

    static hsTArray<Int16> visList;
    visList.SetCount(0);

    plVisMgr* visMgr = fDisableVisMgr ? nil : fVisMgr;

    // Call PrepForRender on each of these bad boys. We only want to call
    // PrepForRender once on each drawable, no matter how many times we're
    // going to pass it off to be rendered (like if we render span 0 from
    // drawable A, span 1 from drawable A, span 0 from drawable B, span 1 from Drawable A, we
    // don't want to PrepForRender twice or three times on drawable A).
    // So we're going to convert our sorted list back into a list of drawable/visList
    // pairs. We could have done this with our original drawable/visList, but we've
    // hopefully trimmed out some spans because of the fades. This drawable/visList
    // isn't appropriate for rendering (because it doesn't let us switch back and forth 
    // from a drawable, but it's right for the PrepForRenderCall (which does things like
    // face sorting).
    for( i = 0; i < drawList.GetCount(); i++ )
        drawList[i]->fVisList.SetCount(0);
    listTrav = sortedList;
    while( listTrav )
    {
        plDrawSpanPair& curPair = *(plDrawSpanPair*)&listTrav->fBody;
        drawList[curPair.fDrawable]->fVisList.Append(curPair.fSpan);
        listTrav = listTrav->fNext;
    }
    for( i = 0; i < drawList.GetCount(); i++ )
    {
        pipe->PrepForRender(drawList[i]->fDrawable, drawList[i]->fVisList, visMgr);
    }

    // We'd like to call Render once on a drawable for each contiguous
    // set of spans (so we want to render span 0 and span 1 on a single Render
    // of drawable A in the above, then render drawable B, then back to A).
    // So we go through the sorted drawable/spanIndex pairs list, building
    // a visList for as long as the drawable remains the same. When it
    // changes, we render what we have so far, and start again with the
    // next drawable. Repeat until done.

#if 0
    listTrav = sortedList;
    plDrawSpanPair& curPair = *(plDrawSpanPair*)&listTrav->fBody;
    int curDraw = curPair.fDrawable;
    visList.Append(curPair.fSpan);
    listTrav = listTrav->fNext;

    while( listTrav )
    {
        curPair = *(plDrawSpanPair*)&listTrav->fBody;
        if( curPair.fDrawable != curDraw )
        {
            pipe->Render(drawList[curDraw]->fDrawable, visList);
            curDraw = curPair.fDrawable;
            visList.SetCount(0);
            visList.Append(curPair.fSpan);
        }
        else
        {
            visList.Append(curPair.fSpan);
        }
        listTrav = listTrav->fNext;
    }
    pipe->Render(drawList[curDraw]->fDrawable, visList);
#else
    listTrav = sortedList;
    plDrawSpanPair& curPair = *(plDrawSpanPair*)&listTrav->fBody;
    int curDraw = curPair.fDrawable;
    listTrav = listTrav->fNext;

    static hsTArray<UInt32> numDrawn;
    numDrawn.SetCountAndZero(drawList.GetCount());

    visList.Append(drawList[curDraw]->fVisList[numDrawn[curDraw]++]);

    while( listTrav )
    {
        curPair = *(plDrawSpanPair*)&listTrav->fBody;
        if( curPair.fDrawable != curDraw )
        {
            pipe->Render(drawList[curDraw]->fDrawable, visList);
            curDraw = curPair.fDrawable;
            visList.SetCount(0);
        }
        visList.Append(drawList[curDraw]->fVisList[numDrawn[curDraw]++]);
        listTrav = listTrav->fNext;
    }
    pipe->Render(drawList[curDraw]->fDrawable, visList);
#endif

    return true;
}

hsBool plPageTreeMgr::IBuildSpaceTree()
{
    if( !fNodes.GetCount() )
        return false;

    plSpaceTreeMaker maker;
    maker.Reset();
    int i;
    for( i = 0; i < fNodes.GetCount(); i++ )
    {
        maker.AddLeaf(fNodes[i]->GetSpaceTree()->GetWorldBounds(), fNodes[i]->GetSpaceTree()->IsEmpty());
    }
    fSpaceTree = maker.MakeTree();

    return true;
}

hsBool plPageTreeMgr::IRefreshTree(plPipeline* pipe)
{
    int i;
    for( i = 0; i < fNodes.GetCount(); i++ )
    {
        if( fNodes[i]->GetSpaceTree()->IsDirty() )
        {
            fNodes[i]->GetSpaceTree()->Refresh();
    
            GetSpaceTree()->MoveLeaf(i, fNodes[i]->GetSpaceTree()->GetWorldBounds());

            if( !fNodes[i]->GetSpaceTree()->IsEmpty() && fSpaceTree->HasLeafFlag(i, plSpaceTreeNode::kDisabled) )
                fSpaceTree->SetLeafFlag(i, plSpaceTreeNode::kDisabled, false);
        
        }
    }

    GetSpaceTree()->SetViewPos(pipe->GetViewPositionWorld());

    GetSpaceTree()->Refresh();

    return true;
}

void plPageTreeMgr::AddOccluderList(const hsTArray<plOccluder*> occList)
{
    int iStart = fOccluders.GetCount();
    fOccluders.Expand(iStart + occList.GetCount());
    fOccluders.SetCount(iStart + occList.GetCount());

    plVisMgr* visMgr = fDisableVisMgr ? nil : fVisMgr;

    if( visMgr )
    {
        const hsBitVector& visSet = visMgr->GetVisSet();
        const hsBitVector& visNot = visMgr->GetVisNot();
        int i;
        for( i = 0; i < occList.GetCount(); i++ )
        {
            if( occList[i] && !occList[i]->InVisNot(visNot) && occList[i]->InVisSet(visSet) )
                fOccluders[iStart++] = occList[i];
        }
    }
    else
    {
        int i;
        for( i = 0; i < occList.GetCount(); i++ )
        {
            if( occList[i] )
                fOccluders[iStart++] = occList[i];
        }
    }
    fOccluders.SetCount(iStart);

}

void plPageTreeMgr::IAddCullPolyList(const hsTArray<plCullPoly>& polyList)
{
    int iStart = fCullPolys.GetCount();
    fCullPolys.Expand(iStart + polyList.GetCount());
    fCullPolys.SetCount(iStart + polyList.GetCount());
    int i;
    for( i = 0; i < polyList.GetCount(); i++ )
    {
        fCullPolys[i + iStart] = &polyList[i];
    }
}

void plPageTreeMgr::ISortCullPolys(plPipeline* pipe)
{
    fSortedCullPolys.SetCount(0);
    if( !fCullPolys.GetCount() )
        return;

    const int kMaxCullPolys = 300;
    int numSubmit = 0;

    hsPoint3 viewPos = pipe->GetViewPositionWorld();

    hsRadixSort::Elem* listTrav;
    scratchList.SetCount(fCullPolys.GetCount());
    int i;
    for( i = 0; i < fCullPolys.GetCount(); i++ )
    {
        hsBool backFace = fCullPolys[i]->fNorm.InnerProduct(viewPos) + fCullPolys[i]->fDist <= 0;
        if( backFace )
        {
            if( !fCullPolys[i]->IsHole() && !fCullPolys[i]->IsTwoSided() )
                continue;
        }
        else
        {
            if( fCullPolys[i]->IsHole() )
                continue;
        }

        listTrav = &scratchList[numSubmit];
        listTrav->fBody = (void*)fCullPolys[i];
        listTrav->fNext = listTrav + 1;
        listTrav->fKey.fFloat = (fCullPolys[i]->GetCenter() - viewPos).MagnitudeSquared();

        numSubmit++;
    }
    if( !numSubmit )
        return;

    listTrav->fNext = nil;

    hsRadixSort rad;
    hsRadixSort::Elem* sortedList = rad.Sort(scratchList.AcquireArray(), 0);
    listTrav = sortedList;

    if( numSubmit > kMaxCullPolys )
        numSubmit = kMaxCullPolys;

    fSortedCullPolys.SetCount(numSubmit);

    for( i = 0; i < numSubmit; i++ )
    {
        fSortedCullPolys[i] = (const plCullPoly*)listTrav->fBody;
        listTrav = listTrav->fNext;
    }
}

hsBool plPageTreeMgr::IGetCullPolys(plPipeline* pipe)
{
    if( !fOccluders.GetCount() )
        return false;

    plProfile_BeginTiming(DrawOccSort);

    hsRadixSort::Elem* listTrav = nil;
    scratchList.SetCount(fOccluders.GetCount());

    hsPoint3 viewPos = pipe->GetViewPositionWorld();

    // cull test the occluders submitted
    int numSubmit = 0;
    int i;
    for( i = 0; i < fOccluders.GetCount(); i++ )
    {
        if( pipe->TestVisibleWorld(fOccluders[i]->GetWorldBounds()) )
        {
            hsScalar invDist = -hsFastMath::InvSqrtAppr((viewPos - fOccluders[i]->GetWorldBounds().GetCenter()).MagnitudeSquared());
            listTrav = &scratchList[numSubmit++];
            listTrav->fBody = (void*)fOccluders[i];
            listTrav->fNext = listTrav+1;
            listTrav->fKey.fFloat = fOccluders[i]->GetPriority() * invDist;
        }
    }
    if( !listTrav )
    {
        plProfile_EndTiming(DrawOccSort);
        return false;
    }

    listTrav->fNext = nil;


    // Sort the occluders by priority
    hsRadixSort rad;
    hsRadixSort::Elem* sortedList = rad.Sort(scratchList.AcquireArray(), 0);
    listTrav = sortedList;

    const UInt32 kMaxOccluders = 1000;
    if( numSubmit > kMaxOccluders )
        numSubmit = kMaxOccluders;

    plProfile_IncCount(DrawOccUsed, numSubmit);

    // Take the polys from the first N of them
    for( i = 0; i < numSubmit; i++ )
    {
        plOccluder* occ = (plOccluder*)listTrav->fBody;
        IAddCullPolyList(occ->GetWorldPolyList());
        
        listTrav = listTrav->fNext;
    }

    plProfile_EndTiming(DrawOccSort);

    return fCullPolys.GetCount() > 0;
}

hsBool plPageTreeMgr::IGetOcclusion(plPipeline* pipe, hsTArray<Int16>& list)
{
    plProfile_BeginTiming(DrawOccBuild);

    fCullPolys.SetCount(0);
    fOccluders.SetCount(0);
    int i;
    for( i = 0; i < fNodes.GetCount(); i++ )
    {
        fNodes[i]->SubmitOccluders(this);
    }

    if( !IGetCullPolys(pipe) )
    {
        plProfile_EndTiming(DrawOccBuild);
        return false;
    }

    plProfile_IncCount(DrawOccPolyProc, fCullPolys.GetCount());

    plProfile_BeginTiming(DrawOccPolySort);
    ISortCullPolys(pipe);
    plProfile_EndTiming(DrawOccPolySort);

    if( fSortedCullPolys.GetCount() )
        pipe->SubmitOccluders(fSortedCullPolys);

    plProfile_EndTiming(DrawOccBuild);

    return fSortedCullPolys.GetCount() > 0;
}

void plPageTreeMgr::IResetOcclusion(plPipeline* pipe)
{
    fCullPolys.SetCount(0);
    fSortedCullPolys.SetCount(0);
}