Changeset 897

Timestamp:

05/04/06 18:26:23 (18 years ago)

Author:

mattausch

Message:

updated to ogre 1.2

Location:

GTP/trunk/Lib/Vis

Files:

• OnlineCullingCHC/OGRE/include/OgreOcclusionCullingSceneManager.h (modified) (5 diffs)
• OnlineCullingCHC/OGRE/include/OgrePlatformHierarchyInterface.h (modified) (1 diff)
• OnlineCullingCHC/OGRE/include/OgrePlatformQueryManager.h (modified) (2 diffs)
• OnlineCullingCHC/OGRE/include/OgreVisibilityOctreeSceneManager.h (modified) (7 diffs)
• OnlineCullingCHC/OGRE/include/OgreVisibilitySceneManager.h (modified) (1 diff)
• OnlineCullingCHC/OGRE/include/OgreVisibilityTerrainSceneManager.h (modified) (7 diffs)
• OnlineCullingCHC/OGRE/scripts/Plugin_VisibilitySceneManager.vcproj (modified) (1 diff)
• OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp (modified) (23 diffs)
• OnlineCullingCHC/OGRE/src/OgrePlatformHierarchyInterface.cpp (modified) (4 diffs)
• OnlineCullingCHC/OGRE/src/OgrePlatformOcclusionQuery.cpp (modified) (1 diff)
• OnlineCullingCHC/OGRE/src/OgrePlatformQueryManager.cpp (modified) (5 diffs)
• OnlineCullingCHC/OGRE/src/OgreSceneContentGenerator.cpp (modified) (1 diff)
• OnlineCullingCHC/OGRE/src/OgreVisibilityOctreeSceneManager.cpp (modified) (23 diffs)
• OnlineCullingCHC/OGRE/src/OgreVisibilityOptionsManager.cpp (modified) (1 diff)
• OnlineCullingCHC/OGRE/src/OgreVisibilitySceneManager.cpp (modified) (1 diff)
• OnlineCullingCHC/OGRE/src/OgreVisibilitySceneManagerDll.cpp (modified) (3 diffs)
• OnlineCullingCHC/OGRE/src/OgreVisibilityTerrainSceneManager.cpp (modified) (17 diffs)
• OnlineCullingCHC/include/CullingManager.h (modified) (1 diff)
• OnlineCullingCHC/include/HierarchyInterface.h (modified) (4 diffs)
• OnlineCullingCHC/include/QueryManager.h (modified) (1 diff)
• OnlineCullingCHC/include/VisibilityManager.h (modified) (1 diff)
• OnlineCullingCHC/scripts/GtpVisibility.vcproj (modified) (2 diffs)
• Preprocessing/src/RenderSampler.cpp (modified) (1 diff)
• README_ONLINE.txt (modified) (2 diffs)
• shared/scripts/GtpVisibility.suo (modified) (previous)

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

@@ -7 +7 @@
 #include <OgreOctreeCamera.h>
 #include <OgrePrerequisites.h>
-
+#include <OgreMovableObject.h>
 #include "OgreOctreeHierarchyInterface.h"
 #include "OgrePlatformQueryManager.h"
 #include "VisibilityManager.h"
+#include "Containers.h"
 #include "ViewCellsManager.h"
-
-//class GtpVisibilityPreprocessor::ViewCellsManager;
-
 
 namespace Ogre {
@@ -25 +23 @@
 {
 public:
-        OcclusionCullingSceneManager(GtpVisibility::VisibilityManager *visManager);
+        OcclusionCullingSceneManager(const String& name, GtpVisibility::VisibilityManager *visManager);
         ~OcclusionCullingSceneManager();
 
@@ -57 +55 @@
                 Override so we can handle delayed rendering of transparent objects
         */
-        virtual void renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+        virtual void renderObjects(const QueuedRenderableCollection& objs, 
+                        QueuedRenderableCollection::OrganisationMode om, 
             bool doLightIteration, const LightList* manualLightList = 0);
 
@@ -66 +65 @@
         /** Override pass so we can do the z-fail pass. 
         */
-        Pass* setPass(Pass* pass);
+        const 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.
-        */
+#ifdef ITEM_BUFFER
         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);
+#endif // ITEM_BUFFER
+        void _renderQueueGroupObjects(RenderQueueGroup* pGroup,
+                QueuedRenderableCollection::OrganisationMode om);
 
         /** Override from SceneManager so that sub entities can be assigned an id for item buffer.
@@ -94 +89 @@
         OctreeHierarchyInterface *GetHierarchyInterface();
 
-        /** Override this because we must handle shadows differently.
+        /** Inherited from scene manager. Neccesary to draw terrain properly.
         */
         void endFrame();
 
-        void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup);
-        void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup);
+        void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup,
+                QueuedRenderableCollection::OrganisationMode om);
+        void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup,
+                QueuedRenderableCollection::OrganisationMode om);
 
         /** 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.
+                msz: Modified to reflect changes in Ogre::TerrainSceneManager
         */
-        void setWorldGeometry( const String& filename );
+        virtual void setWorldGeometry( DataStreamPtr& stream, const String& typeName );
 
+        
         /** Loads view cells for this particular scene.
         */

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

@@ -110 +110 @@
         /** Deletes all occlusion queries.
         */
-        void DeleteQueries();
+        void ResetQueries();
 
 protected:

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

@@ -43 +43 @@
 
 protected:
-
+#ifdef ITEM_BUFFER
         void CollectItemBufferResults(
                                 GtpVisibility::MeshInfoContainer *visibleGeometry,
@@ -50 +50 @@
         void InitItemBuffer(GtpVisibility::MeshInfoContainer *visibleGeometry,
                                                 GtpVisibility::PatchInfoContainer *visiblePatches);
+#endif // ITEM_BUFFER
 
         Viewport *mViewport;

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

@@ -7 +7 @@
 #include <OgreOctreeCamera.h>
 #include <OgrePrerequisites.h>
-
+#include <OgreMovableObject.h>
 #include "OgreOctreeHierarchyInterface.h"
 #include "OgrePlatformQueryManager.h"
@@ -25 +25 @@
 {
 public:
-        VisibilityOctreeSceneManager(GtpVisibility::VisibilityManager *visManager);
+        VisibilityOctreeSceneManager(const String& name, GtpVisibility::VisibilityManager *visManager);
         ~VisibilityOctreeSceneManager();
 
@@ -57 +57 @@
                 Override so we can handle delayed rendering of transparent objects
         */
-        virtual void renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+        virtual void renderObjects(const QueuedRenderableCollection& objs, 
+                        QueuedRenderableCollection::OrganisationMode om, 
             bool doLightIteration, const LightList* manualLightList = 0);
 
@@ -66 +67 @@
         /** Override pass so we can do the z-fail pass. 
         */
-        Pass* setPass(Pass* pass);
+        const 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.
-        */
+#ifdef ITEM_BUFFER
         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);
+#endif // ITEM_BUFFER
+        void _renderQueueGroupObjects(RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om);
 
         /** Override from SceneManager so that sub entities can be assigned an id for item buffer.
@@ -94 +90 @@
         OctreeHierarchyInterface *GetHierarchyInterface();
 
-        void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup);
-        /** Override this because we must handle shadows differently.
-        */
-        void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup);
+        void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup, 
+                QueuedRenderableCollection::OrganisationMode om);
+        void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup,
+                QueuedRenderableCollection::OrganisationMode om);
 
         void loadVisibilityConfig(const String& filename);
