source: trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp @ 222

#include "Plane3.h"
#include "ViewCellBsp.h"
#include "Mesh.h"

#include "ViewCell.h"
#include <stack>

//namespace GtpVisibilityPreprocessor {
/****************************************************************/
/*                  class BspNode implementation                */
/****************************************************************/
bool BspNode::IsRoot() const 
{
        return mParent == NULL;
}

/****************************************************************/
/*              class BspInterior implementation                */
/****************************************************************/


BspInterior::BspInterior(Plane3 plane): mPlane(plane) 
{}

bool BspInterior::IsLeaf() const
{ 
        return false; 
}

BspNode *BspInterior::GetBack() 
{
        return mBack;
}

BspNode *BspInterior::GetFront() 
{
        return mFront;
}

Plane3 *BspInterior::GetPlane()
{
        return &mPlane;
}

void BspInterior::ReplaceChildLink(BspNode *oldChild, BspNode *newChild) 
{
        if (mBack == oldChild)
        {
                mBack = newChild;
        }
    else
        {
                mFront = newChild;
        }
}

void BspInterior::SetupChildLinks(BspNode *b, BspNode *f) 
{
    mBack = b;
    mFront = f;
}


/****************************************************************/
/*                  class BspLeaf implementation                */
/****************************************************************/

BspLeaf::BspLeaf(ViewCell *viewCell): mViewCell(viewCell) 
{
}

ViewCell *BspLeaf::GetViewCell()
{
        return mViewCell;
}

bool BspLeaf::IsLeaf() const 
{ 
        return true; 
}

/****************************************************************/
/*                  class BspTree implementation                */
/****************************************************************/

BspTree::BspTree(ViewCell *cell) 
{
        mRootCell = cell;
        mRoot = new BspLeaf(mRootCell);
}

  
void BspTree::Subdivide()
{
        BspNode *currentNode = mRoot;
  
        std::stack<BspTraversalData> tStack;
        //  stack<STraversalData> tStack;

        //tStack.push(tdata);

        while (!tStack.empty()) 
        {
            BspTraversalData data = tStack.top();
            tStack.pop();
    
                Mesh backPolys;
                Mesh frontPolys;

                if (data.mNode->IsLeaf()) // if we have a leaf => subdivide
                {
                        BspNode *node = SubdivideNode(dynamic_cast<BspLeaf *>(data.mNode),
                                                                                  data.mParent,
                                                                                  &data.mViewCell,
                                                                              data.mDepth,
                                                                                  backPolys,
                                                                                  frontPolys);
        
                        if (!node->IsLeaf()) // node was subdivided
                        {
                                BspInterior *interior = dynamic_cast<BspInterior *>(node);

                                // push the children on the stack (there are always two children)
                                tStack.push(BspTraversalData(interior->GetBack(), interior, backPolys, data.mDepth + 1));
                                tStack.push(BspTraversalData(interior->GetFront(), interior, frontPolys, data.mDepth + 1));
                        }
                }
        }
}

Plane3 BspTree::SelectPlane(Mesh *polys)
{
        // TODO: more sophisticated criteria
        return polys->GetFacePlane(0);
}

BspNode *BspTree::SubdivideNode(BspLeaf *leaf, BspInterior *parent, 
                                                                Mesh *viewCell, const int depth, 
                                                                Mesh &frontPolys, Mesh &backPolys)
{
        ViewCell *viewCell = leaf->GetViewCell();

        // terminate traversal if no more faces in mesh or outside
        if (!viewCell || (viewCell->mFaces.size() == 0))
        {
                return leaf;
        }
        // add the new nodes to the tree + select subdivision plane
        BspInterior *node = new BspInterior(SelectPlane(viewCell)); 

        FaceContainer::const_iterator fi;

        for (fi = viewCell->mFaces.begin(); fi != viewCell->mFaces.end(); ++ fi)
        {
                int  result = node->GetPlane()->Side();
                Mesh *front_piece, *back_piece;

                switch (result)
                {
                        case 1:
                                frontPolys.AddFace(poly);
                                break;
                        case -1:
                                backPolys.AddFace(poly);
                                break;
                        case 0:
                                //Split_Polygon (poly, tree->partition, front_piece, back_piece);
                                backPolys.AddFace(back_piece);
                                frontPolys.AddFace(front_piece);
                                break;
                        default;
                                brak;
                }
        }
        // backside of convex view cell polygon => outside
        BspLeaf *back = new BspLeaf(NULL);
        BspLeaf *front = new BspLeaf(viewCell);

        // replace a link from node's parent
        if (parent)
        {
                parent->ReplaceChildLink(leaf, node);
        }

        // and setup child links
        node->SetupChildLinks(back, front);
  
        delete leaf;
        return node;
}

//} // GtpVisibilityPreprocessor