#include "stdafx.h"
#include "SceneManager.h"

#include "RenderSystem.h"
#include "ResourceManager.h"
// #include "CameraManager.h"
// #include "StageScript.h"
// 
// #include "Terrain.h"
#include "AreaGroup.h"
#include "AreaSceneNode.h"
#include "LightSceneNode.h"
#include "SoundSceneNode.h"
#include "PlayerSceneNode.h"
// #include "TransMonSceneNode.h"
// #include "VehicleSceneNode.h"
#include "NpcSceneNode.h"
#include "EffectSceneNode.h"
#include "DropItemSceneNode.h"
#include "GatheringSceneNode.h"
#include "MapPortalSceneNode.h"
// #include "CardSceneNode.h"
 #include "DoorSceneNode.h"
// #include "Signboard.h"
// 
// #include "WorldManager.h"
// #include "NaviMesh.h"
// #include "ShadowGeometry.h"
// 
// #include "ObjectManager.h"
// #include "Hero.h"
// 
#include "soundsystem.h"
// #include "Application.h"
// 
// #if (defined(_DEVSYS) || defined(_DEBUG))
// #include "DevSystem.h"
// #endif

///// Àå¸é ³ëµå ºñ±³ ÇÔ¼öÀÚ
///// ÇÈÅ· °Å¸®·Î ºñ±³ÇÑ´Ù.
//bool cDynamicSceneNodeCompareByCamDistance( const unsigned long left, const unsigned long right )
//{
//	/// 
//	cDynamicSceneNode* node1 = SCENEMAN->GetDynamicSceneNode( left );
//	cDynamicSceneNode* node2 = SCENEMAN->GetDynamicSceneNode( right );
//
//	if( node1 == 0 )
//	{
//		assert(0);
//	}
//	if( node2 == 0 )
//	{
//		assert(0);
//	}
//
//	return ( node1->mVisibleCamLength < node2->mVisibleCamLength );
//};

cSceneManager* cSceneManager::mSingleton = 0;

cSceneManager::cSceneManager()
: mVersion( 0 )
, mAlphaArray( 1024, 256 )
, mAlphaTestArray( 1024, 256 )
, mSolidArray( 1024, 256 )
, mDamageArray( 256, 64 )
// , mCuller( &mAlphaArray, &mAlphaTestArray, &mSolidArray )
// , mDamageCuller( &mDamageArray, &mAlphaTestArray, &mSolidArray )
, mAlphaArraySorter( &mAlphaArray, &mAlphaTestArray )
, mDamageSorter( &mDamageArray, 0 )
, mSolidArraySorter( &mSolidArray )
, mTextureMap( 22 )
, mScreenShotMode( false )
, mShowDepthPlane( true )
, mEnableLoading( false )
{
	assert( mSingleton == 0 && "bad singleton!" );
	mSingleton = this;

	mHeroPos = NiPoint3::ZERO;

	/// Àüü ¿µ¿ª ³ëµå¸¦ »ý¼º
	cAreaSceneNodeParam param;
	mGlobalArea = new cAreaSceneNode;

	if( mGlobalArea->Init( param ) == false )
	{
		delete mGlobalArea;
		mGlobalArea = 0;

		assert( 0 && "failed to init global area scene node" );
	}

	///
	mPickedArray.Reserve( 1024 );

	/// °¡½Ã ·¹º§ °Å¸®
	mSqaredLevelDistance0 = 5000.0f * 5000.0f;
	mSqaredLevelDistance1 = 10000.0f * 10000.0f;
	mSqaredLevelDistance2 = 20000.0f * 20000.0f;
}

cSceneManager::~cSceneManager()
{
	SAFE_DELETE(mGlobalArea);
	Clear();

	mSingleton = 0;
}

bool cSceneManager::Init()
{
	///
	mPlaneArray.Reserve( 2048 );
	mVisibleDynamicNodeArray.Reserve( 2048 );

	/// ±×¸²ÀÚ °¡½Ã ¹è¿­
	mShadowGeomArray.Reserve( 2048 );
	mTrailGeomArray.Reserve( 100 );
	return true;
}

void cSceneManager::Exit()
{
	Clear();
}

void cSceneManager::Clear()
{

	/// ¿µ¿ª ±×·ìµéÀ» Á¦°Å
	cAreaGroupMap::cIterator i = mAreaGroupMap.Begin();
	cAreaGroupMap::cIterator iend = mAreaGroupMap.End();

	for( ; i != iend; ++i )
	{
		delete (cAreaGroup*)(i->mSecond);
	}
	mAreaGroupMap.Clear();
	cAreaGroup::mCurrentGroup = 0;

	DestroyAll();

	mVisibleDynamicNodeArray.Clear();

	///
	mAlphaArray.RemoveAll();
	mAlphaTestArray.RemoveAll();
	mSolidArray.RemoveAll();
//	mDamageArray.RemoveAll();

	mPickedArray.Clear();

	///
	mShadowGeomArray.Clear();
	mTrailGeomArray.Clear();

	mTextureMap.Clear();

	mShowDepthPlane = true;
}

bool cSceneManager::Init( const NiPoint3& center, float minRadius, float maxRadius )
{
	/// Áö¿ò
	Clear();

	/// Æ®¸®¸¦ Àç»ý¼º
	mNodeTree.Init( center, minRadius, maxRadius );
	return true;
}

