Changeset 865 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src

Timestamp:

04/30/06 15:31:04 (19 years ago)

Author:

mattausch

Message:

fixed uint bug

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src

Files:

• OgreOcclusionCullingSceneManager.cpp (modified) (1 diff)
• OgreVisibilityOctreeSceneManager.cpp (modified) (33 diffs)
• OgreVisibilityTerrainSceneManager.cpp (modified) (12 diffs)

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

@@ -752 +752 @@
                                                                            mLeavePassesInQueue);
                 
-        std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;
-        LogManager::getSingleton().logMessage(d.str());
 }
 //-----------------------------------------------------------------------

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

@@ -11 +11 @@
 #include <OgreConfigFile.h>
 
+// normal terrain rendering
+const static NORMAL_RENDER_HACK = false;
+
 namespace Ogre {
 
 //-----------------------------------------------------------------------
 VisibilityOctreeSceneManager::VisibilityOctreeSceneManager(
-        GtpVisibility::VisibilityManager *visManager)
-: 
+        GtpVisibility::VisibilityManager *visManager):
+OctreeSceneManager(),
 mVisibilityManager(visManager), 
 mShowVisualization(false),
@@ -37 +40 @@
         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
@@ -112 +118 @@
         // ignore
     }
+        // add bounding boxes of rendered objects
         for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
 {
                 getRenderQueue()->addRenderable(*it);
         }
+        
         if (mRenderNodesForViz || mRenderNodesContentForViz)
         {
-                // change node material so it is better suited for visualization
+                // HACK: change node material so it is better suited for visualization
                 MaterialPtr nodeMat = MaterialManager::getSingleton().getByName("Core/NodeMaterial");
                 nodeMat->setAmbient(1, 1, 0);
@@ -128 +136 @@
                         if (mRenderNodesForViz)
                         {
-                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0)
-                                        && (*it)->getAttachedObject(0)->getMovableType() == "Entity")
+                                // render the leaf nodes
+                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) && 
+                                         (*it)->getAttachedObject(0)->getMovableType() == "Entity")
+                                {
                                 getRenderQueue()->addRenderable((*it));
+                                }
 
                                 // addbounding boxes instead of node itself
@@ -145 +156 @@
 Pass *VisibilityOctreeSceneManager::setPass(Pass* pass)
 {
+        if (NORMAL_RENDER_HACK)
+        {
+                return SceneManager::setPass(pass);
+        }
+
+        // TODO: setting vertex program is not efficient
+        //Pass *usedPass = ((mIsDepthPassPhase && !pass->hasVertexProgram()) ? mDepthPass : pass); 
+        
         // set depth fill pass if we currently do not make an aabb occlusion query
-        Pass *usedPass = (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery() ? 
-                                          mDepthPass : pass);
+        const bool useDepthPass = 
+                (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery());
+
+        Pass *usedPass = useDepthPass ? mDepthPass : pass;
 
         IlluminationRenderStage savedStage = mIlluminationStage; 
@@ -158 +179 @@
         }
 
-        //-- set vertex program of current pass in order to set correct depth
-        if (mIsDepthPassPhase && mExecuteVertexProgramForAllPasses && pass->hasVertexProgram())
+        // --- set vertex program of current pass in order to set correct depth
+        if (mExecuteVertexProgramForAllPasses && 
+                mIsDepthPassPhase && 
+                pass->hasVertexProgram())
     {
                 // add vertex program of current pass to depth pass
@@ -174 +197 @@
                 }
         }
-        else if (mDepthPass->hasVertexProgram())
+        else if (mDepthPass->hasVertexProgram()) // reset vertex program
         {
                 mDepthPass->setVertexProgram("");
         }
 
-        // store depth write flag to reset later
-        bool IsDepthWrite = usedPass->getDepthWriteEnabled();
+        // save old depth write: needed for item buffer
+        const bool IsDepthWrite = usedPass->getDepthWriteEnabled();
 
         // global option which enables / disables depth writes
@@ -187 +210 @@
                 usedPass->setDepthWriteEnabled(false);
         }
-        //else if (mIsItemBufferPass) {usedPass = mItemBufferPass;}
-
+
+
+        //-- set actual pass here
         Pass *result = SceneManager::setPass(usedPass);
+
 
         // reset depth write
@@ -205 +230 @@
 void VisibilityOctreeSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
 {
+        if (NORMAL_RENDER_HACK)
+        {
+                OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
+                return;
+        }
+
         //-- show visible scene nodes and octree bounding boxes from last frame
         if (mShowVisualization)
@@ -223 +254 @@
                 }
                 // only shadow casters will be rendered in shadow texture pass
-                // mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
+                if (0) mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
         }
         