@@ -158 +154 @@
         bool mRenderNodesContentForViz;
 
-        /// if we render transparents after the hierarchical traversal
+        /// render transparents after the hierarchical traversal
         bool mDelayRenderTransparents;
 
-        /// if we use a depth pass (i.e., fill only the depth buffer in the first pass)
+        /// use a depth pass (i.e., fill only the depth buffer in the first pass)
         bool mUseDepthPass;
-        /// if we currently rendering the depth pass
+        /// flag indicating if we currently render the depth pass
         bool mIsDepthPassPhase;
 
@@ -209 +205 @@
 };
 
+/// Factory for VisibilityOctreeSceneManager
+class VisibilityOctreeSceneManagerFactory : public SceneManagerFactory
+{
+protected:
+        void initMetaData(void) const;
+        GtpVisibility::VisibilityManager *visManager;
+public:
+        VisibilityOctreeSceneManagerFactory(GtpVisibility::VisibilityManager *vm)
+        {
+                visManager = vm;
+        }
+        ~VisibilityOctreeSceneManagerFactory() {}
+        /// Factory type name
+        static const String FACTORY_TYPE_NAME;
+        SceneManager* createInstance(const String& instanceName);
+        void destroyInstance(SceneManager* instance);
+};
+
 } // namespace Ogre
 

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