// void cSceneManager::Process( unsigned long deltaTime, unsigned long accumTime )
// {
// 	cCamera* cam = CAMERAMAN->GetCurrent();
// 	if( cam == 0 )
// 	{
// 		assert( 0 );
// 		return;
// 	}
// 
// 	///
// 	mPlaneArray.Clear();
// 	mVisibleDynamicNodeArray.Clear();
// 	mShadowGeomArray.Clear();
// 	mTrailGeomArray.Clear();
// 
// 	mSolidArray.RemoveAll();
// 	mAlphaArray.RemoveAll();
// 	mAlphaTestArray.RemoveAll();
// 	mDamageArray.RemoveAll();
// 
// 	/// »èÁ¦ µî·ÏµÈ ³ëµå ó¸®
// 	DelNodeProcess();
// 
// 	if( mNodeTree.IsEmpty() )
// 		return;
// 
// 	if( mEnableLoading == true )
// 		return;
// 
// #ifdef _GMTOOL
// 	if( CAMERAMAN->GetCurrentIdx() == 2 )
// 	{
// 		mHeroPos = cam->GetWorldTranslate();
// 	}
// 	else
// 	{
// #endif
// 	mHeroPos = cam->GetLookAt();
// 
// 	/// Ä«¸Þ¶ó Ãæµ¹ °Ë»ç
// 	if( cam->GetNeedUpdate() )
// 	{
// 		float lookAtDist = cam->GetLookAtDistance();
// 		NiPoint3 invDir = -cam->GetWorldDirection();
// 		invDir.Unitize();
// 
// 		/// Â÷Æó¹°°ú Ãæµ¹ °Ë»ç
// 		bool collided = false;
// 		NiPoint3 pos;
// 		float dist = lookAtDist + 120.0f;
// 		mPickedArray.Clear();
// 
// 		if( PickStatics( &mPickedArray, cRay(mHeroPos, invDir), true, lookAtDist + 120.0f, true ) )
// 		{
// 			if( mPickedArray.IsEmpty() == false )
// 			{
// 				cStaticSceneNode* n = (cStaticSceneNode*)mPickedArray[0];
// //				if( n->GetOccludeLevel() == 2 )
// //				{
// 					collided = true;
// 					dist = n->GetPickDistance() - 120.0f;
// 
// 					if( dist < lookAtDist )
// 						lookAtDist = dist;
// //				}
// 			}
// 		}
// 
// 		/// ³×ºñ¸Þ½Ã¿Í Ãæµ¹ °Ë»ç
// 		dist = lookAtDist + 120.0f;
// 
// 		if( NAVIMESH->Pick( &pos, &dist, cRay(mHeroPos, invDir), lookAtDist + 120.0f ) )
// 		{
// 			collided = true;
// 			lookAtDist = dist - 120.0f;
// 		}
// 
// 		/// Ä«¸Þ¶ó¸¦ °»½Å
// 		if( collided )
// 		{
// 			cam->SetLookAtDistance( lookAtDist );
// 			cam->SetTranslate( mHeroPos + invDir * lookAtDist );
// 			cam->Update( accumTime );
// 		}
// 
// 		/// ½ÃÁ¡°úÀÇ °Å¸®°¡ ³Ê¹« ªÀ¸¸é Åõ¸í ó¸®
// 		if( HERO )
// 		{
// 			const float ALPHA_LOOKAT_DIST = 160.0f;
// 
// 			if( lookAtDist <= ALPHA_LOOKAT_DIST )
// 				HERO->SetAlphaBlended( 0.0f );
// 			else
// 				HERO->SetAlphaBlended( 1.0f );
// 		}
// 	}
// #ifdef _GMTOOL
// 	}
// #endif
// 
// 	/// »ç¿îµå ³ëµåµéÀ» ó¸®
// 	cSphere testSphere;
// 	{
// 		testSphere.Set( mHeroPos, 100.0f );
// 		mPickedArray.Clear();
// 
// 		/// Ãæµ¹ üũ
// 		Pick_Type( &mPickedArray, testSphere, cSceneNode::eSOUND );
// 
// 		/// ó¸®
// 		cSoundMap::cIterator i, iend;
// 		i = mSoundArray.Begin();
// 		iend = mSoundArray.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cSoundSceneNode* n = (cSoundSceneNode*)(*i).mSecond;
// 			if( n->IsRemoved() == false )
// 				n->OnProcess( deltaTime, accumTime );
// 		}
// 	}
// /*
// 	/// Á¶¸í ³ëµåµéÀ» ó¸®
// 	{
// 		testSphere.Set( mHeroPos, 10000.0f );
// 		mPickedArray.Clear();
// 
// 		if( Pick_Type( &mPickedArray, testSphere, cSceneNode::eLIGHT ) )
// 		{
// 			for( unsigned int i = 0, iend = mPickedArray.GetSize(); i < iend; ++i )
// 			{
// 				((cLightSceneNode*)mPickedArray[i])->OnProcess( deltaTime, accumTime );
// 			}
// 		}
// 	}
// //*/
// 
// 	/// Á¤Àû ³ëµåµéÀ» ó¸®
// 	{
// 		cNodeMap::cIterator i, iend;
// 		i = mStaticObjectArray.Begin();
// 		iend = mStaticObjectArray.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cStaticSceneNode* n = (cStaticSceneNode*)(*i).mSecond;
// //			if( n->IsViewNode() )
// 			n->OnProcess( deltaTime, accumTime );
// 		}
// 	}
// 
// 	///
// 	{
// 		cNodeMap::cIterator i, iend;
// 		i = mDynamicObjectArray.Begin();
// 		iend = mDynamicObjectArray.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cDynamicSceneNode* n = (cDynamicSceneNode*)(*i).mSecond;
// 			n->OnProcess( deltaTime, accumTime );
// 		}
// 
// 		i = mMapPortalArray.Begin();
// 		iend = mMapPortalArray.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cMapPortalSceneNode* n = (cMapPortalSceneNode*)(*i).mSecond;
// 			n->OnProcess( deltaTime, accumTime );
// 		}
// 
// 		i = mDropItemArray.Begin();
// 		iend = mDropItemArray.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cDropItemSceneNode* n = (cDropItemSceneNode*)(*i).mSecond;
// 			n->OnProcess( deltaTime, accumTime );
// 		}
// 
// 		i=  mGatheringArray.Begin();
// 		iend = mGatheringArray.End();
// 		for(; i != iend; ++i )
// 		{
// 			cGatheringSceneNode* n = (cGatheringSceneNode*)(*i).mSecond;
// 			n->OnProcess( deltaTime, accumTime );
// 		}
// 
// 		i = mDoorArray.Begin();
// 		iend = mDoorArray.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cDoorSceneNode* n = (cDoorSceneNode*)(*i).mSecond;
// 			n->OnProcess( deltaTime, accumTime );
// 		}
// 	}
// 
// 	/// ¿µ¿ª ±×·ìµéÀ» ó¸®
// 	testSphere.Set( mHeroPos, 10.0f );
// 	{
// 		cAreaGroupMap::cIterator i = mAreaGroupMap.Begin();
// 		cAreaGroupMap::cIterator iend = mAreaGroupMap.End();
// 
// 		for( ; i != iend; ++i )
// 		{
// 			((cAreaGroup*)i->mSecond)->OnProcess( deltaTime, accumTime, testSphere );
// 		}
// 	}
// 
// 	/*{
// 		if( mPlaneArray.IsEmpty() == false )
// 		{
// 			for( unsigned int i = 0, end = mPlaneArray.GetSize(); i < end; ++i )
// 			{
// 				cPlane* n = (cPlane*)mPlaneArray[i];
// 				n->();
// 			}
// 		}
// 	}*/
// 
// 	{
// 		cNodeMap::cIterator i, iend;
// 		i = mEffectNodeArray.Begin();
// 		iend = mEffectNodeArray.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cEffectSceneNode* n = (cEffectSceneNode*)(*i).mSecond;
// 			n->OnProcess( deltaTime, accumTime );
// 
// 			if( n->IsRemoved() || n->IsViewNode() == false )
// 				continue;
// 
// 			if( n->IsEnableFrustumFlag() )
// 			{
// 				if( n->IsDamageEffect() )
// 					mDamageCuller.Cull( *cam, n );
// 				else
// 					mCuller.Cull( *cam, n );
// 			}
// 		}
// 	}
// 
// 	DelNodeProcess();
// 
// 	/// Äøµ
// 	mNodeTree.Cull( &mSolidArray, &mAlphaArray, &mAlphaTestArray, cam, cSceneNode::eRENDERING );
// 
// 	/// mVisibleDynamicNodeArray sorting & planeµî·Ï
// 	if( IsScreenShotMode() == false && mVisibleDynamicNodeArray.IsEmpty() == false )
// 	{
// 		if( mVisibleDynamicNodeArray.GetSize() > 1 )
// 			::Sort( mVisibleDynamicNodeArray.Begin(), mVisibleDynamicNodeArray.End(), cDynamicSceneNodeCompareByCamDistance );
// 
// 		for( int i = mVisibleDynamicNodeArray.GetSize()-1; i >= 0; --i )
// 		{
// 			cDynamicSceneNode* n = GetDynamicSceneNode( mVisibleDynamicNodeArray[i] );
// 			if( n == 0 )
// 			{
// 				assert(0);
// 				continue;
// 			}
// 
// 			if( mShowDepthPlane == true )
// 				n->AddDepthPlaneObject();
// 		}
// 	}
// 
//    	/// Á¤·Ä
// 	mSolidArraySorter.Sort( *cam );
// 	mAlphaArraySorter.Sort( *cam );
// 	mDamageSorter.Sort( *cam );
// 
// 	if( mShadowGeomArray.GetSize() > 1 )
// 		::Sort( mShadowGeomArray.Begin(), mShadowGeomArray.End(), cShadowGeomCompareForRendering() );
// 
// 
// #if (defined(_DEVSYS) || defined(_DEBUG))
// 	if( DEVSYSTEM )
// 	{
// 		DEVSYSTEM->mSolidRenderCount = mSolidArray.GetCount();
// 		DEVSYSTEM->mAlphaRenderCount = mAlphaArray.GetCount();
// 		DEVSYSTEM->mAlphaTestRenderCount = mAlphaTestArray.GetCount();
// 		DEVSYSTEM->mDamageRenderCount = mDamageArray.GetCount();
// 	}
// #endif
// }
// 
// void cSceneManager::Render()
// {
// 	if( mEnableLoading == true )
// 		return;
// 
// 	/// ¼Ö¸®µå °³Ã¼
// 	mSolidArraySorter.Render();
// 
// 	/// ±×¸²ÀÚ
// 	RenderShadow();
// 
// 	/// ¾ËÆÄ °³Ã¼
// 	mAlphaArraySorter.Render();
// 
// 	mSolidArray.RemoveAll();
// 	mAlphaArray.RemoveAll();
// 	mAlphaTestArray.RemoveAll();
// 
// 	RenderTrail();
// }
// 
// void cSceneManager::RenderZFalseDamage()
// {
// 	if( mEnableLoading == true )
// 		return;
// 
// 	/// Damage Geom
// 	mDamageSorter.Render();
// 
// 	mDamageArray.RemoveAll();
// }
// 
// void cSceneManager::RenderShadow()
// {
// 	if( mShadowGeomArray.IsEmpty() == true )
// 		return;
// 
// 	cRenderer* renderer = RENDERSYS->GetRenderer();
// 	if( renderer == 0 )
// 	{
// 		assert( 0 );
// 		return;
// 	}
// 
// 	for( unsigned int i = 0,iend = mShadowGeomArray.GetSize(); i< iend; ++i )
// 	{
// 		cShadowGeometry* geom = mShadowGeomArray[i];
// 		if( geom )
// 			geom->Draw( renderer );
// 	}
// 
// 	mShadowGeomArray.Clear();
// }
// 
// void cSceneManager::RenderTrail()
// {
// 	if( mTrailGeomArray.IsEmpty() == true )
// 		return;
// 
// 	cRenderer* renderer = RENDERSYS->GetRenderer();
// 	if( renderer == 0 )
// 	{
// 		assert( 0 );
// 		return;
// 	}
// 
// 	for( unsigned int i = 0,iend = mTrailGeomArray.GetSize(); i< iend; ++i )
// 	{
// 		cRibbonGeometry* geom = mTrailGeomArray[i];
// 		if( geom )
// 			geom->RenderImmediate( renderer );
// 	}
// 
// 	mTrailGeomArray.Clear();
// }
// 
// 
// void cSceneManager::Render2D()
// {
// 	if( mEnableLoading == true )
// 		return;
// 
// 	/// ¿µ¿ª ±×·ì
// 	cAreaGroupMap::cIterator i = mAreaGroupMap.Begin();
// 	cAreaGroupMap::cIterator iend = mAreaGroupMap.End();
// 
// 	for( ; i != iend; ++i )
// 	{
// 		((cAreaGroup*)i->mSecond)->OnRender();
// 	}
// 
// 	/// ¸»Ç³¼± °´Ã¼ ·£´õ¸µ
// 	if( mPlaneArray.IsEmpty() == false )
// 	{
// 		for( unsigned int i = 0, end = mPlaneArray.GetSize(); i < end; ++i )
// 		{
// 			cPlane* n = (cPlane*)mPlaneArray[i];
// 			n->Draw();
// 		}
// 	}
// }
// 
// bool cSceneManager::Pick_Kind( tArray<void*>* pickedArray, const cSphere& sphere, cSceneNode::eType type )
// {
// 	return mNodeTree.CollideSphere_Kind( pickedArray, sphere, type );
// }
// 
// bool cSceneManager::Pick_Type( tArray<void*>* pickedArray, const cSphere& sphere, cSceneNode::eType type )
// {
// 	return mNodeTree.CollideSphere_Type( pickedArray, sphere, type );
// }
// 
// bool cSceneManager::PickAreas( tArray<void*>* pickedArray, const cSphere& sphere )
// {
// 	return mNodeTree.CollideSphere_Kind( pickedArray, sphere, cSceneNode::eAREA );
// }
// 
// bool cSceneManager::PickLights( tArray<void*>* pickedArray, const cSphere& sphere )
// {
// 	return mNodeTree.CollideSphere_Kind( pickedArray, sphere, cSceneNode::eLIGHT );
// }
// 
// bool cSceneManager::PickSounds( tArray<void*>* pickedArray, const cSphere& sphere )
// {
// 	return mNodeTree.CollideSphere_Kind( pickedArray, sphere, cSceneNode::eSOUND );
// }
// 
// bool cSceneManager::PickStatics( tArray<void*>* pickedArray, int mouseX, int mouseY, bool sortByDistance )
// {
// 	NiPoint3 origin, dir;
// 	if( CAMERAMAN->GetRayFromWindowPoint( &origin, &dir, mouseX, mouseY ) )
// 		return false;
// 
// 	return PickStatics( pickedArray, cRay(origin, dir), false, NI_INFINITY, sortByDistance );
// }
// 
// bool cSceneManager::PickStatics( tArray<void*>* pickedArray, const cRay& ray, bool camRay, float maxDistance, bool sortByDistance )
// {
// 	return mNodeTree.CollideRay_Kind( pickedArray, ray, camRay, maxDistance, sortByDistance, cSceneNode::eSTATIC );
// }
// 
// bool cSceneManager::PickDynamics( tArray<void*>* pickedArray, int mouseX, int mouseY, bool sortByDistance )
// {
// 	NiPoint3 origin, dir;
// 	if( CAMERAMAN->GetRayFromWindowPoint( &origin, &dir, mouseX, mouseY ) == false )
// 		return false;
// 
// 	return PickDynamics( pickedArray, cRay(origin, dir), NI_INFINITY, sortByDistance );
// }
// 
// bool cSceneManager::PickDynamics( tArray<void*>* pickedArray, const cRay& ray, float maxDistance, bool sortByDistance )
// {
// 	return mNodeTree.CollideRay_Kind( pickedArray, ray, false, maxDistance, sortByDistance, cSceneNode::eDYNAMIC );
// }
// 
// bool cSceneManager::PickManagedStatics( tArray<void*>* pickedArray, int mouseX, int mouseY, bool sortByDistance )
// {
// 	NiPoint3 origin, dir;
// 	if( CAMERAMAN->GetRayFromWindowPoint( &origin, &dir, mouseX, mouseY ) == false )
// 		return false;
// 
// 	return PickManagedStatics( pickedArray, cRay(origin, dir), NI_INFINITY, sortByDistance );
// }
// 
// bool cSceneManager::PickManagedStatics( tArray<void*>* pickedArray, const cRay& ray, float maxDistance, bool sortByDistance )
// {
// 	return mNodeTree.CollideRay_Kind( pickedArray, ray, false, maxDistance, sortByDistance, cSceneNode::eMANAGEDSTATIC );
// }
// 
// bool cSceneManager::PickMapportal( tArray<void*>* pickedArray, const cRay& ray, float maxDistance, bool sortByDistance )
// {
// 	return mNodeTree.CollideRay_Kind( pickedArray, ray, false, maxDistance, sortByDistance, cSceneNode::eMAPPORTAL );
// }
// 
// 
// cBaseObject* cSceneManager::PickPlane( int mouseX, int mouseY )
// {
// 	if( mVisibleDynamicNodeArray.IsEmpty() == true )
// 		return 0;
// 
// 	NiPoint3 origin, dir;
// 	if( CAMERAMAN->GetRayFromWindowPoint( &origin, &dir, mouseX, mouseY ) == false )
// 		return 0;
// 
// 	unsigned int count = mVisibleDynamicNodeArray.GetSize();
// 	for( unsigned int i=0; i<count; ++i )
// 	{
// 		cDynamicSceneNode* n = GetDynamicSceneNode( mVisibleDynamicNodeArray[i] );
// 		if( n == 0 )
// 			continue;
// 		if( n->GetType() != cSceneNode::ePLAYER	&& 	n->GetType() != cSceneNode::eNPC )
// 			continue;
//  		if( n->PickManagedPlane( (float)mouseX, (float)mouseY ) == false )
// 			continue;
// 
// 		return n->GetGameObject();
// 	}
// 	return 0;
// }
 
