Changeset 99 for trunk/VUT/work

Timestamp:

05/15/05 04:08:02 (19 years ago)

Author:

mattausch

Message:

 

Location:

trunk/VUT/work

Files:

• TestCulling/TestCullingApplication.cpp (modified) (4 diffs)
• TestCulling/TestCullingApplication.h (modified) (2 diffs)
• TestCullingTerrain/TestCullingTerrainApplication.cpp (modified) (9 diffs)
• TestCullingTerrain/TestCullingTerrainApplication.h (modified) (6 diffs)
• ogre_changes/OgreMain/src/OgreSceneManager.cpp (modified) (4 diffs)
• ogre_changes/Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp (modified) (6 diffs)
• ogre_changes/RenderSystems/GL/src/OgreGLHardwareOcclusionQuery.cpp (modified) (6 diffs)

trunk/VUT/work/TestCulling/TestCullingApplication.cpp

@@ -111 +111 @@
 mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING),
 mShowOctree(false),
-mUseCulling(true),
+mUseVisibilityCulling(true),
 mUseOptimization(true),
-mUseCullCamera(false)
+mShowVisualization(false)
 {
     // Reduce move speed
@@ -153 +153 @@
         
         mSceneMgr->setOption("UseOptimization", &mUseOptimization);
-        mSceneMgr->setOption("UseCulling", &mUseCulling);
-        mSceneMgr->setOption("CullCamera", &mUseCullCamera);
+        mSceneMgr->setOption("UseVisibilityCulling", &mUseVisibilityCulling);
+        mSceneMgr->setOption("ShowVizualisation", &mShowVisualization);
         mSceneMgr->setOption("ShowOctree", &mShowOctree);
 
@@ -235 +235 @@
         KEY_PRESSED(KC_ADD, 0, changeThreshold(10));
         KEY_PRESSED(KC_O, 0.3, toggleUseOptimization());
-        KEY_PRESSED(KC_C, 0.3, toggleUseCulling());
-        KEY_PRESSED(KC_V, 0.3, toggleCullCamera());
+        KEY_PRESSED(KC_C, 0.3, toggleUseVisibilityCulling());
+        KEY_PRESSED(KC_V, 0.3, toggleShowViz());
 
         updateStats();
@@ -281 +281 @@
 }
 //-----------------------------------------------------------------------
-void MouseQueryListener::toggleUseCulling()
-{
-        mUseCulling = !mUseCulling;
-
-        mSceneMgr->setOption("UseCulling", &mUseCulling);
-}
-//-----------------------------------------------------------------------
-void MouseQueryListener::toggleCullCamera()
-{
-        mUseCullCamera = !mUseCullCamera;
-
-        mSceneMgr->setOption("CullCamera", &mUseCullCamera);
+void MouseQueryListener::toggleUseVisibilityCulling()
+{
+        mUseVisibilityCulling = !mUseVisibilityCulling;
+
+        mSceneMgr->setOption("UseVisibilityCulling", &mUseVisibilityCulling);
+}
+//-----------------------------------------------------------------------
+void MouseQueryListener::toggleShowViz()
+{
+        mShowVisualization = !mShowVisualization;
+
+        mSceneMgr->setOption("CullCamera", &mShowVisualization);
 }
 //-----------------------------------------------------------------------

trunk/VUT/work/TestCulling/TestCullingApplication.h

@@ -66 +66 @@
         void toggleUseOptimization();
         void toggleShowOctree();
-        void toggleUseCulling();
-        void toggleCullCamera();
+        void toggleUseVisibilityCulling();
+        void toggleShowViz();
 
 protected:
@@ -94 +94 @@
         bool mUseOptimization;
         bool mShowOctree;
-        bool mUseCulling;
-        bool mUseCullCamera;
+        bool mUseVisibilityCulling;
+        bool mShowVisualization;
 
         Camera *mVisualizationCamera;

trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

@@ -27 +27 @@
         if(mTerrainContentGenerator)
                 delete mTerrainContentGenerator;
+        //if(mRenderTargetListener)     delete mRenderTargetListener;
 }
 //-----------------------------------------------------------------------
 void TestCullingTerrainApplication::createCamera()
 {
-        // Create the camera
-        mCamera = mSceneMgr->createCamera("CullCamera");
-        
-        // Set a nice viewpoint
+        // create the camera
+        mCamera = mSceneMgr->createCamera("PlayerCam");
+        
+        // set a nice viewpoint
         mCamera->setPosition(707, 2500, 528);
         mCamera->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
         
-        //--create cull camera
-        mVisualizationCamera = mSceneMgr->createCamera("VisualizationCamera");
-        mVisualizationCamera->setPosition(707, 2500, 528);
-        mVisualizationCamera->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
+        //--create visualization camera
+        mVisualizationCamera = mSceneMgr->createCamera("VizCam");
+        mVisualizationCamera->setPosition(mCamera->getPosition());
+        mVisualizationCamera->setOrientation(mCamera->getOrientation());
 
         mVisualizationCamera->setNearClipDistance(1);
         mCamera->setNearClipDistance(1);
 
-        // Infinite far plane?
+        // infinite far plane?
         if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
         {
@@ -56 +57 @@
                  mVisualizationCamera->setFarClipDistance(1000);
                  mCamera->setFarClipDistance(1000);
-        }
-        
+        }       
+}
+
+//-----------------------------------------------------------------------
+bool TestCullingTerrainApplication::setup()
+{
+        bool result = ExampleApplication::setup();
+
+        createRenderTargetListener();
+
+        return result;
+}
+//-----------------------------------------------------------------------
+void TestCullingTerrainApplication::createRenderTargetListener()
+{
+        mWindow->addListener(new VisualizationRenderTargetListener(mSceneMgr));
 }
 //-----------------------------------------------------------------------
