Index: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOcclusionCullingSceneManager.h
===================================================================
--- GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOcclusionCullingSceneManager.h	(revision 675)
+++ GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOcclusionCullingSceneManager.h	(revision 675)
@@ -0,0 +1,167 @@
+#ifndef _OcclusionCullingSceneManager_H__
+#define _OcclusionCullingSceneManager_H__
+
+#include <OgreSceneNode.h>
+#include <OgreTerrainSceneManager.h>
+#include <OgreOctreeNode.h>
+#include <OgreOctreeCamera.h>
+#include <OgrePrerequisites.h>
+
+#include "OgreOctreeHierarchyInterface.h"
+#include "OgrePlatformQueryManager.h"
+#include "VisibilityManager.h"
+
+
+namespace Ogre {
+
+/**
+	This class extends the terrain scene manager,
+	using occlusion queries for visibility culling.
+*/
+class __declspec(dllexport) OcclusionCullingSceneManager: public TerrainSceneManager
+{
+public:
+	OcclusionCullingSceneManager(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 set of objects, see renderSingleObject for param definitions 
+		Override so we can handle delayed rendering of transparent objects
+	*/
+	virtual void renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+            bool doLightIteration, const LightList* manualLightList = 0);
+
+	/** Writes out stats into the Ogre log file.
+	*/
+	void WriteLog();
+
+	/** Override pass so we can do the z-fail pass. 
+	*/
+	Pass* setPass(Pass* pass);
+
+	/** Override from SceneManager so we can skip all but first pass for depth pass. 
+	*/
+	bool validatePassForRendering(Pass* pass);
+
+	void RenderItemBuffer(RenderPriorityGroup* pGroup);
+	void RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass);
+	void renderQueueGroupObjects(RenderQueueGroup* pGroup);
+
+	/** 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);
+	void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup);
+
+	/** Override standard function so octree boxes are always of equal side length.
+		This has advantages for CHC, because terrain tiles are in different octree nodes
+		and can be culled.
+	*/
+	void setWorldGeometry( const String& filename );
+
+protected:
+	
+	/** 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);
+
+	/// 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;
+
+	/// if we 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)
+	bool mUseDepthPass;
+	/// if we currently rendering 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;
+
+	bool mIsHierarchicalCulling;
+};
+
+} // namespace Ogre
+
+#endif // CullingTerrainSceneManager_H
Index: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/scripts/Plugin_VisibilitySceneManager.vcproj
===================================================================
--- GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/scripts/Plugin_VisibilitySceneManager.vcproj	(revision 672)
+++ GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/scripts/Plugin_VisibilitySceneManager.vcproj	(revision 675)
@@ -150,4 +150,7 @@
 				Filter="">
 				<File
+					RelativePath="..\include\OgreOcclusionCullingSceneManager.h">
+				</File>
+				<File
 					RelativePath="..\include\OgreOctreeHierarchyInterface.h">
 				</File>
@@ -167,4 +170,7 @@
 				<File
 					RelativePath="..\src\OgreBspHierarchyInterface.cpp">
+				</File>
+				<File
+					RelativePath="..\src\OgreOcclusionCullingSceneManager.cpp">
 				</File>
 				<File
Index: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityTerrainSceneManager.cpp
===================================================================
--- GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityTerrainSceneManager.cpp	(revision 347)
+++ GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityTerrainSceneManager.cpp	(revision 675)
@@ -1,3 +1,3 @@
-#include "OgreVisibilityTerrainSceneManager.h"
+#include "OgreOcclusionCullingSceneManager.h"
 #include "OgreVisibilityOptionsManager.h"
 #include <OgreMath.h>
@@ -14,5 +14,5 @@
 
 //-----------------------------------------------------------------------
-VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(
+OcclusionCullingSceneManager::OcclusionCullingSceneManager(
 							GtpVisibility::VisibilityManager *visManager): 
 mVisibilityManager(visManager), 
@@ -45,5 +45,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::InitDepthPass()
+void OcclusionCullingSceneManager::InitDepthPass()
 {
 	MaterialPtr depthMat = MaterialManager::getSingleton().getByName("Visibility/DepthPass");
@@ -66,10 +66,10 @@
 }
 //-----------------------------------------------------------------------
-VisibilityTerrainSceneManager::~VisibilityTerrainSceneManager()
+OcclusionCullingSceneManager::~OcclusionCullingSceneManager()
 {
 	OGRE_DELETE(mHierarchyInterface);
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::InitItemBufferPass()
+void OcclusionCullingSceneManager::InitItemBufferPass()
 {
 	MaterialPtr itemBufferMat = MaterialManager::getSingleton().
@@ -95,5 +95,5 @@
 }
 //-------------------------------------------------------------------------
-void VisibilityTerrainSceneManager::setWorldGeometry( const String& filename )
+void OcclusionCullingSceneManager::setWorldGeometry( const String& filename )
 {
     // Clear out any existing world resources (if not default)
@@ -124,5 +124,5 @@
 
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::PrepareVisualization(Camera *cam)
+void OcclusionCullingSceneManager::PrepareVisualization(Camera *cam)
 {
 	// add player camera for visualization purpose
@@ -173,5 +173,5 @@
 }
 //-----------------------------------------------------------------------
-Pass *VisibilityTerrainSceneManager::setPass(Pass* pass)
+Pass *OcclusionCullingSceneManager::setPass(Pass* pass)
 {
 	// TODO: setting vertex program is not efficient
@@ -236,5 +236,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::_findVisibleObjects(Camera* cam,
+void OcclusionCullingSceneManager::_findVisibleObjects(Camera* cam,
 														bool onlyShadowCasters)
 {
@@ -266,5 +266,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::_renderVisibleObjects()
+void OcclusionCullingSceneManager::_renderVisibleObjects()
 {
 
@@ -354,5 +354,5 @@
 		if (mUseDepthPass)
 		{
-			for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
+			for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++ it)
 			{
 				(*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
@@ -381,5 +381,5 @@
 
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::_updateSceneGraph(Camera* cam)
+void OcclusionCullingSceneManager::_updateSceneGraph(Camera* cam)
 {
 	mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
@@ -389,5 +389,5 @@
 }
 //-----------------------------------------------------------------------
-bool VisibilityTerrainSceneManager::setOption(const String & key, const void * val)
+bool OcclusionCullingSceneManager::setOption(const String & key, const void * val)
 {
 	if (key == "UseDepthPass")
@@ -482,5 +482,5 @@
 }
 //-----------------------------------------------------------------------
-bool VisibilityTerrainSceneManager::getOption(const String & key, void *val)
+bool OcclusionCullingSceneManager::getOption(const String & key, void *val)
 {
 	if (key == "NumHierarchyNodes")
@@ -494,5 +494,5 @@
 }
 //-----------------------------------------------------------------------
-bool VisibilityTerrainSceneManager::getOptionValues(const String & key, 
+bool OcclusionCullingSceneManager::getOptionValues(const String & key, 
 													StringVector &refValueList)
 {
@@ -500,5 +500,5 @@
 }
 //-----------------------------------------------------------------------
-bool VisibilityTerrainSceneManager::getOptionKeys(StringVector & refKeys)
+bool OcclusionCullingSceneManager::getOptionKeys(StringVector & refKeys)
 {
 	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
@@ -506,5 +506,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::setVisibilityManager(GtpVisibility::
+void OcclusionCullingSceneManager::setVisibilityManager(GtpVisibility::
 														 VisibilityManager *visManager)
 {
@@ -512,10 +512,10 @@
 }
 //-----------------------------------------------------------------------
-GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::getVisibilityManager( void )
+GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::getVisibilityManager( void )
 {
 	return mVisibilityManager;
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::WriteLog()
+void OcclusionCullingSceneManager::WriteLog()
 {
 	std::stringstream d;
@@ -535,5 +535,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::renderObjects(
+void OcclusionCullingSceneManager::renderObjects(
 	const RenderPriorityGroup::TransparentRenderablePassList& objs, 
     bool doLightIteration, const LightList* manualLightList)
@@ -546,5 +546,5 @@
 }
 //-----------------------------------------------------------------------
-bool VisibilityTerrainSceneManager::validatePassForRendering(Pass* pass)
+bool OcclusionCullingSceneManager::validatePassForRendering(Pass* pass)
 {
 	// skip all but first pass if we are doing the depth pass
@@ -553,8 +553,9 @@
 		return false;
 	}
+
 	return SceneManager::validatePassForRendering(pass);
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
+void OcclusionCullingSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
 {
 	if (!mIsItemBufferPhase)
@@ -575,5 +576,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
+void OcclusionCullingSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
 {
 	// Do solids
@@ -632,5 +633,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass)
+void OcclusionCullingSceneManager::RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass)
 {
 	static LightList nullLightList;
@@ -677,10 +678,10 @@
 }
 //-----------------------------------------------------------------------
-GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::GetVisibilityManager()
+GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::GetVisibilityManager()
 {
 	return mVisibilityManager;
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::InitVisibilityCulling(Camera *cam)
+void OcclusionCullingSceneManager::InitVisibilityCulling(Camera *cam)
 {
 	// reset culling manager stats
@@ -742,21 +743,21 @@
 	// possible two cameras (one for culling, one for rendering)
 	mHierarchyInterface->InitTraversal(mCameraInProgress, 
-							mCullCamera ? getCamera("CullCamera") : NULL,
-							mLeavePassesInQueue);
+									   mCullCamera ? getCamera("CullCamera") : NULL,
+									   mLeavePassesInQueue);
 		
 	//std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;LogManager::getSingleton().logMessage(d.str());
 }
 //-----------------------------------------------------------------------
-OctreeHierarchyInterface *VisibilityTerrainSceneManager::GetHierarchyInterface()
+OctreeHierarchyInterface *OcclusionCullingSceneManager::GetHierarchyInterface()
 {
 	return mHierarchyInterface;
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::endFrame()
+void OcclusionCullingSceneManager::endFrame()
 {
 	TerrainRenderable::ResetRenderLevelIndex();
 }
 //-----------------------------------------------------------------------
-Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName, 
+Entity* OcclusionCullingSceneManager::createEntity(const String& entityName, 
 													const String& meshName)
 {
@@ -774,5 +775,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+void OcclusionCullingSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
 {
 	// only render solid passes during hierarchical culling
@@ -806,5 +807,5 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityTerrainSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+void OcclusionCullingSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
 {
    if (mIsHierarchicalCulling)
Index: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp
===================================================================
--- GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp	(revision 675)
+++ GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp	(revision 675)
@@ -0,0 +1,832 @@
+#include "OgreVisibilityTerrainSceneManager.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>
+
+
+namespace Ogre {
+
+//-----------------------------------------------------------------------
+VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(
+							GtpVisibility::VisibilityManager *visManager): 
+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),
+mIsHierarchicalCulling(false)
+{
+	mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
+	
+	//mDisplayNodes = true;
+	//mShowBoundingBoxes = true;
+	//mShowBoxes = true;
+
+	// TODO: set maxdepth to reasonable value
+	mMaxDepth = 50;
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::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);
+	}
+}
+//-----------------------------------------------------------------------
+VisibilityTerrainSceneManager::~VisibilityTerrainSceneManager()
+{
+	OGRE_DELETE(mHierarchyInterface);
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::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);
+}
+//-------------------------------------------------------------------------
+void VisibilityTerrainSceneManager::setWorldGeometry( const String& filename )
+{
+    // Clear out any existing world resources (if not default)
+    if (ResourceGroupManager::getSingleton().getWorldResourceGroupName() != 
+        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)
+    {
+        ResourceGroupManager::getSingleton().clearResourceGroup(
+            ResourceGroupManager::getSingleton().getWorldResourceGroupName());
+    }
+    mTerrainPages.clear();
+    // Load the configuration
+    loadConfig(filename);
+
+    // Resize the octree, allow for 1 page for now
+    float max_x = mOptions.scale.x * mOptions.pageSize;
+    float max_y = mOptions.scale.y;
+    float max_z = mOptions.scale.z * mOptions.pageSize;
+
+	float maxAxis = std::max(max_x, max_y);
+	maxAxis = std::max(maxAxis, max_z);
+	resize( AxisAlignedBox( 0, 0, 0, maxAxis, maxAxis, maxAxis ) );
+    
+    setupTerrainMaterial();
+
+    setupTerrainPages();
+
+ }
+
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::PrepareVisualization(Camera *cam)
+{
+	// add player camera for visualization purpose
+	try 
+	{
+		Camera *c;
+		if ((c = getCamera("PlayerCam")) != NULL)
+		{
+			getRenderQueue()->addRenderable(c);
+		}   
+    }
+    catch (...)
+    {
+        // ignore
+    }
+	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() > 0) && ((*it)->numChildren() == 0) && 
+					 (*it)->getAttachedObject(0)->getMovableType() == "Entity")
+				{
+					getRenderQueue()->addRenderable((*it));
+				}
+
+				// addbounding boxes instead of node itself
+				//(*it)->_addBoundingBoxToQueue(getRenderQueue());
+			}
+			if (mRenderNodesContentForViz) 
+			{
+				(*it)->_addToRenderQueue(cam, getRenderQueue(), false);
+			}
+		}
+	}	
+}
+//-----------------------------------------------------------------------
+Pass *VisibilityTerrainSceneManager::setPass(Pass* pass)
+{
+	// TODO: setting vertex program is not efficient
+	//Pass *usedPass = ((mIsDepthPassPhase && !pass->hasVertexProgram()) ? mDepthPass : pass); 
+	
+	// set depth fill pass if we currently do not make an aabb occlusion query
+	Pass *usedPass = (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery() ? 
+					  mDepthPass : pass);
+		
+	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())
+	{
+		mDepthPass->setVertexProgram("");
+	}
+	
+
+	bool IsDepthWrite = usedPass->getDepthWriteEnabled();
+
+	// global option which enables / disables depth writes
+	if (!mEnableDepthWrite)
+	{
+		usedPass->setDepthWriteEnabled(false);
+	}
+	//else if (mIsItemBufferPass) {usedPass = mItemBufferPass;}
+	
+	Pass *result = SceneManager::setPass(usedPass);
+
+	// reset depth write
+	if (!mEnableDepthWrite)
+	{
+		usedPass->setDepthWriteEnabled(IsDepthWrite);
+	}
+
+	// reset illumination stage
+	mIlluminationStage = savedStage;
+
+	return result;
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::_findVisibleObjects(Camera* cam,
+														bool onlyShadowCasters)
+{
+	//-- 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)
+		{
+			TerrainSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
+		}
+		// only shadow casters will be rendered in shadow texture pass
+		// mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
+	}
+	
+	
+	// -- delete lists stored for visualization
+	mVisible.clear();
+	mBoxes.clear();
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::_renderVisibleObjects()
+{
+
+	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
+	{
+		// 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 not in mLeavePassesInQueue)
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+		_deleteRenderedQueueGroups(mLeavePassesInQueue);
+#endif
+
+		//-- reset parameters
+		mIsDepthPassPhase = false;
+		mIsItemBufferPhase = false;
+		mSkipTransparents = false;
+		mLeavePassesInQueue = 0;
+		
+
+		// add visible nodes found by the visibility culling algorithm
+		if (mUseDepthPass)
+		{
+			for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++ it)
+			{
+				(*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
+			}
+		}
+		
+		//-- now we can render all remaining queue objects
+		// used for depth pass, transparents, overlay 
+		clearSpecialCaseRenderQueues();
+
+		TerrainSceneManager::_renderVisibleObjects();
+	}
+		
+	// 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
+	OGRE_DELETE(mRenderQueue); // HACK: should be cleared before...
+	//WriteLog(); // write out stats
+
+}
+
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::_updateSceneGraph(Camera* cam)
+{
+	mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
+	mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
+
+	TerrainSceneManager::_updateSceneGraph(cam);
+}
+//-----------------------------------------------------------------------
+bool VisibilityTerrainSceneManager::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 == "UseArbQueries")
+	{
+		bool useArbQueries = (*static_cast<const bool *>(val));
+
+		if (useArbQueries)
+		{
+			mHierarchyInterface->DeleteQueries();
+			mDestRenderSystem->setConfigOption("ArbQueries", "Yes");
+		}
+		else
+		{
+			mHierarchyInterface->DeleteQueries();
+			mDestRenderSystem->setConfigOption("ArbQueries", "No");
+		}
+	}
+	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
+		setOption(key, val) || TerrainSceneManager::setOption(key, val);
+}
+//-----------------------------------------------------------------------
+bool VisibilityTerrainSceneManager::getOption(const String & key, void *val)
+{
+	if (key == "NumHierarchyNodes")
+	{
+		* static_cast<unsigned int *>(val) = (unsigned int)mNumOctants;
+		return true;
+	}
+	
+	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
+		getOption(key, val) && TerrainSceneManager::getOption(key, val);
+}
+//-----------------------------------------------------------------------
+bool VisibilityTerrainSceneManager::getOptionValues(const String & key, 
+													StringVector &refValueList)
+{
+	return TerrainSceneManager::getOptionValues( key, refValueList);
+}
+//-----------------------------------------------------------------------
+bool VisibilityTerrainSceneManager::getOptionKeys(StringVector & refKeys)
+{
+	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
+		getOptionKeys(refKeys) || TerrainSceneManager::getOptionKeys(refKeys);
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::setVisibilityManager(GtpVisibility::
+														 VisibilityManager *visManager)
+{
+	mVisibilityManager = visManager;
+}
+//-----------------------------------------------------------------------
+GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::getVisibilityManager( void )
+{
+	return mVisibilityManager;
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::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() << "\n";
+
+	LogManager::getSingleton().logMessage(d.str());
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::renderObjects(
+	const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+    bool doLightIteration, const LightList* manualLightList)
+{
+	// for correct rendering, transparents must be rendered after hierarchical culling
+	if (!mSkipTransparents)
+	{
+		OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList);
+	}
+}
+//-----------------------------------------------------------------------
+bool VisibilityTerrainSceneManager::validatePassForRendering(Pass* pass)
+{
+	// skip all but first pass if we are doing the depth pass
+	if ((mIsDepthPassPhase || mIsItemBufferPhase) && pass->getIndex() > 0)
+	{
+		return false;
+	}
+
+	return SceneManager::validatePassForRendering(pass);
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
+{
+	if (!mIsItemBufferPhase)
+	{
+		TerrainSceneManager::renderQueueGroupObjects(pGroup);
+		return;
+	}
+
+	//-- item buffer
+
+    // Iterate through priorities
+    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
+
+	while (groupIt.hasMoreElements())
+    {
+		RenderItemBuffer(groupIt.getNext());
+	}
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
+{
+	// Do solids
+	RenderPriorityGroup::SolidRenderablePassMap solidObjs = pGroup->_getSolidPasses();
+
+	// ----- 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
+		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)
+		{
+			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 
+
+	// transparents are treated either as solids or completely discarded
+	if (mRenderTransparentsForItemBuffer)
+	{
+		RenderPriorityGroup::TransparentRenderablePassList transpObjs = 
+			pGroup->_getTransparentPasses();
+		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 VisibilityTerrainSceneManager::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("");
+	}
+
+	Pass *usedPass = setPass(mItemBufferPass); 
+
+
+	// Render a single object, this will set up auto params if required
+	renderSingleObject(rend, usedPass, false, &nullLightList);
+}
+//-----------------------------------------------------------------------
+GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::GetVisibilityManager()
+{
+	return mVisibilityManager;
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::InitVisibilityCulling(Camera *cam)
+{
+	// reset culling manager stats
+	mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes);
+
+	// set depth pass flag before rendering
+	mIsDepthPassPhase = mUseDepthPass;
+
+	// 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 (!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 stuff
+			mIlluminationStage = IRS_AMBIENT;
+		}
+	
+		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 in the hierarchical culling
+	// (because they will be rendered afterwards)
+	mSkipTransparents = mUseDepthPass || 
+		(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);
+		
+	//std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;LogManager::getSingleton().logMessage(d.str());
+}
+//-----------------------------------------------------------------------
+OctreeHierarchyInterface *VisibilityTerrainSceneManager::GetHierarchyInterface()
+{
+	return mHierarchyInterface;
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::endFrame()
+{
+	TerrainRenderable::ResetRenderLevelIndex();
+}
+//-----------------------------------------------------------------------
+Entity* VisibilityTerrainSceneManager::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 VisibilityTerrainSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+{
+	// 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
+			mIlluminationStage = IRS_AMBIENT;
+
+			OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), false, &lightList);
+			// Also render any objects which have receive shadows disabled
+			OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPassesNoShadow(), true);
+		}
+	}
+	else
+	{
+		OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup);
+	}
+}
+//-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
+{
+   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->_getSolidPasses(), true);
+	   }
+   }
+   else
+   {
+	   SceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup);
+   }
+}
+} // namespace Ogre