bool cSceneManager::AddAreaNode( cSceneNode* node )
{
	assert( node );
	assert( node->GetType()==cSceneNode::eAREA );

	unsigned long idx = mAreaNodeIndexGen.GenerateIndex();
	if( mAreaArray.GetAt(idx) != 0 )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddAreaNode(GenerateIndex)[%d]", idx );

		idx = mAreaNodeIndexGen.GenerateIndex();
	}
	node->mIndexByManager = idx;//mNodeIndexGen.GenerateIndex();

	if( mAreaArray.Insert( node->mIndexByManager, node ) == false )
	{
		assert(0);
		return false;
	}

	mNodeTree.Push( node );
	return true;
}

// bool cSceneManager::AddLightNode( cSceneNode* node )
// {
// 	assert( node );
// 	assert( node->GetType()==cSceneNode::eLIGHT );
// 
// 	unsigned long idx = mLightNodeIndexGen.GenerateIndex();
// 	if( mLightArray.GetAt(idx) != 0 )
// 	{
// 		assert(0);
// 		GameErrorLog( "cSceneManager::AddLightNode(GenerateIndex)[%d]", idx );
// 
// 		idx = mLightNodeIndexGen.GenerateIndex();
// 	}
// 	node->mIndexByManager = idx;//mNodeIndexGen.GenerateIndex();
// 	if( mLightArray.Insert( node->mIndexByManager, node ) == false )
// 	{
// 		assert(0);
// 		return false;
// 	}
// 
// 	mNodeTree.Push( node );
// 	return true;
// }
// 
bool cSceneManager::AddSoundNode( cSceneNode* node )
{
	assert( node );
	assert( node->GetType()==cSceneNode::eSOUND );

	unsigned long idx = mSoundIndexGen.GenerateIndex();
	if( mSoundArray.GetAt(idx) != 0 )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddSoundNode(GenerateIndex)[%d]", idx );

		idx = mSoundIndexGen.GenerateIndex();
	}
	node->mIndexByManager = idx;//mNodeIndexGen.GenerateIndex();
	if( mSoundArray.Insert( node->mIndexByManager, node ) == false )
	{
		assert(0);
		return false;
	}
	mNodeTree.Push( node );
	return true;
}

