Changeset 41 for trunk/VUT/OcclusionCullingSceneManager/src

Timestamp:

04/07/05 18:51:36 (20 years ago)

Author:

mattausch

Message:

 

Location:

trunk/VUT/OcclusionCullingSceneManager/src

Files:

• OgreOcclusionCullingSceneManager.cpp (modified) (1 diff)
• OgreOcclusionCullingSceneTraverser.cpp (modified) (12 diffs)
• OgreOcclusionCullingTerrainSceneManager.cpp (modified) (7 diffs)
• OgreOcclusionCullingTerrainSceneTraverser.cpp (modified) (6 diffs)

trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingSceneManager.cpp

@@ -42 +42 @@
         {
                 mOcclusionCullingSceneTraverser->setNumSceneNodes(mSceneNodes.size());
+                mOcclusionCullingSceneTraverser->setNumQueries(mSceneNodes.size());
                 mOcclusionCullingSceneTraverser->setRenderSystem(mDestRenderSystem);
 

trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingSceneTraverser.cpp

@@ -16 +16 @@
         mFrameId(1), mDistanceQueue(NULL), mVisibilityThreshold(0), mCurrentTestIdx(0),
         mQueryMode(MODE_RENDER), mNumSceneNodes(0), mCurrentAlgorithm(RENDER_COHERENT),
-        mNumTraversedNodes(0), mNumQueryCulledNodes(0), mNumFrustumCulledNodes(0), 
+        mNumQueries(0), mNumTraversedNodes(0), mNumQueryCulledNodes(0), mNumFrustumCulledNodes(0), 
         mNumRenderedGeometry(0), mSceneManager(sm), mRenderSystem(rsys)
         {               
@@ -42 +42 @@
                 mCurrentTestIdx = 0;
 
-mCurrentAlgorithm = RENDER_CULL_FRUSTUM;
+//mCurrentAlgorithm = RENDER_CULL_FRUSTUM;
                 switch(mCurrentAlgorithm)
                 {
@@ -99 +99 @@
                                 SceneNode *node = mDistanceQueue->top();
                                 mDistanceQueue->pop();
-        
-                                if(cam->isVisible(node->_getWorldAABB()))
-                                {
-                                        // identify previously visible nodes
-                                        bool wasVisible = node->isNodeVisible() && (node->lastVisited() == mFrameId - 1);
+                                
+                                //TODO: Isvisible also checked inside scenenode::findvisibleobjects
+                                if(!cam->isVisible(node->_getWorldAABB()))
+                                {
+                    mNumFrustumCulledNodes ++;
+                                        continue;
+                                }
+
+                                // identify previously visible nodes
+                                bool wasVisible = node->isNodeVisible() && (node->lastVisited() == mFrameId - 1);
                                         
-                                        // identify nodes that we cannot skip queries for
-                                        bool leafOrWasInvisible = !wasVisible || isLeaf(node);
-
-                                        // reset node's visibility classification 
-                                        node->setNodeVisible(false);
-
-                                        // update node's visited flag
-                                        node->setLastVisited(mFrameId);
+                                // identify nodes that we cannot skip queries for
+                                bool leafOrWasInvisible = !wasVisible || isLeaf(node);
+
+                                // reset node's visibility classification 
+                                node->setNodeVisible(false);
+
+                                // update node's visited flag
+                                node->setLastVisited(mFrameId);
                                 
-                                        // skip testing previously visible interior nodes
-                                        if(leafOrWasInvisible)
-                                        {
-                                                HardwareOcclusionQuery *query = issueOcclusionQuery(node, wasVisible);
-                                                queryQueue.push(QueryPair(node, query));
-                                        }
+                                // skip testing previously visible interior nodes
+                                if(leafOrWasInvisible)
+                                {
+                                        HardwareOcclusionQuery *query = issueOcclusionQuery(&node->_getWorldAABB(), wasVisible);
+                                        queryQueue.push(QueryPair(node, query));
+                                }
                                         
-                                        // always traverse a node if it was visible
-                                        if(wasVisible)
-                                        {
-                                                traverseNode(cam, node);
-                                        }
+                                // always traverse a node if it was visible
+                                if(wasVisible)
+                                {
+                                        traverseNode(cam, node);
                                 }
                                 else
@@ -144 +148 @@
                         // interesting for visualization purpose
                         node->setNodeVisible(false);
-                                
-                        if(cam->isVisible(node->_getWorldAABB()))
-                        {
-                                // update node's visited flag 
-                                char msg2[100];
-                                sprintf(msg2,"yes, visible\n");
-                                OutputDebugString(msg2);
-
-                                node->setLastVisited(mFrameId);
-                                node->setNodeVisible(true);
-                                traverseNode(cam, node);
-                        }
-                        else
+
+                        //TODO: IsVisible also checked inside scenenode::_findvisibleobjects
+                        if(!cam->isVisible(node->_getWorldAABB()))
                         {                       
                                 char msg2[100];
@@ -163 +157 @@
 
                                 mNumFrustumCulledNodes ++;
+                                continue;
                         }
+
+                        // update node's visited flag 
+                        node->setLastVisited(mFrameId);
+                        node->setNodeVisible(true);
+                        traverseNode(cam, node);
+
+                        char msg2[100];
+                        sprintf(msg2,"yes, visible\n");
+                        OutputDebugString(msg2);
                 }
         }       
@@ -178 +182 @@
                         node->setLastVisited(mFrameId);
 
-                        if(cam->isVisible(node->_getWorldAABB()))
+                        //TODO: Isvisible also checked inside scenenode::findvisibleobjects
+                        if(!cam->isVisible(node->_getWorldAABB()))
                         {
-                                HardwareOcclusionQuery *query = issueOcclusionQuery(node, false);
+                                mNumFrustumCulledNodes ++;
+                                continue;
+                        }
+
+                        HardwareOcclusionQuery *query = issueOcclusionQuery(&node->_getWorldAABB(), false);
                                 
-                                unsigned int visiblePixels;
-                                // wait if result not available
-                                query->pullOcclusionQuery(&visiblePixels);
+                        unsigned int visiblePixels;
+                        // wait if result not available
+                        query->pullOcclusionQuery(&visiblePixels);
                                 
-                                // node visible
-                                if(visiblePixels > mVisibilityThreshold)
-                                {
-                                        traverseNode(cam, node);
-                                }
-                                else
-                                {
-                                        mNumQueryCulledNodes ++;
-                                }
+                        // node visible
+                        if(visiblePixels > mVisibilityThreshold)
+                        {
+                                traverseNode(cam, node);
                         }
                         else
                         {
-                                mNumFrustumCulledNodes ++;
+                                mNumQueryCulledNodes ++;
                         }
                 }
         }
         //-----------------------------------------------------------------------
