Changeset 726 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE

Timestamp:

04/04/06 23:55:38 (19 years ago)

Author:

mattausch

Message:

improved performance of TerrainSceneManager?
revisit octreescenemanager

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE

Files:

• include/OgrePlatformHierarchyInterface.h (modified) (1 diff)
• include/OgreVisibilityTerrainSceneManager.h (modified) (4 diffs)
• scripts/Plugin_VisibilitySceneManager.vcproj (modified) (2 diffs)
• src/OgreOcclusionCullingSceneManager.cpp (modified) (1 diff)
• src/OgreOcclusionQueriesQueryManager.cpp (modified) (1 diff)
• src/OgreOctreeHierarchyInterface.cpp (modified) (4 diffs)
• src/OgrePlatformHierarchyInterface.cpp (modified) (2 diffs)
• src/OgrePlatformQueryManager.cpp (modified) (3 diffs)
• src/OgreVisibilityOctreeSceneManager.cpp (modified) (1 diff)
• src/OgreVisibilityTerrainSceneManager.cpp (modified) (29 diffs)

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgrePlatformHierarchyInterface.h

@@ -153 +153 @@
         std::vector<PlatformOcclusionQuery *> mOcclusionQueries;
 
+        Vector3 mCameraPosition;
         bool mOnlyShadowCasters;
         int mLeavePassesInQueue;

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreVisibilityTerrainSceneManager.h

@@ -11 +11 @@
 #include "OgrePlatformQueryManager.h"
 #include "VisibilityManager.h"
-
 
 namespace Ogre {
@@ -56 +55 @@
         virtual void renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs, 
             bool doLightIteration, const LightList* manualLightList = 0);
-
         /** Writes out stats into the Ogre log file.
         */
         void WriteLog();
 
-        /** Override pass so we can do the z-fail pass. 
+        /** We override this because we want to include the z-fail pass. 
         */
         Pass* setPass(Pass* pass);
-
         /** Override from SceneManager so we can skip all but first pass for depth pass. 
         */
         bool validatePassForRendering(Pass* pass);
-
+        /** This function renders renderables using false color ids.
+        */
         void RenderItemBuffer(RenderPriorityGroup* pGroup);
+        /** Renders a single object using false color id.
+        */
         void RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass);
+        /** Overritten from scene manager to include the false color id rendering of the
+                scene objects.
+        */
         void renderQueueGroupObjects(RenderQueueGroup* pGroup);
 
@@ -89 +92 @@
         void endFrame();
 
+        /** Override this because we must handle shadows differently.
+        */
         void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup);
+        /** Override this because we must handle shadows differently.
+        */
         void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup);
-
-        /** Override standard function so octree boxes are always of equal side length.
-                This has advantages for CHC, because terrain tiles are in different octree nodes
-                and can be culled.
-        */
-        void setWorldGeometry( const String& filename );
 
 protected:
@@ -161 +162 @@
 
         bool mIsHierarchicalCulling;
+
+        std::ofstream mDummyLog;
 };
 

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/scripts/Plugin_VisibilitySceneManager.vcproj

@@ -94 +94 @@
                                 BufferSecurityCheck="FALSE"
                                 EnableFunctionLevelLinking="TRUE"
-                                RuntimeTypeInfo="TRUE"
+                                RuntimeTypeInfo="FALSE"
                                 UsePrecompiledHeader="0"
                                 WarningLevel="3"
@@ -227 +227 @@
                                         RelativePath="..\include\OgreVisibilitySceneManager.h">
                                 </File>
+                                <File
+                                        RelativePath="..\include\VspBspTree.h">
+                                </File>
                         </Filter>
                         <Filter

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

@@ -380 +380 @@
 
         getRenderQueue()->clear(); // finally clear render queue
-        OGRE_DELETE(mRenderQueue); // HACK: should be cleared before...
+        OGRE_DELETE(mRenderQueue); // HACK: should be cleared before ...
         WriteLog(); // write out stats
 

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

@@ -27 +27 @@
         // we need access to the scene manager and the rendersystem
         PlatformHierarchyInterface *pfHierarchyInterface = 
-                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface);
+                //dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface);
+                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface);
 
         // disable overlays, reset them later

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

@@ -21 +21 @@
 
         // if we come across some renderable geometry => render it
-        if (octree->mNodes.size() > 0)
+        if (!octree->mNodes.empty())
         {
                 RenderNode(node);
         }
         