@@ -18 +18 @@
 {
 public:
-        VisibilitySceneManager(GtpVisibility::VisibilityManager *visManager);
+        VisibilitySceneManager(const String& name, GtpVisibility::VisibilityManager *visManager);
         ~VisibilitySceneManager();
 

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

@@ -22 +22 @@
 {
 public:
-        VisibilityTerrainSceneManager(GtpVisibility::VisibilityManager *visManager);
+        VisibilityTerrainSceneManager(const String& name, GtpVisibility::VisibilityManager *visManager);
         ~VisibilityTerrainSceneManager();
 
@@ -54 +54 @@
                 Override so we can handle delayed rendering of transparent objects
         */
-        virtual void renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+        virtual void renderObjects(const QueuedRenderableCollection& objs, 
+                        QueuedRenderableCollection::OrganisationMode om, 
             bool doLightIteration, const LightList* manualLightList = 0);
 
@@ -61 +62 @@
         void WriteLog();
 
-        /** Override pass so we can do the z-fail pass. 
-        */
-        Pass* setPass(Pass* pass);
-
+        /** We override this because we want to include the z-fail pass. 
+        */
+        const Pass* _setPass(Pass* pass);
         /** Override from SceneManager so we can skip all but first pass for depth pass. 
         */
@@ -70 +70 @@
         /** This function renders renderables using false color ids.
         */
+#ifdef ITEM_BUFFER
         void RenderItemBuffer(RenderPriorityGroup* pGroup);
         /** Renders a single object using false color id.
@@ -77 +78 @@
                 scene objects.
         */
-        void renderQueueGroupObjects(RenderQueueGroup* pGroup);
+#endif // ITEM_BUFFER
+        void _renderQueueGroupObjects(RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om);
 
         /** Override from SceneManager so that sub entities can be assigned an id for item buffer.
@@ -97 +99 @@
         /** Override this because we must handle shadows differently.
         */
-        void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup);
+        void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup,
+                QueuedRenderableCollection::OrganisationMode om);
         /** 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);
+        void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup, 
+                QueuedRenderableCollection::OrganisationMode om);
+/// @copydoc SceneManager::getTypeName
+        const String& getTypeName(void) const;
+        static const String FACTORY_TYPE_NAME;
+
+        void setWorldGeometry( DataStreamPtr& stream, const String& typeName );
 
 protected:
@@ -178 +181 @@
 };
 
+/// Factory for VisibilityTerrainSceneManager
+class VisibilityTerrainSceneManagerFactory : public SceneManagerFactory
+{
+protected:
+        typedef std::vector<TerrainPageSource*> TerrainPageSources;
+        TerrainPageSources mTerrainPageSources;
+        void initMetaData(void) const;
+        GtpVisibility::VisibilityManager *visManager;
+public:
+        VisibilityTerrainSceneManagerFactory(GtpVisibility::VisibilityManager *vm);
+        ~VisibilityTerrainSceneManagerFactory();
+        /// Factory type name
+        static const String FACTORY_TYPE_NAME;
+        SceneManager* createInstance(const String& instanceName);
+        void destroyInstance(SceneManager* instance);
+};
+
 } // namespace Ogre
 

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

@@ -104 +104 @@
                                 Name="VCLinkerTool"
                                 IgnoreImportLibrary="TRUE"
-                                AdditionalDependencies="OgreMain.lib CEGUIBase.lib OgreGUIRenderer.lib Plugin_OctreeSceneManager.lib GtpVisibility.lib Preprocessor.lib xerces-c_2.lib zdll.lib zziplibd.lib devil.lib qtmain.lib QtOpenGL4.lib QtCored4.lib QtGuid4.lib Qt3Support4.lib QAxContainer.lib glut32.lib OpenGL32.Lib glu32.lib cg.lib cgGL.lib"
+                                AdditionalDependencies="OgreMain.lib CEGUIBase.lib OgreGUIRenderer.lib Plugin_OctreeSceneManager.lib GtpVisibility.lib zdll.lib zziplibd.lib Preprocessor.lib xerces-c_2.lib devil.lib qtmain.lib QtOpenGL4.lib QtCored4.lib QtGuid4.lib Qt3Support4.lib QAxContainer.lib glut32.lib OpenGL32.Lib glu32.lib cg.lib cgGL.lib"
                                 OutputFile="$(OutDir)/Plugin_VisibilitySceneManager.dll"
                                 Version="0.99"
                                 LinkIncremental="1"
                                 SuppressStartupBanner="TRUE"
-                                AdditionalLibraryDirectories=""$(OGRE_PATH)\PlugIns\OctreeSceneManager\bin\$(ConfigurationName)";"$(OGRE_PATH)\OgreMain\lib\$(ConfigurationName)";"$(OGRE_PATH)\Samples\Common\CEGUIRenderer\lib";"..\..\GtpVisibility\lib\$(ConfigurationName)";"..\..\lib\$(ConfigurationName)";"..\lib\$(ConfigurationName)";"$(OGRE_PATH)\Dependencies\lib\$(ConfigurationName)";"..\..\..\Preprocessing\lib\$(ConfigurationName)";..\support\xercesc\lib\;..\..\..\..\..\..\..\NonGTP\Xerces;..\..\..\..\..\..\..\NonGTP\Xerces\xercesc\lib;..\..\..\..\..\..\..\NonGTP\zlib\lib;..\..\..\..\..\..\..\NonGTP\Devil\lib;"$(QTDIR)\lib";"$(CG_LIB_PATH)";..\..\..\Preprocessing\src\GL"
+                                AdditionalLibraryDirectories=""$(OGRE_PATH)\PlugIns\OctreeSceneManager\bin\$(ConfigurationName)";"$(OGRE_PATH)\OgreMain\lib\$(ConfigurationName)";"$(OGRE_PATH)\Samples\Common\CEGUIRenderer\lib";"..\..\GtpVisibility\lib\$(ConfigurationName)";"..\..\lib\$(ConfigurationName)";"..\lib\$(ConfigurationName)";"$(OGRE_PATH)\Dependencies\lib\$(ConfigurationName)";..\..\..\..\..\..\..\NonGTP\Zlib\lib;"..\..\..\Preprocessing\lib\$(ConfigurationName)";..\..\..\..\..\..\..\NonGTP\Xerces\xercesc\lib;"$(QTDIR)\lib";..\..\..\Preprocessing\src\GL;"$(CG_LIB_PATH)""
                                 ModuleDefinitionFile="..\misc\OgreVisibilitySceneManager.def"
                                 GenerateDebugInformation="TRUE"

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

@@ -10 +10 @@
 #include <OgreEntity.h>
 #include <OgreSubEntity.h>
+#include <OgreMaterialManager.h>
 #include <OgreIteratorWrappers.h>
 #include "VspBspTree.h"
@@ -22 +23 @@
 
 //-----------------------------------------------------------------------
-OcclusionCullingSceneManager::OcclusionCullingSceneManager(
-                                                        GtpVisibility::VisibilityManager *visManager): 
-TerrainSceneManager(),
+OcclusionCullingSceneManager::OcclusionCullingSceneManager(const String& name, 
+                                                        GtpVisibility::VisibilityManager *visManager):
+TerrainSceneManager(name),
 mVisibilityManager(visManager), 
 mShowVisualization(false),
@@ -35 +36 @@
 mIsDepthPassPhase(false),
 mUseItemBuffer(false),
+//mUseItemBuffer(true),
 mIsItemBufferPhase(false),
 mCurrentEntityId(1),
@@ -105 +107 @@
         //mItemBufferPass->setAmbient(1, 1, 0);
 }
+//-------------------------------------------------------------------------
+void OcclusionCullingSceneManager::setWorldGeometry( DataStreamPtr& stream, const String& typeName )
+{
+    // Clear out any existing world resources (if not default)
+    if (ResourceGroupManager::getSingleton().getWorldResourceGroupName() != 
+        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)
+    {
+        ResourceGroupManager::getSingleton().clearResourceGroup(
+            ResourceGroupManager::getSingleton().getWorldResourceGroupName());
+    }
+        destroyLevelIndexes();
+    mTerrainPages.clear();
+    // Load the configuration
+    loadConfig( stream );
+        initLevelIndexes();
+
+    // 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 OcclusionCullingSceneManager::PrepareVisualization(Camera *cam)
@@ -157 +190 @@
 }
 //-----------------------------------------------------------------------
-Pass *OcclusionCullingSceneManager::setPass(Pass* pass)
+const Pass *OcclusionCullingSceneManager::_setPass(Pass* pass)
 {
         if (NORMAL_RENDER_HACK)
         {
-                return SceneManager::setPass(pass);
+                return SceneManager::_setPass(pass);
         }
 
@@ -217 +250 @@
 
         //-- set actual pass here
-        Pass *result = SceneManager::setPass(usedPass);
+        const Pass *result = SceneManager::_setPass(usedPass);
 
 
@@ -232 +265 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
+void OcclusionCullingSceneManager::_findVisibleObjects(Camera* cam,
+                                                                                                                bool onlyShadowCasters)
 {
         if (NORMAL_RENDER_HACK)
@@ -335 +369 @@
                 addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE);
                 addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
-                        
+        
                 // exclude this queues from hierarchical rendering
                 setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
@@ -343 +377 @@
                 InitVisibilityCulling(mCameraInProgress);
 
-        
+
                 /** 
                 * the hierarchical culling algorithm
@@ -366 +400 @@
                 
                 mLeavePassesInQueue = 0;
-
+                
 #if 1   
                 // add visible nodes found by the visibility culling algorithm
@@ -495 +529 @@
                 if (useArbQueries)
                 {
-                        mHierarchyInterface->DeleteQueries();
+                        mHierarchyInterface->ResetQueries();
                         mDestRenderSystem->setConfigOption("ArbQueries", "Yes");
                 }
                 else
                 {
-                        mHierarchyInterface->DeleteQueries();
+                        mHierarchyInterface->ResetQueries();
                         mDestRenderSystem->setConfigOption("ArbQueries", "No");
                 }
         }
-
         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                 setOption(key, val) || TerrainSceneManager::setOption(key, val);
@@ -564 +597 @@
 //-----------------------------------------------------------------------
 void OcclusionCullingSceneManager::renderObjects(
-        const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+        const QueuedRenderableCollection& objs,
+        QueuedRenderableCollection::OrganisationMode om,
     bool doLightIteration, const LightList* manualLightList)
 {
@@ -571 +605 @@
         if (NORMAL_RENDER_HACK || !mSkipTransparents)
         {
-                OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList);
+                OctreeSceneManager::renderObjects(objs, om, doLightIteration, manualLightList);
         }
 }
@@ -596 +630 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
+void OcclusionCullingSceneManager::_renderQueueGroupObjects(RenderQueueGroup* pGroup,
+                                                                                                                        QueuedRenderableCollection::OrganisationMode om)
 {
         if (NORMAL_RENDER_HACK || !mIsItemBufferPhase)
         {
-                TerrainSceneManager::renderQueueGroupObjects(pGroup);
+                TerrainSceneManager::_renderQueueGroupObjects(pGroup, om);
                 return;
         }
-
+#ifdef  ITEM_BUFFER
+        //-- item buffer
         //-- item buffer: render objects using false colors
 
@@ -613 +649 @@
                 RenderItemBuffer(groupIt.getNext());
         }
-}
+#endif // ITEM_BUFFER
+}
+#ifdef ITEM_BUFFER
 //-----------------------------------------------------------------------
 void OcclusionCullingSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
 {
         // Do solids
-        RenderPriorityGroup::SolidRenderablePassMap solidObjs = pGroup->_getSolidPasses();
+        QueuedRenderableCollection solidObjs = pGroup->getSolidsBasic();//msz
 
         // ----- SOLIDS LOOP -----
@@ -658 +696 @@
         if (mRenderTransparentsForItemBuffer)
         {
-                RenderPriorityGroup::TransparentRenderablePassList transpObjs = 
-                        pGroup->_getTransparentPasses();
+                QueuedRenderableCollection transpObjs = pGroup->getTransparents(); //msz
                 RenderPriorityGroup::TransparentRenderablePassList::const_iterator 
                         itrans, itransend;
@@ -713 +750 @@
         }
 
-        Pass *usedPass = setPass(mItemBufferPass); 
+        const Pass *usedPass = _setPass(mItemBufferPass); 
 
 
@@ -719 +756 @@
         renderSingleObject(rend, usedPass, false, &nullLightList);
 }
+#endif // ITEM_BUFFER
 //-----------------------------------------------------------------------
 GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::GetVisibilityManager()
@@ -749 +787 @@
         mLeavePassesInQueue = 0;
 
-        if (!mUseDepthPass && !mUseItemBuffer)
+        // if we have the depth pass or use an item buffer, no passes are left in the queue
+        if (1 && !mUseDepthPass && !mUseItemBuffer)
         {
                 if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
@@ -761 +800 @@
 
                         // just render ambient stuff
-                        mIlluminationStage = IRS_AMBIENT;
-                        getRenderQueue()->setSplitPassesByLightingType(true);
+                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
+                        // mIlluminationStage = IRS_AMBIENT; 
                 }
         
@@ -820 +859 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+void OcclusionCullingSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
+        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
         // only render solid passes during hierarchical culling
@@ -839 +879 @@
 
                         // Render all the ambient passes first, no light iteration, no lights
-                        mIlluminationStage = IRS_AMBIENT;
-
-                        OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), false, &lightList);
+                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
+                        // mIlluminationStage = IRS_AMBIENT;
+
+                        OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, false, &lightList);
                         // Also render any objects which have receive shadows disabled
-                        OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPassesNoShadow(), true);
+                        OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, true);
                 }
         }
         else
         {
-                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup);
-        }
-}
-//-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup, om);
+        }
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::renderModulativeStencilShadowedQueueGroupObjects(
+        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
    if (mIsHierarchicalCulling)
@@ -867 +909 @@
 
                    // Do (shadowable) solids
-                   OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), true);
+                   OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
            }
    }
    else
    {
-           SceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup);
+           SceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup, om);
    }
-}
-//-------------------------------------------------------------------------
-void OcclusionCullingSceneManager::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();
 }
 

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

@@ -4 +4 @@
 #include <OgreEntity.h>
 #include <OgreMovableObject.h>
+#include <OgreMaterialManager.h>
 #include "OgreSolidBoundingBox.h"
 #include "OgrePlatformHierarchyInterface.h"
@@ -73 +74 @@
 PlatformHierarchyInterface::~PlatformHierarchyInterface()
 {
-        DeleteQueries();
+        ResetQueries();
 
         OGRE_DELETE(mSolidBoundingBox);
 }
 //-----------------------------------------------------------------------
-void PlatformHierarchyInterface::DeleteQueries()
-{
-        for (int i = 0; i < (int)mOcclusionQueries.size(); ++ i)
-                OGRE_DELETE(mOcclusionQueries[i]);
+void PlatformHierarchyInterface::ResetQueries()
+{
+//      for (int i = 0; i < (int)mOcclusionQueries.size(); ++ i) OGRE_DELETE(mOcclusionQueries[i]);
 
         mCurrentTestIdx = 0;
-    mOcclusionQueries.clear();
+    //mOcclusionQueries.clear();
 }
 //-----------------------------------------------------------------------
@@ -97 +97 @@
         
         // set no depth write, no color, no lighting material
-        mSceneManager->setPassWrapper(solidBox->getTechnique()->getPass(0)); // HACK! (mySetPass should be setPass)
+        //mSceneManager->setPassWrapper(solidBox->getTechnique()->getPass(0)); // HACK! (mySetPass should be setPass)
+        mSceneManager->_setPass(solidBox->getTechnique()->getPass(0)); // HACK! (mySetPass should be setPass)
         //SetOcclusionPass();
 
@@ -119 +120 @@
 GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::GetNextOcclusionQuery()
 {
-        if (mCurrentTestIdx == mOcclusionQueries.size())
+        // create new query if there is no query left
+        if (mCurrentTestIdx == (int)mOcclusionQueries.size())
         {
                 mOcclusionQueries.push_back(new PlatformOcclusionQuery(mRenderSystem));

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

@@ -28 +28 @@
                                                                                         const bool waitForResult) const
 {
-        return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels, waitForResult);
+        // return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels, waitForResult);
+
+        bool isAvailable = true;
+
+        if (!waitForResult)
+                isAvailable = !mHardwareOcclusionQuery->isStillOutstanding();
+
+        if (isAvailable)
+                return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels);
+
+        return isAvailable;
 }
 

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

@@ -111 +111 @@
         mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0));
         //pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH);
-
+#ifdef ITEM_BUFFER
         // initialise item buffer (if not already initialised)
         InitItemBuffer(visibleGeometry, visiblePatches);
@@ -120 +120 @@
         bool useItemBuffer = true;
         sm->setOption("UseItemBuffer", &useItemBuffer);
-
+#endif // ITEM_BUFFER
 
         sm->_renderScene(pCam, mViewport, false); // render item buffer
    
-
+#ifdef ITEM_BUFFER
         //-- collect results
         CollectItemBufferResults(visibleGeometry, visiblePatches);
@@ -132 +132 @@
         useItemBuffer = false; // don't need item buffer anymore
         sm->setOption("UseItemBuffer", &useItemBuffer);
+#endif // ITEM_BUFFER
 
         mWasInitialised = false; // reset initialised - flag
@@ -137 +138 @@
         mViewport->setBackgroundColour(bg); // reset background color
 }
+#ifdef ITEM_BUFFER
 //-----------------------------------------------------------------------
 void PlatformQueryManager::CollectItemBufferResults(
@@ -232 +234 @@
         }
 }
+#endif // ITEM_BUFFER
 //-----------------------------------------------------------------------
 void PlatformQueryManager::SetViewport(Viewport *vp)

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

@@ -207 +207 @@
                 mEntities.pop_back();
                 
-                mSceneMgr->removeEntity(ent);
+                mSceneMgr->destroyEntity(ent);
         }
 }

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

@@ -9 +9 @@
 #include <OgreEntity.h>
 #include <OgreSubEntity.h>
+#include <OgreMaterialManager.h>
 #include <OgreIteratorWrappers.h>
 #include "VspBspTree.h"
@@ -24 +25 @@
 
 //-----------------------------------------------------------------------
-VisibilityOctreeSceneManager::VisibilityOctreeSceneManager(
-        GtpVisibility::VisibilityManager *visManager):
-OctreeSceneManager(),
+VisibilityOctreeSceneManager::VisibilityOctreeSceneManager(const String& name, 
+        GtpVisibility::VisibilityManager *visManager)
+:
+OctreeSceneManager(name),
 mVisibilityManager(visManager), 
 mShowVisualization(false),
@@ -135 +137 @@
     }
         // add bounding boxes of rendered objects
-        if (0)
+        if (1)
         for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
 {
@@ -159 +161 @@
                                         (*it)->getAttachedObject(0)->isVisible())
                                 {
-                                        getRenderQueue()->addRenderable((*it));
-                                }
+                                getRenderQueue()->addRenderable((*it));
+                        }
                         }
                         // add renderables itself
@@ -171 +173 @@
 }
 //-----------------------------------------------------------------------
-Pass *VisibilityOctreeSceneManager::setPass(Pass* pass)
+const Pass *VisibilityOctreeSceneManager::_setPass(Pass* pass)
 {
         if (NORMAL_RENDER_HACK)
         {
-                return SceneManager::setPass(pass);
+                return SceneManager::_setPass(pass);
         }
 
@@ -230 +232 @@
 
         //-- set actual pass here
-        Pass *result = SceneManager::setPass(usedPass);
+        const Pass *result = SceneManager::_setPass(usedPass);
 
 
@@ -291 +293 @@
         {
                 OctreeSceneManager::_renderVisibleObjects();
-
+        
                 return;
         }
@@ -357 +359 @@
                 // exclude this queues from hierarchical rendering
                 setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
+        
 
                 // set all necessary parameters for 
@@ -402 +405 @@
                 //-- used for depth pass, transparents, overlay
                 clearSpecialCaseRenderQueues();
-
+        
+                //-- we render all remaining queue objects
+                // used for depth pass, transparents, overlay 
+                clearSpecialCaseRenderQueues();
                 OctreeSceneManager::_renderVisibleObjects();
         
-        } // hierarchical culling
+        }   // hierarchical culling
 
         // reset ambient light
@@ -535 +541 @@
                 return true;
         }
-
+        
         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                 setOption(key, val) || OctreeSceneManager::setOption(key, val);
@@ -593 +599 @@
 //-----------------------------------------------------------------------
 void VisibilityOctreeSceneManager::renderObjects(
-        const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+                        const QueuedRenderableCollection& objs, 
+                        QueuedRenderableCollection::OrganisationMode om,
             bool doLightIteration, const LightList* manualLightList)
 {
@@ -600 +607 @@
         if (NORMAL_RENDER_HACK || !mSkipTransparents)
         {
-                OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList);
+                OctreeSceneManager::renderObjects(objs, om, doLightIteration, manualLightList);
         }
 }
@@ -625 +632 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityOctreeSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
+void VisibilityOctreeSceneManager::_renderQueueGroupObjects(
+        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
         if (NORMAL_RENDER_HACK || !mIsItemBufferPhase)
         {
-                OctreeSceneManager::renderQueueGroupObjects(pGroup);
+                OctreeSceneManager::_renderQueueGroupObjects(pGroup, om);
                 return;
         }
-
-        //-- item buffer: render objects using false colors
+#ifdef ITEM_BUFFER
+        //-- renders item buffer
 
     // Iterate through priorities
@@ -642 +650 @@
                 RenderItemBuffer(groupIt.getNext());
         }
-}
+#endif // ITEM_BUFFER
+}
+#ifdef ITEM_BUFFER
 //-----------------------------------------------------------------------
 void VisibilityOctreeSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
@@ -748 +758 @@
         renderSingleObject(rend, usedPass, false, &nullLightList);
 }
+#endif // ITEM_BUFFER
 //-----------------------------------------------------------------------
 GtpVisibility::VisibilityManager *VisibilityOctreeSceneManager::GetVisibilityManager()
@@ -789 +800 @@
                         mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
 
-                        // just render ambient stuff
-                        mIlluminationStage = IRS_AMBIENT;
+                        // just render ambient passes
+                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
+                        // mIlluminationStage = IRS_AMBIENT;
                         getRenderQueue()->setSplitPassesByLightingType(true);
                 }
@@ -821 +833 @@
                                                         mLeavePassesInQueue);
                 
+        //std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;
+        //LogManager::getSingleton().logMessage(d.str());
 }
 //-----------------------------------------------------------------------
@@ -845 +859 @@
 //-----------------------------------------------------------------------
 void VisibilityOctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
-        RenderQueueGroup* pGroup)
+        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
         // only render solid passes during hierarchical culling
@@ -864 +878 @@
 
                         // Render all the ambient passes first, no light iteration, no lights
-                        mIlluminationStage = IRS_AMBIENT;
-
-                        OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), false, &lightList);
+                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
+                        // mIlluminationStage = IRS_AMBIENT;
+
+                        OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, false, &lightList);
                         // Also render any objects which have receive shadows disabled
-                        OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPassesNoShadow(), true);
+                        OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, true);          
 #if 0           
                         std::stringstream d; 
@@ -881 +896 @@
         else // render the rest of the passes
         {
-                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup);
-        }
-}
-//-----------------------------------------------------------------------
-void VisibilityOctreeSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup, om);
+        }
+}
+//-----------------------------------------------------------------------
+void VisibilityOctreeSceneManager::renderModulativeStencilShadowedQueueGroupObjects(
+        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
    if (mIsHierarchicalCulling)
@@ -900 +916 @@
 
                    // Do (shadowable) solids
-                   OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), true);
+                   OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
            }
    }
    else
    {
-           SceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup);
+           SceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup, om);
    }
 }
-
+//-------------------------------------------------------------------------
+void VisibilityOctreeSceneManager::SetObjectsVisible(const bool visible)
+{
+        GtpVisibilityPreprocessor::ObjectContainer::iterator it, it_end = mObjects.end();
+
+        for (it = mObjects.begin(); it != it_end; ++ it)
+        {
+                OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(*it);
+                Entity *ent = omi->GetMesh();
+                ent->setVisible(visible);
+        }
+}
+//-------------------------------------------------------------------------
+void VisibilityOctreeSceneManager::loadVisibilityConfig(const String& filename)
+{
+        // TODO matt
+        // Set up the options
+        ConfigFile config;
+        String val;
+
+        config.load(filename);
+
+        val = config.getSetting("Algorithm");
+
+    if (!val.empty())
+        {
+                 VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).setOption("Algorithm", val.c_str());
+        }
+
+        val = config.getSetting("UseDepthPass");
+
+        if (!val.empty())
+        {
+                 setOption("UseDepthPass", val.c_str());
+        }
+}
+//-------------------------------------------------------------------------
 inline static AxisAlignedBox EnlargeBox(const AxisAlignedBox &box)
 {
@@ -1056 +1108 @@
 }
 //-------------------------------------------------------------------------
-void VisibilityOctreeSceneManager::SetObjectsVisible(const bool visible)
-{
-        // for OGRE 1.2
-//#ifdef OGRE12
-        //MovableObjectIterator mit = getMovableObjectIterator("Entity");
-#if 0
-        EntityIterator eit = getEntityIterator();
-
-        // set all objects to invisible (initially);
-        while (eit.hasMoreElements())
-        {
-                Entity *ent = eit.getNext();
-                ent->setVisible(visible);
-        }
-
-#else
-        GtpVisibilityPreprocessor::ObjectContainer::iterator it, it_end = mObjects.end();
-
-        for (it = mObjects.begin(); it != it_end; ++ it)
-        {
-                OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(*it);
-                Entity *ent = omi->GetMesh();
-                ent->setVisible(visible);
-        }
-#endif
-}
-//-------------------------------------------------------------------------
-void VisibilityOctreeSceneManager::loadVisibilityConfig(const String &filename)
-{
-        // TODO matt
-        // Set up the options
-        ConfigFile config;
-        String val;
-
-        config.load(filename);
-
-        val = config.getSetting("Algorithm");
-
-    if (!val.empty())
-        {
-                 VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).setOption("Algorithm", val.c_str());
-        }
-
-        val = config.getSetting("UseDepthPass");
-
-        if (!val.empty())
-        {
-                 setOption("UseDepthPass", val.c_str());
-        }
-}
-//-------------------------------------------------------------------------
 void VisibilityOctreeSceneManager::updatePvs(Camera *cam)
 {
@@ -1156 +1157 @@
 }
 
+
+
+//-----------------------------------------------------------------------
+const String VisibilityOctreeSceneManagerFactory::FACTORY_TYPE_NAME = "VisibilityOctreeSceneManager";
+//-----------------------------------------------------------------------
+void VisibilityOctreeSceneManagerFactory::initMetaData(void) const
+{
+        mMetaData.typeName = FACTORY_TYPE_NAME;
+        mMetaData.description = "Scene manager organising the scene on the basis of an octree with advanced occlusion culling (TM).";
+        mMetaData.sceneTypeMask = 0xFFFF; // support all types
+        mMetaData.worldGeometrySupported = false;
+}
+//-----------------------------------------------------------------------
+SceneManager* VisibilityOctreeSceneManagerFactory::createInstance(
+        const String& instanceName)
+{
+        return new VisibilityOctreeSceneManager(instanceName, visManager);
+}
+//-----------------------------------------------------------------------
+void VisibilityOctreeSceneManagerFactory::destroyInstance(SceneManager* instance)
+{
+        delete instance;
+}
+
 }  // namespace Ogre

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

@@ -16 +16 @@
         {
                 // delete old queries (not needed for e.g., view frustum culling)
-                mHierarchyInterface->DeleteQueries();
+                mHierarchyInterface->ResetQueries();
                 mVisibilityManager->SetCullingManager(*static_cast<const 
                         GtpVisibility::VisibilityEnvironment::CullingManagerType *>(val));

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

@@ -11 +11 @@
 
 //-----------------------------------------------------------------------
-VisibilitySceneManager::VisibilitySceneManager(GtpVisibility::VisibilityManager *visManager)
-:mVisibilityManager(visManager), mUseDepthPass(false), mShowVisualization(false)
+VisibilitySceneManager::VisibilitySceneManager(const String& name, 
+                                                                                           GtpVisibility::VisibilityManager *visManager)
+:SceneManager(name), mVisibilityManager(visManager), mUseDepthPass(false), mShowVisualization(false)
 {
         mHierarchyInterface = 

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

@@ -28 +28 @@
 //#include <OgreVisibilityDotSceneManager.h>
 
-#include <OgreHeightmapTerrainPageSource.h>
+//#include <OgreHeightmapTerrainPageSource.h>
 #include <OgreRoot.h>
 #include <OgreLogManager.h>
+
 #include "VisibilityManager.h"
 #include "VisibilityEnvironment.h"
-
+                
 GtpVisibility::VisibilityEnvironment *visEnv;
 GtpVisibility::VisibilityManager *visManager;
@@ -39 +40 @@
 namespace Ogre {
 
-VisibilityOctreeSceneManager *visibilityOctreePlugin;
-VisibilityTerrainSceneManager *visibilityTerrainPlugin;
-//VisibilityDotSceneManager *visibilityDotPlugin;
-
-HeightmapTerrainPageSource *heightmapTerrainPageSource;
+VisibilityOctreeSceneManagerFactory *visibilityOctreePlugin;
+VisibilityTerrainSceneManagerFactory *visibilityTerrainPlugin;
 
 //-----------------------------------------------------------------------
@@ -53 +51 @@
 
         // Create new scene manager
-        visibilityOctreePlugin = new VisibilityOctreeSceneManager(visManager);
-        visibilityTerrainPlugin = new VisibilityTerrainSceneManager(visManager);
-        //occlusionDotPlugin = new VisibilityDotSceneManager();
+        visibilityOctreePlugin = new VisibilityOctreeSceneManagerFactory(visManager);
+        visibilityTerrainPlugin = new VisibilityTerrainSceneManagerFactory(visManager);
+        // Construct listener manager singleton
+        new TerrainPageSourceListenerManager();
 
-        heightmapTerrainPageSource = new HeightmapTerrainPageSource();
-        
         // Register
-        Root::getSingleton().setSceneManager(ST_GENERIC, visibilityOctreePlugin);
-        Root::getSingleton().setSceneManager(ST_EXTERIOR_CLOSE, visibilityTerrainPlugin);
-        //Root::getSingleton().setSceneManager(ST_GENERIC, occlusionDotPlugin);
-
-        visibilityTerrainPlugin->registerPageSource("Heightmap", heightmapTerrainPageSource);
+        Root::getSingleton().addSceneManagerFactory(visibilityOctreePlugin);
+        Root::getSingleton().addSceneManagerFactory(visibilityTerrainPlugin);
 }
 //-----------------------------------------------------------------------
 extern "C" void __declspec(dllexport) dllShutdownPlugin()
 {
-        visibilityTerrainPlugin->shutdown();
-        heightmapTerrainPageSource->shutdown();
+        Root::getSingleton().removeSceneManagerFactory(visibilityOctreePlugin);
+        Root::getSingleton().removeSceneManagerFactory(visibilityTerrainPlugin);
+        // destroy listener manager
+        delete TerrainPageSourceListenerManager::getSingletonPtr();
 }
 //-----------------------------------------------------------------------

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

@@ -10 +10 @@
 #include <OgreSubEntity.h>
 #include <OgreConfigFile.h>
+#include <OgreMaterialManager.h>
+#include <OgreHeightmapTerrainPageSource.h>
 
 // normal terrain rendering
-const static NORMAL_RENDER_HACK = false;
+const static int NORMAL_RENDER_HACK = false;
 
 namespace Ogre {
 
 //-----------------------------------------------------------------------
-VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(
+VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(const String& name, 
         GtpVisibility::VisibilityManager *visManager):
-TerrainSceneManager(),
+TerrainSceneManager(name),
 mVisibilityManager(visManager), 
 mShowVisualization(false),
@@ -62 +64 @@
 
         mDepthPass = depthMat->getTechnique(0)->getPass(0);
+
                 mDepthPass->setColourWriteEnabled(false);
                 mDepthPass->setDepthWriteEnabled(true);
                 mDepthPass->setLightingEnabled(false);
+                //mDepthPass->setDepthCheckEnabled(false);
         }
         else
@@ -152 +156 @@
 }
 //-----------------------------------------------------------------------
-Pass *VisibilityTerrainSceneManager::setPass(Pass* pass)
+const Pass *VisibilityTerrainSceneManager::_setPass(Pass* pass)
 {
         if (NORMAL_RENDER_HACK)
         {
-                return SceneManager::setPass(pass);
+                return SceneManager::_setPass(pass);
         }
 
@@ -212 +216 @@
 
         //-- set actual pass here
-        Pass *result = SceneManager::setPass(usedPass);
+        const Pass *result = SceneManager::_setPass(usedPass);
 
 
@@ -391 +395 @@
 
         getRenderQueue()->clear(); // finally clear render queue
-        if (1) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ...
+        if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ...
 
         if (0) WriteLog(); // write out stats
@@ -491 +495 @@
                 if (useArbQueries)
                 {
-                        mHierarchyInterface->DeleteQueries();
+                        mHierarchyInterface->ResetQueries();
                         mDestRenderSystem->setConfigOption("ArbQueries", "Yes");
                 }
                 else
                 {
-                        mHierarchyInterface->DeleteQueries();
+                        mHierarchyInterface->ResetQueries();
                         mDestRenderSystem->setConfigOption("ArbQueries", "No");
                 }
@@ -559 +563 @@
 //-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::renderObjects(
-                                                const RenderPriorityGroup::TransparentRenderablePassList& objs, 
-                        bool doLightIteration, 
-                                                const LightList* manualLightList)
+        const QueuedRenderableCollection& objs,
+        QueuedRenderableCollection::OrganisationMode om,
+        bool doLightIteration, const LightList* manualLightList)
 {
         // for correct rendering, transparents must be rendered after hierarchical culling
@@ -567 +571 @@
         if (NORMAL_RENDER_HACK || !mSkipTransparents)
         {
-                SceneManager::renderObjects(objs, doLightIteration, manualLightList);
+                SceneManager::renderObjects(objs, om, doLightIteration, manualLightList);
         }
 }
@@ -592 +596 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
+void VisibilityTerrainSceneManager::_renderQueueGroupObjects(
+        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
         if (NORMAL_RENDER_HACK || !mIsItemBufferPhase)
         {
-                OctreeSceneManager::renderQueueGroupObjects(pGroup);
+                SceneManager::_renderQueueGroupObjects(pGroup, om);
                 return;
         }
-
+#ifdef ITEM_BUFFER
         //-- item buffer: render objects using false colors
 
@@ -609 +614 @@
                 RenderItemBuffer(groupIt.getNext());
         }
-}
+#endif // ITEM_BUFFER
+}
+#ifdef ITEM_BUFFER
 //-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
@@ -715 +722 @@
         renderSingleObject(rend, usedPass, false, &nullLightList);
 }
+#endif // ITEM_BUFFER
 //-----------------------------------------------------------------------
 GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::GetVisibilityManager()
@@ -757 +765 @@
 
                         // just render ambient stuff
-                        mIlluminationStage = IRS_AMBIENT;
-                        getRenderQueue()->setSplitPassesByLightingType(true);
+                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
+                        // mIlluminationStage = IRS_AMBIENT;
                 }
         
@@ -818 +826 @@
 //-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
-        RenderQueueGroup* pGroup)
+        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
         // only render solid passes during hierarchical culling
@@ -837 +845 @@
 
                         // Render all the ambient passes first, no light iteration, no lights
-                        mIlluminationStage = IRS_AMBIENT;
-
-                        OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), false, &lightList);
+                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
+                        // mIlluminationStage = IRS_AMBIENT;
+
+                        OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, false, &lightList);
                         // Also render any objects which have receive shadows disabled
-                        OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPassesNoShadow(), true);
+                        OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, true);
                 }
         }
         else // render the rest of the passes
         {
-                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup);
+                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup, om);
         }
 }
 //-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::renderModulativeStencilShadowedQueueGroupObjects(
-        RenderQueueGroup* pGroup)
+        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
 {
    if (mIsHierarchicalCulling)
@@ -866 +875 @@
 
                    // Do (shadowable) solids
-                   OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), true);
+                   OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
            }
    }
    else
    {
-           SceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup);
+           SceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup, om);
    }
 }
 
+const String& VisibilityTerrainSceneManager::getTypeName(void) const
+{
+        return VisibilityTerrainSceneManagerFactory::FACTORY_TYPE_NAME;
+}
+
 //-------------------------------------------------------------------------
-void VisibilityTerrainSceneManager::setWorldGeometry( const String& filename )
+void VisibilityTerrainSceneManager::setWorldGeometry( DataStreamPtr& stream, const String& typeName )
 {
     // Clear out any existing world resources (if not default)
@@ -885 +899 @@
             ResourceGroupManager::getSingleton().getWorldResourceGroupName());
     }
-
+        destroyLevelIndexes();
     mTerrainPages.clear();
     // Load the configuration
-    loadConfig(filename);
+    loadConfig( stream );
+        initLevelIndexes();
 
     // Resize the octree, allow for 1 page for now
@@ -895 +910 @@
     float max_z = mOptions.scale.z * mOptions.pageSize;
 
-        //-- note: slows down view frustum culling!
-#if 1
         float maxAxis = std::max(max_x, max_y);
         maxAxis = std::max(maxAxis, max_z);
         resize( AxisAlignedBox( 0, 0, 0, maxAxis, maxAxis, maxAxis ) );
-#else
-        resize( AxisAlignedBox( 0, 0, 0, max_x, max_y, max_z ) );
-#endif
-
+    
     setupTerrainMaterial();
+
     setupTerrainPages();
 
  }
 
+        //-----------------------------------------------------------------------
+        const String VisibilityTerrainSceneManagerFactory::FACTORY_TYPE_NAME = "VisibilityTerrainSceneManager";
+        //-----------------------------------------------------------------------
+        VisibilityTerrainSceneManagerFactory::VisibilityTerrainSceneManagerFactory(
+                GtpVisibility::VisibilityManager *vm)
+        {
+                visManager = vm;
+        }
+        //-----------------------------------------------------------------------
+        VisibilityTerrainSceneManagerFactory::~VisibilityTerrainSceneManagerFactory()
+        {
+                for (TerrainPageSources::iterator i = mTerrainPageSources.begin();
+                        i != mTerrainPageSources.end(); ++i)
+                {
+                        delete *i;
+                }
+                mTerrainPageSources.clear();
+        }
+        //-----------------------------------------------------------------------
+        void VisibilityTerrainSceneManagerFactory::initMetaData(void) const
+        {
+                mMetaData.typeName = FACTORY_TYPE_NAME;
+                mMetaData.description = "Scene manager which generally organises the scene on "
+                        "the basis of an octree, but also supports terrain world geometry and has awesome (TM) occlusion culling capabilities. ";
+                mMetaData.sceneTypeMask = ST_EXTERIOR_CLOSE; // previous compatiblity
+                mMetaData.worldGeometrySupported = true;
+        }
+        //-----------------------------------------------------------------------
+        SceneManager* VisibilityTerrainSceneManagerFactory::createInstance(
+                const String& instanceName)
+        {
+                VisibilityTerrainSceneManager* tsm = new VisibilityTerrainSceneManager(instanceName, visManager);
+                // Create & register default sources (one per manager)
+                HeightmapTerrainPageSource* ps = new HeightmapTerrainPageSource();
+                mTerrainPageSources.push_back(ps);
+                tsm->registerPageSource("Heightmap", ps);
+
+                return tsm;
+        }
+        //-----------------------------------------------------------------------
+        void VisibilityTerrainSceneManagerFactory::destroyInstance(SceneManager* instance)
+        {
+                delete instance;
+        }
+
 } // namespace Ogre

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/CullingManager.h

@@ -47 +47 @@
 
         /** Some visualization of culled nodes are shown, depending 
-        on the type of hierarchy.
-        @param showVisualization if true, culled nodes are visualized
+                on the type of hierarchy.
+                @param visualizeCulledNodes if true, culled nodes are visualized
         */
         void SetVisualizeCulledNodes(bool visualizeCulledNodes);

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/HierarchyInterface.h