-        HardwareOcclusionQuery *OcclusionCullingSceneTraverser::issueOcclusionQuery( SceneNode *node, bool wasVisible )
+        HardwareOcclusionQuery *OcclusionCullingSceneTraverser::issueOcclusionQuery( 
+                AxisAlignedBox *box, bool wasVisible )
         {
                 // change state so the bounding box gets not actually rendered on the screen
+                // TODO: in rendervisibleobjects, the rendermode is changed by ogre itself => change this!!
                 setRenderingMode(MODE_QUERY);
                 //setRenderingMode(MODE_RENDER);
 
+                char msg2[100];
+                sprintf(msg2,"this is query %d of overall %d\n", mCurrentTestIdx, mNumQueries);
+                OutputDebugString(msg2);
+
                 // get next available test id
                 HardwareOcclusionQuery *query = mOcclusionQueries[mCurrentTestIdx++];
-                
+
+                //-- the actual query test
                 query->beginOcclusionQuery();
                                 
-                renderBoundingBox(node);
+                renderBoundingBox(box);
 
                 query->endOcclusionQuery();
@@ -258 +269 @@
         void OcclusionCullingSceneTraverser::renderSceneNode( Camera *cam, SceneNode *node )
         {
+                //TODO: does not do any changes
                 setRenderingMode(MODE_RENDER);
                 
@@ -268 +280 @@
                 deleteQueries();
 
-                for(unsigned int i=0; i < mNumSceneNodes; i++)
+                for(unsigned int i=0; i < mNumQueries; i++)
                 {
                         mOcclusionQueries.push_back(mRenderSystem->createHardwareOcclusionQuery());
@@ -321 +333 @@
         }
         //-----------------------------------------------------------------------
-        void OcclusionCullingSceneTraverser::renderBoundingBox( SceneNode *node )
+        void OcclusionCullingSceneTraverser::renderBoundingBox( AxisAlignedBox *box )
         {
                 // Render two halfes of the bounding box (using triangle fans)
@@ -327 +339 @@
                 {
                         //static Matrix4 xform[256];
-
-                        SolidHalfBoundingBox *box = getSolidHalfBoundingBox(half);
-                        box->setupBoundingBox(node->_getWorldAABB());
+                        //TODO: this should be full boudning box
+                        SolidHalfBoundingBox *halfbox = getSolidHalfBoundingBox(half);
+                        halfbox->setupBoundingBox(*box);
 
                         mRenderSystem->_setWorldMatrix(Matrix4::IDENTITY);
@@ -335 +347 @@
                         static RenderOperation ro;
 
-                        mSceneManager->useRenderableViewProjMode(box);
-                        box->getRenderOperation(ro);
-                        ro.srcRenderable = box; 
+                        mSceneManager->useRenderableViewProjMode(halfbox);
+                        halfbox->getRenderOperation(ro);
+                        ro.srcRenderable = halfbox; 
                         mRenderSystem->_render(ro);
 
@@ -421 +433 @@
                 mNumSceneNodes = num;
         }
+        //-----------------------------------------------------------------------
+        void OcclusionCullingSceneTraverser::setNumQueries(int num)
+        {
+                mNumQueries = num;
+        }
 }       

trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingTerrainSceneManager.cpp

@@ -8 +8 @@
 #include "OgreSolidHalfBoundingBox.h"
 
-//#include <windows.h>
+#include <windows.h>
 
 namespace Ogre {
@@ -14 +14 @@
         OcclusionCullingTerrainSceneManager::OcclusionCullingTerrainSceneManager()
         {
-                //mOcclusionCullingTerrainSceneTraverser = 
-                //      new OcclusionCullingTerrainSceneTraverser(this, mDestRenderSystem);
+                mOcclusionCullingTerrainSceneTraverser = 
+                        new OcclusionCullingTerrainSceneTraverser(this, mDestRenderSystem);
+                        //new OcclusionCullingSceneTraverser(this, mDestRenderSystem);
 
-                mOcclusionCullingTerrainSceneTraverser = 
-                        new OcclusionCullingSceneTraverser(this, mDestRenderSystem);
-
-                mDisplayNodes = true;
+                //mDisplayNodes = true;
                 //mShowBoundingBoxes = true;
                 mShowBoxes = true;
+                mMaxDepth = 20;
         }
         //-----------------------------------------------------------------------
@@ -46 +45 @@
                 setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
 
-                //mOcclusionCullingTerrainSceneTraverser->renderScene(mCameraInProgress, mOctree);
+                mOcclusionCullingTerrainSceneTraverser->renderScene(mCameraInProgress, mOctree);
                 //mOcclusionCullingTerrainSceneTraverser->renderScene(mCameraInProgress, mTerrainRoot);
-                mOcclusionCullingTerrainSceneTraverser->renderScene(mCullCamera, mSceneRoot);
+                //mOcclusionCullingTerrainSceneTraverser->renderScene(mCameraInProgress, mSceneRoot);
                 _deleteRenderedQueueGroups();
 
@@ -67 +66 @@
         {
         mOcclusionCullingTerrainSceneTraverser->setNumSceneNodes(mSceneNodes.size());
+                //HACK
+                mOcclusionCullingTerrainSceneTraverser->setNumQueries(countOctreeSize(mOctree));
                 mOcclusionCullingTerrainSceneTraverser->setRenderSystem(mDestRenderSystem);
 
@@ -98 +99 @@
                 //Add stuff to be rendered;
         NodeList::iterator it = octant->mNodes.begin();
-
-        if ( mShowBoxes )
-        {
-            mBoxes.push_back( octant->getWireBoundingBox() );
-        }
-
+         
         while ( it != octant->mNodes.end() )
         {
@@ -118 +114 @@
 
                                 if ( mDisplayNodes )
-                                {
                                         getRenderQueue()->addRenderable( sn );
 
-                                        // check if the scene manager or this node wants the bounding box shown.
-                                        if (sn->getShowBoundingBox() || mShowBoundingBoxes)
-                                                sn->_addBoundingBoxToQueue(getRenderQueue());
-                                }
+                                // check if the scene manager or this node wants the bounding box shown.
+                                if (sn->getShowBoundingBox() || mShowBoundingBoxes)
+                                        sn->_addBoundingBoxToQueue(getRenderQueue());
+
+                                if ( mShowBoxes )
+                                        getRenderQueue()->addRenderable(octant->getWireBoundingBox());
                         }
             ++it;
@@ -134 +131 @@
                 _deleteRenderedQueueGroups();
         }
+        //-----------------------------------------------------------------------
+        unsigned int OcclusionCullingTerrainSceneManager::countOctreeSize(Octree *root)
+        {
+                unsigned int result = 1;
+                                
+                for(int i=0; i<8; i++)
+                {
+                        Octree *nextChild = root->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1];
+                
+                        if(nextChild != 0)
+                                result += countOctreeSize(nextChild);
+                }
+                
+                return result;
+        }
 }       

trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingTerrainSceneTraverser.cpp

@@ -1 +1 @@
 #include "OgreOcclusionCullingTerrainSceneTraverser.h"
 #include "OgreOcclusionCullingTerrainSceneManager.h"
+#include "OgreHardwareOcclusionQuery.h"
 
 #include <windows.h>
@@ -11 +12 @@
         }
         //-----------------------------------------------------------------------