-        //if (octree->numNodes() > (int)octree->mNodes.size()) // if not all subtrees are empty
+        // if not all subtrees are empty
         if (!IsLeaf(node))
         {
-                for(int i=0; i<8; ++i)
-                {
-                        Octree *nextChild = 
-                                octree->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1];
-                        
-                        if (nextChild)
-                        {
-                                mDistanceQueue->push(nextChild);
-                        }
-                }
+                Octree *nextChild;
+
+                if ((nextChild = octree->mChildren[0][0][0]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[0][0][1]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[0][1][0]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[0][1][1]) != NULL)
+                mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[1][0][0]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[1][0][1]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[1][1][0]) != NULL)
+                        mDistanceQueue->push(nextChild);
+                if ((nextChild = octree->mChildren[1][1][1]) != NULL)
+                        mDistanceQueue->push(nextChild);
         }
 }
@@ -56 +64 @@
 float OctreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
 {
-        LogManager::getSingleton().logMessage("here4");
+        const Vector3 bmin = static_cast<Octree *>(node)->mBox.getMinimum();
+        const Vector3 bmax = static_cast<Octree *>(node)->mBox.getMaximum();
 
-        const AxisAlignedBox &box = static_cast<Octree *>(node)->mBox;
-        const Vector3 pos = ((box.getMaximum() - box.getMinimum()) * 0.5) + box.getMinimum();
+        const Vector3 pos = (bmax - bmin) * 0.5 + bmin;
         
-        return (mCullCamera->getDerivedPosition() - pos).squaredLength();
+        return (mCameraPosition - pos).squaredLength();
 }
 //-----------------------------------------------------------------------
@@ -101 +109 @@
         {
                 octant->setLastRendered(mFrameId);
-
-                dynamic_cast<OctreeSceneManager *>(mSceneManager)->_renderOctant(mCamera, 
-                        octant, mOnlyShadowCasters, mLeavePassesInQueue);
+                OctreeSceneManager *ocm = 
+                        //dynamic_cast<OctreeSceneManager *>(mSceneManager);
+                        static_cast<OctreeSceneManager *>(mSceneManager);
+                ocm->_renderOctant(mCamera, octant, mOnlyShadowCasters, mLeavePassesInQueue);
 
                 mVisibleNodes.push_back(node);
@@ -155 +164 @@
         }
 
-        dynamic_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box);
+        //dynamic_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box);
+        static_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box);
 }
 //-----------------------------------------------------------------------
-void OctreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,  
-                                                                                   GtpVisibility::GeometryVector *geometryList, 
-                                                                                   bool includeChildren)
+void OctreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,
+                                                                                                   GtpVisibility::GeometryVector *geometryList, 
+                                                                                                   bool includeChildren)
 {
         NodeList::const_iterator nodeIt, nodeIt_end;

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

@@ -11 +11 @@
 
 //-----------------------------------------------------------------------
-PlatformHierarchyInterface::PlatformHierarchyInterface(SceneManager *sm, RenderSystem *rsys):
-mSceneManager(sm), mRenderSystem(rsys), mSolidBoundingBox(NULL), mCamera(NULL), 
-mCullCamera(NULL), mOnlyShadowCasters(false), mLeavePassesInQueue(0),
-mIsBoundingBoxQuery(false)
+PlatformHierarchyInterface::PlatformHierarchyInterface(SceneManager *sm, 
+                                                                                                           RenderSystem *rsys):
+mSceneManager(sm), 
+mRenderSystem(rsys), 
+mSolidBoundingBox(NULL), 
+mCamera(NULL), 
+mCullCamera(NULL), 
+mOnlyShadowCasters(false), 
+mLeavePassesInQueue(0),
+mIsBoundingBoxQuery(false),
+mCameraPosition(Vector3(0, 0, 0))
 {
 }
@@ -131 +138 @@
         mCullCamera = cullCam ? cullCam : cam;
 
+        mCameraPosition = mCullCamera->getDerivedPosition();
         // create materials for node visualization
         CreateNodeVizMaterials();

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

@@ -31 +31 @@
                                bool relativeVisibility)
 {
-        SceneManager *sm = dynamic_cast<PlatformHierarchyInterface *>
+        SceneManager *sm = //dynamic_cast<PlatformHierarchyInterface *>
+                static_cast<PlatformHierarchyInterface *>
                 (mHierarchyInterface)->GetSceneManager();
 
@@ -93 +94 @@
         // we need access to the scene manager and the rendersystem
         PlatformHierarchyInterface *pfHierarchyInterface = 
-                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface);
+                //dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface);
+                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface);
 
         SceneManager *sm = pfHierarchyInterface->GetSceneManager();
@@ -189 +191 @@
 
         SceneManager *sm = 
