Changeset 720 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityTerrainSceneManager.cpp

Timestamp:

03/31/06 10:37:45 (18 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityTerrainSceneManager.cpp (modified) (41 diffs)

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityTerrainSceneManager.cpp

@@ -1 @@
-#include "OgreOcclusionCullingSceneManager.h"
+#include "OgreVisibilityTerrainSceneManager.h"
 #include "OgreVisibilityOptionsManager.h"
 #include <OgreMath.h>
@@ -10 +10 @@
 #include <OgreSubEntity.h>
 
+// HACK
+const static DEBUG_CHC = false;
 
 namespace Ogre {
 
 //-----------------------------------------------------------------------
-OcclusionCullingSceneManager::OcclusionCullingSceneManager(
+VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(
                                                         GtpVisibility::VisibilityManager *visManager): 
 mVisibilityManager(visManager), 
@@ -32 +34 @@
 mSkipTransparents(false),
 mRenderTransparentsForItemBuffer(true),
-mExecuteVertexProgramForAllPasses(true),
+mExecuteVertexProgramForAllPasses(false),
 mIsHierarchicalCulling(false)
 {
         mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
         
-        //mDisplayNodes = true;
-        //mShowBoundingBoxes = true;
-        //mShowBoxes = true;
+        if (0)
+        {
+                mDisplayNodes = true;
+                mShowBoundingBoxes = true;
+                mShowBoxes = true;
+        }
 
         // TODO: set maxdepth to reasonable value
@@ -45 +50 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::InitDepthPass()
+void VisibilityTerrainSceneManager::InitDepthPass()
 {
         MaterialPtr depthMat = MaterialManager::getSingleton().getByName("Visibility/DepthPass");
@@ -56 +61 @@
 
         mDepthPass = depthMat->getTechnique(0)->getPass(0);
+
                 mDepthPass->setColourWriteEnabled(false);
                 mDepthPass->setDepthWriteEnabled(true);
                 mDepthPass->setLightingEnabled(false);
+                //mDepthPass->setDepthCheckEnabled(true);
         }
         else
@@ -66 +73 @@
 }
 //-----------------------------------------------------------------------
-OcclusionCullingSceneManager::~OcclusionCullingSceneManager()
+VisibilityTerrainSceneManager::~VisibilityTerrainSceneManager()
 {
         OGRE_DELETE(mHierarchyInterface);
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::InitItemBufferPass()
+void VisibilityTerrainSceneManager::InitItemBufferPass()
 {
         MaterialPtr itemBufferMat = MaterialManager::getSingleton().
@@ -95 +102 @@
 }
 //-------------------------------------------------------------------------
-void OcclusionCullingSceneManager::setWorldGeometry( const String& filename )
+void VisibilityTerrainSceneManager::setWorldGeometry( const String& filename )
 {
     // Clear out any existing world resources (if not default)
@@ -104 +111 @@
             ResourceGroupManager::getSingleton().getWorldResourceGroupName());
     }
+
     mTerrainPages.clear();
-    // Load the configuration
+        
+        // Load the configuration
     loadConfig(filename);
 
@@ -115 +124 @@
         float maxAxis = std::max(max_x, max_y);
         maxAxis = std::max(maxAxis, max_z);
-        resize( AxisAlignedBox( 0, 0, 0, maxAxis, maxAxis, maxAxis ) );
+        resize(AxisAlignedBox(0, 0, 0, maxAxis, maxAxis, maxAxis));
     
     setupTerrainMaterial();
-
     setupTerrainPages();
-
- }
-
-//-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::PrepareVisualization(Camera *cam)
+}
+
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::PrepareVisualization(Camera *cam)
 {
         // add player camera for visualization purpose
@@ -173 +180 @@
 }
 //-----------------------------------------------------------------------
-Pass *OcclusionCullingSceneManager::setPass(Pass* pass)
+Pass *VisibilityTerrainSceneManager::setPass(Pass* pass)
 {
         // TODO: setting vertex program is not efficient
@@ -179 +186 @@
         
         // set depth fill pass if we currently do not make an aabb occlusion query
-        Pass *usedPass = (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery() ? 
-                                          mDepthPass : pass);
-                
-        IlluminationRenderStage savedStage = mIlluminationStage; 
+        const bool useDepthPass = 1 &&
+                (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery());
+
+        Pass *usedPass = useDepthPass ? mDepthPass : pass;
+        
+
+        const IlluminationRenderStage savedStage = mIlluminationStage; 
         
         // set illumination stage to NONE so no shadow material is used 
         // for depth pass or for occlusion query
-        if (mIsDepthPassPhase || mHierarchyInterface->IsBoundingBoxQuery())
+        if (1 && 
+                (mIsDepthPassPhase || mHierarchyInterface->IsBoundingBoxQuery()))
         {
                 mIlluminationStage = IRS_NONE;
@@ -192 +203 @@
         
         // --- set vertex program of current pass in order to set correct depth
-        if (mExecuteVertexProgramForAllPasses && mIsDepthPassPhase && pass->hasVertexProgram())
+        if (mExecuteVertexProgramForAllPasses 
+                && mIsDepthPassPhase 
+                && pass->hasVertexProgram())
         {
                 // add vertex program of current pass to depth pass
@@ -207 +220 @@
                 }
         }
-        else if (mDepthPass->hasVertexProgram())
+        else if (mDepthPass->hasVertexProgram()) // reset vertex program
         {
                 mDepthPass->setVertexProgram("");
         }
         
-
-        bool IsDepthWrite = usedPass->getDepthWriteEnabled();
+        // save old depth write: needed for item buffer
+        const bool IsDepthWrite = usedPass->getDepthWriteEnabled();
 
         // global option which enables / disables depth writes
@@ -220 +233 @@
                 usedPass->setDepthWriteEnabled(false);
         }
-        //else if (mIsItemBufferPass) {usedPass = mItemBufferPass;}
-        
+        
+
+        //-- set actual pass here
         Pass *result = SceneManager::setPass(usedPass);
+
 
         // reset depth write
@@ -236 +251 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::_findVisibleObjects(Camera* cam,
+void VisibilityTerrainSceneManager::_findVisibleObjects(Camera* cam,
                                                                                                                 bool onlyShadowCasters)
 {
@@ -256 +271 @@
                         TerrainSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
                 }
+
                 // only shadow casters will be rendered in shadow texture pass
-                // mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
+                if (0)
+                        mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
         }
         
@@ -266 +283 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::_renderVisibleObjects()
-{
-
+void VisibilityTerrainSceneManager::_renderVisibleObjects()
+{
         InitDepthPass();          // create material for depth pass
         InitItemBufferPass(); // create material for item buffer pass
@@ -312 +328 @@
 
                 TerrainSceneManager::_renderVisibleObjects();
+                /////////////////////////////////////////////////
 
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
@@ -331 +348 @@
 
                 /** 
-                * the hierarchical culling algorithm
-                * for depth pass: we just find objects and update depth buffer
-                * for "delayed" rendering: we render some passes afterwards
-                * e.g., transparents, because they need front-to-back sorting
+                 * the hierarchical culling algorithm
+                 * for depth pass: we just find objects and update depth buffer
+                 * for "delayed" rendering: we render some passes afterwards
+                 * e.g., transparents, because they need front-to-back sorting
                 **/
                 
@@ -352 +369 @@
 
                 // add visible nodes found by the visibility culling algorithm
+#if 1
                 if (mUseDepthPass)
                 {
@@ -359 +377 @@
                         }
                 }
-                
+#endif  
                 //-- now we can render all remaining queue objects
-                // used for depth pass, transparents, overlay 
+                //-- used for depth pass, transparents, overlay
                 clearSpecialCaseRenderQueues();
-
-                TerrainSceneManager::_renderVisibleObjects();
+        
+                if (!DEBUG_CHC)
+                        TerrainSceneManager::_renderVisibleObjects();
         }
                 
@@ -375 +394 @@
 
         getRenderQueue()->clear(); // finally clear render queue
-        OGRE_DELETE(mRenderQueue); // HACK: should be cleared before...
+        OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared...
+
         //WriteLog(); // write out stats
-
-}
-
-//-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::_updateSceneGraph(Camera* cam)
+}
+
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::_updateSceneGraph(Camera* cam)
 {
         mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
@@ -389 +408 @@
 }
 //-----------------------------------------------------------------------