-        void OcclusionCullingTerrainSceneTraverser::traverseOctree( Camera *cam, Octree *octree )
+        void OcclusionCullingTerrainSceneTraverser::traverseOctant(Camera *cam, Octree *octant )
         {
                 mNumTraversedNodes ++;
         
-                if(octree->numNodes() > 0)
-                {
-                        renderOctree(cam, octree);
-                }
+                //if(octant->numNodes() > 0)
+                        renderOctant(cam, octant);
 
                 for(int i=0; i<8; i++)
                 {
-                        char msg[100];
-                        sprintf(msg,"current node: %d\n", i);
-                        OutputDebugString(msg);
-
-                        if(octree->mChildren[i & 4][i & 2][i & 1] != 0)
-                                traverseOctree(cam, octree->mChildren[i & 4][i & 2][i & 1]);                    
+                        Octree *nextChild = octant->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1];
+                
+                        if(nextChild != 0)
+                                mDistanceQueue->push(nextChild);
                 }
         }
@@ -43 +40 @@
                 mCurrentTestIdx = 0;
                 
-mCurrentAlgorithm = RENDER_CULL_FRUSTUM;
+//mCurrentAlgorithm = RENDER_CULL_FRUSTUM;
                 switch(mCurrentAlgorithm)
                 {
@@ -53 +50 @@
                                 break;
                         case RENDER_COHERENT:
-                                renderCoherentWithQueue(cam);
+                                //renderCoherentWithQueue(cam);
+                                renderStopAndWait(cam);
                                 break;
                         default:
@@ -68 +66 @@
         {
                 AxisAlignedBox box;
-                FrustumPlane plane;
 
                 while(!mDistanceQueue->empty())
                 {
-                        Octree *octree = mDistanceQueue->top();
+                        Octree *octant = mDistanceQueue->top();
                         mDistanceQueue->pop();
         
                         // interesting for visualization purpose
                         //TODO: octree->setNodeVisible(false);
-                        octree->_getCullBounds(&box);
+                        octant->_getCullBounds(&box);
+                        
+                        if(static_cast<OctreeCamera *>(cam)->getVisibility(box) == OctreeCamera::NONE)
+                        if(!cam->isVisible(box))
+                        {
+                                mNumFrustumCulledNodes ++;
+                                continue;
+                        }
 
-                        //if(cam->isVisible(box, &plane))
-                        //{
-                                // update node's visited flag 
-                                //TODO: octree->setLastVisited(mFrameId);
-                                //TODO: octree->setNodeVisible(true);
-                                traverseOctree(cam, octree);
-                        /*}
-                        else
-                        {                       
-                                mNumFrustumCulledNodes ++;
-                        }*/
+                        // update node's visited flag 
+                        //TODO: octree->setLastVisited(mFrameId);
+                        //TODO: octree->setNodeVisible(true);
+                
+                        traverseOctant(cam, octant);
                 }
         }       
-        
+        //-----------------------------------------------------------------------
         /** Renders the scene with the hierarchical stop and wait algorithm. */
         void OcclusionCullingTerrainSceneTraverser::renderStopAndWait( Camera *cam )
         {
+                AxisAlignedBox box;
+
+                while(!mDistanceQueue->empty())
+                {
+                        Octree *octant = mDistanceQueue->top();
+                        mDistanceQueue->pop();
+                
+                        // interesting for visualization purpose
+                        //octant->setNodeVisible(false);
+                        //octant->setLastVisited(mFrameId);
+
+                        //TODO: Isvisible also checked inside scenenode::findvisibleobjects
+                        octant->_getCullBounds(&box);
+
+                        char msg[100]; 
+                        Vector3 max = box.getMaximum();
+                        Vector3 min = box.getMinimum();
+
+                        sprintf(msg, "box max: %3.3f, %3.3f, %3.3f, min: %3.3f, %3.3f, %3.3f\n",max.x,max.y,max.z,min.x,min.y,min.z);
+                        OutputDebugString(msg);
+
+                        if(static_cast<OctreeCamera *>(cam)->getVisibility(box) == OctreeCamera::NONE)
+                        //if(!cam->isVisible(box))
+                        {
+                                mNumFrustumCulledNodes ++;
+                                continue;
+                        }
+
+                        HardwareOcclusionQuery *query = issueOcclusionQuery(&box, false);
+                                
+                        unsigned int visiblePixels;
+                        // wait if result not available
+                        query->pullOcclusionQuery(&visiblePixels);
+//traverseOctant(cam, octant);                  
+                        // node visible
+                        if(visiblePixels > mVisibilityThreshold)
+                        {
+                                traverseOctant(cam, octant);
+                                //mNumQueryCulledNodes ++;
+                        }
+                        else
+                        {
+                                mNumQueryCulledNodes ++;
+                        }
+                }
         }
-
+        //-----------------------------------------------------------------------
         /** Renders the scene with the coherent hierarchical algorithm and the query queye. */
         void OcclusionCullingTerrainSceneTraverser::renderCoherentWithQueue( Camera *cam )
         {
         }
-        
-        //-----------------------------------------------------------------------
-/*      bool OcclusionCullingTerrainSceneTraverser::isLeaf( SceneNode *node )
-        {
-                return (node->numChildren() == 0);
-        }*/
         //-----------------------------------------------------------------------
         void OcclusionCullingTerrainSceneTraverser::pullUpVisibility( Octree *node )
@@ -113 +150 @@
         }
         //-----------------------------------------------------------------------
-        void OcclusionCullingTerrainSceneTraverser::renderOctree( Camera *cam, Octree *octree )
+        void OcclusionCullingTerrainSceneTraverser::renderOctant( Camera *cam, Octree *octree )
         {
                 setRenderingMode(MODE_RENDER);