@@ -234 +265 @@
 void VisibilityOctreeSceneManager::_renderVisibleObjects()
 {
-        
-                //InitVisibilityCulling(mCameraInProgress);
-                //mVisibilityManager->ApplyVisibilityCulling();
-
-                if(1){
+        if (NORMAL_RENDER_HACK)
+        {
+                OctreeSceneManager::_renderVisibleObjects();
+
+                return;
+        }
+
         InitDepthPass();          // create material for depth pass
         InitItemBufferPass(); // create material for item buffer pass
@@ -266 +299 @@
         else //-- the hierarchical culling algorithm
         {       
+                // this is also called in TerrainSceneManager: really
+                // nexessary?
+                mDestRenderSystem -> setLightingEnabled(false);
+
                 // don't render backgrounds for item buffer
                 if (mUseItemBuffer)
@@ -284 +321 @@
 
                 OctreeSceneManager::_renderVisibleObjects();
-
+                /////////////////////////////////////////////////
 
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
@@ -297 +334 @@
                 setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
         
+                // exclude this queues from hierarchical rendering
+                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
 
                 // set all necessary parameters for 
@@ -311 +350 @@
                 mVisibilityManager->ApplyVisibilityCulling();
         
-                // delete remaining renderables from queue (all not in mLeavePassesInQueue)
+                // delete remaining renderables from queue:
+                // all which are not in mLeavePassesInQueue)
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
                 _deleteRenderedQueueGroups(mLeavePassesInQueue);
@@ -324 +364 @@
                 mLeavePassesInQueue = 0;
 
+#if 1   
                 // add visible nodes found by the visibility culling algorithm
                 if (mUseDepthPass)
                 {
-                        for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
+                        NodeList::const_iterator it, it_end = mVisible.end();
+
+                        //getRenderQueue()->clear();
+                        for (it = mVisible.begin(); it != it_end; ++ it)
                         {
                                 (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
                         }
                 }
-        
-                //-- we render all remaining queue objects
-                // used for depth pass, transparents, overlay 
+#endif  
+                //-- now we can render all remaining queue objects
+                //-- used for depth pass, transparents, overlay
                 clearSpecialCaseRenderQueues();
+
                 OctreeSceneManager::_renderVisibleObjects();
         
-        }   // hierarchical culling
+        } // hierarchical culling
 
         // reset ambient light
         setAmbientLight(savedAmbient);
-}       
+
         getRenderQueue()->clear(); // finally clear render queue
-        OGRE_DELETE(mRenderQueue); // HACK: should be cleared before...
-        //WriteLog(); // write out stats
-
+        if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ...
+
+        if (0) WriteLog(); // write out stats
 }
 
@@ -352 +397 @@
 void VisibilityOctreeSceneManager::_updateSceneGraph(Camera* cam)
 {
+        if (NORMAL_RENDER_HACK)
+        {
+                OctreeSceneManager::_updateSceneGraph(cam);
+                return;
+        }
+
         mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
         mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
@@ -431 +482 @@
                 return true;
         }
+
         if (key == "UseArbQueries")
         {
@@ -491 +543 @@
           << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", "
           << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", "
-          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << "\n"
+          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", "
           << "Hierarchy nodes: " << mNumOctants << ", " 
           << "Traversed nodes: " << mHierarchyInterface->GetNumTraversedNodes() << ", "
@@ -497 +549 @@
           << "Query culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumQueryCulledNodes() << ", "
           << "Frustum culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumFrustumCulledNodes() << ", "
-      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << "\n";
-          /*<< "avg. FPS: " << mCurrentViewport->getTarget()->getAverageFPS() << ", "
-          << "best FPS: " << mCurrentViewport->getTarget()->getBestFPS() << ", "
-          << "worst FPS: " << mCurrentViewport->getTarget()->getWorstFPS() << ", "
-          << "best frame time: " <<     mCurrentViewport->getTarget()->getBestFrameTime() << ", "
-          << "worst frame time: " << mCurrentViewport->getTarget()->getWorstFrameTime() << "\n";*/
+      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << ", "
+          << "Found objects: " << (int)mVisible.size() << "\n";
 
         LogManager::getSingleton().logMessage(d.str());
@@ -512 +560 @@
 {
         // for correct rendering, transparents must be rendered after hierarchical culling
-        if (!mSkipTransparents)
-        {
-                OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList);
+        // => do nothing
+        if (NORMAL_RENDER_HACK || !mSkipTransparents)
+        {
+                SceneManager::renderObjects(objs, doLightIteration, manualLightList);
         }
 }
@@ -520 +569 @@
 bool VisibilityOctreeSceneManager::validatePassForRendering(Pass* pass)
 {
+        if (NORMAL_RENDER_HACK)
+        {
+                return SceneManager::validatePassForRendering(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);
 }
@@ -530 +590 @@
 void VisibilityOctreeSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
 {
-        if (!mIsItemBufferPhase)
+        if (NORMAL_RENDER_HACK || !mIsItemBufferPhase)
         {
                 OctreeSceneManager::renderQueueGroupObjects(pGroup);
@@ -536 +596 @@
         }
 
-        //-- renders item buffer
+        //-- item buffer: render objects using false colors
 
     // Iterate through priorities
@@ -562 +622 @@
                         continue;
 
-                // Render only first pass
+                // Render only first pass of renderable as false color
                 if (ipass->first->getIndex() > 0)
                         continue;
@@ -573 +633 @@
                 for (irend = rendList->begin(); irend != irendend; ++irend)
                 {
+                        if (0)
+                        {
                         std::stringstream d; d << "itembuffer, pass name: " << 
                                 ipass->first->getParent()->getParent()->getName();
                                 
                         LogManager::getSingleton().logMessage(d.str());
+                        }
                         
                         RenderSingleObjectForItemBuffer(*irend, ipass->first);
@@ -582 +645 @@
         }
 
-        //-- TRANSPARENT LOOP: must be handled differently 
+        //-- TRANSPARENT LOOP: must be handled differently from solids
 
         // transparents are treated either as solids or completely discarded
@@ -645 +708 @@
 
 
-        // 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);
 }
@@ -678 +741 @@
         mLeavePassesInQueue = 0;
 
-        if (0 && !mUseDepthPass && !mUseItemBuffer)
+        if (!mUseDepthPass && !mUseItemBuffer)
         {
                 if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
@@ -689 +752 @@
                         mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
 
-                        // just render ambient passes
+                        // just render ambient stuff
                         mIlluminationStage = IRS_AMBIENT;
                         getRenderQueue()->setSplitPassesByLightingType(true);
@@ -708 +771 @@
         }
 
-        // 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 = 
+                (mIsDepthPassPhase || (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES));
 
         // -- initialise interface for rendering traversal of the hierarchy
@@ -721 +784 @@
                                                         mLeavePassesInQueue);
                 
-        std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;
-        LogManager::getSingleton().logMessage(d.str());
 }
 //-----------------------------------------------------------------------
