Changeset 26 for trunk/VUT/OcclusionCullingSceneManager/src

Timestamp:

03/22/05 14:51:26 (19 years ago)

Author:

gametools

Message:

 

Location:

trunk/VUT/OcclusionCullingSceneManager/src

Files:

• OgreOcclusionCullingSceneManager.cpp (modified) (19 diffs)
• OgreSolidBoundingBox.cpp (deleted)
• OgreSolidHalfBoundingBox.cpp (added)

trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingSceneManager.cpp

@@ -6 +6 @@
 #include "OgreHardwareOcclusionQuery.h"
 //#include "OgreWireBoundingBox.h"
-#include "OgreSolidBoundingBox.h"
+#include "OgreSolidHalfBoundingBox.h"
 
 #include <windows.h>
@@ -15 +15 @@
         OcclusionCullingSceneManager::OcclusionCullingSceneManager(): 
         mFrameId(1), mDistanceQueue(NULL), mVisibilityThreshold(0), mCurrentTestIdx(0),
-        mQueryMode(MODE_RENDER), mNumSceneNodes(0)
+        mQueryMode(MODE_RENDER), mNumSceneNodes(0), mAlgorithmType(RENDER_COHERENT)
         {               
+                mHalfBoundingBox[0] = mHalfBoundingBox[1] = 0;
         }
         //-----------------------------------------------------------------------