@@ -19 +19 @@
 
 
-/**     Class which implements a hierarchy interface for a scene hierarchy.
+/**     Class which implements a hierarchy interface for a scene hierarchy. It has to be implemented
+        for any rendering engine to use the CHC algorithm.
 */
 class HierarchyInterface
@@ -33 +34 @@
         */
     virtual bool IsLeaf(HierarchyNode *node) const = 0;
-        /** Traverses and renders the given node. 
+        /** Traverses and renders the hierarchy from the given node. 
                 @param node the hierarchy node
         */
         virtual void TraverseNode(HierarchyNode *node) = 0;
-        /** Renders current hierarchy node.
+        /** Renders the given hierarchy node.
                 @param node current hierarchy node to be rendered
         */
@@ -47 +48 @@
         /** Issue a occlusion query for this node. 
                 @param node the current hierarchy node
+                @param wasVisible if the node was visible in the last frame: based
+                on this the method can decide on the way of querying
                 @returns occlusion query for this node
         */
         virtual OcclusionQuery *IssueNodeOcclusionQuery(HierarchyNode *node, 
-                const bool wasVisible = false) = 0;
+                                                                                                        const bool wasVisible = false) = 0;
         /** Sets the root of the scene hierarchy.
                 @param root the hierarchy root
@@ -122 +125 @@
 
         /** Visualization of a culled node, dependent on the culling type. 
+                @param node the hierarchy node to be visualized
                 @param type can be one of FRUSTUM_CULLED, QUERY_CULLED
         */
         virtual void VisualizeCulledNode(HierarchyNode *node, 
-                CullingType type) const = 0;
+                                                                         CullingType type) const = 0;
 
         /** Returns vector of visible hierarchy nodes from previous render.

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/QueryManager.h

@@ -41 +41 @@
         If NULL no visible meshes are not evaluated.
 
-        @param projectedPixels If true the visibility member for
+        @param visiblePatches Pointer to the container where visible patches should be added.
+        If NULL no visible meshes are not evaluated.
+
+        @param relativeVisibility If true the visibility member for
         NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible
         pixels divided by the the number of projected pixels.

GTP/trunk/Lib/Vis/OnlineCullingCHC/include/VisibilityManager.h

@@ -45 +45 @@
 
         /** Sets the threshold for the visibiliy culling algorithm.
-                @param visibilityThreshold number of visible pixels where an object 
+                @param threshold number of visible pixels where an object 
                 is still considered invisible.
                 @remark automatically sets the threshold of the current and of 

GTP/trunk/Lib/Vis/OnlineCullingCHC/scripts/GtpVisibility.vcproj

@@ -128 +128 @@
                         </File>
                         <File
+                                RelativePath="..\include\QueryManager.h">
+                        </File>
+                        <File
                                 RelativePath="..\src\StopAndWaitCullingManager.cpp">
                         </File>
@@ -171 +174 @@
                                 </File>
                                 <File
-                                        RelativePath="..\include\QueryManager.h">
-                                </File>
-                                <File
                                         RelativePath="..\include\StopAndWaitCullingManager.h">
                                 </File>

GTP/trunk/Lib/Vis/Preprocessing/src/RenderSampler.cpp

@@ -29 +29 @@
   // compute histogram from the samples
   int bins = 100;
-  int maxPvs;
+  int maxPvs = 0;
 
   vector<int> histogram(bins);

GTP/trunk/Lib/Vis/README_ONLINE.txt

@@ -1 +1 @@
 How to install the Visibility Work Package
 
+
+ONLINE VISIBILITY (CHC + VIEW CELLS)
 
 1) Requirements: 
@@ -7 +9 @@
 
 2) check out gametools repository
-   in the following it is assumed that your repository is located in e:\svn\gametools (not required, just replace your path)
+   in the following it is assumed that your repository is located in d:\svn\gametools (not required, just replace your path)
 
 3) add following environment variables:
-   OGRE_PATH: points to directory where ogre.sln is located (i.e., the directory OGRE)
 
-4) Set preprocessor flag GTP_VISIBILITY_MODIFIED_OGRE to the example projects you want to use
+   OGRE_PATH: points to directory where ogre.sln is located (i.e., the
+directory OGRE), e.g. D:\svn\gametools\OGRE\trunk\ogrenew
+
+4) copy the ogre_dependencies and ogre_changes_12 into the ogrenew directory
+
+5) Set preprocessor flag GTP_VISIBILITY_MODIFIED_OGRE to the example projects you want to use
 
 5) open scripts GTP\trunk\Lib\Vis\shared\GtpVisibility.sln and build all
 
+
 6) start TerrainExampleApplication for testing
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+FOR USING THE PREPROCESSED VIEW CELLS:
+
+the same as above, before step 6) change in the code: 
+
+in 
+
+D:\svn\gametools\GTP\trunk\App\Demos\Vis\HillyTerrain\OGRE\TestCullingTerrainApplication.cpp
+
+replace 
+
+bool TestCullingTerrainApplication::msShowHillyTerrain = true;
+
+with 
+
+bool TestCullingTerrainApplication::msShowHillyTerrain = false;
+
+
+Then the vienna model is loaded together with the view cells. The
+usage of the view cells is toggled using key "V".