@@ -152 +167 @@
 mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING),
 mShowOctree(false),
-mUseCulling(true),
+mUseVisibilityCulling(true),
 mUseOptimization(true),
-mUseCullCamera(false),
 mVisualizationCamera(vizCamera)
 {
@@ -197 +211 @@
 
         mSceneMgr->setOption("UseOptimization", &mUseOptimization);
-        mSceneMgr->setOption("UseCulling", &mUseCulling);
-        mSceneMgr->setOption("CullCamera", &mUseCullCamera);
+        mSceneMgr->setOption("UseVisibilityCulling", &mUseVisibilityCulling);
         mSceneMgr->setOption("ShowOctree", &mShowOctree);
-
+        
     pOver->show();
 } 
@@ -241 +254 @@
      } // else if
 } // mousePressed
-
- //-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 void MouseQueryListener::mouseReleased(MouseEvent* e)
 {
@@ -316 +328 @@
         KEY_PRESSED(KC_O, 0.3, toggleUseOptimization());
         KEY_PRESSED(KC_Y, 0.3, toggleShowOctree());
-        KEY_PRESSED(KC_C, 0.3, toggleUseCulling());
-        KEY_PRESSED(KC_V, 0.3, toggleCullCamera());
+        KEY_PRESSED(KC_C, 0.3, toggleUseVisibilityCulling());
+        KEY_PRESSED(KC_V, 0.3, toggleShowViz());
         KEY_PRESSED(KC_X, 0.3, FixVizCamera());
 
@@ -397 +409 @@
 }
 //-----------------------------------------------------------------------
-void MouseQueryListener::toggleUseCulling()
-{
-        mUseCulling = !mUseCulling;
-
-        mSceneMgr->setOption("UseCulling", &mUseCulling);
-}
-//-----------------------------------------------------------------------
-void MouseQueryListener::toggleCullCamera()
-{
-        mUseCullCamera = !mUseCullCamera;
-
-        if(mUseCullCamera)
+void MouseQueryListener::toggleUseVisibilityCulling()
+{
+        mUseVisibilityCulling = !mUseVisibilityCulling;
+
+        mSceneMgr->setOption("UseVisibilityCulling", &mUseVisibilityCulling);
+}
+//-----------------------------------------------------------------------
+void MouseQueryListener::toggleShowViz()
+{
+        mShowVisualization = !mShowVisualization;
+
+        // create viewport with priority 10: will be rendered over standard viewport
+        if(mShowVisualization)
         {       
                 mWindow->addViewport(mVisualizationCamera, 10, 0.5, 0.5, 1, 1);
@@ -414 +427 @@
         }
         else
+        {
                 mWindow->removeViewport(10);
-
-        mSceneMgr->setOption("CullCamera", &mUseCullCamera);
+        }
 }
 //-----------------------------------------------------------------------
@@ -451 +464 @@
         // Do nothing
         e->consume();
+}
+/**************************************************************/
+/*      VisualizationRenderTargetListener implementation      */
+/**************************************************************/
+VisualizationRenderTargetListener::VisualizationRenderTargetListener(SceneManager *sceneMgr)
+:RenderTargetListener(), mSceneMgr(sceneMgr)
+{
+}
+//-----------------------------------------------------------------------
+void VisualizationRenderTargetListener::preViewportUpdate(const RenderTargetViewportEvent &evt)
+{
+        const bool b = evt.source->getZOrder() == 10; // visualization viewport
+                        
+        mSceneMgr->setOption("ShowVisualization", &b);
+        
+        RenderTargetListener::preViewportUpdate(evt);
+}
+//-----------------------------------------------------------------------
+void VisualizationRenderTargetListener::postRenderTargetUpdate(const RenderTargetEvent &evt)
+{
+        RenderTargetListener::postRenderTargetUpdate(evt);
 }
 //-----------------------------------------------------------------------

trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.h

@@ -7 +7 @@
 #include "TerrainContentGenerator.h"
 #include "VisibilityEnvironment.h"
+#include <OgreRenderTargetListener.h>
 
 Real timeDelay = 0;
@@ -23 +24 @@
         "Stop and Wait Culling", 
         "Coherent Hierarchical Culling"
+};
+
+class VisualizationRenderTargetListener: public RenderTargetListener
+{
+public:
+        VisualizationRenderTargetListener(SceneManager *sceneMgr);
+
+protected:
+        void preViewportUpdate (const RenderTargetViewportEvent &evt);
+        void postRenderTargetUpdate (const RenderTargetEvent &evt);
+
+        SceneManager *mSceneMgr;
 };
 
@@ -65 +78 @@
         void toggleUseOptimization();
         void toggleShowOctree();
-        void toggleUseCulling();
-        void toggleCullCamera();
+        void toggleUseVisibilityCulling();
+        void toggleShowViz();
         void FixVizCamera();
 
@@ -100 +113 @@
         bool mUseOptimization;
         bool mShowOctree;
-        bool mUseCulling;
-        bool mUseCullCamera;
+        bool mUseVisibilityCulling;
+        bool mShowVisualization;
 
         Camera *mVisualizationCamera;
@@ -113 +126 @@
 
 protected:
+        //-- inherited from ExampleApplication
+        bool setup();
         void createScene();
         void createFrameListener();
+        void createCamera();
+        //void createViewports();
+        
+        virtual void createRenderTargetListener();
+
+        /** cegui setup */
         void setupGui();
-        virtual void createCamera();
 
         CEGUI::OgreCEGUIRenderer *mGUIRenderer;
@@ -128 +148 @@
 
         TerrainContentGenerator *mTerrainContentGenerator;
+        
+        Camera *mVisualizationCamera;
+        VisualizationRenderTargetListener *mRenderTargetListener;
 
-        Camera *mVisualizationCamera;
-        
 private:
         void chooseSceneManager(void);
 };
-

trunk/VUT/work/ogre_changes/OgreMain/src/OgreSceneManager.cpp

@@ -4178 +4178 @@
     }
 }
-#ifdef OGRE_COHERENT_OCCLUSION_CULLING
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
 //-----------------------------------------------------------------------
 void SceneManager::_renderSceneNode( Camera *cam, SceneNode *node )
@@ -4193 +4193 @@
         RenderQueue::QueueGroupIterator queueIt = getRenderQueue()->_getQueueGroupIterator();
 
+        // find currently processed queue groups and delelete them from render queue
         while (queueIt.hasMoreElements())
         {
@@ -4198 +4199 @@
                 RenderQueueGroup* pGroup = queueIt.getNext();
 
-                // delete this queue group if already processed
                 if (isRenderQueueToBeProcessed(qId))
                         pGroup->clear();
@@ -4206 +4206 @@
         // Pass::processPendingPassUpdates();
 }
-#endif //OGRE_COHERENT_OCCLUSION_CULLING
-}
+#endif //GTP_VISIBILITY_MODIFIED_OGRE
+}

trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp

@@ -316 +316 @@
 
     mOctree = new Octree( 0 );
-#ifdef OGRE_COHERENT_OCCLUSION_CULLING
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
         mNumOctreeNodes = 1;
-#endif // OGRE_COHERENT_OCCLUSION_CULLING
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
     mMaxDepth = depth;
     mBox = box;
@@ -461 +461 @@
         {
             octant -> mChildren[ x ][ y ][ z ] = new Octree( octant );
-#ifdef OGRE_COHERENT_OCCLUSION_CULLING
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
         mNumOctreeNodes ++;
-#endif // OGRE_COHERENT_OCCLUSION_CULLING
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
 
             const Vector3 *corners = octant -> mBox.getAllCorners();
@@ -1028 +1028 @@
 
     mOctree = new Octree( 0 );
-#ifdef OGRE_COHERENT_OCCLUSION_CULLING
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
         mNumOctreeNodes = 1;
-#endif // OGRE_COHERENT_OCCLUSION_CULLING
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
     mOctree->mBox = box;
 
@@ -1166 +1166 @@
     return q;
 }
-#ifdef OGRE_COHERENT_OCCLUSION_CULLING
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
 //-----------------------------------------------------------------------
 void OctreeSceneManager::_renderOctant(Camera *cam, Octree *octant)
@@ -1177 +1177 @@
                 OctreeNode *sn = *it;
 
-        mNumObjects++;
+        ++mNumObjects;
 
                 // check bounding box visibility of scene nodes