bool cSceneManager::AddStaticNode( cSceneNode* node )
{
	assert( node );
	assert( node->GetType()==cSceneNode::eSTATIC );

	unsigned long idx = mStaticNodeIndexGen.GenerateIndex();
	if( mStaticObjectArray.GetAt(idx) != 0 )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddStaticNode(GenerateIndex)[%d]", idx );

		idx = mStaticNodeIndexGen.GenerateIndex();
	}
	node->mIndexByManager = idx;//mNodeIndexGen.GenerateIndex();
	if( mStaticObjectArray.Insert( node->mIndexByManager, node ) == false )
	{
		assert(0);
		return false;
	}
	mNodeTree.Push( node );
	return true;
}

// bool cSceneManager::AddDropItemNode( cSceneNode* node )
// {
// 	assert( node );
// 	assert( node->GetType()==cSceneNode::eDROPITEM );
// 
// 	unsigned long idx = mDropItemNodeIndexGen.GenerateIndex();
// 	if( mDropItemArray.GetAt(idx) != 0 )
// 	{
// 		assert(0);
// 		GameErrorLog( "cSceneManager::AddDropItemNode(GenerateIndex)[%d]", idx );
// 
// 		idx = mDropItemNodeIndexGen.GenerateIndex();
// 	}
// 	node->mIndexByManager = idx;//mNodeIndexGen.GenerateIndex();
// 	if( mDropItemArray.Insert( node->mIndexByManager, node ) == false )
// 	{
// 		assert(0);
// 		return false;
// 	}
// 	mNodeTree.Push( node );
// 	return true;
// }
// 
// bool cSceneManager::AddGatheringNode( cSceneNode* node )
// {
// 	assert( node );
// 	assert( node->GetType()==cSceneNode::eGATHERING );
// 
// 	unsigned long idx = mGatheringNodeIndexGen.GenerateIndex();
// 	if( mGatheringArray.GetAt(idx) != 0 )
// 	{
// 		assert(0);
// 		GameErrorLog( "cSceneManager::AddGatheringNode(GenerateIndex)[%d]", idx );
// 
// 		idx = mGatheringNodeIndexGen.GenerateIndex();
// 	}
// 	node->mIndexByManager = idx;//mNodeIndexGen.GenerateIndex();
// 	if( mGatheringArray.Insert( node->mIndexByManager, node ) == false )
// 	{
// 		assert(0);
// 		return false;
// 	}
// 	mNodeTree.Push( node );
// 	return true;
// }
 
bool cSceneManager::AddMapPotalNode( cSceneNode* node )
{
	assert( node );
	assert( node->GetType()==cSceneNode::eMAPPORTAL );

	unsigned long idx = mMapPortalNodeIndexGen.GenerateIndex();
	if( mMapPortalArray.GetAt(idx) != 0 )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddMapPotalNode(GenerateIndex)[%d]", idx );
		idx = mMapPortalNodeIndexGen.GenerateIndex();
	}

	node->mIndexByManager = idx;//mNodeIndexGen.GenerateIndex();
	if( mMapPortalArray.Insert( node->mIndexByManager, node ) == false )
	{
		assert(0);
		return false;
	}
	mNodeTree.Push( node );
	return true;
}
 
bool cSceneManager::AddDynamicNode( cSceneNode* node )
{
	assert( node );
	assert( node->GetType()&cSceneNode::eDYNAMIC );

	unsigned long idx = mDynamicNodeIndexGen.GenerateIndex();
	if( mDynamicObjectArray.GetAt(idx) != 0 )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddDynamicNode(GenerateIndex)[%d]", idx );
		idx = mDynamicNodeIndexGen.GenerateIndex();
	}

	node->mIndexByManager = idx;//mDynamicNodeIndexGen.GenerateIndex();
	if( mDynamicObjectArray.Insert( node->mIndexByManager, (cDynamicSceneNode*)node ) == false )
	{
		assert(0);
		return false;
	}

	mNodeTree.Push( node );
	return true;
}
 
bool cSceneManager::AddEffectNode( cEffectSceneNode* node )
{
	assert( node );
	assert( node->GetType()==cSceneNode::eEFFECT );

	unsigned long idx = mEffectIndexGen.GenerateIndex();
	if( mEffectNodeArray.GetAt(idx) != 0 )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddEffectNode(GenerateIndex)[%d]", idx );
		idx = mEffectIndexGen.GenerateIndex();
	}

	node->mIndexByManager = idx;//mNodeIndexGen.GenerateIndex();
	if( idx == (unsigned long)-1 )
	{
		assert(0);
	}

	if( mEffectNodeArray.Insert( node->mIndexByManager, node ) == false )
	{
		assert(0);
		return false;
	}

	return true;
}

// bool cSceneManager::AddDoorNode( unsigned long index, cSceneNode* node )
// {
// 	assert( node );
// 	assert( node->GetType()==cSceneNode::eDOOR );
// 
// 	if( mDoorArray.GetAt(index) != 0 )
// 	{
// 		assert(0);
// 		return false;
// 	}
// 
// 	node->mIndexByManager = index;
// 	if( mDoorArray.Insert( node->mIndexByManager, node ) == false )
// 	{
// 		assert(0);
// 		return false;
// 	}
// 
// 	mNodeTree.Push( node );
// 	return true;
// }
// 
void cSceneManager::AddDeleteEffectNode( cEffectSceneNode* node )
{
	if( node == 0 )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddDeleteEffectNode : node == 0" );
		return;
	}

	if( IsValidEffectNode( node->GetIndexByManger(), node ) == false )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddDeleteEffectNode : IsValidEffectNode Faile(%d)", node->GetIndexByManger() );
		return;
	}

	mDelEffectList.PushBack( node );
}

void cSceneManager::AddDeleteGatheringNode( cGatheringSceneNode* node )
{
	if( node == 0 )
	{
		assert(0);
		GameErrorLog( "cSceneManager::AddDeleteGatheringNode : node == 0" );
		return;
	}

	mDelGatheringList.PushBack( node );
}

void cSceneManager::AddDeleteSoundNode( cSoundSceneNode* node )
{
	if( node == 0 )
		return;
	if( node->IsRemoved() )
		return;

	node->SetRemoveFlag( true );

	mDelSoundList.PushBack( node );
}

void cSceneManager::AddDeleteDoorNode( cDoorSceneNode* node )
{
	if( node == 0 )
		return;

	mDelDoorList.PushBack( node );
}
// 
// void cSceneManager::AddPlane( cPlane* pPlane )
// {
// 	mPlaneArray.PushBack( pPlane );
// }
// 
// void cSceneManager::AddVisibleDynamicNode( cDynamicSceneNode* node )
// {
// 	if( node == 0 )
// 	{
// 		assert(0);
// 		return;
// 	}
// 
// 	if( ((cDynamicSceneNode*)node)->mSetVisibleArray == true )
// 	{
// //		assert(0);
// 		return;
// 	}
// 
// 	((cDynamicSceneNode*)node)->mSetVisibleArray = true;
// 	mVisibleDynamicNodeArray.PushBack( node->GetIndexByManger() );
// }
 
