CWE-ou-minkata/Sources/Plasma/PubUtilLib/plScene/plOccTree.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==*/


void plOccTree::AddPoly(plPolygon* poly)
{
    fBasePolys.Append(*poly);
}

void plOccTree::MakeOccTree()
{
    if( !fBasePolys.GetCount() )
        return;

    ISortBasePolys();

    int i;
    for( i = 0; i < fBasePolys.GetCount(); i++ )
        fRoot = IAddPolyRecur(fRoot, fBasePolys[i], false);

    fBasePolys.SetCount(0);
}

plOccNode* poOccTree::IMakeSubTree(plOccPoly* poly)
{
    plOccNode* nextNode = nil;
    plOccNode* lastNode = nil;

    int i;
    for( i = 0; i < poly->fVerts.GetCount(); i++ )
    {
        if( poly->fEdgeFlags[i] & plOccPoly::kEdgeClipped )
            continue;

        nextNode = fNodePool.Append();
        nextNode->fFlags = 0;
        nextNode->fOutChild = nil;

        int j = i+1 < poly->fVerts.GetCount() ? i+1 : 0;

        // Need to set the viewplane here. Calc once per base poly and use
        // that for fragments?
        nextNode->Init(poly->fVerts[i], poly->fVerts[j], fViewPos);

        if( nextNode->fInChild = lastChild )
            nextNode->fFlags = plOccNode::kHasInChild;
        else
        {
            nextNode->fInChild = fNodePool.Append();
            nextNode->fInChild->Init(poly, false);
        }

        lastNode = nextNode;
    }

    // If we have no nextNode, all our edges were clipped. In
    // that case, we'll just return an "out" leaf.
    if( !nextNode )
    {
        nextNode = fNodePool.Append();
        nextNode->fFlags = 0;
        nextNode->fInChild = nextNode->fOutChild = nil;
        nextNode->Init(poly, true);
    }

    return nextNode;
}

void plOccNode::Init(const hsPoint3& p0, const hsPoint3& p1, const hsPoint3& pv)
{
    hsVector3 v0, v1;
    v0.Set(&p0, &pv);
    v1.Set(&p1, &pv);

    fPlane.fNormal = v0 % v1;
    fPlane.fDist = fPlane.fNormal.InnerProduct(v0);
}

void plOccNode::Init(plOccPoly* poly)
{
    fPlane = poly->fPlane;
    // set the viewplane
    fFlags = kIsLeaf;
}

// Adding a poly to a node
//      if the node is nil
//          IMakeSubTree(poly) replaces the node
//      else
//      if the node is a leaf
//          pitch the poly
//          return node (no replacement)
//      else
//      if poly is inside the node
//          recur on node's inner child
//          return node (no replacement)
//      else
//      if poly is ouside the node
//          recur on node's outer child
//          return node (no replacement)
//      else (node splits poly)
//          recur on node's inner child
//          recur on node's outer child
//          return node (no replacement)
//      end
//
//      Special case - Degenarate poly's can come
//      from ITestPoly if an edge of the input poly
//      is on the plane. In that case, the function
//      will return kSplit, but either inPoly or outPoly
//      will have no vertices. That degenerate poly,
//      when added to a node, should just be pitched.
//  




// Returns new root, in case it changed.
// This assumes polys are being added front to back.
// This function will break the poly into fragments that fit in the
// current planes within the tree. Planes are added when a final fragment
// is added (in IMakeSubTree).
// We count on ITestPoly to properly mark edges which were created by
// clipping, as those won't generate leaf nodes.
plOccNode* plOccTree::IAddPolyRecur(plOccNode* node, plOccPoly* poly)
{
    if( !poly->fVerts.GetCount() )
        return node;

    if( !node )
    {
        return IMakeSubTree(poly);
    }

    plOccPoly* inPoly = nil;
    plOccPoly* outPoly = nil;


    UInt32 test = ITestPoly(node->fPlane, poly, inPoly, outPoly);

    switch( test )
    {
    case kAllIn:
        node->fInChild = IAddPolyRecur(node->fInChild, poly);
        break;
    case kAllOut:
        node->fOutChild = IAddPolyRecur(node->fOutChild, poly);
        break;
    case kSplit:
        node->fInChild = IAddPolyRecur(node->fInChild, inPoly);
        node->fOutChild = IAddPolyRecur(node->fOutChild, outPoly);
        break;
    };

    return node;
}

hsBool plOccTree::BoundsVisible(const hsBounds3Ext& bnd) const
{
    if( !fRoot )
        return true;

    return fRoot->IBoundsVisible(bnd);
}


hsBool plOccNode::IInChildBoundsVisible(const hsBounds3Ext& bnd) const
{
    return fInChild
            ? fInChild->IBoundsVisible(bnd)
            : false;
}

hsBool plOccNode::IOutChildBoundsVisible(const hsBounds3Ext& bnd) const
{
    return fOutChild
            ? fOutChild->IBoundsVisible(bnd)
            : true;
}

hsBool plOccNode::IBoundsVisible(const hsBounds3Ext& bnd) const
{
    hsPoint2 depth;
    bnd.TestPlane(fPlane.fNormal, depth);
    if( depth.fX > fPlane.fDist )
    {
        return IOutChildVisible(bnd);
    }
    else if( depth.fY < fPlane.fDist )
    {
        return IInChildVisible(bnd);
    }

    // here's where it gets wierd. we pass the bounds in
    // both directions. if either says it's visible, it's visible.
    // doesn't seem like it would work, but you never know.
    return IOutChildVisible(bnd) || IInChildVisible(bnd);
}