Changeset 41

Timestamp:

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

Author:

mattausch

Message:

 

Location:

trunk/VUT/OcclusionCullingSceneManager

Files:

• TestCulling/TestCullingApplication.cpp (modified) (4 diffs)
• include/OgreOcclusionCullingSceneTraverser.h (modified) (4 diffs)
• include/OgreOcclusionCullingTerrainSceneManager.h (modified) (1 diff)
• include/OgreOcclusionCullingTerrainSceneTraverser.h (modified) (1 diff)
• src/OgreOcclusionCullingSceneManager.cpp (modified) (1 diff)
• src/OgreOcclusionCullingSceneTraverser.cpp (modified) (12 diffs)
• src/OgreOcclusionCullingTerrainSceneManager.cpp (modified) (7 diffs)
• src/OgreOcclusionCullingTerrainSceneTraverser.cpp (modified) (6 diffs)

trunk/VUT/OcclusionCullingSceneManager/TestCulling/TestCullingApplication.cpp

@@ -62 +62 @@
         ColourValue fadeColour(0.93, 0.86, 0.76);
         mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 500, 1000);
+ //mSceneMgr->setFog( FOG_EXP, fadeColour, 0.005 );
         mWindow->getViewport(0)->setBackgroundColour(fadeColour);
+
+         // Create a skybox
+     //mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", 500, false);
+         //mSceneMgr->setSkyDome( true, "Examples/CloudySky", 5, 8, 500, false );
 
         std::string terrain_cfg("terrain.cfg");
@@ -70 +75 @@
         mSceneMgr -> setWorldGeometry( terrain_cfg );
         // Infinite far plane?
-        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
+/*      if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
         {
                 mCamera->setFarClipDistance(0);
-        }
-
-        // Define the required skyplane
+        }*/
+
+/*      // Define the required skyplane
         Plane plane;
         // 5000 world units from the camera
@@ -81 +86 @@
         // Above the camera, facing down
         plane.normal = -Vector3::UNIT_Y;
+        // Create the plane 10000 units wide, tile the texture 3 times
+    mSceneMgr->setSkyPlane(true, plane, "Examples/SpaceSkyPlane",10000,3);*/
 
         // Set a nice viewpoint
@@ -89 +96 @@
         Ray(mCamera->getPosition(), Vector3::NEGATIVE_UNIT_Y));
 
-     // Create a skybox
-  //   mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox");
-
-         // CEGUI setup
-         setupGui();
+        Entity *robotEnt = mSceneMgr->createEntity( "Robot", "robot.mesh" );
+        SceneNode *robotNode = mSceneMgr->getRootSceneNode()->createChildSceneNode( "RobotNode", Vector3( 750, 25, 600 ));
+        robotNode->attachObject( robotEnt );
+        robotNode->scale( .3, .3, .3 );
+        robotNode->yaw( Degree( 160 ) );
+
+        Entity *ogreEnt = mSceneMgr->createEntity( "Ogre", "ogrehead.mesh" );
+    SceneNode *ogreNode = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Ogre", Vector3( 800, 50, 830 ) );
+    ogreNode->attachObject( ogreEnt );
+        ogreNode->scale(.2,.2,.2);
+        ogreNode->yaw( Degree( 20 ) );
+
+        Entity *ogreEnt2 = mSceneMgr->createEntity( "Ogre2", "ogrehead.mesh" );
+    SceneNode *ogreNode2 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Ogre2", Vector3( 700, 50, 730 ) );
+    ogreNode2->attachObject( ogreEnt2 );
+        ogreNode2->scale(.05,.05,.05);
+        ogreNode->yaw( Degree( 40 ) );
+
+        // CEGUI setup
+        setupGui();
 }
 //-----------------------------------------------------------------------

trunk/VUT/OcclusionCullingSceneManager/include/OgreOcclusionCullingSceneTraverser.h

@@ -93 +93 @@
                 void setNumSceneNodes(int num );
 
+                /** Sets the required number of occlusion queries.
+                @param num number occlusion queries
+                */
+                void setNumQueries( int num );
+
         protected:
                 /** query mode (= without color) or RENDER_MODE */
@@ -114 +119 @@
                 /** Renders the scene with the coherent hierarchical algorithm and the query queye. */
                 void renderCoherentWithQueue( Camera *cam );
-                /** Issue a occlusion query for this node. */
-                HardwareOcclusionQuery *issueOcclusionQuery( SceneNode *node, bool wasVisible );
+                /** Issue a occlusion query for this node. 
+                @param box the axis aligned bounding box of the node
+                @wasVisible if the node was visible in previous frame
+                */
+                HardwareOcclusionQuery *issueOcclusionQuery( AxisAlignedBox *box, bool wasVisible );
                 /** Pulls up the visibility from the child nodes. */
                 void pullUpVisibility( SceneNode *node );
@@ -121 +129 @@
                 void deleteQueries();
                 /** Renders bounding box of specified node.
-                @param the scene node contained in the bounding box to be rendered
-                */
-                void renderBoundingBox( SceneNode *node );
+                @param box the bounding box of the scene node to be rendered */
+                void renderBoundingBox( AxisAlignedBox *box );
                 /** Returns one half of the bounding box.
-                @param the half of the bouding box
+                @param half the half index of the bouding box (0 or 1)
                 */
                 SolidHalfBoundingBox *getSolidHalfBoundingBox( int half );
@@ -147 +154 @@
                 int mQueryMode;
 
+                unsigned int mNumQueries;
+
                 //--- statistics
                 unsigned int mNumSceneNodes;

trunk/VUT/OcclusionCullingSceneManager/include/OgreOcclusionCullingTerrainSceneManager.h

@@ -55 +55 @@
 
         protected:
-                //OcclusionCullingTerrainSceneTraverser *mOcclusionCullingTerrainSceneTraverser;
-                OcclusionCullingSceneTraverser *mOcclusionCullingTerrainSceneTraverser;
+                /** Recursively counts octree size (i.e., number of octree instances)
+                @param root current octree
+                */
+                unsigned int countOctreeSize(Octree *root);
+
+                OcclusionCullingTerrainSceneTraverser *mOcclusionCullingTerrainSceneTraverser;
+                //OcclusionCullingSceneTraverser *mOcclusionCullingTerrainSceneTraverser;
         };
 

trunk/VUT/OcclusionCullingSceneManager/include/OgreOcclusionCullingTerrainSceneTraverser.h

@@ -59 +59 @@
                 
                 void pullUpVisibility( Octree *octree );
-                void traverseOctree( Camera *cam, Octree *octree );
-                void renderOctree( Camera *cam, Octree *octree );
+                void traverseOctant(Camera *cam, Octree *octant );
+                void renderOctant( Camera *cam, Octree *octant );
 
                 OctreePriorityQueue *mDistanceQueue;

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);