Changeset 26

Timestamp:

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

Author:

gametools

Message:

 

Location:

trunk/VUT/OcclusionCullingSceneManager

Files:

• TestCulling/TestCullingApplication.h (modified) (8 diffs)
• include/OgreOcclusionCullingSceneManager.h (modified) (5 diffs)
• include/OgreSolidBoundingBox.h (deleted)
• include/OgreSolidHalfBoundingBox.h (added)
• scripts/Plugin_OcclusionCullingSceneManager.vcproj (modified) (2 diffs)
• src/OgreOcclusionCullingSceneManager.cpp (modified) (19 diffs)
• src/OgreSolidBoundingBox.cpp (deleted)
• src/OgreSolidHalfBoundingBox.cpp (added)

trunk/VUT/OcclusionCullingSceneManager/TestCulling/TestCullingApplication.h

@@ -5 +5 @@
 #include "CEGUIForwardRefs.h"
 #include "ExampleApplication.h"
-
+#include "OgreOcclusionCullingSceneManager.h"
 
 class MouseQueryListener : public ExampleFrameListener, public MouseListener, public MouseMotionListener
@@ -13 +13 @@
     MouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager, CEGUI::Renderer *renderer,
                                            SceneNode* shipNode)
-        : ExampleFrameListener(win, cam, false, true), mGUIRenderer(renderer), mShipNode(shipNode)
+        : ExampleFrameListener(win, cam, false, true), mGUIRenderer(renderer), mShipNode(shipNode),  mShutdownRequested(false)
     {
                 // Setup default variables
@@ -24 +24 @@
         mMoveSpeed = 50;
         mRotateSpeed *= 2;
+        
+                mAlgorithmType = OcclusionCullingSceneManager::RENDER_COHERENT;
+
+                 showDebugOverlay(false);
 
                 // Register this so that we get mouse events.
-        mEventProcessor->addMouseListener( this );
-        mEventProcessor->addMouseMotionListener( this );
+        mEventProcessor->addMouseListener(this);
+        mEventProcessor->addMouseMotionListener(this);
+                mEventProcessor->addKeyListener(this);
     } // MouseQueryListener
 
@@ -36 +41 @@
     bool frameStarted(const FrameEvent &evt)
     {
-        return ExampleFrameListener::frameStarted( evt );
+       Real MoveFactor = 80.0 * evt.timeSinceLastFrame;
+ 
+                mInputDevice->capture();
+ 
+                if(mInputDevice->isKeyDown(Ogre::KC_UP))
+                {
+
+                        mAlgorithmType = (mAlgorithmType + 1) % OcclusionCullingSceneManager::NUM_RENDERMODES;
+                        //mShipNode->translate(0.0, MoveFactor, 0.0);
+                }
+ 
+                if(mInputDevice->isKeyDown(Ogre::KC_DOWN))
+                        mShipNode->translate(0.0, -MoveFactor, 0.0);
+ 
+                if(mInputDevice->isKeyDown(Ogre::KC_LEFT))
+                        mShipNode->translate(-MoveFactor, 0.0, 0.0);
+ 
+                if(mInputDevice->isKeyDown(Ogre::KC_RIGHT))
+                        mShipNode->translate(MoveFactor, 0.0, 0.0);             
+ 
+                if(mInputDevice->isKeyDown(Ogre::KC_ESCAPE))
+                        return false;
+
+                return true;
     }
 
@@ -56 +84 @@
    virtual void mouseDragged (MouseEvent *e);
 
+   void keyPressed(KeyEvent* e)
+   {
+        if(e->getKey() == KC_ESCAPE)
+        {
+            mShutdownRequested = true;
+            e->consume();
+            return;
+        }
+
+        CEGUI::System::getSingleton().injectKeyDown(e->getKey());
+                CEGUI::System::getSingleton().injectChar(e->getKeyChar());
+        e->consume();
+    }
+
+        void keyReleased(KeyEvent* e)
+        {
+                CEGUI::System::getSingleton().injectKeyUp(e->getKey());
+                e->consume();
+        }
+        void keyClicked(KeyEvent* e) 
+        {
+                // Do nothing
+                e->consume();
+        }
+
+          bool frameEnded(const FrameEvent& evt)
+    {
+        if (mShutdownRequested)
+            return false;
+        else
+            return ExampleFrameListener::frameEnded(evt);
+    }
+
+        void setAlgorithmType(int type) { mAlgorithmType = type; }
+        int getAlgorithmType() { return mAlgorithmType; }
+
 protected:
     bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down
@@ -62 +126 @@
     CEGUI::Renderer *mGUIRenderer;     // cegui renderer
         SceneNode* mShipNode;
+        bool mShutdownRequested;
+        int mAlgorithmType;
 };
 
-
-class TestCullingFrameListener : public ExampleFrameListener
-{
-protected:
-    SceneNode* mShipNode;
-
-public:
-    TestCullingFrameListener(RenderWindow* win, Camera* cam, SceneNode* shipNode) : ExampleFrameListener(win, cam)
-    {
-                mShipNode = shipNode;
-    };
-
-        bool frameStarted(const FrameEvent& evt)
-        {
-                Real MoveFactor = 80.0 * evt.timeSinceLastFrame;
- 
-                mInputDevice->capture();
- 
-                if(mInputDevice->isKeyDown(Ogre::KC_UP))
-                        mShipNode->translate(0.0, MoveFactor, 0.0);
- 
-                if(mInputDevice->isKeyDown(Ogre::KC_DOWN))
-                        mShipNode->translate(0.0, -MoveFactor, 0.0);
- 
-                if(mInputDevice->isKeyDown(Ogre::KC_LEFT))
-                        mShipNode->translate(-MoveFactor, 0.0, 0.0);
- 
-                if(mInputDevice->isKeyDown(Ogre::KC_RIGHT))
-                        mShipNode->translate(MoveFactor, 0.0, 0.0);             
- 
-                if(mInputDevice->isKeyDown(Ogre::KC_ESCAPE))
-                        return false;
- 
-                return true;
-        }
-};
 
 class TestCullingApplication : public ExampleApplication
