Index: /GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager.cpp
===================================================================
--- /GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager.cpp	(revision 938)
+++ /GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager.cpp	(revision 955)
@@ -31,14 +31,22 @@
 		//if (mHierarchyInterface->GetQueue()->empty())
 		//	Ogre::LogManager::getSingleton().logMessage("distance queue empty!!");
+		bool resultAvailable = false;
 
-		// only wait for result if there are no nodes to process
+		//-- only wait for result if there are no nodes to process
 		while (!queryQueue.empty() && 
-			   queryQueue.front().second->GetQueryResult(visiblePixels, 
-									mHierarchyInterface->GetQueue()->empty()))
+				queryQueue.front().second->GetQueryResult(visiblePixels, 
+				mHierarchyInterface->GetQueue()->empty()))
 		{
+		
+		/*while (!queryQueue.empty() && 
+			   ((resultAvailable = queryQueue.front().second->GetQueryResult(visiblePixels, false)) ||
+                mHierarchyInterface->GetQueue()->empty()))
+		{
+			if (!resultAvailable) visiblePixels = 0;//1e20; // render if result not available
+			*/
            	HierarchyNode *node = queryQueue.front().first;
 			
 			queryQueue.pop();
-
+			
 			if (visiblePixels > mVisibilityThreshold)
 			{
Index: /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreViewCellsManager.h
===================================================================
--- /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreViewCellsManager.h	(revision 955)
+++ /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreViewCellsManager.h	(revision 955)
@@ -0,0 +1,238 @@
+#ifndef _OcclusionCullingSceneManager_H__
+#define _OcclusionCullingSceneManager_H__
+
+#include <OgreSceneNode.h>
+#include <OgreTerrainSceneManager.h>
+#include <OgreOctreeNode.h>
+#include <OgreOctreeCamera.h>
+#include <OgrePrerequisites.h>
+#include <OgreMovableObject.h>
+#include "OgreOctreeHierarchyInterface.h"
+#include "OgrePlatformQueryManager.h"
+#include "VisibilityManager.h"
+#include "Containers.h"
+#include "ViewCellsManager.h"
+
+namespace Ogre {
+
+/**
+	This class extends the terrain scene manager,
+	using occlusion queries for visibility culling.
+*/
+class __declspec(dllexport) OcclusionCullingSceneManager: public TerrainSceneManager
+{
+public:
+	OcclusionCullingSceneManager(const String& name, GtpVisibility::VisibilityManager *visManager);
+	~OcclusionCullingSceneManager();
+
+	void _renderVisibleObjects();
+	void _findVisibleObjects(Camera* cam, bool onlyShadowCasters);
+	void _updateSceneGraph(Camera* cam);
+
+	/** Sets the given option for the SceneManager
+		@remarks Options are: "Algorithm", int *;			
+	*/
+	
+	virtual bool setOption(const String &, const void *);
+	/** Gets the given option for the Scene VisibilityManager.
+	    @remarks
+		See setOption
+	*/
+	virtual bool getOption(const String &, void *);
+
+	bool getOptionValues(const String & key, StringVector &refValueList);
+	bool getOptionKeys(StringVector &refKeys);
+
+	/** Sets the visibility manager.
+		@param visManager the visibility manager
+	*/
+	void setVisibilityManager(GtpVisibility::VisibilityManager *visManager);
+	/** See set.
+	*/
+	GtpVisibility::VisibilityManager *getVisibilityManager();
+
+	/** Render a queue group. 
+		Override so we can handle delayed rendering of transparent objects
+	*/
+	void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 
+									  QueuedRenderableCollection::OrganisationMode om);
+
+	/** Writes out stats into the Ogre log file.
+	*/
+	void WriteLog();
+
+	/** Override pass so we can do the z-fail pass. 
+	*/
+	const Pass* _setPass(Pass* pass);
+
+	/** Override from SceneManager so we can skip all but first pass for depth pass. 
+	*/
+	bool validatePassForRendering(Pass* pass);
+#ifdef ITEM_BUFFER
+	void RenderItemBuffer(RenderPriorityGroup* pGroup);
+	void RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass);
+#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.
+	*/
+	Entity* createEntity(const String& entityName, const String& meshName);
+
+	/** Returns pointer to visibility manager.
+	*/
+	GtpVisibility::VisibilityManager *GetVisibilityManager();
+
+	/** Returns hierarchy interface.
+	*/
+	OctreeHierarchyInterface *GetHierarchyInterface();
+
+	/** Inherited from scene manager. Neccesary to draw terrain properly.
+	*/
+	void endFrame();
+
+	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
+	*/
+#if 1
+	virtual void setWorldGeometry( DataStreamPtr& stream, const String& typeName );
+#endif
+	
+	/** Loads view cells for this particular scene.
+	*/
+	bool LoadViewCells(const String &filename);
+
+protected:
+	
+	/** Creates material for depth pass, e.g., a pass that only fills the depth buffer. 
+	*/
+	void InitDepthPass();
+	/** Creates material for item buffer. 
+	*/
+	void InitItemBufferPass();
+	/** Fills render queue so that a visualization can be rendered. 
+	*/
+	void PrepareVisualization(Camera *cam);
+	/** Initialises necessary parameters for hierarchical visibility culling.
+	*/
+	void InitVisibilityCulling(Camera *cam);
+#if 0
+	/** Finds object corresponding to this bounding box in the scene.
+	*/
+	Entity *FindCorrespondingObject(const AxisAlignedBox &box);
+
+	/** Identifies objects in the scene and gives them unique ids that
+		correspond to preprocessor ids.
+	*/
+	void IdentifyObjects(GtpVisibilityPreprocessor::ObjectContainer &objects);
+#endif
+	/** Loads / unloads pvs of the view cell to set the visibility in the scene.
+	*/
+	void applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc, const bool load);
+
+	/** updates pvs in current frame.
+	*/
+	void updatePvs(Camera *cam);
+
+	/** Sets all objects invisible.
+	*/
+	void SetObjectsVisible(const bool visible);
+
+	/// the interface to the scene hierarchy.
+	OctreeHierarchyInterface *mHierarchyInterface;
+	/// manages all visibility options
+	GtpVisibility::VisibilityManager *mVisibilityManager;
+
+	/// if a visualization of the hierarchical culling is shown
+	bool mShowVisualization;
+
+	/// if the culled nodes are indicated in the visualization
+	bool mVisualizeCulledNodes;
+
+	/// if symbols for the nodes are shown in the visualization
+	bool mRenderNodesForViz;
+	/// if content of the nodes is shown in the visualization
+	bool mRenderNodesContentForViz;
+
+	/// render transparents after the hierarchical traversal
+	bool mDelayRenderTransparents;
+
+	/// use a depth pass (i.e., fill only the depth buffer in the first pass)
+	bool mUseDepthPass;
+	/// flag indicating if we currently render the depth pass
+	bool mIsDepthPassPhase;
+	
+	/// if we use an item buffer for rendering (i.e., object ids as color codes
+	bool mUseItemBuffer;
+	/// if we currently render the item buffer 
+	bool mIsItemBufferPhase;
+
+	/// if depth write should be enabled
+	bool mEnableDepthWrite;
+	/// if transparents are skipped during rendering
+	bool mSkipTransparents;
+
+	/// the depth pass (no lighting, just filling the depth buffer)
+	Pass *mDepthPass;
+	Pass *mItemBufferPass;
+
+	int mCurrentEntityId;
+	/// flag for passes which should not be deleted from queue during first traversal
+	int mLeavePassesInQueue;
+
+
+	/// if transparent object are considered for item buffer visibility
+	bool mRenderTransparentsForItemBuffer;
+	/// Always execute the vertex program of a pass, e.g., for the depth pass or item buffer
+	bool mExecuteVertexProgramForAllPasses;
+
+	/// if hierarchical culling is currently in use
+	bool mIsHierarchicalCulling;
+
+	bool mViewCellsLoaded;
+	GtpVisibilityPreprocessor::ViewCellsManager *mViewCellsManager;
+
+
+	/// Used to assign Ogre meshes to view cell entries.
+	GtpVisibilityPreprocessor::ObjectContainer mObjects;
+
+	GtpVisibilityPreprocessor::ViewCell *mElementaryViewCell;
+	GtpVisibilityPreprocessor::ViewCell *mCurrentViewCell;
+
+	/// If view cells are used.
+	bool mUseViewCells;
+
+	/// if the view cells are filtered
+	bool mUseVisibilityFilter;
+};
+
+/// Factory for VisibilityOctreeSceneManager
+class OcclusionCullingSceneManagerFactory : public SceneManagerFactory
+{
+protected:
+	typedef std::vector<TerrainPageSource*> TerrainPageSources;
+	TerrainPageSources mTerrainPageSources;
+	void initMetaData(void) const;
+	GtpVisibility::VisibilityManager *visManager;
+public:
+	OcclusionCullingSceneManagerFactory(GtpVisibility::VisibilityManager *vm)
+	{
+		visManager = vm;
+	}
+
+	/// Factory type name
+	static const String FACTORY_TYPE_NAME;
+	SceneManager* createInstance(const String& instanceName);
+	void destroyInstance(SceneManager* instance);
+};
+
+} // namespace Ogre
+
+#endif // OcclusionCullingSceneManager_H
Index: /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp
===================================================================
--- /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp	(revision 951)
+++ /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp	(revision 955)
@@ -1120,4 +1120,5 @@
 		mViewCellsManager->DeleteLocalMergeTree(viewCell);
 }