bool cSceneManager::DestroyDynamic( cSceneNode* node )
{
	assert( node );

	if( (node->GetType() & cSceneNode::eDYNAMIC) == 0 )
	{
		assert(0);
		GameErrorLog( "DestroyDynamic exeption wrong type" );
		return false;
	}

	unsigned long idx = node->mIndexByManager;
	cDynamicSceneNode* n = (cDynamicSceneNode*)mDynamicObjectArray.GetAt( idx );
	if( n == 0 )
	{
		assert(0);
		GameErrorLog( "DestroyDynamic exeption n == 0" );
		return false;
	}
	if( n != node )
	{
		assert(0);
		GameErrorLog( "DestroyDynamic exeption n != node" );
		return false;
	}

	if( n->mContainer )
	{
		n->mContainer->Remove(n);
		n->mContainer = 0;
	}
	else
	{
		assert(0);
		GameErrorLog( "DestroyDynamic exeption (n->mContainer == 0)" );
	}

//	if( n->mSetVisibleArray == true )
//	{
//		assert(0);
//	}

	delete n;

	mDynamicObjectArray.Erase( idx );
	n = (cDynamicSceneNode*)mDynamicObjectArray.GetAt( idx );
	if( n )
	{
		GameErrorLog( "DestroyDynamic exeption Erase Faile" );
		assert(0);
	}

	mDynamicNodeIndexGen.RestoreIndex( idx );

	return true;
}

// bool cSceneManager::DestroyDropItemNode( cSceneNode* node )
// {
// 	assert( node );
// 
// 	if( node->GetType() != cSceneNode::eDROPITEM )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyDropItemNode exeption wrong type" );
// 		return false;
// 	}
// 
// 	unsigned long idx = node->mIndexByManager;
// 	cDropItemSceneNode* n = (cDropItemSceneNode*)mDropItemArray.GetAt( idx );
// 	if( n == 0 )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyDropItemNode exeption n == 0" );
// 		return false;
// 	}
// 	if( n != node )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyDropItemNode exeption n != node" );
// 		return false;
// 	}
// 
// 	if( n->mContainer )
// 	{
// 		n->mContainer->Remove(n);
// 		n->mContainer = 0;
// 	}
// 
// 	delete n;
// 
// 	mDropItemArray.Erase( idx );
// 	n = (cDropItemSceneNode*)mDropItemArray.GetAt( idx );
// 	if( n )
// 	{
// 		GameErrorLog( "DestroyDropItemNode exeption Erase Faile" );
// 		assert(0);
// 	}
// 
// 	mDropItemNodeIndexGen.RestoreIndex( idx );
// 
// 	return true;
// }
// 
// bool cSceneManager::DestroyGathringNode( cSceneNode* node )
// {
// 	assert( node );
// 
// 	if( node->GetType() != cSceneNode::eGATHERING )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyGathringNode exeption wrong type" );
// 		return false;
// 	}
// 
// 	unsigned long idx = node->mIndexByManager;
// 	cGatheringSceneNode* n = (cGatheringSceneNode*)mGatheringArray.GetAt( idx );
// 	if( n == 0 )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyGathringNode exeption n == 0" );
// 		return false;
// 	}
// 	if( n != node )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyGathringNode exeption n != node" );
// 		return false;
// 	}
// 
// 	if( n->mContainer )
// 	{
// 		n->mContainer->Remove(n);
// 		n->mContainer = 0;
// 	}
// 
// 	delete n;
// 
// 	mGatheringArray.Erase( idx );
// 	n = (cGatheringSceneNode*)mGatheringArray.GetAt( idx );
// 	if( n )
// 	{
// 		GameErrorLog( "DestroyGathringNode exeption Erase Faile" );
// 		assert(0);
// 	}
// 
// 	mGatheringNodeIndexGen.RestoreIndex( idx );
// 
// 	return true;
// }
// 
// 
// bool cSceneManager::DestroyMapPortalNode( cSceneNode* node )
// {
// 	assert( node );
// 
// 	if( node->GetType() != cSceneNode::eMAPPORTAL )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyMapPortalNode exeption wrong type" );
// 		return false;
// 	}
// 
// 	unsigned long idx = node->mIndexByManager;
// 	cMapPortalSceneNode* n = (cMapPortalSceneNode*)mMapPortalArray.GetAt( idx );
// 	if( n == 0 )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyMapPortalNode exeption n == 0" );
// 		return false;
// 	}
// 	if( n != node )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyMapPortalNode exeption n != node" );
// 		return false;
// 	}
// 
// 	if( n->mContainer )
// 	{
// 		n->mContainer->Remove(n);
// 		n->mContainer = 0;
// 	}
// 
// 	delete n;
// 
// 	mMapPortalArray.Erase( idx );
// 	n = (cMapPortalSceneNode*)mMapPortalArray.GetAt( idx );
// 	if( n )
// 	{
// 		GameErrorLog( "DestroyMapPortalNode exeption Erase Faile" );
// 		assert(0);
// 	}
// 
// 	mMapPortalNodeIndexGen.RestoreIndex( idx );
// 
// 	return true;
// }
// 
// bool cSceneManager::DestroyDoorNode( cSceneNode* node )
// {
// 	assert( node );
// 
// 	if( node->GetType() != cSceneNode::eDOOR )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyDoorNode exeption wrong type" );
// 		return false;
// 	}
// 
// 	unsigned long idx = node->mIndexByManager;
// 	cDoorSceneNode* n = (cDoorSceneNode*)mDoorArray.GetAt( idx );
// 	if( n == 0 )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyDoorNode exeption n == 0" );
// 		return false;
// 	}
// 	if( n != node )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyDoorNode exeption n != node" );
// 		return false;
// 	}
// 
// 	if( n->mContainer )
// 	{
// 		n->mContainer->Remove(n);
// 		n->mContainer = 0;
// 	}
// 
// 	delete n;
// 
// 	mDoorArray.Erase( idx );
// 	n = (cDoorSceneNode*)mDoorArray.GetAt( idx );
// 	if( n )
// 	{
// 		GameErrorLog( "DestroyDoorNode exeption Erase Fail" );
// 		assert(0);
// 	}
// 	return true;
// }
// 
// bool cSceneManager::DestroyEffectNode( cSceneNode* node )
// {
// 	assert( node );
// 
// 	if( node->GetType() != cSceneNode::eEFFECT )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestoryEffectNode exeption wrong type" );
// 		return false;
// 	}
// 
// 	unsigned long idx = node->mIndexByManager;
// 	cEffectSceneNode* n = (cEffectSceneNode*)mEffectNodeArray.GetAt( idx );
// 	if( n == 0 )
// 	{
// 		GameErrorLog( "DestoryEffectNode exeption n == 0" );
// 		assert(0);
// 		return false;
// 	}
// 	if( n != node )
// 	{
// 		GameErrorLog( "DestoryEffectNode exeption n != node" );
// 		assert(0);
// 		return false;
// 	}
// 
// 	if( n->IsRemoved() == false )
// 	{
// 		GameErrorLog( "DestoryEffectNode exeption IsRemoved == false" );
// 		assert(0);
// 		return false;
// 	}
// 
// 	if( n->mContainer )
// 	{
// 		assert(0);
// 		n->mContainer->Remove(n);
// 		n->mContainer = 0;
// 	}
// 
// 	delete n;
// 
// 	mEffectNodeArray.Erase( idx );
// 	n = (cEffectSceneNode*)mEffectNodeArray.GetAt( idx );
// 	if( n )
// 	{
// 		GameErrorLog( "DestoryEffectNode exeption Erase Faile" );
// 		assert(0);
// 	}
// 
// 	mEffectIndexGen.RestoreIndex( idx );
// 
// 	return true;
// }
// 
// bool cSceneManager::DestroySoundNode( cSceneNode* node )
// {
// 	assert( node );
// 
// 	if( node->GetType() != cSceneNode::eSOUND )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroySoundNode exeption wrong type" );
// 		return false;
// 	}
// 
// 	unsigned long idx = node->mIndexByManager;
// 	cSoundSceneNode* n = (cSoundSceneNode*)mSoundArray.GetAt( idx );
// 	if( n == 0 )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroySoundNode exeption n == 0" );
// 		return false;
// 	}
// 	if( n != node )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroySoundNode exeption n != node" );
// 		return false;
// 	}
// 
// 	if( n->mContainer )
// 	{
// 		n->mContainer->Remove(n);
// 		n->mContainer = 0;
// 	}
// 
// 	delete n;
// 
// 	mSoundArray.Erase( idx );
// 	n = (cSoundSceneNode*)mSoundArray.GetAt( idx );
// 	if( n )
// 	{
// 		GameErrorLog( "DestroySoundNode exeption Erase Faile" );
// 		assert(0);
// 	}
// 
// 	mSoundIndexGen.RestoreIndex( idx );
// 
// 	return true;
// }
// 
// bool cSceneManager::DestroyStaticNode( cSceneNode* node )
// {
// 	assert( node );
// 
// 	if( node->GetType() != cSceneNode::eSTATIC )
// 	{
// 		assert(0);
// 		GameErrorLog( "DestroyStaticNode exeption wrong type" );
// 		return false;
// 	}
// 
// 	unsigned long idx = node->mIndexByManager;
// 	cStaticSceneNode* n = (cStaticSceneNode*)mStaticObjectArray.GetAt( idx );
// 	if( n == 0 )
// 	{
// 		assert(0);
// 		return false;
// 	}
// 	if( n != node )
// 	{
// 		assert(0);
// 		return false;
// 	}
// 
// 
// 	if( n->mContainer )
// 	{
// 		n->mContainer->Remove(n);
// 		n->mContainer = 0;
// 	}
// 
// 	delete n;
// 
// 	mStaticObjectArray.Erase( idx );
// 	mStaticNodeIndexGen.RestoreIndex( idx );
// 
// 	return true;
// }
// 
void cSceneManager::DestroyAll()
{
	mPlaneArray.Clear();

	{
		cAreaMap::cIterator i, iend;
		i = mAreaArray.Begin();
		iend = mAreaArray.End();
		for( ; i != iend; ++i )
		{
			cAreaSceneNode* p = (cAreaSceneNode*)(*i).mSecond;
			delete p;
		}
		mAreaArray.Clear();
	}
	{
		cLightMap::cIterator i, iend;
		i = mLightArray.Begin();
		iend = mLightArray.End();
		for( ; i != iend; ++i )
		{
			cLightSceneNode* p = (cLightSceneNode*)(*i).mSecond;
			delete p;
		}
		mLightArray.Clear();
	}
	{
		cNodeMap::cIterator i, iend;
		i = mDropItemArray.Begin();
		iend = mDropItemArray.End();
		for( ; i != iend; ++i )
		{
			cDropItemSceneNode* p = (cDropItemSceneNode*)(*i).mSecond;
			delete p;
		}
		mDropItemArray.Clear();
	}
	{
		cNodeMap::cIterator i, iend;
		i = mGatheringArray.Begin();
		iend = mGatheringArray.End();
		for( ; i != iend; ++i )
		{
			cGatheringSceneNode* p = (cGatheringSceneNode*)(*i).mSecond;
			delete p;
		}
		mGatheringArray.Clear();
	}
	{
		cNodeMap::cIterator i, iend;
		i = mDynamicObjectArray.Begin();
		iend = mDynamicObjectArray.End();
		for( ; i != iend; ++i )
		{
			cDynamicSceneNode* p = (cDynamicSceneNode*)(*i).mSecond;
			delete p;
		}
		mDynamicObjectArray.Clear();
	}
	{
		cNodeMap::cIterator i, iend;
		i = mMapPortalArray.Begin();
		iend = mMapPortalArray.End();
		for( ; i != iend; ++i )
		{
			cMapPortalSceneNode* p = (cMapPortalSceneNode*)(*i).mSecond;
			delete p;
		}
		mMapPortalArray.Clear();
	}
	{
		cNodeMap::cIterator i, iend;
		i = mDoorArray.Begin();
		iend = mDoorArray.End();
		for( ; i != iend; ++i )
		{
			cDoorSceneNode* p = (cDoorSceneNode*)(*i).mSecond;
			delete p;
		}
		mDoorArray.Clear();
	}
	{
		cNodeMap::cIterator i, iend;
		i = mStaticObjectArray.Begin();
		iend = mStaticObjectArray.End();
		for( ; i != iend; ++i )
		{
			cStaticSceneNode* p = (cStaticSceneNode*)(*i).mSecond;
			delete p;
		}
		mStaticObjectArray.Clear();
	}
	{
		cNodeMap::cIterator i, iend;
		i = mEffectNodeArray.Begin();
		iend = mEffectNodeArray.End();
		for( ; i != iend; ++i )
		{
			cEffectSceneNode* p = (cEffectSceneNode*)(*i).mSecond;
			delete p;
		}
		mEffectNodeArray.Clear();
	}
	{
		cSoundMap::cIterator i, iend;
		i = mSoundArray.Begin();
		iend = mSoundArray.End();
		for( ; i != iend; ++i )
		{
			cSoundSceneNode* p = (cSoundSceneNode*)(*i).mSecond;
			delete p;
		}
		mSoundArray.Clear();
	}

	mDelEffectList.Clear();
	mDelGatheringList.Clear();
	mDelSoundList.Clear();
	mDelDoorList.Clear();

	///
	mNodeTree.Clear();
	mAreaNodeIndexGen.RestoreAll();
	mLightNodeIndexGen.RestoreAll();
	mSoundIndexGen.RestoreAll();
	mStaticNodeIndexGen.RestoreAll();
	mDropItemNodeIndexGen.RestoreAll();
	mGatheringNodeIndexGen.RestoreAll();
	mMapPortalNodeIndexGen.RestoreAll();
	mDynamicNodeIndexGen.RestoreAll();
	mEffectIndexGen.RestoreAll();
}

