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

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


namespace Ogre {

//-----------------------------------------------------------------------
VisibilityOctreeSceneManager::VisibilityOctreeSceneManager(
        GtpVisibility::VisibilityManager *visManager)
: 
mVisibilityManager(visManager), 
mIsDepthPass(false),
mShowVisualization(false),
mRenderNodesForViz(false),
mRenderNodesContentForViz(false),
mVisualizeCulledNodes(false),
mSkipTransparents(false),
mDelayRenderTransparents(true),
mUseDepthPass(true)
{
        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
                
        //mDisplayNodes = true;
        //mShowBoundingBoxes = true;
        //mShowBoxes = true;

        // TODO: find reasonable value for max depth
        mMaxDepth = 50;
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::InitDepthPass()
{
        MaterialPtr depthMat = MaterialManager::getSingleton().getByName("Visibility/DepthPass");

        if (depthMat.isNull())
    {
                // Init
                depthMat = MaterialManager::getSingleton().create(
                "Visibility/DepthPass",
                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

                mDepthPass = depthMat->getTechnique(0)->getPass(0);
                mDepthPass->setColourWriteEnabled(false);
                mDepthPass->setDepthWriteEnabled(true);
                mDepthPass->setLightingEnabled(false);
        }
        else
        {
                mDepthPass = depthMat->getTechnique(0)->getPass(0);
        }
}
//-----------------------------------------------------------------------
VisibilityOctreeSceneManager::~VisibilityOctreeSceneManager()
{
        if (mHierarchyInterface)
        {
                delete mHierarchyInterface;
                mHierarchyInterface = NULL;
        }
}
//-----------------------------------------------------------------------
Pass *VisibilityOctreeSceneManager::setPass(Pass* pass)
{
        // setting vertex program is not efficient
        Pass *usedPass = ((mIsDepthPass && pass->getDepthWriteEnabled() && !pass->hasVertexProgram()) ? mDepthPass : pass);             

        /*
        // set depth fill pass only if depth write enabled
        Pass *usedPass = (mIsDepthPass && pass->getDepthWriteEnabled() ? mDepthPass : pass);

    if (mIsDepthPass && pass->hasVertexProgram())
    {
                // set vertex program of current pass to depth pass
                mDepthPass->setVertexProgram(pass->getVertexProgramName());

                if (mDepthPass->hasVertexProgram())
                {
                        const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
                        // Load this program if not done already
                        if (!prg->isLoaded())
                                prg->load();
                        // Copy params
                        mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
                }
                else if (mDepthPass->hasVertexProgram())
                {
                        mDepthPass->setVertexProgram("");
                }
        }*/

        SceneManager::setPass(usedPass);

        return usedPass;
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::ShowVisualization(Camera *cam)
{
        // add player camera for visualization purpose
        try {
                Camera *c;
                if ((c = getCamera("PlayerCam")) != NULL)
                {
                        getRenderQueue()->addRenderable(c);
                }   
    }
    catch(...)
    {
        // ignore
    }
        for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
{
                getRenderQueue()->addRenderable(*it);
        }
        if (mRenderNodesForViz || mRenderNodesContentForViz)
        {
                // change node material so it is better suited for visualization
                MaterialPtr nodeMat = MaterialManager::getSingleton().getByName("Core/NodeMaterial");
                nodeMat->setAmbient(1, 1, 0);
                nodeMat->setLightingEnabled(true);
                nodeMat->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();

                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
        {

                        if (mRenderNodesForViz)
                        {
                                getRenderQueue()->addRenderable(*it);
                                // addbounding boxes instead of node itself
                                //(*it)->_addBoundingBoxToQueue(getRenderQueue());
                        }
                        if (mRenderNodesContentForViz) 
                        {
                                (*it)->_addToRenderQueue(cam, getRenderQueue(), false);
                        }
                }
        }
        
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
{
        //-- show visible scene nodes and octree bounding boxes from last frame
        if (mShowVisualization)
    {
                ShowVisualization(cam);
        }
        else 
        {       
                mVisible.clear();
            mBoxes.clear();
        
                // if there is no depth pass =>
                // we interleave identification and rendering of objects 
                // in _renderVisibibleObjects

                // only shadow casters will be rendered in shadow texture pass
                mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
        }
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::_renderVisibleObjects()
{
        // create material for depth pass
        InitDepthPass();

        // visualization: apply standard rendering
        if (mShowVisualization)
        {       
                OctreeSceneManager::_renderVisibleObjects();
                return;
        } 
        

        //-- hierarchical culling
        // the objects of different layers (e.g., background, scene, 
        // overlay) must be identified and rendered one after another

        bool leaveTransparentsInQueue = mDelayRenderTransparents && !mUseDepthPass;

        // possible two cameras (one for culling, one for rendering)
        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress, 
                                                        mCullCamera ? getCamera("CullCamera") : NULL,
                                                        leaveTransparentsInQueue);

        // call initframe to reset culling manager stats
        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes);
        
        mSkipTransparents = false;

        //-- render background, in case there is one
        clearSpecialCaseRenderQueues();
        addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
        addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);
        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);

        SceneManager::_renderVisibleObjects();


#ifdef GTP_VISIBILITY_MODIFIED_OGRE
        _deleteRenderedQueueGroups(false);
#endif

        //-- render visible objects (i.e., all but overlay)
        clearSpecialCaseRenderQueues();
        addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE);
        addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
        
        // transparents are skipped from hierarchical rendering
        // => they need sorting, thus we render them afterwards
        mSkipTransparents = mDelayRenderTransparents;

        // set state for depth pass
    mIsDepthPass = mUseDepthPass;
        
        /** 
        * the hierarchical culling algorithm
          * for depth pass: will just find objects and update depth buffer
          * for delayed rendering: will render all but transparents
        **/
        
        mVisibilityManager->ApplyVisibilityCulling();
        
        //-- now we can savely render all remaining objects, e.g., transparents, overlay
        mSkipTransparents = false;

        clearSpecialCaseRenderQueues();
        SceneManager::_renderVisibleObjects();

        // for depth pass: add visible nodes found with the visibility culling
        if (mUseDepthPass)
        {
                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
                {
                        (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
                }
                mIsDepthPass = false;
    }
        mSkipTransparents = false;
                
        //-- now we can render all remaining queue objects
        // for depth pass: all
        // for delayed rendering: transparents, overlay 
        clearSpecialCaseRenderQueues();
        SceneManager::_renderVisibleObjects();
        
        WriteLog(); // write out stats
}
//-----------------------------------------------------------------------
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 == "UseDepthPass")
        {
                mUseDepthPass = (*static_cast<const bool *>(val));
                return true;
        }
        if (key == "ShowVisualization")
        {
                mShowVisualization = (*static_cast<const bool *>(val));
                return true;
        }
        if (key == "RenderNodesForViz")
        {
                mRenderNodesForViz = (*static_cast<const bool *>(val));
                return true;
        }
        if (key == "RenderNodesContentForViz")
        {
                mRenderNodesContentForViz = (*static_cast<const bool *>(val));
                return true;
        }
        if (key == "SkyBoxEnabled")
        {
                mSkyBoxEnabled = (*static_cast<const bool *>(val));
                return true;
        }
        if (key == "SkyPlaneEnabled")
        {
                mSkyPlaneEnabled = (*static_cast<const bool *>(val));
                return true;
        }
        if (key == "SkyDomeEnabled")
        {
                mSkyDomeEnabled = (*static_cast<const bool *>(val));
                return true;
        }
        if (key == "VisualizeCulledNodes")
        {
                mVisualizeCulledNodes = (*static_cast<const bool *>(val));
                return true;
        }
        if (key == "DelayRenderTransparents")
        {
                mDelayRenderTransparents = (*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 << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", "
          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", "
          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetUseOptimization()) << ", "
          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << "\n"
          << "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";
          /*<< "avg. FPS: " << mCurrentViewport->getTarget()->getAverageFPS() << ", "
          << "best FPS: " << mCurrentViewport->getTarget()->getBestFPS() << ", "
          << "worst FPS: " << mCurrentViewport->getTarget()->getWorstFPS() << ", "
          << "best frame time: " <<     mCurrentViewport->getTarget()->getBestFrameTime() << ", "
          << "worst frame time: " << mCurrentViewport->getTarget()->getWorstFrameTime() << "\n";*/

        LogManager::getSingleton().logMessage(d.str());
}
//-----------------------------------------------------------------------
void VisibilityOctreeSceneManager::renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs, 
            bool doLightIteration, const LightList* manualLightList)
{
        if (!mSkipTransparents)
        {
                OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList);
        }
}

}   // namespace Ogre