@@ -106 +136 @@
     /*TestCullingApplication()
     {
-
 
     }*/
@@ -150 +179 @@
     {
         mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
-                //mSceneMgr = mRoot->getSceneManager(ST_INTERIOR);
     }
-        /*
-    // Scene creation
-    void createScene(void)
-    {
-
-        // Load world geometry
-        mSceneMgr->setWorldGeometry(mQuakeLevel);
-
-        // modify camera for close work
-        mCamera->setNearClipDistance(4);
-        mCamera->setFarClipDistance(4000);
-
-        // Also change position, and set Quake-type orientation
-        // Get random player start point
-        ViewPoint vp = mSceneMgr->getSuggestedViewpoint(true);
-        mCamera->setPosition(vp.position);
-        mCamera->pitch(Degree(90)); // Quake uses X/Y horizon, Z up
-        mCamera->rotate(vp.orientation);
-        // Don't yaw along variable axis, causes leaning
-        mCamera->setFixedYawAxis(true, Vector3::UNIT_Z);
-    }*/
-
+        
 };
 

trunk/VUT/OcclusionCullingSceneManager/include/OgreOcclusionCullingSceneManager.h

@@ -5 +5 @@
 #include "OgreSceneManager.h"
 #include "OgrePrerequisites.h"
+#include "OgreSolidHalfBoundingBox.h"
 #include <queue>
 
@@ -27 +28 @@
         };
 
+        typedef pair<SceneNode *, HardwareOcclusionQuery *> query_pair;
         typedef priority_queue<SceneNode *, vector<SceneNode *>, myless<vector<SceneNode *>::value_type> > PriorityQueue;
-        typedef queue<SceneNode *> QueryQueue;
+        typedef queue<query_pair> QueryQueue;
         /**
                 Class which implements a scene mangager which uses occlusion queries for culling occluded objects
@@ -35 +37 @@
         {
         public:
-                enum {RENDER_CULL_FRUSTUM, RENDER_STOP_AND_WAIT, RENDER_COHERENT, NUM_RENDERMODES};
-                
                 OcclusionCullingSceneManager();
                 ~OcclusionCullingSceneManager();
         
-                /** Overriden from SceneManager. */
+
+                enum {RENDER_CULL_FRUSTUM, RENDER_STOP_AND_WAIT, RENDER_COHERENT, NUM_RENDERMODES};
+                
+                /** Overriden from SceneManager. Renders the scene with the specified algorithm
+                /**
+                        The algorithm is one of
+                        RENDER_CULL_FRUSTUM: renders the scene with view frustum culling only
+                        RENDER_STOP_AND_WAIT: renders the scene with the hierarchical stop and wait algorithm
+                        RENDER_COHERENT: renders the scene with the coherent hierarchical algorithm
+                */
                 void _renderVisibleObjects(void);
                 void _findVisibleObjects(Camera* cam, bool onlyShadowCasters);
@@ -64 +73 @@
                 void renderCoherentWithQueue();
                 /** Issue a occlusion query for this node. */
-                void issueOcclusionQuery(SceneNode *node, bool wasVisible);
+                HardwareOcclusionQuery *issueOcclusionQuery(SceneNode *node, bool wasVisible);
                 /** Pulls up the visibility from the child nodes. */
                 void pullUpVisibility(SceneNode *node);
+                /** delete all previously defined occlusion queries */
+                void deleteQueries();
+                /** Renders bounding box of specified node.
+                @param the node which bounding box is to be rendered
+                */
+                void renderBoundingBox(SceneNode *node);
+                /** Returns one half of the bounding box.
+                @param the half of the bouding box
+                */
+                SolidHalfBoundingBox *getSolidHalfBoundingBox(int half);
+                /** sets the type of the algorithm
+                @param algorithm type
+                */
+                void setAlgorithmType(int type);
+        
+                int getAlgorithmType();
 
-                void deleteQueries();
-
-                /** we use a priority queue rather than a renderstack */
+                // we use a priority queue rather than a renderstack
                 PriorityQueue *mDistanceQueue; 
-
+                
                 unsigned int mFrameId;
                 unsigned int mVisibilityThreshold;
@@ -80 +103 @@
                 
                 std::vector<HardwareOcclusionQuery *> mOcclusionQueries;
+                // two halfes of a aabb
+                SolidHalfBoundingBox *mHalfBoundingBox[2];      
+                int mAlgorithmType;
         };
 

trunk/VUT/OcclusionCullingSceneManager/scripts/Plugin_OcclusionCullingSceneManager.vcproj

@@ -154 +154 @@
                         </File>
                         <File
-                                RelativePath="..\src\OgreSolidBoundingBox.cpp">
+                                RelativePath="..\src\OgreSolidHalfBoundingBox.cpp">
                         </File>
                         <File
@@ -170 +170 @@
                         </File>
                         <File
-                                RelativePath="..\include\OgreSolidBoundingBox.h">
+                                RelativePath="..\include\OgreSolidHalfBoundingBox.h">
                         </File>
                 </Filter>

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;
+        }
 }