cAreaSceneNode* cSceneManager::CreateArea( cAreaSceneNodeParam& param )
{
	static int i = 0;

	/// ³ëµå¸¦ »ý¼º
	cAreaSceneNode* node = new cAreaSceneNode;

	/// ³ëµå¸¦ ÃʱâÈ­
	if( param.mPathName.IsEmpty() )
		param.mPathName.Format( "area%d", i++ );

	if( node->Init( param ) == false )
	{
		delete node;
		assert( 0 && "failed to init area scene node" );
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddAreaNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}

// cLightSceneNode* cSceneManager::CreateLight( cLightSceneNodeParam& param )
// {
// 	static int i = 0;
// 
// 	/// ³ëµå¸¦ »ý¼º
// 	cLightSceneNode* node = new cLightSceneNode;
// 
// 	/// ³ëµå¸¦ ÃʱâÈ­
// 	if( param.mPathName.IsEmpty() )
// 		param.mPathName.Format( "light%d", i++ );
// 
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init light scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddLightNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
cSoundSceneNode* cSceneManager::CreateMapSound( cSoundSceneNodeParam& param )
{
	if( SOUNDSYS->IsUsableSoundSystem() == false )
		return false;

	static int i = 0;

	/// ³ëµå¸¦ »ý¼º
	cSoundSceneNode* node = new cSoundSceneNode;

	/// ³ëµå¸¦ ÃʱâÈ­
	if( param.mPathName.IsEmpty() )
		param.mPathName.Format( "sound%d", i++ );

	if( node->Init( param ) == false )
	{
		delete node;
		assert( 0 && "failed to init sound scene node" );
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddSoundNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}

cSoundSceneNode* cSceneManager::CreateEffectSound( cSoundSceneNodeParam& param )
{
	if( SOUNDSYS->IsUsableSoundSystem() == false )
		return false;

	/// ³ëµå¸¦ »ý¼º
	cSoundSceneNode* node = new cSoundSceneNode;

	if( node->Init( param ) == false )
	{
		delete node;
		assert( 0 && "failed to init sound scene node" );
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddSoundNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}
 
cStaticSceneNode* cSceneManager::CreateStatic( cStaticSceneNodeParam& param )
{
	/// ³ëµå¸¦ »ý¼º
	cStaticSceneNode* node = new cStaticSceneNode;

	/// ³ëµå¸¦ ÃʱâÈ­
	if( node->Init( param ) == false )
	{
		delete node;
		assert( 0 && "failed to init static scene node" );
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddStaticNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}

// cCardSceneNode* cSceneManager::CreateCard( cCardSceneNodeParam& param )
// {
// 	/// ³ëµå¸¦ »ý¼º
// 	cCardSceneNode* node = new cCardSceneNode;
// 
// 	/// ³ëµå¸¦ ÃʱâÈ­
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init card scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddStaticNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
// cDropItemSceneNode* cSceneManager::CreateDropItem( cDropItemSceneNodeParam& param )
// {
// 	cDropItemSceneNode* node = new cDropItemSceneNode;
// 	param.mPathName = "./Data/Effect/DropBox.nif";
// 
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init DropItem scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddDropItemNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
// cGatheringSceneNode* cSceneManager::CreateGathering( cGatheringSceneNodeParam& param )
// {
// 	cGatheringSceneNode* node = new cGatheringSceneNode;
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init Gathering scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddGatheringNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
 
cMapPortalSceneNode* cSceneManager::CreateMapPortal( unsigned long scriptIdx, NiPoint3 pos, NiMatrix3 rot )
{
	cMapPortalSceneNodeParam param;
	param.mTranslate = pos;
	param.mRotate = rot;
	param.mPosScriptIdx = scriptIdx;
	param.mPathName = "./Data/Effect/";

	cMapPortalSceneNode* node = new cMapPortalSceneNode;
	if( node->Init( param) == false )
	{
		delete node;
		assert( 0 && "failed to init MapPortal scene node" );
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddMapPotalNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}

// cUserPortalSceneNode* cSceneManager::CreateUserPortal( unsigned long portalIdx, unsigned long ownerIdx, unsigned long scriptIdx, NiPoint3 pos )
// {
// 	cUserPortalSceneNodeParam param;
// 	param.mTranslate = pos;
// 	param.mPortalIdx = portalIdx;
// 	param.mOwnerIdx = ownerIdx;
// 	param.mPosScriptIdx = scriptIdx;
// 	param.mPathName = "./Data/Effect/map_portal_c.nif";
// 
// 	cUserPortalSceneNode* node = new cUserPortalSceneNode;
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init UserPortal scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddMapPotalNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 	return node;
// }
// 
// cPlayerSceneNode* cSceneManager::CreatePlayer( cPlayerSceneNodeParam& param )
// {
// 	/// ³ëµå¸¦ »ý¼º
// 	cPlayerSceneNode* node = new cPlayerSceneNode;
// 
// 	/// ³ëµå¸¦ ÃʱâÈ­
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init player scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddDynamicNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
// cMonsterSceneNode* cSceneManager::CreateMonster( cMonsterSceneNodeParam& param )
// {
// 	/// ³ëµå¸¦ »ý¼º
// 	cMonsterSceneNode* node = new cMonsterSceneNode;
// 
// 	/// ³ëµå¸¦ ÃʱâÈ­
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init Monster scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddDynamicNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
// cTransMonSceneNode* cSceneManager::CreateTransMonster( cMonsterSceneNodeParam& param, bool IsHero )
// {
// 	/// ³ëµå¸¦ »ý¼º
// 	cTransMonSceneNode* node = new cTransMonSceneNode;
// 
// 	/// ³ëµå¸¦ ÃʱâÈ­
// 	if( node->Init( param, IsHero ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init Transform Monster scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddDynamicNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
// 
// cNpcSceneNode* cSceneManager::CreateNPC( cNpcSceneNodeParam& param )
// {
// 	/// ³ëµå¸¦ »ý¼º
// 	cNpcSceneNode* node = new cNpcSceneNode;
// 
// 	/// ³ëµå¸¦ ÃʱâÈ­
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init Npc scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddDynamicNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
 
cEffectSceneNode* cSceneManager::CreateEffect( cEffectSceneNodeParam& param )
{
	cEffectSceneNode* node = new cEffectSceneNode;
	if( node->Init( param ) == false )
	{
		delete node;
		assert( 0 && "failed to init Effect scene node" );
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddEffectNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}

cEffectSceneNode* cSceneManager::CreateDamageEffect( cEffectSceneNodeParam& param, bool IsMiss, bool zFalse )
{
	cEffectSceneNode* node = new cEffectSceneNode;
	if( node->InitDamageEffect( param, IsMiss, zFalse ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddEffectNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}
 
cEffectSceneNode* cSceneManager::CreateSelfEffect( cString pathName, bool distCheck, NiTransform& trans, bool bLoop )
{
	cEffectSceneNode* node = new cEffectSceneNode;
	if( node->InitSelfNode( pathName, distCheck, trans, bLoop ) == false )
	{
		assert( 0 && "failed to init Effect scene node" );
		delete node;
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddEffectNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}

// cHeroSceneNode* cSceneManager::CreateHero( cPlayerSceneNodeParam& param )
// {
// 	/// ³ëµå¸¦ »ý¼º
// 	cHeroSceneNode* node = new cHeroSceneNode;
// 
// 	/// ³ëµå¸¦ ÃʱâÈ­
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init player scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddDynamicNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
// cVehicleSceneNode* cSceneManager::CreateVehicle( cVehicleSceneNodeParam& param )
// {
// 	/// ³ëµå¸¦ »ý¼º
// 	cVehicleSceneNode* node = new cVehicleSceneNode;
// 
// 	/// ³ëµå¸¦ ÃʱâÈ­
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init vehicle scene node" );
// 		return 0;
// 	}
// 
// 	/// ³ëµå¸¦ Ãß°¡
// 	if( AddDynamicNode( node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
cRefereeSceneNode* cSceneManager::CreateReferee( cSceneNodeParam& param )
{
	/// ³ëµå¸¦ »ý¼º
	cRefereeSceneNode* node = new cRefereeSceneNode;

	/// ³ëµå¸¦ ÃʱâÈ­
	if( node->Init( param ) == false )
	{
		delete node;
		assert( 0 && "failed to init referee scene node" );
		return 0;
	}

	/// ³ëµå¸¦ Ãß°¡
	if( AddDynamicNode( node ) == false )
	{
		assert(0);
		delete node;
		return 0;
	}

	return node;
}

// cDoorSceneNode* cSceneManager::CreateDoor( unsigned long index ) //cDoorSceneNodeParam& param )
// {
// 	sDoorInfo* pInfo = STAGESCRIPT->GetManagedDoorInfo( index );
// 	if( pInfo == 0 )
// 		return 0;
// 
// 
// 	cDoorSceneNodeParam param;
// 	param.mPathName.Format( "./data/effect/%s", pInfo->mFileName.Cstr() );
// 	param.mOccludeLevel = 2;
// 	param.mVisibleLevel = 3;
// 
// 	if( pInfo->mMapNumber >= 200 )
// 		param.mDisableAnimation = true;
// 	else
// 		param.mDisableAnimation = false;
// 
// 	param.mDoorIdx = index;
// 
// 	NiPoint3 pos = NiPoint3(pInfo->mPosX, pInfo->mPosY, 0.0f );
// 
// 	if( WORLDMAN->CalcHeight( &(pos.z), pos.x, pos.y ) == false )
// 		assert(0);
// 
// 	param.mTranslate = pos;
// 	param.mRotate.FromEulerAnglesXYZ( 0, 0, pInfo->mRotAngle);
// 	param.mScale = 1.0f;
// 
// 	cDoorSceneNode* node = new cDoorSceneNode;
// 
// 	if( node->Init( param ) == false )
// 	{
// 		delete node;
// 		assert( 0 && "failed to init post scene node" );
// 		return 0;
// 	}
// 
// 	/// 
// 	if( AddDoorNode( param.mDoorIdx, node ) == false )
// 	{
// 		assert(0);
// 		delete node;
// 		return 0;
// 	}
// 
// 	return node;
// }
// 
// void cSceneManager::ActiveSoundNodeAll( bool active )
// {
// 	{
// 		cSoundMap::cIterator i, iend;
// 		i = mSoundArray.Begin();
// 		iend = mSoundArray.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cSoundSceneNode* n = (cSoundSceneNode*)(*i).mSecond;
// 			n->ActiveSound( active );
// 		}
// 	}
// 
// 	{
// 		cAreaGroupMap::cIterator i = mAreaGroupMap.Begin();
// 		cAreaGroupMap::cIterator iend = mAreaGroupMap.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cAreaGroup* group = (cAreaGroup*)(i->mSecond);
// 			group->SetActive( active );
// 		}
// 	}
// }
// 
// unsigned int cSceneManager::CalcVisibleLevel( cStaticSceneNode* n )
// {
// 	if( n == 0 )
// 	{
// 		assert(0);
// 		return 0;
// 	}
// 
// #ifdef _GMTOOL
// 	if( CAMERAMAN->GetCurrentIdx() == 2 )
// 		return 0;
// #endif
// 
// 	float sqrDist = (mHeroPos - n->GetCenter()).SqrLength();
// 
// 	if( sqrDist > mSqaredLevelDistance2 )
// 		return 3;
// 	if( sqrDist > mSqaredLevelDistance1 )
// 		return 2;
// 	if( sqrDist > mSqaredLevelDistance0 )
// 		return 1;
// 	return 0;
// }
// 
// bool cSceneManager::CalcDynamicVisibleLevel( cSceneNode* n )
// {
// 	if( n == 0 )
// 	{
// 		assert(0);
// 		return false;
// 	}
// 
// 	float sqrDist = (mHeroPos - n->GetWorldTranslate()).SqrLength();
// 	if( sqrDist > 16000000.0f ) // 4000 * 4000
// 		return false;
// 	else
// 		return true;
// }
// 
// void cSceneManager::UpdateSoundGain()
// {
// 	cSoundMap::cIterator i, iend;
// 	i = mSoundArray.Begin();
// 	iend = mSoundArray.End();
// 	for( ; i != iend; ++i )
// 	{
// 		cSoundSceneNode* p = (cSoundSceneNode*)(*i).mSecond;
// 		p->UpdatVolumeRatio();
// 	}
// }
 
bool cSceneManager::IsValidEffectNode( cEffectSceneNode* node )
{
	assert(node->GetType() == cSceneNode::eEFFECT);

	cNodeMap::cIterator i, iend;
	i = mEffectNodeArray.Begin();
	iend = mEffectNodeArray.End();

	for( ; i != iend; ++i )
	{
		cEffectSceneNode* p = (cEffectSceneNode*)(*i).mSecond;
		if( p == node )
			return true;
	}

	return false;
}

bool cSceneManager::IsValidEffectNode( unsigned long idx, cEffectSceneNode* node )
{
	assert(node->GetType() == cSceneNode::eEFFECT);

	cEffectSceneNode* n = (cEffectSceneNode*)mEffectNodeArray.GetAt( idx );
	if( n == 0 )
	{
//		OutputDebugString(_T("\nn==0"));
		return false;
	}
	if( n != node )
	{
//		OutputDebugString(_T("\nn!=node"));
		return false;
	}

	return true;
}

// bool cSceneManager::IsValidSoundNode( cSoundSceneNode* node )
// {
// 	cNodeMap::cIterator i, iend;
// 	i = mSoundArray.Begin();
// 	iend = mSoundArray.End();
// 
// 	for( ; i != iend; ++i )
// 	{
// 		cSoundSceneNode* p = (cSoundSceneNode*)(*i).mSecond;
// 		if( p == node )
// 			return true;
// 	}
// 
// 	return false;
// }
// 
// 
// bool cSceneManager::IsValidSoundNode( unsigned long idx, cSoundSceneNode* node )
// {
// 	cSoundSceneNode* n = (cSoundSceneNode*)mSoundArray.GetAt( idx );
// 	if( n == 0 )
// 		return false;
// 	if( n != node )
// 		return false;
// 
// 	return true;
// }
// 
// 
// bool cSceneManager::IsValidDynamicNode( cDynamicSceneNode* node )
// {
// 	cNodeMap::cIterator i, iend;
// 	i = mDynamicObjectArray.Begin();
// 	iend = mDynamicObjectArray.End();
// 	for( ; i != iend; ++i )
// 	{
// 		cDynamicSceneNode* p = (cDynamicSceneNode*)(*i).mSecond;
// 		if( p == node )
// 			return true;
// 	}
// 
// 	return false;
// }
// 
// bool cSceneManager::IsValidDynamicNode( unsigned long idx, cDynamicSceneNode* node )
// {
// 	cDynamicSceneNode* n = (cDynamicSceneNode*)mDynamicObjectArray.GetAt( idx );
// 	if( n == 0 )
// 		return false;
// 	if( n != node )
// 		return false;
// 
// 	return true;
// }
// 
// cManagedStaticSceneNode* cSceneManager::GetManagedStaticNode( unsigned int type, unsigned long nodeIdx )
// {
// 	switch( type )
// 	{
// 	case cSceneNode::eDROPITEM:
// 		{
// 			return (cManagedStaticSceneNode*)mDropItemArray.GetAt( nodeIdx );
// 		}
// 		break;
// 	case cSceneNode::eGATHERING: 
// 		{
// 			return (cManagedStaticSceneNode*)mGatheringArray.GetAt( nodeIdx );
// 		}
// 		break;
// 	case cSceneNode::eMAPPORTAL: 
// 		{
// 			return (cManagedStaticSceneNode*)mMapPortalArray.GetAt( nodeIdx );
// 		}
// 		break;
// 	case cSceneNode::eDOOR:
// 		{
// 			return (cManagedStaticSceneNode*)mDoorArray.GetAt( nodeIdx );
// 		}
// 		break;
// 	default:
// 		break;
// 	}
// 	return 0;
// }
// 
// void cSceneManager::OnVisibleModifierPocess( cSceneNode* node )
// {
// 	mModifierProcess.Cull( CAMERAMAN->GetCurrentNi(), node );
// }
// 
// void cSceneManager::DelNodeProcess()
// {
// 	cDelNodeList::cIterator i, iend;
// 	if( mDelEffectList.IsEmpty() == false )
// 	{
// 		i = mDelEffectList.Begin();
// 		iend = mDelEffectList.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cEffectSceneNode* n = (cEffectSceneNode*)*i;
// 			DestroyEffectNode(n);
// 		}
// 		mDelEffectList.Clear();
// 	}
// 	if( mDelGatheringList.IsEmpty() == false )
// 	{
// 		i = mDelGatheringList.Begin();
// 		iend = mDelGatheringList.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cGatheringSceneNode* n = (cGatheringSceneNode*)*i;
// 			DestroyGathringNode(n);
// 		}
// 		mDelGatheringList.Clear();
// 	}
// 	if( mDelSoundList.IsEmpty() == false )
// 	{
// 		i = mDelSoundList.Begin();
// 		iend = mDelSoundList.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cSoundSceneNode* n = (cSoundSceneNode*)*i;
// 			DestroySoundNode(n);
// 		}
// 		mDelSoundList.Clear();
// 	}
// 
// 	if( mDelDoorList.IsEmpty() == false )
// 	{
// 		i = mDelDoorList.Begin();
// 		iend = mDelDoorList.End();
// 		for( ; i != iend; ++i )
// 		{
// 			cDoorSceneNode* n = (cDoorSceneNode*)*i;
// 			DestroyDoorNode(n);
// 		}
// 		mDelDoorList.Clear();
// 	}
// }
// 
// sDoorInfo* cSceneManager::DisableDoorMove( NiPoint2 startPos, NiPoint2 goalPos )
// {
// 	cNodeMap::cIterator i = mDoorArray.Begin();
// 	cNodeMap::cIterator iend = mDoorArray.End();
// 	for( ; i != iend; ++i )
// 	{
// 		cDoorSceneNode* n = (cDoorSceneNode*)(*i).mSecond;
// 		if( n == 0 )
// 			continue;
// 
// 		sDoorInfo* pInfo = STAGESCRIPT->CrashDoor( n->GetDoorIdx(), startPos, goalPos );
// 		if( pInfo )
// 			return pInfo;
// 	}
// 	return 0;
// }
// 
// void cSceneManager::RemoveAllDoorNode()
// {
// 	cNodeMap::cIterator i = mDoorArray.Begin();
// 	cNodeMap::cIterator iend = mDoorArray.End();
// 	for( ; i != iend; ++i )
// 	{
// 		cDoorSceneNode* n = (cDoorSceneNode*)(*i).mSecond;
// 		if( n == 0 )
// 			continue;
// 
// 		n->Remove( THEAPP->GetWorldAccumTime() );
// 	}
// }