-                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager();
+                //dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager();
+                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager();
 
         SceneManager::EntityIterator it = sm->getEntityIterator();

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

@@ -24 +24 @@
 mLeavePassesInQueue(0),
 mDelayRenderTransparents(true),
-//mDelayRenderTransparents(false),
-//mUseDepthPass(true),
 mUseDepthPass(false),
 mIsDepthPassPhase(false),
 mUseItemBuffer(false),
-//mUseItemBuffer(true),
 mIsItemBufferPhase(false),
 mCurrentEntityId(1),

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

@@ -10 +10 @@
 #include <OgreSubEntity.h>
 
-// HACK
-const static DEBUG_CHC = false;
+
+// normal terrain rendering
+const static NORMAL_RENDER_HACK = false;
 
 namespace Ogre {
@@ -17 +18 @@
 //-----------------------------------------------------------------------
 VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(
-                                                        GtpVisibility::VisibilityManager *visManager): 
+        GtpVisibility::VisibilityManager *visManager):
+TerrainSceneManager(),
 mVisibilityManager(visManager), 
 mShowVisualization(false),
@@ -28 +30 @@
 mIsDepthPassPhase(false),
 mUseItemBuffer(false),
-//mUseItemBuffer(true),
 mIsItemBufferPhase(false),
 mCurrentEntityId(1),
@@ -101 +102 @@
         //mItemBufferPass->setAmbient(1, 1, 0);
 }
-//-------------------------------------------------------------------------
-void VisibilityTerrainSceneManager::setWorldGeometry( const String& filename )
-{
-    // Clear out any existing world resources (if not default)
-    if (ResourceGroupManager::getSingleton().getWorldResourceGroupName() != 
-        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)
-    {
-        ResourceGroupManager::getSingleton().clearResourceGroup(
-            ResourceGroupManager::getSingleton().getWorldResourceGroupName());
-    }
-
-    mTerrainPages.clear();
-        
-        // Load the configuration
-    loadConfig(filename);
-
-    // Resize the octree, allow for 1 page for now
-    float max_x = mOptions.scale.x * mOptions.pageSize;
-    float max_y = mOptions.scale.y;
-    float max_z = mOptions.scale.z * mOptions.pageSize;
-
-        float maxAxis = std::max(max_x, max_y);
-        maxAxis = std::max(maxAxis, max_z);
-        resize(AxisAlignedBox(0, 0, 0, maxAxis, maxAxis, maxAxis));
-    
-    setupTerrainMaterial();
-    setupTerrainPages();
-}
-
 //-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::PrepareVisualization(Camera *cam)
@@ -146 +118 @@
         // ignore
     }
+        // add bounding boxes of rendered objects
         for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
         {
                 getRenderQueue()->addRenderable(*it);
         }
+        
         if (mRenderNodesForViz || mRenderNodesContentForViz)
         {
@@ -182 +156 @@
 Pass *VisibilityTerrainSceneManager::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
-        const bool useDepthPass = 1 &&
+        const bool useDepthPass = 
                 (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery());
 
@@ -196 +175 @@
         // set illumination stage to NONE so no shadow material is used 
         // for depth pass or for occlusion query
-        if (1 && 
-                (mIsDepthPassPhase || mHierarchyInterface->IsBoundingBoxQuery()))
+        if (mIsDepthPassPhase || mHierarchyInterface->IsBoundingBoxQuery())
         {
                 mIlluminationStage = IRS_NONE;
@@ -203 +181 @@
         
         // --- 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
@@ -254 +232 @@
                                                                                                                 bool onlyShadowCasters)
 {
+        if (NORMAL_RENDER_HACK)
+        {
+                TerrainSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
+                return;
+        }
+
         //-- show visible scene nodes and octree bounding boxes from last frame
         if (mShowVisualization)
@@ -273 +257 @@
 
                 // only shadow casters will be rendered in shadow texture pass
-                if (0)
-                        mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
+                if (0) mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
         }
         
@@ -285 +268 @@
 void VisibilityTerrainSceneManager::_renderVisibleObjects()
 {
+        if (NORMAL_RENDER_HACK)
+        {
+                TerrainSceneManager::_renderVisibleObjects();
+
+                return;
+        }
+
         InitDepthPass();          // create material for depth pass
         InitItemBufferPass(); // create material for item buffer pass
@@ -309 +299 @@
         }
         else //-- the hierarchical culling algorithm
-        {
+        { 
+                // from TerrainSceneManager
+                mDestRenderSystem -> setLightingEnabled(false);
+
                 // don't render backgrounds for item buffer
                 if (mUseItemBuffer)
@@ -327 +320 @@
                 setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
 
-                TerrainSceneManager::_renderVisibleObjects();
+                OctreeSceneManager::_renderVisibleObjects();
                 /////////////////////////////////////////////////
 
@@ -356 +349 @@
                 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);
@@ -367 +361 @@
                 mLeavePassesInQueue = 0;
                 
-
+#if 1   
                 // add visible nodes found by the visibility culling algorithm
-#if 1
                 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);
@@ -382 +378 @@
                 clearSpecialCaseRenderQueues();
         
-                if (!DEBUG_CHC)
-                        TerrainSceneManager::_renderVisibleObjects();
+                OctreeSceneManager::_renderVisibleObjects();
         }
                 
