/*
-----------------------------------------------------------------------------
This source file is part of the GameTools Project
http://www.gametools.org

Author: Martin Szydlowski
-----------------------------------------------------------------------------
*/
#include <OgreGpuProgramManager.h>
#include <OgreConfigFile.h>
#include <OgreMaterialManager.h>
#include <OgreLogManager.h>

#include "OgreKdTerrainPage.h"
#include "OgreKdHeightmapTerrainPageSource.h"
#include "OgreKdTerrainVertexProgram.h"

#include "OgreKdTerrainSceneManager.h"

#define TERRAIN_MATERIAL_NAME "TerrainSceneManager/Terrain"

namespace Ogre
{

KdTerrainSceneManager::KdTerrainSceneManager(const String& name, GtpVisibility::VisibilityManager *vm):
KdTreeSceneManager(name, vm),
mUseCustomMaterial(false),
mUseNamedParameterLodMorph(false),
mLodMorphParamIndex(3),
mTerrainRoot(0),
mActivePageSource(0),
mPagingEnabled(false),
mLivePageMargin(0),
mBufferedPageMargin(0)
{

}
//-----------------------------------------------------------------------
KdTerrainSceneManager::~KdTerrainSceneManager()
{
	shutdown();
}
//-----------------------------------------------------------------------
const String& KdTerrainSceneManager::getTypeName() const
{
	return KdTerrainSceneManagerFactory::FACTORY_TYPE_NAME;
}
//-----------------------------------------------------------------------
void KdTerrainSceneManager::clearScene()
{
	KdTreeSceneManager::clearScene();

	// clear terrain
	mTerrainPages.clear();
	destroyLevelIndexes();
	// sm has destroyed our root
	mTerrainRoot = 0;
}
//-----------------------------------------------------------------------
bool KdTerrainSceneManager::setOption(const String& strKey, const void* pValue)
{
	// options for terrain
	if (strKey == "PageSize")
	{
		setPageSize(*static_cast<const int*>(pValue));
		return true;
	} 
	else if (strKey == "TileSize")
	{
		setTileSize(*static_cast<const int*>(pValue));
		return true;
	}
	else if (strKey == "PrimaryCamera")
	{
		setPrimaryCamera(static_cast<const Camera*>(pValue));
		return true;
	}
	else if (strKey == "MaxMipMapLevel")
	{
		setMaxGeoMipMapLevel(*static_cast<const int*>(pValue));
		return true;
	}
	else if (strKey == "Scale")
	{
		setScale(*static_cast<const Vector3*>(pValue));
		return true;
	}
	else if (strKey == "MaxPixelError")
	{
		setMaxPixelError(*static_cast<const int*>(pValue));
		return true;
	}
	else if (strKey == "UseTriStrips")
	{
		setUseTriStrips(*static_cast<const bool*>(pValue));
		return true;
	}
	else if (strKey == "VertexProgramMorph")
	{
		setUseLODMorph(*static_cast<const bool*>(pValue));
		return true;
	}
	else if (strKey == "DetailTile")
	{
		setDetailTextureRepeat(*static_cast<const int*>(pValue));
		return true;
	}
	else if (strKey == "LodMorphStart")
	{
		setLODMorphStart(*static_cast<const Real*>(pValue));
		return true;
	}
	else if (strKey == "VertexNormals")
	{
		setUseVertexNormals(*static_cast<const bool*>(pValue));
		return true;
	}
	else if (strKey == "VertexColours")
	{
		setUseVertexColours(*static_cast<const bool*>(pValue));
		return true;
	}
	else if (strKey == "MorphLODFactorParamName")
	{
		setCustomMaterialMorphFactorParam(*static_cast<const String*>(pValue));
		return true;
	}
	else if (strKey == "MorphLODFactorParamIndex")
	{
		setCustomMaterialMorphFactorParam(*static_cast<const uint*>(pValue));
		return true;
	}
	else if (strKey == "CustomMaterialName")
	{
		setCustomMaterial(*static_cast<const String*>(pValue));
		return true;
	}
	else if (strKey == "WorldTexture")
	{
		setWorldTexture(*static_cast<const String*>(pValue));
		return true;
	}
	else if (strKey == "DetailTexture")
	{
		setDetailTexture(*static_cast<const String*>(pValue));
		return true;
	}

	return KdTreeSceneManager::setOption(strKey, pValue);
}
//-----------------------------------------------------------------------
Camera* KdTerrainSceneManager::createCamera(const String &name )
{
	Camera* cam = KdTreeSceneManager::createCamera(name);

	// Set primary camera, if none
	if (!mOptions.primaryCamera)
		setPrimaryCamera(cam);

	return cam;
}
//-------------------------------------------------------------------------
//void _findVisibleObjects(Camera *cam, bool onlyShadowCasters)
//{
//	KdTreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
//}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::_renderScene(Camera* cam, Viewport *vp, bool includeOverlays)
{
	// For now, no paging and expect immediate response
	if (!mTerrainPages.empty() && mTerrainPages[0][0] == 0)
	{
		mActivePageSource->requestPage(0, 0);
	}
	KdTreeSceneManager::_renderScene(cam, vp, includeOverlays);

}
//-----------------------------------------------------------------------
//void KdTerrainSceneManager::_renderVisibleObjects()
//{
//	KdTreeSceneManager::_renderVisibleObjects();
//}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::shutdown(void)
{
	// Make sure the indexes are destroyed during orderly shutdown
	// and not when statics are destroyed (may be too late)
	mIndexCache.shutdown();
	destroyLevelIndexes();

	// Make sure we free up material (static)
	mOptions.terrainMaterial.setNull();

}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::loadConfig(DataStreamPtr& stream)
{
	/* Set up the options */
	ConfigFile config;
	String val;

	config.load( stream );

	val = config.getSetting( "DetailTile" );
	if ( !val.empty() )
		setDetailTextureRepeat(atoi(val.c_str()));

	val = config.getSetting( "MaxMipMapLevel" );
	if ( !val.empty() )
		setMaxGeoMipMapLevel(atoi( val.c_str() ));


	val = config.getSetting( "PageSize" );
	if ( !val.empty() )
		setPageSize(atoi( val.c_str() ));
	else
		OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing option 'PageSize'",
		"TerrainSceneManager::loadConfig");


