source: trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp @ 96

#include "OgreVisibilityOctreeSceneManager.h"
#include "OgreVisibilityOptionsManager.h"
#include <OgreMath.h>
#include <OgreIteratorWrappers.h>
#include <OgreRenderSystem.h>
#include <OgreCamera.h>
#include <OgreLogManager.h>

namespace Ogre {

//-----------------------------------------------------------------------
VisibilityOctreeSceneManager::VisibilityOctreeSceneManager(
        GtpVisibility::VisibilityManager *visManager)
: mVisibilityManager(visManager), mUseCulling(true)
{
        mHierarchyInterface = 
                new OctreeHierarchyInterface(this, mDestRenderSystem);
                
        //mDisplayNodes = true;
        //mShowBoundingBoxes = true;
        //mShowBoxes = true;

        // TODO: find reasonable value for max depth
        mMaxDepth = 50;
}
//-----------------------------------------------------------------------
VisibilityOctreeSceneManager::~VisibilityOctreeSceneManager()
{
        delete mHierarchyInterface;
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::_renderVisibleObjects()
{
        // two cameras (one for culling, one for rendering)
        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress, 
                                                        mCullCamera ? getCamera("CullCamera") : NULL);
        mVisibilityManager->GetCullingManager()->InitFrame();

        // standard scenemanager rendering without hierarchical culling
        if(!mUseCulling)
        {       
                OctreeSceneManager::_renderVisibleObjects();
                return;
        } 
    
        //-- hierarchical culling
        // the objects of different layers (e.g., background, scene, 
        // overlay) must be identified and rendered one after another

        //-- render background
        clearSpecialCaseRenderQueues();
        addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
        addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);

        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
        SceneManager::_renderVisibleObjects();

#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        _deleteRenderedQueueGroups();
#endif

        //-- render visible objects (i.e., all but overlay)
        clearSpecialCaseRenderQueues();
        addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);

        //-- the hierarchical culling algorithm
        mVisibilityManager->ApplyVisibilityCulling();

#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        _deleteRenderedQueueGroups();
#endif

        //-- render remaining objects, e.g., overlay
        clearSpecialCaseRenderQueues();
        SceneManager::_renderVisibleObjects();

        // write out stats
        WriteLog();
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
{
        // empty if hierarchical culling is used =>
        // we interleave identification and rendering of objects 
        // in _renderVisibibleObjects 
        if(!mUseCulling)
        {
                OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
        }
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::_updateSceneGraph(Camera* cam)
{
        mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
        mHierarchyInterface->SetRenderSystem(mDestRenderSystem);

#ifdef GTP_VISIBILITY_MODIFIED_OGRE
    mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes);
#endif
        OctreeSceneManager::_updateSceneGraph(cam);
}
//-----------------------------------------------------------------------
bool VisibilityOctreeSceneManager::setOption(const String & key, const void * val)
{
        if (key == "UseCulling")
        {
                mUseCulling = (*static_cast<const bool *>(val));
                return true;
        }

        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                setOption(key, val) || OctreeSceneManager::setOption(key, val);
}
//-----------------------------------------------------------------------
bool VisibilityOctreeSceneManager::getOption(const String & key, void *val)
{
        if (key == "NumHierarchyNodes")
        {
                * static_cast<unsigned int *>(val) = (unsigned int)mNumOctreeNodes;
                return true;
        }

        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                getOption(key, val) && OctreeSceneManager::getOption(key, val);
}
//-----------------------------------------------------------------------
bool VisibilityOctreeSceneManager::getOptionValues(const String & key, StringVector  &refValueList)
{
        return OctreeSceneManager::getOptionValues( key, refValueList );
}
//-----------------------------------------------------------------------
bool VisibilityOctreeSceneManager::getOptionKeys(StringVector & refKeys)
{
        return  VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                getOptionKeys ( refKeys ) || OctreeSceneManager::getOptionKeys(refKeys);
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::setVisibilityManager(GtpVisibility::VisibilityManager *visManager)
{
    mVisibilityManager = visManager;
}
//-----------------------------------------------------------------------
GtpVisibility::VisibilityManager *VisibilityOctreeSceneManager::getVisibilityManager()
{
        return mVisibilityManager;
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::WriteLog()
{
        std::stringstream d;

        d << "Algorithm: " << mVisibilityManager->GetCullingManagerType() << ", "
          << "Hierarchy nodes: " << mNumOctreeNodes << ", " << "Traversed nodes: " << mHierarchyInterface->GetNumTraversedNodes() << ", "
          << "Rendered nodes: " << mHierarchyInterface->GetNumRenderedNodes() << ", "
          << "Query culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumQueryCulledNodes() << ", "
          << "Frustum culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumFrustumCulledNodes() << ", "
      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << "\n";

        LogManager::getSingleton().logMessage(d.str());
}
}   // namespace Ogre