@@ -26 +27 @@
         OcclusionCullingSceneManager::~OcclusionCullingSceneManager()
         {               
+                delete mHalfBoundingBox[0];
+                delete mHalfBoundingBox[1];
+
                 deleteQueries();
                 //SceneManager::~SceneManager();
@@ -37 +41 @@
 
                 mCurrentTestIdx = 0;
+
                 //renderZPass();
-                //renderCullFrustum();
-                //renderCoherentWithQueue();
-                renderStopAndWait();
+
+                switch(mAlgorithmType)
+                {
+                        case RENDER_CULL_FRUSTUM:
+                                renderCullFrustum();
+                        break;
+                        case RENDER_STOP_AND_WAIT:
+                                renderStopAndWait();
+                                break;
+                        case RENDER_COHERENT:
+                                renderCoherentWithQueue();
+                                break;
+                        default:
+                                renderCullFrustum();
+                                break;
+                }       
+                
                 delete mDistanceQueue;
 
@@ -67 +86 @@
                 {
                         while(!queryQueue.empty() && 
-                                  (queryQueue.front()->getOcclusionQuery()->resultAvailable() || mDistanceQueue->empty()))
-                        {
-                                SceneNode *node = queryQueue.front();
+                                  ((queryQueue.front().second)->resultAvailable() || mDistanceQueue->empty()))
+                        {
+                                SceneNode *node = queryQueue.front().first;
+                                HardwareOcclusionQuery *query = queryQueue.front().second;
+
                                 queryQueue.pop();
                         
                                 // wait until result available
                                 unsigned int visiblePixels;
-                                node->getOcclusionQuery()->pullOcclusionQuery(&visiblePixels);
+                                query->pullOcclusionQuery(&visiblePixels);
 
                                 if(visiblePixels > mVisibilityThreshold)
@@ -99 +120 @@
 
                                         // reset node's visibility classification 
-                                        node->setVisible(false);
+                                        node->setNodeVisible(false);
 
                                         // update node's visited flag
@@ -107 +128 @@
                                         if(leafOrWasInvisible)
                                         {
-                                                issueOcclusionQuery(node, wasVisible);
-                                                queryQueue.push(node);
+                                                HardwareOcclusionQuery *query = issueOcclusionQuery(node, wasVisible);
+                                                queryQueue.push(query_pair(node, query));
                                         }
                                         
@@ -126 +147 @@
                         mDistanceQueue->pop();
         
-                        // interesting for the visualization, so rest and set
-                        //node->SetVisible(false);
+                        // interesting for visualization purpose
+                        node->setNodeVisible(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);
+                                // update node's visited flag 
+                                node->setLastVisited(mFrameId);
+                                node->setNodeVisible(true);
                                 traverseNode(node);
                         }
@@ -148 +168 @@
                 
                         // interesting for the visualization
-                        //node->SetVisible(false);
+                        node->setNodeVisible(false);
                         node->setLastVisited(mFrameId);
 
                         if(mCameraInProgress->isVisible(node->_getWorldAABB()))
                         {
-                                issueOcclusionQuery(node, false);
+                                HardwareOcclusionQuery *query = issueOcclusionQuery(node, false);
                                 
                                 unsigned int visiblePixels;
                                 // wait if result not available
-                                node->getOcclusionQuery()->pullOcclusionQuery(&visiblePixels);
+                                query->pullOcclusionQuery(&visiblePixels);
                                 
                                 //char str[100]; sprintf(str, "number: %d, id: %d", (int)visiblePixels, mCurrentTestIdx);
@@ -171 +191 @@
         }
         //-----------------------------------------------------------------------
-        void OcclusionCullingSceneManager::issueOcclusionQuery(SceneNode *node, bool wasVisible)
+        HardwareOcclusionQuery *OcclusionCullingSceneManager::issueOcclusionQuery(SceneNode *node, bool wasVisible)
         {
                 // change state so the bounding box gets not actually rendered on the screen
@@ -178 +198 @@
                 // get next available test id
                 HardwareOcclusionQuery *query = mOcclusionQueries[mCurrentTestIdx++];
-                node->setOcclusionQuery(query);
-
+                
                 query->beginOcclusionQuery();
                 
-                SolidBoundingBox boxHalf[2];
-                boxHalf[1].mIsFirstHalf = false;
-
                 /*
                 static RenderOperation ro;
@@ -193 +209 @@
                 box.getRenderOperation(ro);
                 ro.srcRenderable = &box; 
-                mDestRenderSystem->_render(ro);*/
-                for(int i = 0; i < 2; i++)
-                {
-                        boxHalf[i].setupBoundingBox(node->_getWorldAABB());
-                        //setPass(boxHalf[i].getTechnique()->getPass(0)); //setRenderingMode(MODE_QUERY);
-                        SceneManager::renderSingleObject(&boxHalf[i], boxHalf[i].getTechnique()->getPass(0), false);
-                }
+                mDestRenderSystem->_render(ro);
+                */
+                                
+                renderBoundingBox(node);
 
                 query->endOcclusionQuery();
+
+                return query;
         }
 
@@ -212 +227 @@
                         bool enabled = (mode == MODE_RENDER);
                         
-                //      char str[100]; sprintf(str, "number: %d", mode);
-                //      MessageBox( NULL, str, "this is my plugin", MB_OK | MB_ICONERROR | MB_TASKMODAL);
                         mDestRenderSystem->_setColourBufferWriteEnabled(enabled, 
                                 enabled, enabled, enabled);
@@ -224 +237 @@
         void OcclusionCullingSceneManager::traverseNode(SceneNode *node)
         {
-                if(isLeaf(node)) // reached leaf
+                if(isLeaf(node))
                 {
                         render(node);
@@ -235 +248 @@
                         { 
                                 SceneNode* sceneChild = static_cast<SceneNode*>(it.getNext());
-                                //mDistanceQueue->addRenderable(sceneChild);
-                mDistanceQueue->push(sceneChild);
+                                mDistanceQueue->push(sceneChild);
                         }
                  }
@@ -243 +255 @@
         void OcclusionCullingSceneManager::render(SceneNode *node)
         {
-                setRenderingMode(MODE_RENDER);
-
+                //setRenderingMode(MODE_RENDER);
+                //MessageBox( NULL, "harhar", "this is my plugin", MB_OK | MB_ICONERROR | MB_TASKMODAL);
                 //HACK (too slow)
                 node->_findVisibleObjects(mCameraInProgress, getRenderQueue(), false, 
@@ -267 +279 @@
                                 mOcclusionQueries.push_back(hw);
                         }
-                        //char str[100]; sprintf(str, "number: %d", mNumSceneNodes);
-                        //MessageBox( NULL, str, "this is my plugin", MB_OK | MB_ICONERROR | MB_TASKMODAL);
                 }
 
@@ -300 +310 @@
         void OcclusionCullingSceneManager::pullUpVisibility(SceneNode *node)
         {
-                while(node && !node->isNodeVisible())
+                while(!node->isNodeVisible())
                 {
                         node->setNodeVisible(true);
-                        node = static_cast<SceneNode *>(node->getParent());
+                        
+                        if(node != mSceneRoot)
+                                node = static_cast<SceneNode *>(node->getParent());
                 }
         }
@@ -314 +326 @@
                 mOcclusionQueries.clear();
         }
+        //-----------------------------------------------------------------------
+        void OcclusionCullingSceneManager::renderBoundingBox(SceneNode *node)
+        {
+                // Render two halfes of the bounding box (using triangle fans)
+                for(int half=0; half < 2; half ++)
+                {
+                        getSolidHalfBoundingBox(half)->setupBoundingBox(node->_getWorldAABB());
+                        SceneManager::renderSingleObject(getSolidHalfBoundingBox(half), 
+                                getSolidHalfBoundingBox(half)->getTechnique()->getPass(0), false);
+                }
+        }
+        //-----------------------------------------------------------------------
+        SolidHalfBoundingBox *OcclusionCullingSceneManager::getSolidHalfBoundingBox(int half)
+        {
+                if(!mHalfBoundingBox[half])
+                        mHalfBoundingBox[half] = new SolidHalfBoundingBox(half == 1);
+
+                return mHalfBoundingBox[half];  
+        }
+        //-----------------------------------------------------------------------
+        void OcclusionCullingSceneManager::setAlgorithmType(int type)
+        {
+                mAlgorithmType = type;
+        }
+        //-----------------------------------------------------------------------
+        int OcclusionCullingSceneManager::getAlgorithmType()
+        {
+                return mAlgorithmType;
+        }
 }