	val = config.getSetting( "TileSize" );
	if ( !val.empty() )
		setTileSize(atoi( val.c_str() ));
	else
		OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing option 'TileSize'",
		"TerrainSceneManager::loadConfig");

	Vector3 v = Vector3::UNIT_SCALE;

	val = config.getSetting( "PageWorldX" );
	if ( !val.empty() )
		v.x = atof( val.c_str() );

	val = config.getSetting( "MaxHeight" );
	if ( !val.empty() )
		v.y = atof( val.c_str() );

	val = config.getSetting( "PageWorldZ" );
	if ( !val.empty() )
		v.z = atof( val.c_str() );

	// Scale x/z relative to pagesize
	v.x /= mOptions.pageSize;
	v.z /= mOptions.pageSize;
	setScale(v);

	val = config.getSetting( "MaxPixelError" );
	if ( !val.empty() )
		setMaxPixelError(atoi( val.c_str() ));

	mDetailTextureName = config.getSetting( "DetailTexture" );

	mWorldTextureName = config.getSetting( "WorldTexture" );

	if ( config.getSetting( "VertexColours" ) == "yes" )
		mOptions.coloured = true;

	if ( config.getSetting( "VertexNormals" ) == "yes" )
		mOptions.lit = true;

	if ( config.getSetting( "UseTriStrips" ) == "yes" )
		setUseTriStrips(true);

	if ( config.getSetting( "VertexProgramMorph" ) == "yes" )
		setUseLODMorph(true);

	val = config.getSetting( "LODMorphStart");
	if ( !val.empty() )
		setLODMorphStart(atof(val.c_str()));

	val = config.getSetting( "CustomMaterialName" );
	if ( !val.empty() )
		setCustomMaterial(val);

	val = config.getSetting( "MorphLODFactorParamName" );
	if ( !val.empty() )
		setCustomMaterialMorphFactorParam(val);

	val = config.getSetting( "MorphLODFactorParamIndex" );
	if ( !val.empty() )
		setCustomMaterialMorphFactorParam(atoi(val.c_str()));

	// Now scan through the remaining settings, looking for any PageSource
	// prefixed items
	String pageSourceName = config.getSetting("PageSource");
	if (pageSourceName == "")
	{
		OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing option 'PageSource'",
			"TerrainSceneManager::loadConfig");
	}
	KdTerrainPageSourceOptionList optlist;
	ConfigFile::SettingsIterator setIt = config.getSettingsIterator();
	while (setIt.hasMoreElements())
	{
		String name = setIt.peekNextKey();
		String value = setIt.getNext();
		if (StringUtil::startsWith(name, pageSourceName, false))
		{
			optlist.push_back(KdTerrainPageSourceOption(name, value));
		}
	}
	// set the page source
	selectPageSource(pageSourceName, optlist);
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setupTerrainMaterial(void)
{
	if (mCustomMaterialName == "")
	{
		// define our own material
		mOptions.terrainMaterial = 
			MaterialManager::getSingleton().getByName(TERRAIN_MATERIAL_NAME);
		if (mOptions.terrainMaterial.isNull())
		{
			// Make unique terrain material name
			StringUtil::StrStreamType s;
			s << mName << "/Terrain";
			mOptions.terrainMaterial = MaterialManager::getSingleton().create(
				s.str(),
				ResourceGroupManager::getSingleton().getWorldResourceGroupName());

		}
		else
		{
			mOptions.terrainMaterial->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
		}

		Pass* pass = mOptions.terrainMaterial->getTechnique(0)->getPass(0);

		if ( mWorldTextureName != "" )
		{
			pass->createTextureUnitState( mWorldTextureName, 0 );
		}
		if ( mDetailTextureName != "" )
		{
			pass->createTextureUnitState( mDetailTextureName, 1 );
		}

		mOptions.terrainMaterial -> setLightingEnabled( mOptions.lit );

		if (mOptions.lodMorph && 
			mDestRenderSystem->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM) &&
			GpuProgramManager::getSingleton().getByName("Terrain/VertexMorph").isNull())
		{
			// Create & assign LOD morphing vertex program
			String syntax;
			if (GpuProgramManager::getSingleton().isSyntaxSupported("arbvp1"))
			{
				syntax = "arbvp1";
			}
			else
			{
				syntax = "vs_1_1";
			}

			// Get source, and take into account current fog mode
			FogMode fm = getFogMode();
			const String& source = KdTerrainVertexProgram::getProgramSource(
				fm, syntax);

			GpuProgramPtr prog = GpuProgramManager::getSingleton().createProgramFromString(
				"Terrain/VertexMorph", ResourceGroupManager::getSingleton().getWorldResourceGroupName(), 
				source, GPT_VERTEX_PROGRAM, syntax);

			// Attach
			pass->setVertexProgram("Terrain/VertexMorph");

			// Get params
			GpuProgramParametersSharedPtr params = pass->getVertexProgramParameters();

			// worldviewproj
			params->setAutoConstant(0, GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
			// morph factor
			params->setAutoConstant(4, GpuProgramParameters::ACT_CUSTOM, MORPH_CUSTOM_PARAM_ID);
			// fog exp density(if relevant)
			if (fm == FOG_EXP || fm == FOG_EXP2)
			{
				params->setConstant(5, Vector3(getFogDensity(), 0, 0));
				// Override scene fog since otherwise it's applied twice
				// Set to linear and we derive [0,1] fog value in the shader
				pass->setFog(true, FOG_LINEAR, getFogColour(), 0, 1, 0);
			}

			// Also set shadow receiver program
			const String& source2 = KdTerrainVertexProgram::getProgramSource(
				fm, syntax, true);

			prog = GpuProgramManager::getSingleton().createProgramFromString(
				"Terrain/VertexMorphShadowReceive", 
				ResourceGroupManager::getSingleton().getWorldResourceGroupName(), 
				source2, GPT_VERTEX_PROGRAM, syntax);
			pass->setShadowReceiverVertexProgram("Terrain/VertexMorphShadowReceive");
			params = pass->getShadowReceiverVertexProgramParameters();
			// worldviewproj
			params->setAutoConstant(0, GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
			// world
			params->setAutoConstant(4, GpuProgramParameters::ACT_WORLD_MATRIX);
			// texture view / proj
			params->setAutoConstant(8, GpuProgramParameters::ACT_TEXTURE_VIEWPROJ_MATRIX);
			// morph factor
			params->setAutoConstant(12, GpuProgramParameters::ACT_CUSTOM, MORPH_CUSTOM_PARAM_ID);


			// Set param index
			mLodMorphParamName = "";
			mLodMorphParamIndex = 4;
		}

		mOptions.terrainMaterial->load();

	}
	else
	{
		// Custom material
		mOptions.terrainMaterial = 
			MaterialManager::getSingleton().getByName(mCustomMaterialName);
		mOptions.terrainMaterial->load();

	}

	// now set up the linkage between vertex program and LOD morph param
	if (mOptions.lodMorph)
	{
		Technique* t = mOptions.terrainMaterial->getBestTechnique();
		for (ushort i = 0; i < t->getNumPasses(); ++i)
		{
			Pass* p = t->getPass(i);
			if (p->hasVertexProgram())
			{
				// we have to assume vertex program includes LOD morph capability
				GpuProgramParametersSharedPtr params = 
					p->getVertexProgramParameters();
				// Check to see if custom param is already there
				GpuProgramParameters::AutoConstantIterator aci = params->getAutoConstantIterator();
				bool found = false;
				while (aci.hasMoreElements())
				{
					const GpuProgramParameters::AutoConstantEntry& ace = aci.getNext();
					if (ace.paramType == GpuProgramParameters::ACT_CUSTOM && 
						ace.data == MORPH_CUSTOM_PARAM_ID)
					{
						found = true;
					}
				}
				if (!found)
				{
					if(mLodMorphParamName != "")
					{
						params->setNamedAutoConstant(mLodMorphParamName, 
							GpuProgramParameters::ACT_CUSTOM, MORPH_CUSTOM_PARAM_ID);
					}
					else
					{
						params->setAutoConstant(mLodMorphParamIndex, 
							GpuProgramParameters::ACT_CUSTOM, MORPH_CUSTOM_PARAM_ID);
					}
				}

			}
		}
	}

}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setupTerrainPages(void)
{

	//create a root terrain node.
	if (!mTerrainRoot)
		mTerrainRoot = getRootSceneNode() -> createChildSceneNode( "Terrain" );

	//setup the page array.
	unsigned short pageSlots = 1 + (mBufferedPageMargin * 2);
	unsigned short i, j;
	for (i = 0; i < pageSlots; ++i)
	{
		mTerrainPages.push_back(KdTerrainPageRow());
		for (j = 0; j < pageSlots; ++j)
		{
			mTerrainPages[i].push_back(0);
		}
	}

	// If we're not paging, load immediate for convenience
	if ( mActivePageSource && !mPagingEnabled )
		mActivePageSource->requestPage(0,0);


}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setWorldGeometry( const String& filename )
{
	// try to open in the current folder first
	std::ifstream fs;
	fs.open(filename.c_str());
	if (fs)
	{
		// Wrap as a stream
		DataStreamPtr stream(
			new FileStreamDataStream(filename, &fs, false));
		setWorldGeometry(stream);
	}
	else
	{
		// otherwise try resource system
		DataStreamPtr stream = 
			ResourceGroupManager::getSingleton().openResource(filename, 
			ResourceGroupManager::getSingleton().getWorldResourceGroupName());

		setWorldGeometry(stream);
	}
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::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;
	//resize( AxisAlignedBox( 0, 0, 0, max_x, max_y, max_z ) );

	setupTerrainMaterial();

	setupTerrainPages();

}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::attachPage(ushort pageX, ushort pageZ, KdTerrainPage* page)
{
	assert(pageX == 0 && pageZ == 0 && "Multiple pages not yet supported");

	assert(mTerrainPages[pageX][pageZ] == 0 && "Page at that index not yet expired!");
	// Insert page into list
	mTerrainPages[pageX][pageZ] = page;
	// Attach page to terrain root
	mTerrainRoot->addChild(page->pageSceneNode);

}
//-------------------------------------------------------------------------
float KdTerrainSceneManager::getHeightAt( float x, float z )
{


	Vector3 pt( x, 0, z );

	KdTerrainRenderable * t = getTerrainTile( pt );

	if ( t == 0 )
	{
		//  printf( "No tile found for point\n" );
		return -1;
	}

	float h = t -> getHeightAt( x, z );

	// printf( "Height is %f\n", h );
	return h;

}
//-------------------------------------------------------------------------
KdTerrainPage* KdTerrainSceneManager::getTerrainPage( const Vector3 & pt )
{
	if (mPagingEnabled)
	{
		// TODO
		return 0;
	}
	else
	{
		// Single page
		if (mTerrainPages.empty() || mTerrainPages[0].empty())
			return 0;
		return mTerrainPages[0][0];
	}
}
//-------------------------------------------------------------------------
KdTerrainRenderable * KdTerrainSceneManager::getTerrainTile( const Vector3 & pt )
{
	KdTerrainPage* tp = getTerrainPage(pt);
	if (!tp)
		return NULL;
	else
		return tp->getTerrainTile(pt);
}
//-------------------------------------------------------------------------
bool KdTerrainSceneManager::intersectSegment( const Vector3 & start, 
										  const Vector3 & end, Vector3 * result )
{
	KdTerrainRenderable * t = getTerrainTile( start );

	if ( t == 0 )
	{
		*result = Vector3( -1, -1, -1 );
		return false;
	}

	return t -> intersectSegment( start, end, result );
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setUseTriStrips(bool useStrips)
{
	mOptions.useTriStrips = useStrips;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setUseLODMorph(bool morph)
{
	// Set true only if vertex programs are supported
	mOptions.lodMorph = morph && 
		mDestRenderSystem->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM);
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setUseVertexNormals(bool useNormals)
{
	mOptions.lit = useNormals;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setUseVertexColours(bool useColours)
{
	mOptions.coloured = useColours;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setWorldTexture(const String& textureName)
{
	mWorldTextureName = textureName;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setDetailTexture(const String& textureName)
{
	mDetailTextureName = textureName;

}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setDetailTextureRepeat(int repeat)
{
	mOptions.detailTile = repeat;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setTileSize(int size) 
{
	mOptions.tileSize = size;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setPageSize(int size)
{
	mOptions.pageSize = size;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setMaxPixelError(int pixelError) 
{
	mOptions.maxPixelError = pixelError;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setScale(const Vector3& scale)
{
	mOptions.scale = scale;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setMaxGeoMipMapLevel(int maxMip)
{
	mOptions.maxGeoMipMapLevel = maxMip;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setCustomMaterial(const String& materialName)
{
	mCustomMaterialName = materialName;
	if (materialName != "")
		mUseCustomMaterial = true;
	else
		mUseCustomMaterial = false;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setCustomMaterialMorphFactorParam(const String& paramName)
{
	mUseNamedParameterLodMorph = true;
	mLodMorphParamName = paramName;

}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setCustomMaterialMorphFactorParam(uint paramIndex)
{
	mUseNamedParameterLodMorph = false;
	mLodMorphParamIndex = paramIndex;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setLODMorphStart(Real morphStart)
{
	mOptions.lodMorphStart = morphStart;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setPrimaryCamera(const Camera* cam)
{
	mOptions.primaryCamera = cam;
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::registerPageSource(const String& typeName, 
											KdTerrainPageSource* source)
{
	std::pair<KdPageSourceMap::iterator, bool> retPair = 
		mPageSources.insert(
		KdPageSourceMap::value_type(typeName, source));
	if (!retPair.second)
	{
		OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, 
			"The page source " + typeName + " is already registered",
			"TerrainSceneManager::registerPageSource");
	}
	LogManager::getSingleton().logMessage(
		"TerrainSceneManager: Registered a new PageSource for "
		"type " + typeName);
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::selectPageSource(const String& typeName, 
										  KdTerrainPageSourceOptionList& optionList)
{
	KdPageSourceMap::iterator i = mPageSources.find(typeName);
	if (i == mPageSources.end())
	{
		OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, 
			"Cannot locate a TerrainPageSource for type " + typeName,
			"TerrainSceneManager::selectPageSource");
	}

	if (mActivePageSource)
	{
		mActivePageSource->shutdown();
	}
	mActivePageSource = i->second;
	mActivePageSource->initialise(this, mOptions.tileSize, mOptions.pageSize,
		mPagingEnabled, optionList);

	LogManager::getSingleton().logMessage(
		"TerrainSceneManager: Activated PageSource " + typeName);

}
//-------------------------------------------------------------------------
int KdTerrainSceneManager::getDetailTextureRepeat(void)
{
	return (int)mOptions.detailTile;
}
//-------------------------------------------------------------------------
int KdTerrainSceneManager::getTileSize(void)
{
	return (int)mOptions.tileSize;
}
//-------------------------------------------------------------------------
int KdTerrainSceneManager::getPageSize(void)
{
	return (int)mOptions.pageSize;
}
//-------------------------------------------------------------------------
int KdTerrainSceneManager::getMaxPixelError(void)
{
	return (int)mOptions.maxPixelError;
}
//-------------------------------------------------------------------------
const Vector3& KdTerrainSceneManager::getScale(void)
{
	return mOptions.scale;
}
//-------------------------------------------------------------------------
int KdTerrainSceneManager::getMaxGeoMipMapLevel(void)
{
	return (int)mOptions.maxGeoMipMapLevel;
}
//-----------------------------------------------------------------------
void KdTerrainSceneManager::initLevelIndexes()
{
	if ( mLevelIndex.size() == 0 )
	{
		for ( int i = 0; i < 16; i++ )
		{

			mLevelIndex.push_back( new IndexMap() );

		}

	}
}
//-----------------------------------------------------------------------
void KdTerrainSceneManager::destroyLevelIndexes()
{
	for ( size_t i = 0; i < mLevelIndex.size(); i++ )
	{
		delete mLevelIndex[i];
	}
	mLevelIndex.clear();
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
RaySceneQuery* 
KdTerrainSceneManager::createRayQuery(const Ray& ray, unsigned long mask)
{
	KdTerrainRaySceneQuery *trsq = new KdTerrainRaySceneQuery(this);
	trsq->setRay(ray);
	trsq->setQueryMask(mask);
	return trsq;
}
//-------------------------------------------------------------------------
KdTerrainRaySceneQuery::KdTerrainRaySceneQuery(SceneManager* creator)
:DefaultRaySceneQuery(creator)
{
	mSupportedWorldFragments.insert(SceneQuery::WFT_SINGLE_INTERSECTION);
}
//-------------------------------------------------------------------------
KdTerrainRaySceneQuery::~KdTerrainRaySceneQuery()
{
}
//-------------------------------------------------------------------------
void KdTerrainRaySceneQuery::execute(RaySceneQueryListener* listener)
{
	mWorldFrag.fragmentType = SceneQuery::WFT_SINGLE_INTERSECTION;

	const Vector3& dir = mRay.getDirection();
	const Vector3& origin = mRay.getOrigin();
	// Straight up / down?
	if (dir == Vector3::UNIT_Y || dir == Vector3::NEGATIVE_UNIT_Y)
	{
		Real height = static_cast<KdTerrainSceneManager*>(mParentSceneMgr)->getHeightAt(
			origin.x, origin.z);
		if (height != -1 && (height <= origin.y && dir.y < 0) || (height >= origin.y && dir.y > 0))
		{
			mWorldFrag.singleIntersection.x = origin.x;
			mWorldFrag.singleIntersection.z = origin.z;
			mWorldFrag.singleIntersection.y = height;
			if (!listener->queryResult(&mWorldFrag, 
				(mWorldFrag.singleIntersection - origin).length()))
				return;
		}
	}
	else
	{
		// Perform arbitrary query
		if (static_cast<KdTerrainSceneManager*>(mParentSceneMgr)->intersectSegment(
			origin, origin + (dir * 100000), &mWorldFrag.singleIntersection))
		{
			if (!listener->queryResult(&mWorldFrag, 
				(mWorldFrag.singleIntersection - origin).length()))
				return;
		}
	}
	DefaultRaySceneQuery::execute(listener);
}
//-------------------------------------------------------------------------
MaterialPtr& KdTerrainSceneManager::getTerrainMaterial(void)
{
	return mOptions.terrainMaterial;
}
//-------------------------------------------------------------------------
KdTerrainSceneManager::KdPageSourceIterator KdTerrainSceneManager::getPageSourceIterator(void)
{
	return KdPageSourceIterator(mPageSources.begin(), mPageSources.end());
}
//-------------------------------------------------------------------------
void KdTerrainSceneManager::setWorldGeometryRenderQueue(uint8 qid)
{
	for (KdTerrainPage2D::iterator pi = mTerrainPages.begin(); 
		pi != mTerrainPages.end(); ++pi)
	{
		KdTerrainPageRow& row = *pi;
		for (KdTerrainPageRow::iterator ri = row.begin(); ri != row.end(); ++ri)
		{
			KdTerrainPage* page = *ri;
			if (page)
			{
				page->setRenderQueue(qid);
			}
		}
	}

}
/************************************************************************/
/* Factory for KdTreeTerrainSceneManager                                */
/************************************************************************/
//-----------------------------------------------------------------------
const String KdTerrainSceneManagerFactory::FACTORY_TYPE_NAME = "KdTreeTerrainSceneManager";
//-----------------------------------------------------------------------
void KdTerrainSceneManagerFactory::initMetaData(void) const
{
	mMetaData.typeName = FACTORY_TYPE_NAME;
	mMetaData.description = "Scene manager that organises the scene based on a kd-tree and renders terrain";
	mMetaData.sceneTypeMask = 0xFFFF; // support all types of scenes (hopefully)
	mMetaData.worldGeometrySupported = true;
}
//-----------------------------------------------------------------------
KdTerrainSceneManagerFactory::
KdTerrainSceneManagerFactory(GtpVisibility::VisibilityManager * vm)
{
	visManager = vm;
}
//-----------------------------------------------------------------------
KdTerrainSceneManagerFactory::~KdTerrainSceneManagerFactory()
{
	for (KdTerrainPageSources::iterator i = mTerrainPageSources.begin();
		i != mTerrainPageSources.end(); ++i)
	{
		delete *i;
	}
	mTerrainPageSources.clear();
}
//-----------------------------------------------------------------------
SceneManager* KdTerrainSceneManagerFactory::createInstance(
	const String& instanceName)
{
	KdTerrainSceneManager * sm = 
		new KdTerrainSceneManager(instanceName, visManager);

	KdHeightmapTerrainPageSource* ps = new KdHeightmapTerrainPageSource();
	mTerrainPageSources.push_back(ps);
	sm->registerPageSource("Heightmap", ps);

	return sm;
}
//-----------------------------------------------------------------------
void KdTerrainSceneManagerFactory::destroyInstance(SceneManager* instance)
{
	delete instance;
}
} // namespace Ogre