@@ -394 +389 @@
 
         getRenderQueue()->clear(); // finally clear render queue
-        OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared...
-
-        //WriteLog(); // write out stats
+        if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ...
+
+        if (0) WriteLog(); // write out stats
 }
 
@@ -402 +397 @@
 void VisibilityTerrainSceneManager::_updateSceneGraph(Camera* cam)
 {
+        if (NORMAL_RENDER_HACK)
+        {
+                TerrainSceneManager::_updateSceneGraph(cam);
+                return;
+        }
+
         mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
         mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
@@ -531 +532 @@
 }
 //-----------------------------------------------------------------------
-GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::getVisibilityManager( void )
+GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::getVisibilityManager()
 {
         return mVisibilityManager;
@@ -549 +550 @@
           << "Query culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumQueryCulledNodes() << ", "
           << "Frustum culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumFrustumCulledNodes() << ", "
-      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << "\n";
+      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << ", "
+          << "Found objects: " << (int)mVisible.size() << "\n";
 
         LogManager::getSingleton().logMessage(d.str());
@@ -560 +562 @@
 {
         // for correct rendering, transparents must be rendered after hierarchical culling
-        if (1 && !mSkipTransparents)
-        {
-                OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList);
+        // => do nothing
+        if (NORMAL_RENDER_HACK || !mSkipTransparents)
+        {
+                SceneManager::renderObjects(objs, doLightIteration, manualLightList);
         }
 }
 //-----------------------------------------------------------------------
 bool VisibilityTerrainSceneManager::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))
@@ -584 +592 @@
 void VisibilityTerrainSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
 {
-        if (!mIsItemBufferPhase)
-        {
-                TerrainSceneManager::renderQueueGroupObjects(pGroup);
+        if (NORMAL_RENDER_HACK || !mIsItemBufferPhase)
+        {
+                SceneManager::renderQueueGroupObjects(pGroup);
                 return;
         }
@@ -616 +624 @@
                         continue;
 
-                // Render only first pass
+                // Render only first pass of renderable as false color
                 if (ipass->first->getIndex() > 0)
                         continue;
@@ -627 +635 @@
                 for (irend = rendList->begin(); irend != irendend; ++irend)
                 {
-                        std::stringstream d; d << "itembuffer, pass name: " << 
+                        if (0)
+                        {
+                                std::stringstream d; d << "itembuffer, pass name: " << 
                                 ipass->first->getParent()->getParent()->getName();
-                                
-                        //LogManager::getSingleton().logMessage(d.str());
+                                LogManager::getSingleton().logMessage(d.str());
+                        }
                         
                         RenderSingleObjectForItemBuffer(*irend, ipass->first);
@@ -636 +646 @@
         }
 
-        // -- TRANSPARENT LOOP: must be handled differently 
+        //-- TRANSPARENT LOOP: must be handled differently from solids
 
         // transparents are treated either as solids or completely discarded
@@ -729 +739 @@
         mLeavePassesInQueue = 0;
 
-        if (!DEBUG_CHC && !mUseDepthPass && !mUseItemBuffer)
+        if (!mUseDepthPass && !mUseItemBuffer)
         {
                 if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
@@ -760 +770 @@
         // skip rendering transparents during the hierarchical culling
         // (because they will be rendered afterwards)
-        mSkipTransparents = !DEBUG_CHC && 
+        mSkipTransparents = 
                 (mIsDepthPassPhase || (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES));
 
@@ -800 +810 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+void VisibilityTerrainSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
+        RenderQueueGroup* pGroup)
 {
         // only render solid passes during hierarchical culling
@@ -832 +843 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+void VisibilityTerrainSceneManager::renderModulativeStencilShadowedQueueGroupObjects(
+        RenderQueueGroup* pGroup)
 {
    if (mIsHierarchicalCulling)