source: trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp @ 85

#include "OgreOctreeHierarchyInterface.h"
#include "OgreVisibilityOctreeSceneManager.h"
#include <OgreOctree.h>
#include <windows.h>

namespace Ogre {
//namespace GtpVisibility {
//-----------------------------------------------------------------------
OctreeHierarchyInterface::OctreeHierarchyInterface(SceneManager *sm, RenderSystem *rsys): 
PlatformHierarchyInterface(sm, rsys)
{
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node)
{
        mNumTraversedNodes ++;

        // if we come across some renderable geometry => render it
        RenderNode(node);
        
        for(int i=0; i<8; ++i)
        {
                Octree *nextChild = 
                        static_cast<Octree *>(node)->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1];

        if (nextChild)
                {
                        mDistanceQueue->push(nextChild);
                }
        }
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::IsLeaf(GtpVisibility::HierarchyNode *node) const
{
        Octree *octant = static_cast<Octree *>(node);

        for(int i=0; i<8; i++)
        {
                if (octant->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1])
                        return false;
        }

        return true;
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const
{
        return static_cast<Octree *>(node)->numNodes() > 0;
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::SetNumOctreeNodes(unsigned int num)
{
        mNumOctreeNodes = num;
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::HasGreaterDistance(GtpVisibility::HierarchyNode *node1, 
                                                                                                  GtpVisibility::HierarchyNode *node2) const
{
        // matt: change this (inefficient)
        AxisAlignedBox box1, box2;

        static_cast<Octree *>(node1)->_getCullBounds(&box1);
        static_cast<Octree *>(node2)->_getCullBounds(&box2);

        return GetSquaredViewDepth(mCamera, &box1) > GetSquaredViewDepth(mCamera, &box2);
}
//-----------------------------------------------------------------------
Real OctreeHierarchyInterface::GetSquaredViewDepth(const Camera* cam, 
                                                                                                   const AxisAlignedBox* box) const
{
        Vector3 mid = ((box->getMinimum() - box->getMaximum()) * 0.5) + box->getMinimum();
        return (cam->getDerivedPosition() - mid).squaredLength();                                                                   
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node, 
                                                                                          const bool visible)
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        static_cast<Octree *>(node)->setOctreeVisible(visible);
#endif
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node, 
                                                                                          const unsigned int frameId)
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        static_cast<Octree *>(node)->setLastVisited(frameId);
#endif
}
//-----------------------------------------------------------------------
void OctreeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node)
{               
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        Octree *octant = static_cast<Octree *>(node);

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

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

                if (!HasGeometry(octant)) return;

                static_cast<OctreeSceneManager *>(mSceneManager)->_renderOctant(mCamera, octant);

                mNumRenderedNodes ++;
        }
#endif
}
//-----------------------------------------------------------------------
bool OctreeHierarchyInterface::IsNodeVisible(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        return static_cast<Octree *>(node)->isOctreeVisible();
#else
        return true;
#endif
}
//-----------------------------------------------------------------------
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)
{
        if(node != mPreviousNode)
        {
                mPreviousNode = node;
                static_cast<Octree *>(node)->_getCullBounds(&mBox);
        }

        return &mBox;
}

//} // namespace GtpVisibility
} // namespace Ogre