@@ -1187 +1187 @@
 
                         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());
-
-                        if (mShowBoxes)
-                                getRenderQueue()->addRenderable(octant->getWireBoundingBox());
+                        }
                 }
         ++it;
         }
 
+        if (mShowBoxes)
+        {
+                getRenderQueue()->addRenderable(octant->getWireBoundingBox());
+                ++mNumObjects;
+        }
+
         SceneManager::_renderVisibleObjects();
 
-        // delete all rendered objects from renderqueue
+        // delete all rendered objects from the render queue
         _deleteRenderedQueueGroups();
 }
-#endif // OGRE_COHERENT_OCCLUSION_CULLING
-}
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
+}

trunk/VUT/work/ogre_changes/RenderSystems/GL/src/OgreGLHardwareOcclusionQuery.cpp

@@ -161 +161 @@
 
         // Check for hardware occlusion support
-    // if( glDeleteOcclusionQueriesNV_ptr != 0 )        // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported.
-        if( glDeleteQueriesARB_ptr != 0 )
+    if ( glDeleteOcclusionQueriesNV_ptr != 0 )  // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported.
+        //if ( glDeleteQueriesARB_ptr != 0 )
         {
                 m_bHWOcclusionSupport = true;
@@ -171 +171 @@
         }
 
-        if( m_bHWOcclusionSupport )
-        {
-                //glGenOcclusionQueriesNV_ptr( 1, m_uintQuery );        
-                glGenQueriesARB_ptr(1, m_uintQuery);
+        if ( m_bHWOcclusionSupport )
+        {
+                glGenOcclusionQueriesNV_ptr( 1, m_uintQuery );  
+                //glGenQueriesARB_ptr(1, m_uintQuery);
         }
 }
@@ -182 +182 @@
 GLHardwareOcclusionQuery::~GLHardwareOcclusionQuery() 
 { 
-        if( m_bHWOcclusionSupport )
-        {
-                //glDeleteOcclusionQueriesNV_ptr( 1, &m_uintQuery[0] );  
-                glDeleteQueriesARB_ptr(1, &m_uintQuery[0]);
+        if ( m_bHWOcclusionSupport )
+        {
+                glDeleteOcclusionQueriesNV_ptr( 1, &m_uintQuery[0] );  
+                //glDeleteQueriesARB_ptr(1, &m_uintQuery[0]);
         }       
 }
@@ -192 +192 @@
 void GLHardwareOcclusionQuery::beginOcclusionQuery() 
 { 
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
+        if ( m_bHWOcclusionSupport )    // Make it fail silently if hardware occlusion isn't supported
         {
                 // do the actual occlusion query for this node
-                //glBeginOcclusionQueryNV_ptr( m_uintQuery[0] );
-                glBeginQueryARB_ptr(GL_SAMPLES_PASSED_ARB, m_uintQuery[0]);
+                glBeginOcclusionQueryNV_ptr( m_uintQuery[0] );
+                //glBeginQueryARB_ptr(GL_SAMPLES_PASSED_ARB, m_uintQuery[0]);
         }
 }
@@ -202 +202 @@
 void GLHardwareOcclusionQuery::endOcclusionQuery() 
 { 
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
-        {
-                //glEndOcclusionQueryNV_ptr();
-                glEndQueryARB_ptr(GL_SAMPLES_PASSED_ARB);
+        if ( m_bHWOcclusionSupport )    // Make it fail silently if hardware occlusion isn't supported
+        {
+                glEndOcclusionQueryNV_ptr();
+                //glEndQueryARB_ptr(GL_SAMPLES_PASSED_ARB);
         }
 }
@@ -211 +211 @@
 bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments, const bool waitForResult) 
 {
-        //unsigned int isAvailable = GL_TRUE;
-        int isAvailable = GL_TRUE;
+        unsigned int isAvailable = GL_TRUE;
+        //int isAvailable = GL_TRUE;
 
         if( m_bHWOcclusionSupport )     
         {
-                if(!waitForResult)
-                {
-                        //glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable );
-                        glGetQueryivARB_ptr(m_uintQuery[0], GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable);
-                }
-
-                if(isAvailable == GL_TRUE)
-                {
-                        glGetQueryObjectuivARB_ptr( m_uintQuery[0], GL_QUERY_RESULT_ARB, NumOfFragments);
-                        //glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
+                if (!waitForResult)
+                {
+                        glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable );
+                        //glGetQueryivARB_ptr(m_uintQuery[0], GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable);
+                }
+
+                if (isAvailable == GL_TRUE)
+                {
+                        glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
+                        //glGetQueryObjectuivARB_ptr( m_uintQuery[0], GL_QUERY_RESULT_ARB, NumOfFragments);
                 }
         }