source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOctreeHierarchyInterface.cpp @ 2455

#include "OgreOctreeHierarchyInterface.h"
#include <OgreOctree.h>
#include <OgreLogManager.h>
#include <OgreStringConverter.h>
#include <OgreOctreeNode.h>


namespace Ogre {

//-----------------------------------------------------------------------
OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, 
                                                                                                   RenderSystem *rsys): 
SceneNodeHierarchyInterface(sm, rsys)
{}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node)
{
        ++ mNumTraversedNodes;

        Octree *octree = static_cast<Octree *>(node);

        // if we come across some renderable geometry => render it
        if (!octree->mNodes.empty())
        {
                RenderNode(node);
        }
        
        
        // if not all subtrees are empty
        if (!IsLeaf(node))
        {
                Octree *nextChild;

                for (int z = 0; z < 2; ++ z)
                {       
                        for (int y = 0; y < 2; ++ y)
                        {
                                for (int x = 0; x < 2; ++ x)
                                {
                                        nextChild = octree->mChildren[x][y][z];
        
                                        if (nextChild)
                        GetQueue()->push(nextChild);
                                }
            }
        }
        }
}
//-----------------------------------------------------------------------
GtpVisibility::HierarchyNode *OctreeHierarchyInterface::GetRandomLeaf(GtpVisibility::HierarchyNode *root) 
{ 
        if (IsLeaf(root))
                return root;

        Octree *octree = static_cast<Octree *>(root);

        // random decision
        Octree *child = NULL;
        
        std::vector<Octree *> nodes;
        nodes.reserve(8);

        for (int z = 0; z < 2; ++ z)
        {       
                for (int y = 0; y < 2; ++ y)
                {
                        for (int x = 0; x < 2; ++ x)
                        {
                                if ((child = octree->mChildren[x][y][z]) != NULL)
                                {
                                        nodes.push_back(child);
                                }
                        }
                }
        }

        if (nodes.empty())
                return NULL;

        int r = (int)(((float)rand() / RAND_MAX) * ((float)nodes.size() - 0.5f));

        return GetRandomLeaf(nodes[r]);
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::IsLeaf(GtpVisibility::HierarchyNode *node) const
{
        Octree *octree = static_cast<Octree *>(node);

        // HACK: if there are subtrees, they are empty => we are not interested in them
        return octree->numNodes() == (int)octree->mNodes.size();
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const
{
        return !(static_cast<Octree *>(node))->mNodes.empty();
}
//-----------------------------------------------------------------------
float OctreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
{
        const Vector3 bmin = static_cast<Octree *>(node)->mBox.getMinimum();
        const Vector3 bmax = static_cast<Octree *>(node)->mBox.getMaximum();

        const Vector3 pos = (bmax - bmin) * 0.5f + bmin;
        
        return (mCameraPosition - pos).squaredLength();
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node, 
                                                                                          const bool visible) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        static_cast<Octree *>(node)->setOctreeVisible(visible);
#endif
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node, 
                                                                                          const unsigned int frameId) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        static_cast<Octree *>(node)->setLastVisited(frameId);
#endif
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const
{               
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        Octree *octant = static_cast<Octree *>(node);

        while (octant && !octant->isOctreeVisible())
        {
                octant->setOctreeVisible(true);
                octant = octant->getParent();
        }
#endif
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::PullUpLastVisited(GtpVisibility::HierarchyNode *node, const int frameId) const
{               
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        Octree *octant = static_cast<Octree *>(node);

        while (octant && (octant->lastVisited() != frameId))
        {
                octant->setLastVisited(frameId);
                octant = octant->getParent();
        }
#endif
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::DetermineFullVisibility(GtpVisibility::HierarchyNode *node) const
{               
        Octree *octant = static_cast<Octree *>(node);

        // node not visited in this frame => no change
        if (octant->lastVisited() != mFrameId) 
                return;

        // leaf node: terminate recursion
        if (IsLeaf(node))
        {
                octant->setOctreeFullyVisible(octant->isOctreeVisible());       
                return;
        }

        octant->setOctreeFullyVisible(true);
        Octree *nextChild;
        
        for (int i = 0; i < 8; ++ i)
        {
                int x = (i & 4) / 4;
                int y = (i & 2) / 2;
                int z = i & 1;

                nextChild = octant->mChildren[x][y][z];

                if (!nextChild)
                        continue;
                
                // recursive traversal
                DetermineFullVisibility(nextChild);
                
                // this leaf is not fully visible
                if (!nextChild->isOctreeFullyVisible())
                {
                        octant->setOctreeFullyVisible(false);
                }
        }
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node)
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        Octree *octant = static_cast<Octree *>(node);

        if (octant->lastRendered() != mFrameId)
        {
                octant->setLastRendered(mFrameId);
                OctreeSceneManager *ocm = 
                        static_cast<OctreeSceneManager *>(mSceneManager);

                ocm->_renderOctant(mCamera, 
                                                   octant, 
                                                   mOnlyShadowCasters, 
                                                   mLeavePassesInQueue);

                mVisibleNodes.push_back(node);
        }
#endif  
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::RenderNodeRecursive(GtpVisibility::HierarchyNode *node)
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        Octree *octant = static_cast<Octree *>(node);

        if (octant->lastRendered() != mFrameId)
        {
                octant->setLastRendered(mFrameId);

                OctreeSceneManager *ocm = 
                        static_cast<OctreeSceneManager *>(mSceneManager);

                ocm->_renderOctantRecursive(mCamera, 
                                                                        octant, 
                                                                        mOnlyShadowCasters, 
                                                                        mLeavePassesInQueue);

                mVisibleNodes.push_back(node);
        }
#endif  
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::IsNodeVisible(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        return static_cast<Octree *>(node)->isOctreeVisible();
#else
        return true;
#endif
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::IsNodeFullyVisible(GtpVisibility::HierarchyNode *node) const
{
        return static_cast<Octree *>(node)->isOctreeFullyVisible();
}
//-----------------------------------------------------------------------
unsigned int OctreeHierarchyInterface::LastVisited(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        return static_cast<Octree *>(node)->lastVisited();
#else
        return 0;
#endif
}
//-----------------------------------------------------------------------
AxisAlignedBox *OctreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node)
{
        // reuse box if node is the same
        // only create renderable bounding box for new node
        if (node != mOldNode)
        {
                mOldNode = node;
            //static_cast<Octree *>(node)->_getCullBounds(&mBox);
                mBox = static_cast<Octree *>(node)->_getWorldAABB();
        }

        return &mBox;
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node, 
                                                                                                   GtpVisibility::CullingType type) const
{
        WireBoundingBox *box = static_cast<Octree *>(node)->getWireBoundingBox();

        if (type == GtpVisibility::FRUSTUM_CULLED)
        {
                box->setMaterial("FrustumCulledNodesMaterial");
        }
        else // type == GtpVisibility::QUERY_CULLED
        {
                box->setMaterial("QueryCulledNodesMaterial");
        }

        static_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box);
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,
                                                                                                   GeometryVector *geometryList, 
                                                                                                   bool includeChildren)
{
        NodeList::const_iterator nodeIt, nodeIt_end;
        nodeIt_end = static_cast<Octree *>(node)->mNodes.end();

        for (nodeIt = static_cast<Octree *>(node)->mNodes.begin(); nodeIt != nodeIt_end; ++nodeIt)
        {
                SceneNodeHierarchyInterface::GetNodeGeometryList(*nodeIt, geometryList, includeChildren);
        }
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::CollectLeaves(GtpVisibility::HierarchyNode *root, 
                                                                                         GtpVisibility::HierarchyNodeContainer &nodes)
{
        std::stack<GtpVisibility::HierarchyNode *> tStack;
        tStack.push(root);

        Octree *child;

        while (!tStack.empty())
        {
                GtpVisibility::HierarchyNode *node = tStack.top();
                tStack.pop();

                if (IsLeaf(node))
                {
                        nodes.push_back(node);
                }
                else
                {
                        Octree *octree = static_cast<Octree *>(node);
                        
                        for (int z = 0; z < 2; ++ z)
                                for (int y = 0; y < 2; ++ y)
                                        for (int x = 0; x < 2; ++ x)
                                                if ((child = octree->mChildren[x][y][z]) != NULL)
                                                        tStack.push(child);
                }
        }
}

//-----------------------------------------------------------------------
GtpVisibility::HierarchyNode *OctreeHierarchyInterface::GetParent(GtpVisibility::HierarchyNode *node)
{
        Octree *octree = static_cast<Octree *>(node);
        return octree->getParent();
}
//-----------------------------------------------------------------------
int OctreeHierarchyInterface::GetNodeAssumedVisible(GtpVisibility::HierarchyNode *node)
{
        Octree *octree = static_cast<Octree *>(node);
        return octree->getAssumedVisible();
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::SetNodeAssumedVisible(GtpVisibility::HierarchyNode *node, int assumedVisible)
{
        Octree *octree = static_cast<Octree *>(node);
        octree->setAssumedVisible(assumedVisible);
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::DecNodeAssumedVisible(GtpVisibility::HierarchyNode *node)
{
        Octree *octree = static_cast<Octree *>(node);
        octree->decAssumedVisible();
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::RenderGeometryBounds(GtpVisibility::HierarchyNode *node)
{
        Octree *octree = static_cast<Octree *>(node);

        NodeList::iterator it, it_end = octree->mNodes.end();

    for (it = octree->mNodes.begin(); it != it_end; ++ it)
    {
                RenderBoundingBox(&(*it)->_getWorldAABB());
    }   
}


} // namespace Ogre