source: trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingSceneManager.cpp @ 21

#include "OgreOcclusionCullingSceneManager.h"
#include "OgreMath.h"
#include "OgreIteratorWrappers.h"
#include "OgreRenderSystem.h"
#include "OgreCamera.h"
#include "OgreHardwareOcclusionQuery.h"

#include <windows.h>

namespace Ogre {
        
        //-----------------------------------------------------------------------
        OcclusionCullingSceneManager::OcclusionCullingSceneManager(): 
        mFrameID(1), mDistanceQueue(NULL), mVisibilityThreshold(0), mCurrentTestIdx(0),
        mIsQueryMode(false)
        {               
        }

        void OcclusionCullingSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
        {
                // empty because we have to find in _renderVisibleObjects
        }

        //-----------------------------------------------------------------------
        void OcclusionCullingSceneManager::_renderVisibleObjects(void)
        {
                mDistanceQueue = new PriorityQueue(myless<SceneNode *>(mCameraInProgress));
                mDistanceQueue->push(mSceneRoot);
                //renderZPass();
                renderCullFrustum();
                delete mDistanceQueue;
                //mDestRenderSystem->_setDepthBufferParams(true, false, CMPF_LESS);
                //SceneManager::_renderVisibleObjects();
                //mDestRenderSystem->_setDepthBufferParams();
        //mDistanceQueue.push(mSceneRoot);
                //Preprocess();
                
                //renderCullFrustum();

                //mFrameID ++;
                //ResetQueries();
        }

        //-----------------------------------------------------------------------
        void OcclusionCullingSceneManager::renderZPass()
        {
                traverseNode(mSceneRoot);
        }

        //-----------------------------------------------------------------------
        void OcclusionCullingSceneManager::renderCullFrustum()
        {
                while(!mDistanceQueue->empty())
                {
                        SceneNode *node = mDistanceQueue->top();
                        mDistanceQueue->pop();
        
                        // interesting for the visualization, so rest and set
                        //node->SetVisible(false);
                                
                        if(mCameraInProgress->isVisible(node->_getWorldAABB()))
                        {
                                // update node's visited flag => needed for rendering
                                // so set it also here
                                //node->SetLastVisited(mFrameID);
                                //node->SetVisible(true);
                                traverseNode(node);
                        }
                        //else
                        //MessageBox( NULL, "myplugin registered", "this is my plugin", MB_OK | MB_ICONERROR | MB_TASKMODAL);
                }
        }
        
        
        //-----------------------------------------------------------------------
        void OcclusionCullingSceneManager::renderStopAndWait()
        {
                while(!mDistanceQueue->empty())
                {
                        SceneNode *node = mDistanceQueue->top();
                        mDistanceQueue->pop();
                
                        // interesting for the visualization, so rest and set
                        //node->SetVisible(false);

                        if(mCameraInProgress->isVisible(node->_getWorldAABB()))
                        {
                                issueOcclusionQuery(node, false);
                                
                                unsigned int visiblePixels;
                                // wait if result not available
                                mOcclusionQueries[mCurrentTestIdx++]->pullOcclusionQuery(&visiblePixels);
                                
                                // node visible
                                if(visiblePixels > mVisibilityThreshold)
                                {
                                        traverseNode(node);
                                }
                        }                                       
                }
        }

        void OcclusionCullingSceneManager::issueOcclusionQuery(SceneNode *node, bool wasVisible)
        {
                // get next available test id
                mOcclusionQueries[mCurrentTestIdx]->beginOcclusionQuery();
        
                // change state so the bounding box gets not actually rendered on the screen
                switchMode(false);
                node->_addBoundingBoxToQueue(getRenderQueue());
                SceneManager::_renderVisibleObjects();
                getRenderQueue()->clear();
                switchMode(true);

                mOcclusionQueries[mCurrentTestIdx++]->endOcclusionQuery();
        }


        //-----------------------------------------------------------------------
        void OcclusionCullingSceneManager::switchMode(bool switch2QueryMode)
        {       
                // boolean used to avoid unnecessary state changes
                if(switch2QueryMode != mIsQueryMode)
                {
                        mDestRenderSystem->_setColourBufferWriteEnabled(switch2QueryMode, 
                                switch2QueryMode, switch2QueryMode, switch2QueryMode);
                        mDestRenderSystem->_setDepthBufferWriteEnabled(switch2QueryMode);
                        mDestRenderSystem->setLightingEnabled(switch2QueryMode);
                        mIsQueryMode = switch2QueryMode;
                }
        }
        

        //-----------------------------------------------------------------------
        void OcclusionCullingSceneManager::traverseNode(SceneNode *node)
        {
                if(node->numChildren() == 0) // reached leaf
                {
                        renderSceneNode(node);
                }
                else // internal node: add children to priority queue for further processing
                {
                        Node::ChildNodeIterator it = node->getChildIterator();
                        char str[100]; sprintf(str, "number of children: %d", node->numChildren());
                
                        while (it.hasMoreElements())
                        { 
                                SceneNode* sceneChild = static_cast<SceneNode*>(it.getNext());
                                //mDistanceQueue->addRenderable(sceneChild);
                mDistanceQueue->push(sceneChild);
                        }
                 }

                 /*
                 static RenderOperation ro;
                 node->getRenderOperation(ro);
                 ro.srcRenderable = node; 
                 mDestRenderSystem->_render(ro);
                 Pass pass();
                 renderSingleObject(node, &pass, true);
                 */
        }

        void OcclusionCullingSceneManager::renderSceneNode(SceneNode *node)
        {
                node->_findVisibleObjects(mCameraInProgress, getRenderQueue(), false, 
                                                                  mDisplayNodes, false);
                SceneManager::_renderVisibleObjects();
                getRenderQueue()->clear();
        }
}