source: trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp @ 86

//#include <OgreMath.h>
//#include <OgreIteratorWrappers.h>
#include <OgreCamera.h>

#include "OgreSolidHalfBoundingBox.h"
#include "OgrePlatformHierarchyInterface.h"
#include "OgrePlatformOcclusionQuery.h"
#include <windows.h>

namespace Ogre {

//-----------------------------------------------------------------------
PlatformHierarchyInterface::PlatformHierarchyInterface(SceneManager *sm, RenderSystem *rsys):
mSceneManager(sm), mRenderSystem(rsys), mSolidHalfBoundingBox(NULL)
{
}
//-----------------------------------------------------------------------
PlatformHierarchyInterface::~PlatformHierarchyInterface()
{
        DeleteQueries();

        if(mSolidHalfBoundingBox)
                delete mSolidHalfBoundingBox;
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::DeleteQueries()
{
        for(unsigned int i=0; i < (unsigned int)mOcclusionQueries.size(); ++i)
                delete mOcclusionQueries[i];

        mOcclusionQueries.clear();
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::RenderBoundingBox(AxisAlignedBox *box)
{
        static RenderOperation ro;

        //TODO: this should be the full bounding box
        SolidHalfBoundingBox *halfbox = GetSolidHalfBoundingBox();
        
        mRenderSystem->_setWorldMatrix(Ogre::Matrix4::IDENTITY);
        mSceneManager->useRenderableViewProjMode(halfbox);
    mSceneManager->setPass(halfbox->getTechnique()->getPass(0));

        // Render two halfes of the bounding box (using triangle fans)
        for(int halfIdx = 0; halfIdx < 2; ++halfIdx)
        {
                halfbox->SetupBoundingBoxVertices(*box, halfIdx == 1);
                                
                halfbox->getRenderOperation(ro);
                ro.srcRenderable = halfbox;
                mRenderSystem->_render(ro);     
        }
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::SetCamera(Ogre::Camera *cam)
{
        mCamera = cam;
}
//-----------------------------------------------------------------------
GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::GetNextOcclusionQuery()
{
        if(mCurrentTestIdx == mOcclusionQueries.size())
        {
                mOcclusionQueries.push_back(new PlatformOcclusionQuery(mRenderSystem));
        }
        
        return mOcclusionQueries[mCurrentTestIdx ++];
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam)
{
        GtpVisibility::HierarchyInterface::InitFrame(root);
        mPreviousNode = NULL;
        SetCamera(cam);
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::SetSceneManager(SceneManager *sm)
{
        mSceneManager = sm;
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::SetRenderSystem(RenderSystem *rsys)
{
        mRenderSystem = rsys;
}
//-----------------------------------------------------------------------
bool PlatformHierarchyInterface::CheckFrustumVisible(GtpVisibility::HierarchyNode *node, 
                                                                                                         bool &intersects)
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        return mCamera->isVisible(*GetBoundingBox(node), intersects);
#else
        return true;
#endif
}
//-----------------------------------------------------------------------
GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery(
        GtpVisibility::HierarchyNode *node, const bool wasVisible) 
{
        // get next available test id
        GtpVisibility::OcclusionQuery *query = GetNextOcclusionQuery();

        //-- the actual query test
        query->BeginQuery();
                        
        // if leaf and was visible => will be rendered anyway, thus we
        // can also test with the real geometry 
        if(mUseOptimization && wasVisible && IsLeaf(node))
        {
        //      OutputDebugString("Using optimization!!\n");
                RenderNode(node);
        }
        else
        {
        //      OutputDebugString("Not optimized!!\n");
                RenderBoundingBox(GetBoundingBox(node));
        }

        query->EndQuery();
        
        return query;
}
//-----------------------------------------------------------------------
SolidHalfBoundingBox *PlatformHierarchyInterface::GetSolidHalfBoundingBox()
{
        if(!mSolidHalfBoundingBox)
                mSolidHalfBoundingBox = new SolidHalfBoundingBox;

        return mSolidHalfBoundingBox;
}

} // namespace Ogre