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

#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                */
/****************************************************************/

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

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) 
{
}

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;

                BSPNode *node = SubdivideNode(dynamic_cast<BSPLeaf *>(data.mNode),
                                                                          data.mParent,
                                                                          &data.mViewCell,
                                                                      data.mDepth,
                                                                          backPolys,
                                                                          frontPolys);
        
                if (!node->IsLeaf())
                {
                        BSPInterior *interior = dynamic_cast<BSPInterior *>(node);

                        // push the children on the stack
                        if (interior->GetBack())
                                tStack.push(BSPTraversalData(interior->GetBack(), interior, backPolys, data.mDepth+1));
                        if (interior->GetFront())
                                tStack.push(BSPTraversalData(interior->GetFront(), interior, frontPolys, data.mDepth+1));
                }
        }
}

Plane3 *BSPTree::SelectPlane(Mesh *viewcell)
{
        return &viewcell->GetFacePlane(0);
}

BSPNode *BSPTree::SubdivideNode(BSPLeaf *leaf, BSPInterior *parent, 
                                                                Mesh *viewCell, const int depth, 
                                                                Mesh &frontPolys, Mesh &backPolys)
{
static int sMaxDepth = 5; // HACK
        // terminate traversal if no more faces in mesh
        if ((viewCell->mFaces.size() == 0) && depth > sMaxDepth)
                return leaf;
 
        // add the new nodes to the tree + select subdivision plane
        Plane3 *plane = SelectPlane(viewCell);
        BSPInterior *node = new BSPInterior(*plane); // ERROR!!
  

        FaceContainer::const_iterator fi;

        for ( fi = viewCell->mFaces.begin(); fi != viewCell->mFaces.end(); ++ fi)
        {
        }
  
        BSPLeaf *back = new BSPLeaf(mRootCell);
        BSPLeaf *front = new BSPLeaf(mRootCell);

        // 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