+#if 0
 //-------------------------------------------------------------------------
 void OcclusionCullingSceneManager::TestVisible(SceneNode *node)
@@ -1151,6 +1152,5 @@
 	}
 }
-
-
+#endif
 //-----------------------------------------------------------------------
 const String OcclusionCullingSceneManagerFactory::FACTORY_TYPE_NAME = "OcclusionCullingSceneManager";
Index: /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreViewCellsManager.cpp
===================================================================
--- /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreViewCellsManager.cpp	(revision 955)
+++ /GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreViewCellsManager.cpp	(revision 955)
@@ -0,0 +1,1184 @@
+#include "OgreOcclusionCullingSceneManager.h"
+#include "OgreVisibilityOptionsManager.h"
+#include <OgreMath.h>
+#include <OgreIteratorWrappers.h>
+#include <OgreRenderSystem.h>
+#include <OgreCamera.h>
+#include <OgreLogManager.h>
+#include <OgreStringConverter.h>
+#include <OgreEntity.h>
+#include <OgreSubEntity.h>
+#include <OgreMaterialManager.h>
+#include <OgreIteratorWrappers.h>
+#include <OgreHeightmapTerrainPageSource.h>
+#include "VspBspTree.h"
+#include "Containers.h"
+#include "ViewCellsManager.h"
+#include <OgreConfigFile.h>
+#include "OgreTypeConverter.h"
+#include "OgreMeshInstance.h"
+#include "common.h"
+#include "OgreBoundingBoxConverter.h"
+
+// normal terrain rendering
+const static NORMAL_RENDER_HACK = false;
+
+namespace Ogre {
+
+//-----------------------------------------------------------------------
+OcclusionCullingSceneManager::OcclusionCullingSceneManager(const String& name, 
+							GtpVisibility::VisibilityManager *visManager):
+TerrainSceneManager(name),
+mVisibilityManager(visManager), 
+mShowVisualization(false),
+mRenderNodesForViz(false),
+mRenderNodesContentForViz(false),
+mVisualizeCulledNodes(false),
+mLeavePassesInQueue(0),
+mDelayRenderTransparents(true),
+mUseDepthPass(false),
+mIsDepthPassPhase(false),
+mUseItemBuffer(false),
+//mUseItemBuffer(true),
+mIsItemBufferPhase(false),
+mCurrentEntityId(1),
+mEnableDepthWrite(true),
+mSkipTransparents(false),
+mRenderTransparentsForItemBuffer(true),
+//mExecuteVertexProgramForAllPasses(true),
+mExecuteVertexProgramForAllPasses(false),
+mIsHierarchicalCulling(false),
+mViewCellsLoaded(false),
+mUseViewCells(false),
+mUseVisibilityFilter(false),
+mCurrentViewCell(NULL),
+mElementaryViewCell(NULL)
+{
+	mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
+	
+	if (0)
+	{
+		mDisplayNodes = true;
+		mShowBoundingBoxes = true;
+		mShowBoxes = true;
+	}
+
+	// TODO: set maxdepth to reasonable value
+	mMaxDepth = 50;
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::InitDepthPass()
+{
+	MaterialPtr depthMat = MaterialManager::getSingleton().getByName("Visibility/DepthPass");
+
+	if (depthMat.isNull())
+    {
+		depthMat = MaterialManager::getSingleton().create(
+                "Visibility/DepthPass",
+                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+
+        mDepthPass = depthMat->getTechnique(0)->getPass(0);
+		mDepthPass->setColourWriteEnabled(false);
+		mDepthPass->setDepthWriteEnabled(true);
+		mDepthPass->setLightingEnabled(false);
+	}
+	else
+	{
+		mDepthPass = depthMat->getTechnique(0)->getPass(0);
+	}
+}
+//-----------------------------------------------------------------------
+OcclusionCullingSceneManager::~OcclusionCullingSceneManager()
+{
+	OGRE_DELETE(mHierarchyInterface);
+	CLEAR_CONTAINER(mObjects);
+	OGRE_DELETE(mCurrentViewCell);
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::InitItemBufferPass()
+{
+	MaterialPtr itemBufferMat = MaterialManager::getSingleton().
+		getByName("Visibility/ItemBufferPass");
+
+	if (itemBufferMat.isNull())
+    {
+		// Init
+		itemBufferMat = MaterialManager::getSingleton().create("Visibility/ItemBufferPass",
+                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+
+		mItemBufferPass = itemBufferMat->getTechnique(0)->getPass(0);
+		mItemBufferPass->setColourWriteEnabled(true);
+		mItemBufferPass->setDepthWriteEnabled(true);
+		mItemBufferPass->setLightingEnabled(true);
+		//mItemBufferPass->setLightingEnabled(false);
+	}
+	else
+	{
+		mItemBufferPass = itemBufferMat->getTechnique(0)->getPass(0);
+	}
+	//mItemBufferPass->setAmbient(1, 1, 0);
+}
+//-------------------------------------------------------------------------
+#if 1
+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();
+
+ }
+#endif
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::PrepareVisualization(Camera *cam)
+{
+	// add player camera for visualization purpose
+	try 
+	{
+		Camera *c;
+		if ((c = getCamera("PlayerCam")) != NULL)
+		{
+			getRenderQueue()->addRenderable(c);
+		}   
+    }
+    catch (...)
+    {
+        // ignore
+    }
+	// add bounding boxes of rendered objects
+	if (0)
+	for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
+	{
+		getRenderQueue()->addRenderable(*it);
+	}
+	
+	if (mRenderNodesForViz || mRenderNodesContentForViz)
+	{
+		// HACK: change node material so it is better suited for visualization
+		MaterialPtr nodeMat = MaterialManager::getSingleton().getByName("Core/NodeMaterial");
+		nodeMat->setAmbient(1, 1, 0);
+		nodeMat->setLightingEnabled(true);
+		nodeMat->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
+
+		for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
+		{
+			if (mRenderNodesForViz)
+			{
+				// render the leaf nodes
+				if ((*it)->numAttachedObjects() && 
+					!(*it)->numChildren() && 
+					((*it)->getAttachedObject(0)->getMovableType() == "Entity") &&
+					(*it)->getAttachedObject(0)->isVisible())
+				{
+					getRenderQueue()->addRenderable((*it));
+				}
+
+				// addbounding boxes instead of node itself
+				//(*it)->_addBoundingBoxToQueue(getRenderQueue());
+			}
+			// add renderables itself
+			if (mRenderNodesContentForViz) 
+			{
+				(*it)->_addToRenderQueue(cam, getRenderQueue(), false);
+			}
+		}
+	}	
+}
+//-----------------------------------------------------------------------
+const Pass *OcclusionCullingSceneManager::_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 = 
+		(mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery());
+
+	Pass *usedPass = useDepthPass ? mDepthPass : pass;
+		
+
+	const IlluminationRenderStage savedStage = mIlluminationStage; 
+	
+	// set illumination stage to NONE so no shadow material is used 
+	// for depth pass or for occlusion query
+	if (mIsDepthPassPhase || mHierarchyInterface->IsBoundingBoxQuery())
+	{
+		mIlluminationStage = IRS_NONE;
+	}
+	
+	// --- 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
+		mDepthPass->setVertexProgram(pass->getVertexProgramName());
+
+		if (mDepthPass->hasVertexProgram())
+		{
+			const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
+			// Load this program if not done already
+			if (!prg->isLoaded())
+				prg->load();
+			// Copy params
+			mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
+		}
+	}
+	else if (mDepthPass->hasVertexProgram()) // reset vertex program
+	{
+		mDepthPass->setVertexProgram("");
+	}
+	
+	// save old depth write: needed for item buffer
+	const bool IsDepthWrite = usedPass->getDepthWriteEnabled();
+
+	// global option which enables / disables depth writes
+	if (!mEnableDepthWrite)
+	{
+		usedPass->setDepthWriteEnabled(false);
+	}
+	//else if (mIsItemBufferPass) {usedPass = mItemBufferPass;}
+	
+
+	//-- set actual pass here
+	const Pass *result = SceneManager::_setPass(usedPass);
+
+
+	// reset depth write
+	if (!mEnableDepthWrite)
+	{
+		usedPass->setDepthWriteEnabled(IsDepthWrite);
+	}
+
+	// reset illumination stage
+	mIlluminationStage = savedStage;
+
+	return result;
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::_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)
+    {
+		PrepareVisualization(cam);
+	}
+	else 
+	{	
+		// for hierarchical culling, we interleave identification 
+		// and rendering of objects in _renderVisibibleObjects
+
+		// for the shadow pass we use only standard rendering
+		// because of low occlusion
+		if (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE && 
+			mIlluminationStage == IRS_RENDER_TO_TEXTURE)
+		{
+			OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
+		}
+
+		// only shadow casters will be rendered in shadow texture pass
+		if (0) mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
+
+
+		//-- apply view cell pvs
+		updatePvs(cam);
+	}
+	
+	
+	// -- delete lists stored for visualization
+	mVisible.clear();
+	mBoxes.clear();
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::_renderVisibleObjects()
+{
+	if (NORMAL_RENDER_HACK)
+	{
+		OctreeSceneManager::_renderVisibleObjects();
+
+		return;
+	}
+
+	InitDepthPass(); 	  // create material for depth pass
+	InitItemBufferPass(); // create material for item buffer pass
+
+	// save ambient light to reset later
+	ColourValue savedAmbient = mAmbientLight;
+
+	//-- apply standard rendering for some modes (e.g., visualization, shadow pass)
+
+	if (mShowVisualization ||
+	   (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE && 
+	    mIlluminationStage == IRS_RENDER_TO_TEXTURE))
+	{	
+		IlluminationRenderStage savedStage = mIlluminationStage; 
+	
+		if (mShowVisualization) 
+		{
+			// disable illumination stage to prevent rendering shadows
+			mIlluminationStage = IRS_NONE;
+		}
+
+		// standard rendering for shadow maps because of performance
+		TerrainSceneManager::_renderVisibleObjects();
+
+		mIlluminationStage = savedStage;
+	}
+	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)
+		{
+			clearSpecialCaseRenderQueues();
+			getRenderQueue()->clear();
+		}
+
+		//-- hierarchical culling
+		// the objects of different layers (e.g., background, scene, 
+		// overlay) must be identified and rendered one after another
+
+		//-- render all early skies
+		clearSpecialCaseRenderQueues();
+		addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
+		addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);
+		setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
+
+		TerrainSceneManager::_renderVisibleObjects();
+
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+		// delete previously rendered content
+		_deleteRenderedQueueGroups();
+#endif
+
+		//-- prepare queue for visible objects (i.e., all but overlay and skies late)
+		clearSpecialCaseRenderQueues();
+		addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE);
+		addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
+	
+		// exclude this queues from hierarchical rendering
+		setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
+
+
+		// set all necessary parameters for 
+		// hierarchical visibility culling and rendering
+		InitVisibilityCulling(mCameraInProgress);
+
+
+		/** 
+		* the hierarchical culling algorithm
+		* for depth pass: we just find objects and update depth buffer
+		* for "delayed" rendering: we render some passes afterwards
+		* e.g., transparents, because they need front-to-back sorting
+		**/
+		
+		mVisibilityManager->ApplyVisibilityCulling();
+
+		// delete remaining renderables from queue:
+		// all which are not in mLeavePassesInQueue)
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+		_deleteRenderedQueueGroups(mLeavePassesInQueue);
+#endif
+
+		//-- reset parameters
+		mIsDepthPassPhase = false;
+		mIsItemBufferPhase = false;
+		mSkipTransparents = false;
+		mIsHierarchicalCulling = false;
+		
+		mLeavePassesInQueue = 0;
+		
+#if 1	
+		// add visible nodes found by the visibility culling algorithm
+		if (mUseDepthPass)
+		{
+			NodeList::const_iterator it, it_end = mVisible.end();
+
+			//getRenderQueue()->clear();
+			for (it = mVisible.begin(); it != it_end; ++ it)
+			{
+				(*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
+			}
+		}
+#endif	
+		//-- now we can render all remaining queue objects
+		//-- used for depth pass, transparents, overlay
+		clearSpecialCaseRenderQueues();
+
+		TerrainSceneManager::_renderVisibleObjects();
+	} // hierarchical culling
+		
+	// HACK: set the new render level index, important to avoid cracks
+	// in terrain caused by LOD
+	TerrainRenderable::NextRenderLevelIndex();
+	
+	// reset ambient light
+	setAmbientLight(savedAmbient);
+
+	getRenderQueue()->clear(); // finally clear render queue
+	if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ...
+
+	if (0) WriteLog(); // write out stats
+}
+
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::_updateSceneGraph(Camera* cam)
+{
+	if (NORMAL_RENDER_HACK)
+	{
+		OctreeSceneManager::_updateSceneGraph(cam);
+		return;
+	}
+
+	mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
+	mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
+
+	TerrainSceneManager::_updateSceneGraph(cam);
+}
+//-----------------------------------------------------------------------
+bool OcclusionCullingSceneManager::setOption(const String & key, const void * val)
+{
+	if (key == "UseDepthPass")
+	{
+		mUseDepthPass = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "PrepareVisualization")
+	{
+		mShowVisualization = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "RenderNodesForViz")
+	{
+		mRenderNodesForViz = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "RenderNodesContentForViz")
+	{
+		mRenderNodesContentForViz = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "SkyBoxEnabled")
+	{
+		mSkyBoxEnabled = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "SkyPlaneEnabled")
+	{
+		mSkyPlaneEnabled = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "SkyDomeEnabled")
+	{
+		mSkyDomeEnabled = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "VisualizeCulledNodes")
+	{
+		mVisualizeCulledNodes = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "DelayRenderTransparents")
+	{
+		mDelayRenderTransparents = (*static_cast<const bool *>(val));
+		return true;
+	}
+
+	if (key == "DepthWrite")
+	{
+		mEnableDepthWrite = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "UseItemBuffer")
+	{
+		mUseItemBuffer = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "ExecuteVertexProgramForAllPasses")
+	{ 
+		mExecuteVertexProgramForAllPasses  = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "RenderTransparentsForItemBuffer")
+	{ 
+		mRenderTransparentsForItemBuffer  = (*static_cast<const bool *>(val));
+		return true;
+	}
+	if (key == "NodeVizScale")
+	{ 
+		OctreeNode::setVizScale(*static_cast<const float *>(val));
+		return true;
+	}
+	if (key == "LoadViewCells")
+	{ 
+		if (!mViewCellsLoaded)
+		{
+			String filename(static_cast<const char *>(val));
+			mViewCellsLoaded = LoadViewCells(filename);	
+		}
+
+		return mViewCellsLoaded;
+	}
+	if (key == "UseViewCells")
+	{ 
+		if (mViewCellsLoaded)
+		{
+			mUseViewCells = *static_cast<const bool *>(val);
+
+			// reset view cell
+			OGRE_DELETE(mCurrentViewCell);
+
+			if (mUseViewCells)
+				mCurrentViewCell = mViewCellsManager->GenerateViewCell();
+
+			mElementaryViewCell = NULL;
+
+			// if using view cells, all objects are set to false initially
+			SetObjectsVisible(!mUseViewCells);
+		}
+
+		return true;
+	}
+	if (key == "UseVisibilityFilter")
+	{
+		mUseVisibilityFilter = *static_cast<const bool *>(val);
+		// set null =>recomputation of the pvs
+        mElementaryViewCell = NULL;
+		return true;
+	}
+
+	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
+		setOption(key, val) || TerrainSceneManager::setOption(key, val);
+}
+//-----------------------------------------------------------------------
+bool OcclusionCullingSceneManager::getOption(const String & key, void *val)
+{
+	if (key == "NumHierarchyNodes")
+	{
+		* static_cast<unsigned int *>(val) = (unsigned int)mNumOctants;
+		return true;
+	}
+	if (key == "VisibilityManager")
+	{
+		* static_cast<GtpVisibility::VisibilityManager **>(val) = 
+			(GtpVisibility::VisibilityManager *)mVisibilityManager;
+		return true;
+	}
+	if (key == "HierarchInterface")
+	{
+		* static_cast<GtpVisibility::HierarchyInterface **>(val) = 
+			(GtpVisibility::HierarchyInterface *)mHierarchyInterface;
+		return true;
+	}
+
+	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
+		getOption(key, val) && TerrainSceneManager::getOption(key, val);
+}
+//-----------------------------------------------------------------------
+bool OcclusionCullingSceneManager::getOptionValues(const String & key, 
+													StringVector &refValueList)
+{
+	return TerrainSceneManager::getOptionValues( key, refValueList);
+}
+//-----------------------------------------------------------------------
+bool OcclusionCullingSceneManager::getOptionKeys(StringVector & refKeys)
+{
+	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
+		getOptionKeys(refKeys) || TerrainSceneManager::getOptionKeys(refKeys);
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::setVisibilityManager(GtpVisibility::
+														 VisibilityManager *visManager)
+{
+	mVisibilityManager = visManager;
+}
+//-----------------------------------------------------------------------
+GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::getVisibilityManager( void )
+{
+	return mVisibilityManager;
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::WriteLog()
+{
+	std::stringstream d;
+
+	d << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", "
+	  << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", "
+	  << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", "
+	  << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", "
+	  << "Hierarchy nodes: " << mNumOctants << ", " 
+	  << "Traversed nodes: " << mHierarchyInterface->GetNumTraversedNodes() << ", "
+	  << "Rendered nodes: " << mHierarchyInterface->GetNumRenderedNodes() << ", "
+	  << "Query culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumQueryCulledNodes() << ", "
+	  << "Frustum culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumFrustumCulledNodes() << ", "
+      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << ", "
+	  << "Found objects: " << (int)mVisible.size() << "\n";
+
+	LogManager::getSingleton().logMessage(d.str());
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 
+																QueuedRenderableCollection::OrganisationMode om)
+{
+    // Basic render loop
+    // Iterate through priorities
+    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
+
+    while (groupIt.hasMoreElements())
+    {
+        RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
+
+        // Sort the queue first
+        pPriorityGrp->sort(mCameraInProgress);
+
+        // Do solids
+        renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
+
+		// for correct rendering, transparents must be rendered after hierarchical culling
+		// => do nothing
+
+        // Do transparents (always descending)
+		if (NORMAL_RENDER_HACK || !mSkipTransparents)
+		{
+			renderObjects(pPriorityGrp->getTransparents(), 
+			QueuedRenderableCollection::OM_SORT_DESCENDING, true);
+		}
+
+
+    }// for each priority
+}
+
+//-----------------------------------------------------------------------
+bool OcclusionCullingSceneManager::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))
+	{
+		return false;
+	}
+	// all but first pass
+	/*else if ((!mIsDepthPassPhase || mIsItemBufferPhase) && (pass->getIndex() != 0))
+	{
+		return false;
+	}*/
+
+	return SceneManager::validatePassForRendering(pass);
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::_renderQueueGroupObjects(RenderQueueGroup* pGroup,
+															QueuedRenderableCollection::OrganisationMode om)
+{
+	if (NORMAL_RENDER_HACK || !mIsItemBufferPhase)
+	{
+		TerrainSceneManager::_renderQueueGroupObjects(pGroup, om);
+		return;
+	}
+#ifdef  ITEM_BUFFER
+	//-- item buffer
+	//-- item buffer: render objects using false colors
+
+    // Iterate through priorities
+    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
+
+	while (groupIt.hasMoreElements())
+    {
+		RenderItemBuffer(groupIt.getNext());
+	}
+#endif // ITEM_BUFFER
+}
+#ifdef ITEM_BUFFER
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
+{
+	// Do solids
+	QueuedRenderableCollection solidObjs = pGroup->getSolidsBasic();//msz
+
+	// ----- SOLIDS LOOP -----
+	RenderPriorityGroup::SolidRenderablePassMap::const_iterator ipass, ipassend;
+	ipassend = solidObjs.end();
+
+	for (ipass = solidObjs.begin(); ipass != ipassend; ++ipass)
+	{
+		// Fast bypass if this group is now empty
+		if (ipass->second->empty()) 
+			continue;
+
+		// Render only first pass of renderable as false color
+		if (ipass->first->getIndex() > 0)
+			continue;
+
+		RenderPriorityGroup::RenderableList* rendList = ipass->second;
+		
+		RenderPriorityGroup::RenderableList::const_iterator irend, irendend;
+		irendend = rendList->end();
+			
+		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);
+		}
+	}
+
+	//-- TRANSPARENT LOOP: must be handled differently from solids
+
+	// transparents are treated either as solids or completely discarded
+	if (mRenderTransparentsForItemBuffer)
+	{
+		QueuedRenderableCollection transpObjs = pGroup->getTransparents(); //msz
+		RenderPriorityGroup::TransparentRenderablePassList::const_iterator 
+			itrans, itransend;
+
+		itransend = transpObjs.end();
+		for (itrans = transpObjs.begin(); itrans != itransend; ++itrans)
+		{
+			// like for solids, render only first pass
+			if (itrans->pass->getIndex() == 0)
+			{	
+				RenderSingleObjectForItemBuffer(itrans->renderable, itrans->pass);
+			}
+		}
+	}
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass)
+{
+	static LightList nullLightList;
+	
+	int col[4];
+	
+	// -- create color code out of object id
+	col[0] = (rend->getId() >> 16) & 255;
+	col[1] = (rend->getId() >> 8) & 255;
+	col[2] = rend->getId() & 255;
+//	col[3] = 255;
+
+	//mDestRenderSystem->setColour(col[0], col[1], col[2], col[3]);
+    
+	mItemBufferPass->setAmbient(ColourValue(col[0] / 255.0f,
+										    col[1] / 255.0f, 
+											col[2] / 255.0f, 1));
+
+	// set vertex program of current pass
+	if (mExecuteVertexProgramForAllPasses && pass->hasVertexProgram())
+	{
+		mItemBufferPass->setVertexProgram(pass->getVertexProgramName());
+
+		if (mItemBufferPass->hasVertexProgram())
+		{
+			const GpuProgramPtr& prg = mItemBufferPass->getVertexProgram();
+			// Load this program if not done already
+			if (!prg->isLoaded())
+				prg->load();
+			// Copy params
+			mItemBufferPass->setVertexProgramParameters(pass->getVertexProgramParameters());
+		}
+	}
+	else if (mItemBufferPass->hasVertexProgram())
+	{
+		mItemBufferPass->setVertexProgram("");
+	}
+
+	const Pass *usedPass = _setPass(mItemBufferPass); 
+
+
+	// render a single object, this will set up auto params if required
+	renderSingleObject(rend, usedPass, false, &nullLightList);
+}
+#endif // ITEM_BUFFER
+//-----------------------------------------------------------------------
+GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::GetVisibilityManager()
+{
+	return mVisibilityManager;
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::InitVisibilityCulling(Camera *cam)
+{
+	// reset culling manager stats
+	mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes);
+
+	// set depth pass flag before rendering
+	mIsDepthPassPhase = mUseDepthPass;
+
+	mIsHierarchicalCulling = true; // during hierarchical culling
+
+	// item buffer needs full ambient lighting to use item colors as unique id
+	if (mUseItemBuffer) 
+	{
+		mIsItemBufferPhase = true;
+		setAmbientLight(ColourValue(1,1,1,1));
+	}
+
+
+	// set passes which are stored in render queue 
+	// for rendering AFTER hierarchical culling, i.e., passes which need 
+	// a special rendering order
+	
+	mLeavePassesInQueue = 0;
+
+	// 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)
+		{
+			// TODO: remove this pass because it should be processed during hierarchical culling
+			//mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW;
+
+			mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DECAL;
+			mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DIFFUSE_SPECULAR;
+			mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
+
+			// just render ambient passes
+			/*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
+			// mIlluminationStage = IRS_AMBIENT; 
+			//getRenderQueue()->setSplitPassesByLightingType(true);
+		}
+	
+		if (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE)
+		{
+			mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW;
+			mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
+		}
+	
+		// transparents should be rendered after hierarchical culling to 
+		// provide front-to-back ordering
+		if (mDelayRenderTransparents)
+		{
+			mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
+		}
+	}
+
+	// skip rendering transparents during the hierarchical culling
+	// (because they will be rendered afterwards)
+	mSkipTransparents = 
+		(mIsDepthPassPhase || (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES));
+
+	// -- initialise interface for rendering traversal of the hierarchy
+	mHierarchyInterface->SetHierarchyRoot(mOctree);
+	
+	// possible two cameras (one for culling, one for rendering)
+	mHierarchyInterface->InitTraversal(mCameraInProgress, 
+									   mCullCamera ? getCamera("CullCamera") : NULL,
+									   mLeavePassesInQueue);
+		
+}
+//-----------------------------------------------------------------------
+OctreeHierarchyInterface *OcclusionCullingSceneManager::GetHierarchyInterface()
+{
+	return mHierarchyInterface;
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::endFrame()
+{
+	TerrainRenderable::ResetRenderLevelIndex();
+}
+//-----------------------------------------------------------------------
+Entity* OcclusionCullingSceneManager::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 OcclusionCullingSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
+	RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
+{
+	// only render solid passes during hierarchical culling
+	if (mIsHierarchicalCulling)
+	{
+		RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
+	    LightList lightList;
+
+		while (groupIt.hasMoreElements())
+		{
+			RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
+
+			// Sort the queue first
+			pPriorityGrp->sort(mCameraInProgress);
+
+			// Clear light list
+			lightList.clear();
+
+			// Render all the ambient passes first, no light iteration, no lights
+			/*** 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->getSolidsNoShadowReceive(), om, true);
+#if 0		
+			std::stringstream d; 
+			d << " solid size: " << (int)pPriorityGrp->_getSolidPasses().size()
+				<< " solid no shadow size: " << (int)pPriorityGrp->_getSolidPassesNoShadow().size()
+				<< "difspec size: " << (int)pPriorityGrp->_getSolidPassesDiffuseSpecular().size()
+				<< " decal size: " << (int)pPriorityGrp->_getSolidPassesDecal().size();
+			LogManager::getSingleton().logMessage(d.str());
+#endif
+		}
+	}
+	else // render the rest of the passes
+	{
+		OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup, om);
+	}
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::renderModulativeStencilShadowedQueueGroupObjects(
+	RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
+{
+   if (mIsHierarchicalCulling)
+   {
+	   // Iterate through priorities
+	   RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
+
+	   while (groupIt.hasMoreElements())
+	   {
+		   RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
+
+		   // Sort the queue first
+		   pPriorityGrp->sort(mCameraInProgress);
+
+		   // Do (shadowable) solids
+		   OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
+	   }
+   }
+   else
+   {
+	   OctreeSceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup, om);
+   }
+}
+//-------------------------------------------------------------------------
+void OcclusionCullingSceneManager::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);
+	}
+}
+//-----------------------------------------------------------------------
+bool OcclusionCullingSceneManager::LoadViewCells(const String &filename)
+{
+	// objects are set to invisible initially
+	SetObjectsVisible(false);
+	
+	const string bboxesFilename = mVisibilityManager->GetVisibilityEnvironment()->getViewCellsFileName();
+
+	// converter between view cell ids and Ogre entites 
+	GtpVisibilityPreprocessor::IndexedBoundingBoxContainer iboxes;
+	OgreBoundingBoxConverter bconverter(this);
+
+	
+	GtpVisibilityPreprocessor::Environment *env = 
+		mVisibilityManager->GetVisibilityEnvironment()->GetPreprocessorEnvironment();
+
+	// load the view cells assigning the found objects to the pvss
+	mViewCellsManager = 
+		GtpVisibilityPreprocessor::ViewCellsManager::LoadViewCells(filename, &mObjects, env, false, &bconverter);
+
+	if (!mViewCellsManager)
+	{
+		std::stringstream d;
+		d << "error loading view cells" << endl;
+		LogManager::getSingleton().logMessage(d.str());
+	}
+
+	return (mViewCellsManager != NULL);
+}
+//-------------------------------------------------------------------------
+void OcclusionCullingSceneManager::applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc, 
+													const bool load)
+{	// NOTE: should not happen, rather apply view cell representing unbounded space then
+	if (!vc) 
+	{	
+		// set everything visible for savety
+		SetObjectsVisible(true);
+
+		return;
+	}
+		
+	GtpVisibilityPreprocessor::ObjectPvsMap::const_iterator oit,
+			oit_end = vc->GetPvs().mEntries.end();
+
+	//-- PVS of view cell
+	for (oit = vc->GetPvs().mEntries.begin(); oit != oit_end; ++ oit)
+	{
+		if (!(*oit).first) continue;
+
+		OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance*>((*oit).first);
+		omi->GetMesh()->setVisible(load);
+		//GtpVisibilityPreprocessor::Debug << "assigned id " << omi->GetId() << endl;
+	}
+}
+//-------------------------------------------------------------------------
+void OcclusionCullingSceneManager::updatePvs(Camera *cam)
+{
+	if (!(mViewCellsLoaded && mUseViewCells))
+		return;
+
+	const GtpVisibilityPreprocessor::Vector3 viewPoint = 
+		OgreTypeConverter::ConvertFromOgre(cam->getDerivedPosition());
+
+	GtpVisibilityPreprocessor::ViewCell *newElementary = 
+		mViewCellsManager->GetViewCell(viewPoint);
+
+	// elementary view cell did not change => apply same pvs
+	if (mElementaryViewCell == newElementary)
+		return;
+
+	mElementaryViewCell = newElementary;
+	//LogManager::getSingleton().logMessage("unloading");
+	//-- unload old pvs
+	applyViewCellPvs(mCurrentViewCell, false);
+
+
+	//-- the new view cell
+		
+	GtpVisibilityPreprocessor::ViewCell *viewCell;
+
+		
+	if (mUseVisibilityFilter)
+	{
+		//-- compute new filtered cell
+		GtpVisibilityPreprocessor::PrVs prvs;
+		mViewCellsManager->GetPrVS(viewPoint, prvs, 5);
+		viewCell = prvs.mViewCell;
+	}
+	else
+	{
+		viewCell = newElementary;
+	}
+	//LogManager::getSingleton().logMessage("loading");
+	//-- load new pvs
+	applyViewCellPvs(viewCell, true);
+
+	// store pvs
+	mCurrentViewCell->SetPvs(viewCell->GetPvs());
+
+	// delete merge tree of filtered view cell
+	if (mUseVisibilityFilter)
+		mViewCellsManager->DeleteLocalMergeTree(viewCell);
+}
+//-------------------------------------------------------------------------
+void OcclusionCullingSceneManager::TestVisible(SceneNode *node)
+{
+	// first test for scene node, then for octant (part of the hierarchy)
+	if (!node->mVisibleChildren)
+		node->setVisible(false);
+
+	node->getOctant()->mVisibleChildren --;
+}
+//-------------------------------------------------------------------------
+void OcclusionCullingSceneManager::TestVisible(Octree *octant)
+{
+	// first test for scene node, then for octant (part of the hierarchy)
+	if (!octant->mVisibleChildren)
+		octant->setVisible(false);
+}
+
+//-------------------------------------------------------------------------
+void OcclusionCullingSceneManager::UpdateVisibility(Entity *ent)
+{
+	if (!ent->isVisible())
+	{
+		bool visible = TestVisible(ent->getParentNode());
+		
+		if (!visible)
+			visible = TestVisible(octant->getParentNode());
+
+		if (!visible)
+			mHierarchyInterface->pullupVisibility();
+	}
+}
+
+
+//-----------------------------------------------------------------------
+const String OcclusionCullingSceneManagerFactory::FACTORY_TYPE_NAME = "OcclusionCullingSceneManager";
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManagerFactory::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 *OcclusionCullingSceneManagerFactory::createInstance(
+		const String& instanceName)
+{
+	OcclusionCullingSceneManager* tsm = new OcclusionCullingSceneManager(instanceName, visManager);
+	
+	// Create & register default sources (one per manager)
+	HeightmapTerrainPageSource* ps = new HeightmapTerrainPageSource();
+	mTerrainPageSources.push_back(ps);
+	tsm->registerPageSource("Heightmap", ps);
+
+	return tsm;
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManagerFactory::destroyInstance(SceneManager* instance)
+{
+	delete instance;
+}
+
+} // namespace Ogre
Index: /GTP/trunk/Lib/Vis/Preprocessing/scripts/vienna_simple.env
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/scripts/vienna_simple.env	(revision 942)
+++ /GTP/trunk/Lib/Vis/Preprocessing/scripts/vienna_simple.env	(revision 955)
@@ -30,4 +30,6 @@
 	detectEmptyViewSpace true
 	loadPolygonsAsMeshes false
+	applyVisibilityFilter false
+	applyVisibilitySpatialFilter false
 }
 
@@ -356,6 +358,6 @@
 		missTolerance		6
 		globalCostMissTolerance 4
-		#minGlobalCostRatio      0.0000001
-		minGlobalCostRatio      0.0001
+		minGlobalCostRatio      0.0000001
+		#minGlobalCostRatio      0.0001
 		maxViewCells		5000
 	
Index: /GTP/trunk/Lib/Vis/Preprocessing/scripts/generate_viewcells.env
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/scripts/generate_viewcells.env	(revision 944)
+++ /GTP/trunk/Lib/Vis/Preprocessing/scripts/generate_viewcells.env	(revision 955)
@@ -30,4 +30,6 @@
 	detectEmptyViewSpace true
 	loadPolygonsAsMeshes false
+	applyVisibilityFilter false
+	applyVisibilitySpatialFilter false
 }
 
Index: /GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.h
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.h	(revision 882)
+++ /GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.h	(revision 955)
@@ -10,4 +10,6 @@
 #include "RayInfo.h"
 #include "ViewCellBsp.h"
+
+
 
 namespace GtpVisibilityPreprocessor {
@@ -325,4 +327,5 @@
 	/** Writes tree to output stream
 	*/
+	//bool Export(ogzstream &stream);
 	bool Export(ofstream &stream);
 
@@ -691,7 +694,8 @@
 
 	/** Writes the node to disk
-		@note: should be implemented as visitor
+		@note: should be implemented as visitor.
 	*/
 	void ExportNode(BspNode *node, ofstream &stream);
+	//void ExportNode(BspNode *node, ogzstream &stream);
 
 	/** Returns estimated memory usage of tree.
Index: /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCell.cpp
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCell.cpp	(revision 938)
+++ /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCell.cpp	(revision 955)
@@ -13,5 +13,8 @@
 #include <stack>
 
+
+
 namespace GtpVisibilityPreprocessor {
+
 
 
@@ -1944,4 +1947,5 @@
 
 bool ViewCellsTree::Export(ofstream &stream, const bool exportPvs)
+//bool ViewCellsTree::Export(ogzstream &stream, const bool exportPvs)
 {
 	// export recursivly all view cells from the root
@@ -1980,4 +1984,5 @@
 
 
+//void ViewCellsTree::ExportPvs(ViewCell *viewCell, ogzstream &stream)
 void ViewCellsTree::ExportPvs(ViewCell *viewCell, ofstream &stream)
 {
@@ -1992,4 +1997,5 @@
 
 void ViewCellsTree::ExportViewCell(ViewCell *viewCell, ofstream &stream, const bool exportPvs)
+//void ViewCellsTree::ExportViewCell(ViewCell *viewCell, ogzstream &stream, const bool exportPvs)
 {
 	if (viewCell->IsLeaf())
@@ -2003,6 +2009,8 @@
 		//-- export pvs
 		if (exportPvs)
+		{
 			ExportPvs(viewCell, stream);
-	
+		}
+
 		stream << "\" />" << endl;
 		//stream << " </Leaf>" << endl;
Index: /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.h
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.h	(revision 944)
+++ /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.h	(revision 955)
@@ -465,5 +465,5 @@
 	/** Exports bounding boxes as xml stream
 	*/
-	bool ExportBoundingBoxes(ofstream &xmlstream, const ObjectContainer &objects) const;
+	//bool ExportBoundingBoxes(ofstream &xmlstream, const ObjectContainer &objects) const;
 
 	/** Intersects box with the tree and returns the number of intersected boxes.
Index: /GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.cpp
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.cpp	(revision 882)
+++ /GTP/trunk/Lib/Vis/Preprocessing/src/VspBspTree.cpp	(revision 955)
@@ -3846,4 +3846,5 @@
 
 bool VspBspTree::Export(ofstream &stream)
+//bool VspBspTree::Export(ogzstream &stream)
 {
 	ExportNode(mRoot, stream);
@@ -3854,4 +3855,5 @@
 
 void VspBspTree::ExportNode(BspNode *node, ofstream &stream)
+//void VspBspTree::ExportNode(BspNode *node, ogzstream &stream)
 {
 	if (node->IsLeaf())
Index: /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCell.h
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCell.h	(revision 938)
+++ /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCell.h	(revision 955)
@@ -7,5 +7,8 @@
 #include "Statistics.h"
 #include "Material.h"
-//namespace GtpVisibilityPreprocessor {
+//#include "bzip2stream.hpp"
+#include "gzstream.h"
+
+//class ogzstream;
 
 namespace GtpVisibilityPreprocessor {
@@ -25,4 +28,5 @@
 class Environment;
 
+
 /** Statistics for a view cell partition.
 */
@@ -436,5 +440,6 @@
 	/** Exports view cells to file.
 	*/
-    bool Export(ofstream &stream, const bool exportPvs = false);
+	bool Export(ofstream &stream, const bool exportPvs = false);
+    //bool Export(ogzstream &stream, const bool exportPvs = false);
 
 	/** Export statistics of this view cell tree.
@@ -541,8 +546,10 @@
 	*/
 	void ExportViewCell(ViewCell *viewCell, ofstream &stream, const bool exportPvs);
+	//void ExportViewCell(ViewCell *viewCell, ogzstream &stream, const bool exportPvs);
 
 	/** Exports pvs of a view cell.
 	*/
 	void ExportPvs(ViewCell *viewCell, ofstream &stream);
+	//void ExportPvs(ViewCell *viewCell, ogzstream &stream);
 
 
Index: /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParserXerces.h
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParserXerces.h	(revision 938)
+++ /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParserXerces.h	(revision 955)
@@ -8,4 +8,5 @@
 #include "Mesh.h"
 #include "BoundingBoxConverter.h"
+//#include "gzstream.h"
 
 namespace GtpVisibilityPreprocessor {
@@ -179,5 +180,4 @@
   return target;
 }
-
 }
 
Index: /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParser.cpp
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParser.cpp	(revision 944)
+++ /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsParser.cpp	(revision 955)
@@ -755,4 +755,5 @@
 	const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
 	parser->parse(filename.c_str());
+	//ogzstream stream; parser->parse(stream);
 	const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
 	duration = endMillis - startMillis;
Index: /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp
===================================================================
--- /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp	(revision 944)
+++ /GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp	(revision 955)
@@ -18,4 +18,6 @@
 
 
+
+
 namespace GtpVisibilityPreprocessor {
 
@@ -508,8 +510,8 @@
 	PostProcess(preprocessor->mObjects, postProcessSamples);
 
-	cout << "time needed for  post processing (merge) step: "
+	cout << "time needed for post processing (merge) step: "
 		 << TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl;
 
-	Debug << "time needed for  post processing (merge) step: "
+	Debug << "time needed for post processing (merge) step: "
 		 << TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl;
 
@@ -2037,29 +2039,4 @@
 
 
-bool ViewCellsManager::ExportBoundingBoxes(ofstream &xmlstream, 
-										   const ObjectContainer &objects) const
-{
-	//-- export the view cells and the pvs
-	xmlstream << "<BoundingBoxes>" << endl;
-
-	ObjectContainer::const_iterator oit, oit_end = objects.end();
-
-	for (oit = objects.begin(); oit != oit_end; ++ oit)
-	{
-			MeshInstance *mi = dynamic_cast<MeshInstance *>(*oit);
-			const AxisAlignedBox3 box = mi->GetBox();
-
-			//-- the bounding boxes
-			xmlstream << "<BoundingBox" << " id=\"" << mi->GetId() << "\""
-				      << " min=\"" << box.Min().x << " " << box.Min().y << " " << box.Min().z << "\""
-					  << " max=\"" << box.Max().x << " " << box.Max().y << " " << box.Max().z << "\" />" << endl;
-	}
-
-	xmlstream << "</BoundingBoxes>" << endl;
-
-	return true;
-}
-
-
 /**********************************************************************/
 /*                 BspViewCellsManager implementation                 */
@@ -2772,4 +2749,5 @@
 bool BspViewCellsManager::ExportViewCells(const string filename, const bool exportPvs, const ObjectContainer &objects)
 {
+#if STILL_HAS_TODO
 	cout << "exporting view cells to xml ... ";
 	std::ofstream stream;
@@ -2809,5 +2787,5 @@
 
 	cout << "finished" << endl;
-
+#endif
 	return true;
 }
@@ -4773,10 +4751,11 @@
 {
 	cout << "exporting view cells to xml ... ";
-	std::ofstream stream;
+	
+	//ogzstream stream(filename.c_str());
+	std::ofstream stream(filename.c_str());
 
 	// for output we need unique ids for each view cell
 	CreateUniqueViewCellIds();
 
-	stream.open(filename.c_str());
 	stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"<<endl;
 	stream << "<Visibility_Solution>" << endl;
@@ -4787,13 +4766,28 @@
 		   << " max=\"" << mViewSpaceBox.Max().x << " " << mViewSpaceBox.Max().y << " " << mViewSpaceBox.Max().z << "\" />" << endl;
 
-	ExportBoundingBoxes(stream, objects);
-
-	//-- the type of the view cells hierarchy
-	stream << "<Hierarchy name=\"vspBspTree\" />" << endl;
+	
+	//-- export bounding boxes
+	stream << "<BoundingBoxes>" << endl;
+
+	ObjectContainer::const_iterator oit, oit_end = objects.end();
+
+	for (oit = objects.begin(); oit != oit_end; ++ oit)
+	{
+			MeshInstance *mi = dynamic_cast<MeshInstance *>(*oit);
+			const AxisAlignedBox3 box = mi->GetBox();
+
+			//-- the bounding boxes
+			stream << "<BoundingBox" << " id=\"" << mi->GetId() << "\""
+				   << " min=\"" << box.Min().x << " " << box.Min().y << " " << box.Min().z << "\""
+				   << " max=\"" << box.Max().x << " " << box.Max().y << " " << box.Max().z << "\" />" << endl;
+	}
+
+	stream << "</BoundingBoxes>" << endl;
+
 
 	//-- export the view cells and the pvs
 	const int numViewCells = mCurrentViewCellsStats.viewCells;
 
-	stream << "<ViewCells number=\"" << numViewCells << "\" />" << endl;
+	stream << "<ViewCells number=\"" << numViewCells << "\" >" << endl;
 	
 	mViewCellsTree->Export(stream, exportPvs);
@@ -4803,5 +4797,7 @@
 
 	//-- export the spatial hierarchy
-	stream << "<Hierarchy>" << endl;
+	
+	// the type of the view cells hierarchy
+	stream << "<Hierarchy name=\"vspBspTree\" />" << endl;
 	mVspBspTree->Export(stream);
 	stream << endl << "</Hierarchy>" << endl;
@@ -4810,6 +4806,7 @@
 
 	stream << "</Visibility_Solution>" << endl;
+
+
 	stream.close();
-
 	cout << "finished" << endl;
 
