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

#include <OgreCamera.h>
#include <OgreLogManager.h>
//#include "OgreSolidHalfBoundingBox.h"
#include "OgreSolidBoundingBox.h"
#include "OgrePlatformHierarchyInterface.h"
#include "OgrePlatformOcclusionQuery.h"
#include <windows.h>

namespace Ogre {

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

        if(mSolidBoundingBox)
                delete mSolidBoundingBox;
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::DeleteQueries()
{
        for(int i=0; i < (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
        SolidBoundingBox *solidBox = GetSolidBoundingBox();
        
        mRenderSystem->_setWorldMatrix(Ogre::Matrix4::IDENTITY);
        mSceneManager->useRenderableViewProjMode(solidBox);
    mSceneManager->setPass(solidBox->getTechnique()->getPass(0));

        solidBox->SetupBoundingBoxVertices(*box);
                                
        solidBox->getRenderOperation(ro);
        ro.srcRenderable = solidBox;
        mRenderSystem->_render(ro);

        // Render two halfes of the bounding box (using triangle fans)
        /*for(int halfIdx = 0; halfIdx < 2; ++halfIdx)
        {
                solidBox->SetupBoundingBoxVertices(*box, halfIdx == 1);
                                
                solidBox->getRenderOperation(ro);
                ro.srcRenderable = solidBox;
                mRenderSystem->_render(ro);
        }*/
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::SetCamera(Ogre::Camera *cam)
{
        mCamera = cam;
}
//-----------------------------------------------------------------------
void PlatformHierarchyInterface::SetCullCamera(Ogre::Camera *cullCam)
{
        mCullCamera = cullCam;
}
//-----------------------------------------------------------------------
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, Camera *cullCam)
{
        GtpVisibility::HierarchyInterface::InitFrame(root);
        mPreviousNode = NULL;

        SetCamera(cam);

        if(cullCam)
                SetCullCamera(cullCam);
        else
                SetCullCamera(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 mCullCamera->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 node is leaf and was visible => will be rendered anyway.
        // In this case we can also test with the real geometry.
        // if camera for culling is different from camera for rendering => cannot optimize
        if (mUseOptimization && wasVisible && IsLeaf(node) && (mCamera == mCullCamera))
        {
                //LogManager::getSingleton().logMessage("render node\n");
                RenderNode(node);
        }
        else
        {
                //LogManager::getSingleton().logMessage("render box\n");
                RenderBoundingBox(GetBoundingBox(node));
        }

        query->EndQuery();
        
        return query;
}
//-----------------------------------------------------------------------
SolidBoundingBox *PlatformHierarchyInterface::GetSolidBoundingBox()
{
        if(!mSolidBoundingBox)
                mSolidBoundingBox = new SolidBoundingBox;

        return mSolidBoundingBox;
}

} // namespace Ogre