-bool OcclusionCullingSceneManager::setOption(const String & key, const void * val)
+bool VisibilityTerrainSceneManager::setOption(const String & key, const void * val)
 {
         if (key == "UseDepthPass")
@@ -482 +501 @@
 }
 //-----------------------------------------------------------------------
-bool OcclusionCullingSceneManager::getOption(const String & key, void *val)
+bool VisibilityTerrainSceneManager::getOption(const String & key, void *val)
 {
         if (key == "NumHierarchyNodes")
@@ -494 +513 @@
 }
 //-----------------------------------------------------------------------
-bool OcclusionCullingSceneManager::getOptionValues(const String & key, 
+bool VisibilityTerrainSceneManager::getOptionValues(const String & key, 
                                                                                                         StringVector &refValueList)
 {
@@ -500 +519 @@
 }
 //-----------------------------------------------------------------------
-bool OcclusionCullingSceneManager::getOptionKeys(StringVector & refKeys)
+bool VisibilityTerrainSceneManager::getOptionKeys(StringVector & refKeys)
 {
         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
@@ -506 +525 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::setVisibilityManager(GtpVisibility::
+void VisibilityTerrainSceneManager::setVisibilityManager(GtpVisibility::
                                                                                                                  VisibilityManager *visManager)
 {
@@ -512 +531 @@
 }
 //-----------------------------------------------------------------------
-GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::getVisibilityManager( void )
+GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::getVisibilityManager( void )
 {
         return mVisibilityManager;
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::WriteLog()
+void VisibilityTerrainSceneManager::WriteLog()
 {
         std::stringstream d;
@@ -535 +554 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::renderObjects(
-        const RenderPriorityGroup::TransparentRenderablePassList& objs, 
-    bool doLightIteration, const LightList* manualLightList)
+void VisibilityTerrainSceneManager::renderObjects(
+                                                const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+                        bool doLightIteration, 
+                                                const LightList* manualLightList)
 {
         // for correct rendering, transparents must be rendered after hierarchical culling
-        if (!mSkipTransparents)
+        if (1 && !mSkipTransparents)
         {
                 OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList);
@@ -546 +566 @@
 }
 //-----------------------------------------------------------------------
-bool OcclusionCullingSceneManager::validatePassForRendering(Pass* pass)
+bool VisibilityTerrainSceneManager::validatePassForRendering(Pass* pass)
 {
         // skip all but first pass if we are doing the depth pass
-        if ((mIsDepthPassPhase || mIsItemBufferPhase) && pass->getIndex() > 0)
+        if ((mIsDepthPassPhase || mIsItemBufferPhase) && (pass->getIndex() > 0))
         {
                 return false;
         }
+        // all but first pass
+        /*else if ((!mIsDepthPassPhase || mIsItemBufferPhase) && (pass->getIndex() != 0))
+        {
+                return false;
+        }*/
 
         return SceneManager::validatePassForRendering(pass);
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
+void VisibilityTerrainSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
 {
         if (!mIsItemBufferPhase)
@@ -565 +590 @@
         }
 
-        //-- item buffer
+        //-- item buffer: render objects using false colors
 
     // Iterate through priorities
@@ -576 +601 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
+void VisibilityTerrainSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
 {
         // Do solids
@@ -605 +630 @@
                                 ipass->first->getParent()->getParent()->getName();
                                 
-                        LogManager::getSingleton().logMessage(d.str());
+                        //LogManager::getSingleton().logMessage(d.str());
                         
                         RenderSingleObjectForItemBuffer(*irend, ipass->first);
@@ -633 +658 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass)
+void VisibilityTerrainSceneManager::RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass)
 {
         static LightList nullLightList;
@@ -674 +699 @@
 
 
-        // Render a single object, this will set up auto params if required
+        // render a single object, this will set up auto params if required
         renderSingleObject(rend, usedPass, false, &nullLightList);
 }
 //-----------------------------------------------------------------------
-GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::GetVisibilityManager()
+GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::GetVisibilityManager()
 {
         return mVisibilityManager;
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::InitVisibilityCulling(Camera *cam)
+void VisibilityTerrainSceneManager::InitVisibilityCulling(Camera *cam)
 {
         // reset culling manager stats
@@ -704 +729 @@
         mLeavePassesInQueue = 0;
 
-        if (!mUseDepthPass && !mUseItemBuffer)
+        if (!DEBUG_CHC && !mUseDepthPass && !mUseItemBuffer)
         {
                 if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
@@ -733 +758 @@
         }
 
-        // skip rendering transparents in the hierarchical culling
+        // skip rendering transparents during the hierarchical culling
         // (because they will be rendered afterwards)
-        mSkipTransparents = mUseDepthPass || 
-                (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES);
+        mSkipTransparents = !DEBUG_CHC && 
+                (mIsDepthPassPhase || (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES));
 
         // -- initialise interface for rendering traversal of the hierarchy
@@ -749 +774 @@
 }
 //-----------------------------------------------------------------------
-OctreeHierarchyInterface *OcclusionCullingSceneManager::GetHierarchyInterface()
+OctreeHierarchyInterface *VisibilityTerrainSceneManager::GetHierarchyInterface()
 {
         return mHierarchyInterface;
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::endFrame()
+void VisibilityTerrainSceneManager::endFrame()
 {
         TerrainRenderable::ResetRenderLevelIndex();
 }
 //-----------------------------------------------------------------------
-Entity* OcclusionCullingSceneManager::createEntity(const String& entityName, 
+Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName, 
                                                                                                         const String& meshName)
 {
@@ -775 +800 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+void VisibilityTerrainSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
 {
         // only render solid passes during hierarchical culling
@@ -807 +832 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+void VisibilityTerrainSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
 {
    if (mIsHierarchicalCulling)
@@ -830 +855 @@
    }
 }
+
 } // namespace Ogre