@@ -730 +791 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityOctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+Entity* VisibilityOctreeSceneManager::createEntity(const String& entityName, 
+                                                                                                        const String& meshName)
+{
+        Entity *ent = SceneManager::createEntity(entityName, meshName);
+
+        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
+        {
+                ent->getSubEntity(i)->setId(mCurrentEntityId);
+        }
+
+        // increase counter of entity id values
+        ++ mCurrentEntityId;
+
+        return ent;
+}
+//-----------------------------------------------------------------------
+void VisibilityOctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
+        RenderQueueGroup* pGroup)
 {
         // only render solid passes during hierarchical culling

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

@@ -9 +9 @@
 #include <OgreEntity.h>
 #include <OgreSubEntity.h>
-
+#include <OgreConfigFile.h>
 
 // normal terrain rendering
@@ -62 +62 @@
 
         mDepthPass = depthMat->getTechnique(0)->getPass(0);
-
                 mDepthPass->setColourWriteEnabled(false);
                 mDepthPass->setDepthWriteEnabled(true);
                 mDepthPass->setLightingEnabled(false);
-                //mDepthPass->setDepthCheckEnabled(true);
         }
         else
@@ -290 +288 @@
         
                 if (mShowVisualization) 
+                {
                         // disable illumination stage to prevent rendering shadows
                         mIlluminationStage = IRS_NONE;
+                }
 
                 // standard rendering for shadow maps because of performance
@@ -300 +300 @@
         else //-- the hierarchical culling algorithm
         { 
-                // from TerrainSceneManager
+                // this is also called in TerrainSceneManager: really
+                // nexessary?
                 mDestRenderSystem -> setLightingEnabled(false);
 
@@ -379 +380 @@
         
                 OctreeSceneManager::_renderVisibleObjects();
-        }
+        } // hierarchical culling
                 
         // HACK: set the new render level index, important to avoid cracks
@@ -389 +390 @@
 
         getRenderQueue()->clear(); // finally clear render queue
-        if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ...
+        if (1) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ...
 
         if (0) WriteLog(); // write out stats
@@ -594 +595 @@
         if (NORMAL_RENDER_HACK || !mIsItemBufferPhase)
         {
-                SceneManager::renderQueueGroupObjects(pGroup);
+                OctreeSceneManager::renderQueueGroupObjects(pGroup);
                 return;
         }
@@ -639 +640 @@
                                 std::stringstream d; d << "itembuffer, pass name: " << 
                                 ipass->first->getParent()->getParent()->getName();
+                                
                                 LogManager::getSingleton().logMessage(d.str());
                         }
@@ -726 +728 @@
         mIsDepthPassPhase = mUseDepthPass;
 
+        mIsHierarchicalCulling = true; // during hierarchical culling
+
         // item buffer needs full ambient lighting to use item colors as unique id
         if (mUseItemBuffer) 
@@ -737 +741 @@
         // for rendering AFTER hierarchical culling, i.e., passes which need 
         // a special rendering order
+        
         mLeavePassesInQueue = 0;
 
@@ -752 +757 @@
                         // just render ambient stuff
                         mIlluminationStage = IRS_AMBIENT;
+                        getRenderQueue()->setSplitPassesByLightingType(true);
                 }
         
@@ -837 +843 @@
                 }
         }
-        else
+        else // render the rest of the passes
         {
                 OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup);