// SceneManager.cpp: implementation of the CSceneManager class.
//
//////////////////////////////////////////////////////////////////////

#include "SceneManager.h"
#include <d3dx8.h>
#include "ConvertTexture.h"
#include "BaseGraphicsLayer.h"
#include "SectorSoundMap.h"
#include "BGMController.h"
//#include "RenderOption.h"
#include <exception>
#include "CCameraScript.h"
#include "WBEnvPlaneTex.h"
#include "RainParticle.h"
#include "ChristmasParticle.h"
#include "hristmasParticleManager.h"
#include "SceneStateMgr.h"
#include "FullSceneEffect.h"

using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CViewCamera* CSceneManager::m_ViewCamera;

#define KeyPressed( key )    HIBYTE( GetAsyncKeyState( key ) )	

// SceneData Container
CHeightFieldScene CSceneManager::m_HeightField;
CMeshObjectContainer CSceneManager::m_MeshObjectContainer;
CHouseObjectContainer CSceneManager::m_HouseObjectContainer;
CLightContainer CSceneManager::m_LightObjectContainer;
CObjectContainer CSceneManager::m_ObjectContainer;
CWeatherManager CSceneManager::m_WeatherManager;
COctreeContainer CSceneManager::m_OctreeContainer;
CInstanceObjectManager CSceneManager::m_InstanceObjectManager;
WBWaterNormalTexGenerator *CSceneManager::m_pWaterTexGenerator = NULL;

float CSceneManager::m_fWeatherTimeAdder;

CCharacterLightShadowManager CSceneManager::m_CharacterManager;
//CMapStorage CSceneManager::m_MapStorage;
//Pick Member
long CSceneManager::m_bIsPickObjectMoving;
CHouseObjectScene *CSceneManager::m_PickHouseScene;
CLightObjectScene *CSceneManager::m_PickLightScene;
CSectorLandscapeEffectMap *CSceneManager::m_PickLandscape;

CObjectScene *CSceneManager::m_PickObjectScene;
matrix CSceneManager::m_matUndo;
bool CSceneManager::m_bPickFix=false;
//Lod Member
int CSceneManager::m_isTessellate;
//Detail Member
long CSceneManager::m_DetailCharShadow;
long CSceneManager::m_DetailMapShadow;
long CSceneManager::m_DetailBuildShadow;
long CSceneManager::m_DetailTerrain;
long CSceneManager::m_DetailChrMesh;
long CSceneManager::m_DetailViewRange;
long CSceneManager::m_DetailWaterReflection;
long CSceneManager::m_DetailLensflare;
long CSceneManager::m_DetailTreeDetail;
//
LPDIRECT3DDEVICE8 CSceneManager::m_pd3dDevice;
CCollisionDetection CSceneManager::m_CollisionDetection;
bool CSceneManager::m_isCollisionDetection;
//

//Particle Manager//
//CParticleManager CSceneManager::m_ParticleManager;


int CSceneManager::m_ViewerMode;

long CSceneManager::m_cRenderVertex;
long CSceneManager::m_cRenderPolygon;
long CSceneManager::m_cRenderSector;

long CSceneManager::m_cRenderSectorPoly;
long CSceneManager::m_cRenderSectorVertex;
long CSceneManager::m_cRenderPrimitive;

vector3 CSceneManager::m_vecPickRayStart;
vector3 CSceneManager::m_vecPickRayDir;

float CSceneManager::m_fRemainFrame;

bool CSceneManager::m_bEditor;

CTexture CSceneManager::m_NsTexture;

float CSceneManager::m_fChrCameraInter;
float CSceneManager::m_fWeatherTime;

//CBoidScene CSceneManager::m_Boid;

CHouseObjectScene *CSceneManager::m_pBspScene=NULL;
List<vector3> CSceneManager::m_vecBspConvertList;
List<CHouseObjectScene*> CSceneManager::m_pBspConvertList;
List<vector3> CSceneManager::m_vecFieldConvertList;
CX3DEffectManager CSceneManager::m_EffectManager;


CSectorEffectMap *CSceneManager::m_Effect_Map;

CSectorEffectMap *CSceneManager::m_PickEffect;
BOOL CSceneManager::m_bPickEffect;
int CSceneManager::m_EffectNum;

CTexture CSceneManager::m_ChracterEnvTexture;

LPDIRECT3DCUBETEXTURE8 CSceneManager::m_LightCubeTexture;
List<CSceneManager::CGlareNode> CSceneManager::m_GlareList;
CRenderEnvTexture CSceneManager::m_DiffuseLightCubeTexture;
CRenderEnvTexture CSceneManager::m_SpecularLightTexture;
CRenderTexture CSceneManager::m_SpGlareTexture;


CLightEffectManager CSceneManager::m_LightEffectManager;
color CSceneManager::m_FullSceneFade;

char CSceneManager::m_SceneManagerPath[256];
//Å©¸®½º¸¶½º ´«
CSnowFall CSceneManager::m_SnowFall;
CRenderOption::ZoneInfo CSceneManager::m_ZoneInfoData;
//////////////////////////BSPÃß°¡
RBspSceneManager CSceneManager::m_RBspSceneManager;
bool CSceneManager::m_bRBspSceneIn = false;
//// Sector Light
CSectorLight *CSceneManager::m_pPickSectorLight = NULL;
bool CSceneManager::m_bRenderSectorLight = true;

D3DLIGHT8 CSceneManager::m_CharacterLight;
bool CSceneManager::m_bCharacterLight;
float CSceneManager::m_fGlowPlaneRange;
bool CSceneManager::m_bCharacterLightOp;

bool CSceneManager::m_bSectorLightFactor = false;
DWORD CSceneManager::m_dwSectorLightFactor = 0xffffffff;

CCameraScript *g_CameraScript = NULL;

CShaderManager CSceneManager::m_ShaderManager;
WBEnvPlaneTex	*CSceneManager::m_pEnvPlaneTex = NULL;
CGlareManager *CSceneManager::m_GlareManager = NULL; 
bool CSceneManager::m_bEnv = false;
CTexture *CSceneManager::m_pBlackGlare = NULL;

CEffectCasher *CSceneManager::m_pEsfCasher = NULL;
int g_iBlurTextureNum = 6;
int g_iBlurCount = 0;
D3DXVECTOR3 CSceneManager::m_vecLifeColor;
CFullSceneEffect *CSceneManager::m_pFullSceneEffect = NULL;
bool CSceneManager::m_bSceneNodeCulling = true;
bool CSceneManager::m_bMinimapGenerate = false;
CSectorScene *CSceneManager::m_pPickSector = NULL;

IDirect3DCubeTexture8* CSceneManager::m_pWorldCubemap = NULL;
ID3DXRenderToEnvMap* CSceneManager::m_pRenderEnvMap = NULL;

bool CSceneManager::m_bInView = false;		// true À϶§ ³»ºÎ ¾À 
CHouseObjectScene *CSceneManager::m_pInViewHouseScene = NULL;

//Caldron::Base::CResourceLoader *CSceneManager::m_pResourceLoader = NULL;
//CCaldronHouseCacheMgr	*CSceneManager::m_pCaldronHouseCacheMgr = NULL;


CSceneManager::CSceneManager()
{	
	//LogMessage("Constructor SceneManager");
	m_isTessellate=1;
	m_PickHouseScene=NULL;
	m_bIsPickObjectMoving=0;
	m_fWeatherTimeAdder=0.001f;
	m_ViewerMode=0;
	m_fRemainFrame=0;
	m_isCollisionDetection=false;	
	m_bEditor=false;
	m_fChrCameraInter=350.0f;
	m_fWeatherTime=0.0f;
	m_fWeatherTimeAdder=0.0f;
	m_EffectNum = 0;
	m_bPickEffect = NULL;
	m_PickLandscape = NULL;
	m_ScreenSize=1024;
	m_FullSceneFade.c=0x0;

	strcpy(m_SceneManagerPath,"");
	m_bSnowFall = false;

	memset(&m_CharacterLight,0,sizeof(D3DLIGHT8));
	m_CharacterLight.Type=D3DLIGHT_POINT;					
/*	m_CharacterLight.Attenuation0=0.2f;					
	m_CharacterLight.Attenuation1=0.005f;
	m_CharacterLight.Attenuation2=0.0f;
*/	

	m_CharacterLight.Attenuation0=0.6f;					
	m_CharacterLight.Attenuation1=0.001f;
	m_CharacterLight.Attenuation2=0.0f;

	m_CharacterLight.Diffuse.r = 227.0f / 255.0f;
	m_CharacterLight.Diffuse.g = 186.0f / 255.0f;
	m_CharacterLight.Diffuse.b = 31.0f / 255.0f;

	m_CharacterLight.Position.x = 0.0f;
	m_CharacterLight.Position.y = 0.0f;
	m_CharacterLight.Position.z = 0.0f;
	m_CharacterLight.Range= 1500.0f;
	m_CharacterLight.Falloff = 1.0f;

	m_fGlowPlaneRange = 800.0f;

	m_bCharacterLight = true;
	m_bCharacterLightOp = true;
	m_pBlackGlare = NULL;
	m_pRainParticle = NULL;
	m_pChristmasParticle = NULL;
	m_pChristmasParticleManager = NULL;
	m_bChristmas = true;

	srand(time(0));
	m_pFullSceneEffect = NULL;
	m_pFullsceneEffect2 = NULL;

	m_vecLifeColor = D3DXVECTOR3(0.0f,0.0f,0.0f);
	m_pRenderEnvMap = NULL;
	m_pWorldCubemap = NULL;
	m_bInView = false;
	m_pInViewHouseScene = NULL;

//	m_pResourceLoader = new Caldron::Base::CResourceLoader();
//	m_pCaldronHouseCacheMgr = new CCaldronHouseCacheMgr();



}

CSceneManager::~CSceneManager()
{	
	//CMapStorage::DeleteAllData();	
	m_MapStorage.DeleteAllObject();
	m_HouseObjectContainer.DeleteAllObject();	
	m_LightObjectContainer.DeleteAllObject();
	m_ObjectContainer.DeleteAllObject();	
	m_MeshObjectContainer.DeleteAllObject();	
	m_OctreeContainer.DeleteAllObject();	
	if(CGrassScene::m_NormalTexture != NULL)
	{	
		delete CGrassScene::m_NormalTexture;
		CGrassScene::m_NormalTexture = NULL;
	}
/**/	if(m_pWaterTexGenerator != NULL) 
	{
		delete m_pWaterTexGenerator;
		m_pWaterTexGenerator = NULL;
	}
	if(m_pEnvPlaneTex != NULL)
		delete m_pEnvPlaneTex;

	if(m_GlareManager != NULL)
		delete m_GlareManager;

	if(m_pBlackGlare != NULL) {
		delete m_pBlackGlare;
		m_pBlackGlare = NULL;
	}

	if(m_pRainParticle != NULL) {
		delete m_pRainParticle;
		m_pRainParticle = NULL;
	}
	if(m_pChristmasParticle != NULL) {
		delete m_pChristmasParticle;
		m_pChristmasParticle = NULL;

	}
	if(m_pChristmasParticleManager) {
		delete m_pChristmasParticleManager;
		m_pChristmasParticleManager = NULL;
	}

	if(m_pEsfCasher != NULL) {
		delete m_pEsfCasher;
		m_pEsfCasher = NULL;
	}
	if(m_pFullSceneEffect) {
		delete m_pFullSceneEffect;
		m_pFullSceneEffect = NULL;
	}
	if(m_pFullsceneEffect2) {
		delete m_pFullsceneEffect2;
		m_pFullsceneEffect2 = NULL;
	}
/*	if(m_pResourceLoader)
	{
		delete m_pResourceLoader;
		m_pResourceLoader = NULL;

	}
	if(m_pCaldronHouseCacheMgr)
	{
		delete m_pCaldronHouseCacheMgr;
		m_pCaldronHouseCacheMgr = NULL;
	}*/
	if(m_pRenderEnvMap)
	{
		m_pRenderEnvMap->Release();
	}
				
	if(m_pWorldCubemap)
	{
		m_pWorldCubemap->Release();
	}
}

void CSceneManager::Create()
{

	m_bEditor=true;
	m_DetailCharShadow=4;
	m_DetailMapShadow=4;
	m_DetailBuildShadow=4;
	m_DetailTerrain=4;
	m_DetailChrMesh=4;
	m_DetailViewRange=4;
	m_DetailWaterReflection=4;
	m_DetailLensflare=4;
	m_DetailTreeDetail=4;
	CPerlinNoise::Init();

	SHADOWSIZE=256;

	
	char path[256];
	GetCurrentDirectory(256,path);
	SetSceneManagerPath(path);	

	CSceneStateMgr::_Init();

	m_HeightField.Create(CRenderOption::m_TerrainRange,CRenderOption::m_TerrainRange,&m_MapStorage);		
	m_HeightField.CheckingNextTerrain();		
	m_CollisionDetection.m_HeightField=&m_HeightField;	

//	CParticle::SetMatPosition(&m_ViewCamera->m_matPosition);
	m_InstanceObjectManager.Create(m_pd3dDevice);
	DETAILGROUND=25;

	m_EffectManager.SetDevice(m_pd3dDevice);

	//m_Boid.Create(100,0);

	CRenderTargetTexture::Create(m_pd3dDevice,SHADOWSIZE,SHADOWSIZE);
	LENS_REALPOLYTREE=12000.0f;

	//m_CharacterManager.Create();
	//m_CharacterManager.SetHeightField(&m_HeightField);

	CHRTEXTURESIZE=0;

	m_LightCubeTexture=NULL;

	if(CRenderOption::m_FullSceneGlare)
	{
		/*
		m_GlareTexture.Create(m_ScreenSize,m_ScreenSize);
		m_FullSceneTexture.Create(m_ScreenSize,m_ScreenSize);
		m_SpecularGlareTexture.Create(m_ScreenSize,m_ScreenSize);

		m_GlareCompositeTexture.Create(256,256);	

		m_FullSceneAnti=true;

		CTexture::SetPath(NATURETEXTUREPATH);
		m_ChracterEnvTexture.Load("Env.dds");

		char strCubeTextureName[256];
		sprintf(strCubeTextureName,"%s\\%s",NATURETEXTUREPATH,"LightCubemap.dds");

		D3DXCreateCubeTextureFromFileExA(m_pd3dDevice,
				strCubeTextureName, 
				D3DX_DEFAULT,
				0,
				0,
				D3DFMT_UNKNOWN,
				D3DPOOL_MANAGED,
				D3DX_FILTER_LINEAR,
				D3DX_FILTER_LINEAR,
				0,
				NULL,
				NULL,
				&m_LightCubeTexture);

		//sprintf(strCubeTextureName,"%s\\%s",NATURETEXTUREPATH,"LightCubemap.dds");

		m_DiffuseLightCubeTexture.Create(m_pd3dDevice,"sky",NATURETEXTUREPATH);		
		m_SpecularLightTexture.Create(m_pd3dDevice,"sp_light",NATURETEXTUREPATH,false);

		m_SpGlareTexture.Create(256,256);

		m_SmoothGlareTexture.Create(128);
		*/
		m_LightEffectManager.Create(m_ScreenSize);
		
	}

	

	//m_GlareTexture.Create(256,256);

	//CShadowMap::Create(512,512);

	//m_CharacterManager.CreateEditor();
	
	//CParticleManager::AddParticle(SMOKE_PARTICLE,vector3(0.0f,0.0f,0.0f),vector3(1.0f,1.0f,0.0f));


	///m_GrassScene.Create();	
	//	
	//m_pShip.Load("c:\\MP-Project\\Objects\\Object\\flying-trans-1.R3S");
	//CTexture::SetPath(OBJECTTEXTUREPATH);
	//m_pShip.TextureLoad();
	//m_pShip.ConvertNormal();

	//m_AniObject.Load("c:\\test.R3A");

	//strcpy(CRenderOption::m_strBaseGraphicsDataPath,"Zone2");
	//strcpy(CRenderOption::m_strBaseGraphicsDataPath,"");
	BaseGraphicsDataLoad(CRenderOption::m_strBaseGraphicsDataPath);
	m_WeatherManager.Create();
	m_CharacterManager.Create();
	m_CharacterManager.SetHeightField(&m_HeightField);
	g_CameraScript = new CCameraScript;
	m_ShaderManager.Init();
/**/	if(m_pWaterTexGenerator == NULL) {
		m_pWaterTexGenerator = new WBWaterNormalTexGenerator;
		m_pWaterTexGenerator->Init(GetDevice(),256,256,"Displacement.dds");
	}
	if(m_pEnvPlaneTex != NULL)
		delete m_pEnvPlaneTex;


	m_pEnvPlaneTex = new WBEnvPlaneTex;
	m_pEnvPlaneTex->Init(GetDevice(),256,256);
	//===================
	// Glare Test 
	//===================
	m_GlareManager = new CGlareManager;
	m_GlareManager->Create(); 

	if(m_pBlackGlare != NULL)
		delete m_pBlackGlare;
	m_pBlackGlare = new CTexture;
	CTexture::SetPath(EFFECTTEXTUREPATH);
	m_pBlackGlare->Load("spec_black.dds");
	///////////////////Å©¸®½º¸¶½º ´« 
	
	if(m_bSnowFall) {
		D3DXMATRIX tmpview;
		m_pd3dDevice->GetTransform(D3DTS_VIEW,&tmpview);
		D3DXMatrixInverse(&tmpview,NULL,&tmpview);
		
		vector3 tmppos;
		tmppos.x = tmpview._41;
		tmppos.y = tmpview._42;
		tmppos.z = tmpview._43;
		/*m_SnowFall.SetWorldValue(0.0f,-2.0f,0.0f,8.0f,-3.0f,8.0f,"snow.dds");
		//m_SnowFall.Init(GetDevice(),300,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
		m_SnowFall.Init(GetDevice(),500,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 2000.0f);
		*/
		
		m_SnowFall.SetWorldValue(0.0f,-15.0f,0.0f,1.0f,-0.5f,1.0f,"snow.dds");
		//m_SnowFall.Init(GetDevice(),300,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
		m_SnowFall.Init(GetDevice(),200,tmppos.x,tmppos.y,tmppos.z,500.0f,500.0f,tmppos.y + 2000.0f);
	}
	
	if(CRenderOption::m_bRain) {
		m_pRainParticle = new CRainParticle;
		
		m_pRainParticle->Init(1000,"RainPar.dds");
		m_pRainParticle->SetMaxLife(75.0f);
		m_pRainParticle->Explode(0.12f, 777 );
		m_pRainParticle->SetVisible(1.0f,0.2f);
		m_pRainParticle->SetBaseMass(1.2f);
		m_pRainParticle->SetFraction(0.0f);
		m_pRainParticle->SetGravity( 10.5f, -0.980001f, 0.0f );

		
		m_pRainParticle->SetColor(1.0f,1.0f,1.0f,1.0f,1.0f,1.0f);
		m_pRainParticle->SetSize(0.1f,3.5f,0.1f,3.5f);
	
		
		
		/*m_pRainParticle->SetColor(0.6f,0.6f,0.6f,0.6f,0.6f,0.6f);
		m_pRainParticle->SetSize(0.1f,3.5f,0.1f,3.5f);
	
		m_pChristmasParticle = new CChristmasParticle;
		m_pChristmasParticle->Init(900,"CParticle.dds");
		m_pChristmasParticle->SetMaxLife(75.0f);
		m_pChristmasParticle->SetVisible(1.0f,0.0f);
		m_pChristmasParticle->SetBaseMass(1.2f);
		m_pChristmasParticle->SetFraction(0.0f);
		m_pChristmasParticle->SetGravity( 0.0f, -0.1f, 0.0f );
		m_pChristmasParticle->SetColor(1.0f,1.0f,1.0f,0.0f,0.0f,0.0f);
		m_pChristmasParticle->SetSize(4.0f,4.0f,4.0f,4.0f);
			*/
		
	}
	if(m_bChristmas) {
		m_pChristmasParticleManager = new CChristmasParticleManager;
		
	}
/*	if(m_pEsfCasher) {
		delete m_pEsfCasher;

	}
	m_pEsfCasher = new CEffectCasher;
	m_pEsfCasher->BuildHashTable(EFFECTSCRIPTPATH);
*/
	
	if(m_pFullSceneEffect) {
		delete m_pFullSceneEffect;
		m_pFullSceneEffect = NULL;
	}
	m_pFullSceneEffect = new CFullSceneEffect;
	m_pFullSceneEffect->SetFullSceneEffectEnable(CRenderOption::m_bFullSceneEffect);
	m_pFullSceneEffect->Init(GetDevice());
	m_pFullSceneEffect->SetFlag(11,true);	//FullScene Glare
	//	m_pFullSceneEffect->SetFlag(9,true);
	// Blur Enable
	//m_pFullSceneEffect->SetFlag(1,true);


/*	FULLSCENE_MOTIONBLUR = 0,
	FULLSCENE_BRIGHT,
	FULLSCENE_BLACK,
	FULLSCENE_CONTRAST,
	FULLSCENE_LEVEL,
	FULLSCENE_GRAYLEVEL,
	FULLSCENE_EDGE,
	FULLSCENE_NEGATIVE,
	FULLSCENE_SEPIA,
	FULLSCENE_SOLAR,
	FULLSCENE_NUMS,	
*/
	///////////////
		
	// Cubemap Generation
	//////////////
	if(CRenderOption::m_WaterBumpEnvRendering)
	{
		D3DXCreateRenderToEnvMap( BaseGraphicsLayer::GetDevice(), 256, 
			BaseGraphicsLayer::m_d3dpp.BackBufferFormat, TRUE, D3DFMT_D16, &m_pRenderEnvMap );
		
		D3DXCreateCubeTexture( BaseGraphicsLayer::GetDevice(), 256, 1,
				D3DUSAGE_RENDERTARGET,BaseGraphicsLayer::m_d3dpp.BackBufferFormat, D3DPOOL_DEFAULT, &m_pWorldCubemap );
	}
	//////////////
}	


D3DXMATRIX D3DUtil_RGetCubeMapViewMatrix( DWORD dwFace )
{
    D3DXVECTOR3 vEyePt   = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
    D3DXVECTOR3 vLookDir;
    D3DXVECTOR3 vUpDir;

    switch( dwFace )
    {
        case D3DCUBEMAP_FACE_POSITIVE_X:
            vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case D3DCUBEMAP_FACE_NEGATIVE_X:
            vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case D3DCUBEMAP_FACE_POSITIVE_Y:
            vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
            break;
        case D3DCUBEMAP_FACE_NEGATIVE_Y:
            vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
            break;
        case D3DCUBEMAP_FACE_POSITIVE_Z:
            vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case D3DCUBEMAP_FACE_NEGATIVE_Z:
            vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
    }

    // Set the view transform for this cubemap surface
    D3DXMATRIX matView;
    D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookDir, &vUpDir );
    return matView;
}

D3DXMATRIX DD3DUtil_GetCubeMapViewMatrix( DWORD dwFace )
{
    D3DXVECTOR3 vEyePt   = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
    D3DXVECTOR3 vLookDir;
    D3DXVECTOR3 vUpDir;

    switch( dwFace )
    {
        case D3DCUBEMAP_FACE_POSITIVE_X:
            vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case D3DCUBEMAP_FACE_NEGATIVE_X:
            vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case D3DCUBEMAP_FACE_POSITIVE_Y:
            vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
            break;
        case D3DCUBEMAP_FACE_NEGATIVE_Y:
            vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
            break;
        case D3DCUBEMAP_FACE_POSITIVE_Z:
            vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case D3DCUBEMAP_FACE_NEGATIVE_Z:
            vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
    }

    // Set the view transform for this cubemap surface
    D3DXMATRIX matView;
    D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookDir, &vUpDir );
    return matView;
};



const long T3LVERTEXFVF=D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1|D3DFVF_TEXCOORDSIZE3(0);
class T3LVertex
{
public:
	vector3 v;
	float w;
	color Diffuse;
	color Specular;
	float tu,tv,tw;	
};


void CSceneManager::Render()
{	

	
	D3DVIEWPORT8 Viewport;

	m_pd3dDevice->GetViewport(&Viewport);

	/*
	m_pd3dDevice->EndScene();
	m_DiffuseLightCubeTexture.RenderCubeMap(m_pd3dDevice);	
	m_pd3dDevice->BeginScene();	

	m_pd3dDevice->EndScene();	
	m_SpGlareTexture.Begin(m_pd3dDevice);
	m_pd3dDevice->BeginScene();	
	m_pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET,0x0,1.0f, 0);	

	D3DXMATRIX matProj;

	D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/2.0f , 1.0f, 100.0f, 2000.0f );

	D3DXMATRIX matOldView,matOldProjection;
	m_pd3dDevice->GetTransform(D3DTS_VIEW,&matOldView);
	m_pd3dDevice->GetTransform(D3DTS_PROJECTION,&matOldProjection);	

	D3DXMATRIX matViewDir( matOldView);
    matViewDir._41 = 0.0f; matViewDir._42 = 0.0f; matViewDir._43 = 0.0f;

	
	D3DXMATRIX matView;	
	matView =matViewDir;
    //matView = DD3DUtil_GetCubeMapViewMatrix( (D3DCUBEMAP_FACES) 1 );
    //D3DXMatrixMultiply( &matView, &matViewDir, &matView );
	//D3DXMatrixMultiply( &matView, &matView ,&matViewDir );

	

	m_pd3dDevice->SetTransform(D3DTS_VIEW,&matView);
	m_pd3dDevice->SetTransform(D3DTS_PROJECTION,&matProj);
	
	m_SpecularLightTexture.RenderSkymap(m_pd3dDevice);
	//m_DiffuseLightCubeTexture.RenderSkymap(m_pd3dDevice);

	vector3 vecSunPos;
	vector3 vecProjPos;
	float w;
	vecSunPos=vector3(-1000.0f,-500.0f,-1000.0f);
	bool isInScreenSun=BaseGraphicsLayer::TransformVector(vecSunPos,vecProjPos,w);

	TLVertex m_SunVertex[4];

	float sx=100.0f;
	float sy=100.0f;
	m_SunVertex[0].v=vecProjPos;
	m_SunVertex[1].v=vecProjPos;
	m_SunVertex[2].v=vecProjPos;
	m_SunVertex[3].v=vecProjPos;
		
	m_SunVertex[0].v.x-=sx;m_SunVertex[0].v.y+=sy;
	m_SunVertex[1].v.x-=sx;m_SunVertex[1].v.y-=sy;
	m_SunVertex[2].v.x+=sx;m_SunVertex[2].v.y+=sy;
	m_SunVertex[3].v.x+=sx;m_SunVertex[3].v.y-=sy;	
		
	m_SunVertex[0].w=w;
	m_SunVertex[1].w=w;
	m_SunVertex[2].w=w;
	m_SunVertex[3].w=w;
	
	m_SunVertex[0].Diffuse.c=0xffffffff;
	m_SunVertex[1].Diffuse.c=0xffffffff;
	m_SunVertex[2].Diffuse.c=0xffffffff;
	m_SunVertex[3].Diffuse.c=0xffffffff;

	m_SunVertex[0].tu=0.0f;
	m_SunVertex[0].tv=1.0f;	
	m_SunVertex[0].Specular.c=0x0;
	
	m_SunVertex[1].tu=0.0f;
	m_SunVertex[1].tv=0.0f;	
	m_SunVertex[1].Specular.c=0x0;
	
	m_SunVertex[2].tu=1.0f;
	m_SunVertex[2].tv=1.0f;	
	m_SunVertex[2].Specular.c=0x0;
	
	m_SunVertex[3].tu=1.0f;
	m_SunVertex[3].tv=0.0f;	
	m_SunVertex[3].Specular.c=0x0;

		
	CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);	
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);

	//m_pd3dDevice->SetTexture(0,);

	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);    
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);		
	CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE);
	m_pd3dDevice->SetVertexShader(TLVERTEXFVF);	

	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);	

	CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);

	m_pd3dDevice->SetTexture(0,m_WeatherManager.m_SunScene.m_SunTexture.GetTexture());

	m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,m_SunVertex,sizeof(TLVertex));

	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);	

	m_pd3dDevice->SetTransform(D3DTS_VIEW,&matOldView);
	m_pd3dDevice->SetTransform(D3DTS_PROJECTION,&matOldProjection);	
	m_pd3dDevice->EndScene();	
	m_SpGlareTexture.End(m_pd3dDevice);
	m_pd3dDevice->BeginScene();

	

	m_pd3dDevice->EndScene();
	m_SpecularLightTexture.RenderCubeMap(m_pd3dDevice);	
	m_pd3dDevice->BeginScene();	
	

	if(GF3OPTION)
	{
		RenderFullSceneTextureBegin();		
	}
	*/

////////////////////
	m_pFullSceneEffect->BeginRender(BaseGraphicsLayer::m_ClearColor.c);
	
/////////////////////
					
	if(g_CameraScript->ISPlay()) {
		D3DXMATRIX tmp = g_CameraScript->GetCurrentViewMat();
		D3DXVECTOR3 vecCameraPos = g_CameraScript->GetVecPos();
		D3DXVECTOR3 vecCameraUp = g_CameraScript->GetVecUp();
		D3DXVECTOR3 vecCameraLook = g_CameraScript->GetVecLook();

		m_ViewCamera->LookAt(vector3(vecCameraPos.x,vecCameraPos.y,vecCameraPos.z),
							vector3(vecCameraLook.x,vecCameraLook.y,vecCameraLook.z),
							vector3(vecCameraUp.x,vecCameraUp.y,vecCameraUp.z));
		
		m_pd3dDevice->SetTransform(D3DTS_VIEW,m_ViewCamera->GetMatView());

		//m_pd3dDevice->SetTransform(  D3DTS_VIEW ,&tmp);
		
	}
	
	if(CRenderOption::m_FullSceneGlare)
	{
		m_LightEffectManager.PrepareLightingEnvmap(m_pd3dDevice);
	}

	m_RBspSceneManager.Render();
	
	D3DVIEWPORT8 m_pTempViewPort;
	
	bool bRenderEnv = false;
	
	if(m_RBspSceneManager.m_pCurrentBspScene == NULL) 
	{

	
		if(m_bMinimapGenerate)
		{
			m_bMinimapGenerate = false;
			m_bSceneNodeCulling = false;

			CFullSceneEffect *pScene = NULL;
			matrix *matPos= m_ViewCamera->GetMatPosition();	
			pScene = new CFullSceneEffect;
			pScene->SetFullSceneEffectEnable(true);
			pScene->Init(m_pd3dDevice,256,256);


			m_pFullSceneEffect->EndRender();
			pScene->BeginRender(BaseGraphicsLayer::m_ClearColor.c);
			vector3 vecViewPos=matPos->GetLoc();

			matrix matInit;
			matrix matProjection,matView;
			D3DXMATRIX matOldProjection,matOldView;
			
			m_pd3dDevice->GetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&matOldProjection);
			m_pd3dDevice->GetTransform(D3DTS_VIEW,(D3DMATRIX*)&matOldView);	

			matInit.MakeIdent();
			
			CSectorScene *pCenterSectorScene=NULL;
			for(int i=0;i<LSIZEX*LSIZEY;i++)
			{
				if( 	m_HeightField.m_SectorScene[i].m_AccumulateTM._41 <= vecViewPos.x &&
					vecViewPos.x <= m_HeightField.m_SectorScene[i].m_AccumulateTM._41+SECTORSIZE &&
					m_HeightField.m_SectorScene[i].m_AccumulateTM._43 <= vecViewPos.z &&
					vecViewPos.z<= m_HeightField.m_SectorScene[i].m_AccumulateTM._43+SECTORSIZE )
				{
					pCenterSectorScene=&m_HeightField.m_SectorScene[i];
					break;
				}

			}
			float fStartX = pCenterSectorScene->m_AccumulateTM._41;
			float fStartZ = pCenterSectorScene->m_AccumulateTM._43;
			
			int SectorPx=(int)(pCenterSectorScene->m_AccumulateTM._41/SECTORSIZE);
			int SectorPy=(int)(pCenterSectorScene->m_AccumulateTM._43/SECTORSIZE);

			//float fViewHeight=(SECTORSIZE/2.0f)/tanf(3.14159f/6.0f) + 100.0f;
			float fViewHeight=60000.0f;
			
			matrix *matpPos = m_ViewCamera->GetMatPosition();
			matpPos->_41 = fStartX + SECTORSIZE/2.0f;
			matpPos->_42 = fViewHeight;
			matpPos->_43 = fStartZ + SECTORSIZE/2.0f;

			matrix *matViewCamera = (matrix *)m_ViewCamera->GetMatView();
			matViewCamera->_41 = fStartX + SECTORSIZE/2.0f;
			matViewCamera->_42 = 0.0f;
			matViewCamera->_43 = fStartZ + SECTORSIZE/2.0f;
			matView.CameraLookAt(vector3(fStartX + SECTORSIZE/2.0f,fViewHeight,fStartZ + SECTORSIZE/2.0f),vector3(fStartX + SECTORSIZE/2.0f,0.0f,fStartZ + SECTORSIZE/2.0f),vector3(0.0f,0.0f,1.0f));
			
			D3DXMatrixOrthoLH(matProjection,SECTORSIZE,SECTORSIZE,10.0f, 100000.0f);
			m_pd3dDevice->SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&matProjection);
			m_pd3dDevice->SetTransform(D3DTS_VIEW,(D3DMATRIX*)&matView);	
			m_HeightField.RenderMinimap(m_pd3dDevice);
				
			pScene->EndRender();
			char strTextureFileName[256];
			sprintf(strTextureFileName,"%s\\Minimap\\%d_%d.dds",WIDETEXTUREPATH,SectorPx,SectorPy);

			pScene->SaveTexture(strTextureFileName);
			
			m_pd3dDevice->SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)&matOldProjection);
			m_pd3dDevice->SetTransform(D3DTS_VIEW,(D3DMATRIX*)&matOldView);	
			
			m_pFullSceneEffect->BeginRender(BaseGraphicsLayer::m_ClearColor.c);
			delete pScene;
			pScene = NULL;
			m_bSceneNodeCulling = true;
			MessageBox(NULL,"Save Success","minimap",MB_OK);
		

		}
		if(!GetInView())
			m_WeatherManager.Render(m_pd3dDevice);		
		
		m_pd3dDevice->GetViewport(&m_pTempViewPort);

		m_HeightField.Render(m_pd3dDevice);
				
		m_pd3dDevice->GetViewport(&m_pTempViewPort);
		//m_CharacterManager.Render(m_pd3dDevice);
		//////////////////////////////////////////////////////Render Env
		
		D3DXMATRIX matWorld,matView;
		D3DXMATRIX matInvView;

		CSceneManager::GetDevice()->GetTransform(D3DTS_WORLD,&matWorld);
		D3DXMatrixIdentity(&matWorld);
		CSceneManager::GetDevice()->GetTransform(D3DTS_VIEW,&matView);
		
		D3DXMatrixInverse(&matInvView,NULL,&matView);

		D3DXVECTOR3 vecViewPos = D3DXVECTOR3(matInvView._41,matInvView._42,matInvView._43);

		D3DXVECTOR3 vecClipRange[4];
		vecClipRange[0].y = vecClipRange[1].y = vecClipRange[2].y = vecClipRange[3].y = 300.0f;
		vecClipRange[0].x = 15800.0f;
		vecClipRange[0].z = 63000.0f;

		vecClipRange[1].x = 281000.0f;
		vecClipRange[1].z = 63000.0f;

		vecClipRange[2].x = 15800.0f;
		vecClipRange[2].z = 292000.0f;

		vecClipRange[3].x = 281000.0f;
		vecClipRange[3].z = 292000.0f;

		if((vecClipRange[0].x <= vecViewPos.x) && (vecClipRange[0].z <= vecViewPos.z))
		{
			if((vecClipRange[3].x >= vecViewPos.x) && (vecClipRange[3].z >= vecViewPos.z))
			{
				bRenderEnv = false;
			}
		}
		
		if(bRenderEnv) {
		/*	CSceneManager::m_pEnvPlaneTex->InitClipRange(vecClipRange[0],
														vecClipRange[1],
														vecClipRange[2],
														vecClipRange[3]);*/

			vecViewPos.y = 1900.0f;
			CSceneManager::m_pEnvPlaneTex->RenderBegin(vecViewPos,matWorld,1900.0f);
/*
				CSceneManager::m_WeatherManager.Render(CSceneManager::GetDevice());		
				CSceneManager::m_HeightField.Render(CSceneManager::GetDevice());
				
				CSceneManager::m_CharacterManager.Render(CSceneManager::GetDevice());
				
			CSceneManager::m_pEnvPlaneTex->RenderEnd();*/
		}
		//////////////////////////////////////////////////////////////////////////


		//m_HeightField.RenderWater(m_pd3dDevice);
		m_pd3dDevice->GetViewport(&m_pTempViewPort);

		if(SHADOWSIZE!=0)
		{
			if(strcmp(CRenderOption::m_strBaseGraphicsDataPath, "Zone100"))
			{
				m_CharacterManager.HeightFieldShadowRender(m_pd3dDevice);
				m_CharacterManager.HeightFieldCharacterLightRender(m_pd3dDevice);
			}
		}		
		m_InstanceObjectManager.Render(m_pd3dDevice);
		m_CharacterManager.HeightFieldCharacterLightRender(m_pd3dDevice);

		// µ¿±â :: ³ªÁß¿¡ ¾îÂîµÉÁö´Â ¸ð¸§m_HeightField.RenderShadow(m_pd3dDevice);

		m_pd3dDevice->GetViewport(&m_pTempViewPort);
		//m_Boid.Render(m_pd3dDevice);
		if(!GetInView())
			m_HeightField.m_GrassSceneManager.Render(m_pd3dDevice);
	/*	m_pd3dDevice->GetViewport(&m_pTempViewPort);
		m_WeatherManager.SecondRender(m_pd3dDevice);
		m_pd3dDevice->GetViewport(&m_pTempViewPort);
	*/
	}
	else
	{
		//m_HeightField.SetObjectCulling(false);
		//m_HeightField.Render(m_pd3dDevice);
		//m_WeatherManager.Render(m_pd3dDevice);			
		m_CharacterManager.Render(m_pd3dDevice);	
	
	}
/*	{
		D3DXMATRIX matOldView;
		D3DXVECTOR3 vecViewPos;
		m_pd3dDevice->GetTransform(D3DTS_VIEW,&matOldView);
		D3DXMatrixInverse(&matOldView,NULL,&matOldView);
		
		vecViewPos.x = matOldView._41;
		vecViewPos.y = matOldView._42;
		vecViewPos.z = matOldView._43;
		
		vector3 vecToward = m_ViewCamera->GetViewTowardVector();
		
		D3DXVECTOR3 vecLine[2];
		vecLine[0].x = vecViewPos.x + 500.0f;
		vecLine[0].y = vecViewPos.y ;
		vecLine[0].z = vecViewPos.z + 500.0f;

		vecLine[1].x = vecViewPos.x + 500.0f + (vecToward.x) * 1000.0f;
		vecLine[1].y = vecViewPos.y + vecToward.y * 1000.0f;
		vecLine[1].z = vecViewPos.z + 500.0f + vecToward.z * 1000.0f;
		m_pd3dDevice->SetVertexShader(D3DFVF_XYZ);
		m_pd3dDevice->SetPixelShader(NULL);
		
		if(CheckRayCollision(vecLine[0],vecLine[1]))
			CSceneStateMgr::_SetD3DRenderState(D3DRS_TEXTUREFACTOR,0xffff00ff);
		else
			CSceneStateMgr::_SetD3DRenderState(D3DRS_TEXTUREFACTOR,0xff00ffff);
		CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );	
		CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);
		CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,    D3DTOP_DISABLE );

		CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
		CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP,    D3DTOP_DISABLE );

		m_pd3dDevice->DrawPrimitiveUP(D3DPT_LINELIST,1,vecLine,sizeof(D3DXVECTOR3));	
		

	}*/
	m_EffectManager.Render();
	m_EffectManager.RenderScript();
	m_HeightField.RenderMapEffect();
	if(!g_CameraScript->ISPlay()) {
		g_CameraScript->RenderPos_Up();
		g_CameraScript->RenderLook();
		g_CameraScript->RenderLine();
		g_CameraScript->RenderPosSpline();
		g_CameraScript->RenderLookSpline();
	}
	// Å©¸®½º¸¶½º ´« 
	if(m_bSnowFall) {
		m_SnowFall.Render();
	}
		
	
	if(CRenderOption::m_bRain) {
	
		m_pRainParticle->UpdateBuffer();
		m_pRainParticle->Render();

	/**	m_pChristmasParticle->UpdateBuffer();
		m_pChristmasParticle->Render();
	*/
		

	}
	if(m_bChristmas) {
		m_pChristmasParticleManager->Render();
	}

	//m_EffectManager.RenderWorldScript();

	if(CRenderOption::m_FullSceneGlare)
	{
		m_LightEffectManager.RenderGlareScene(m_pd3dDevice);
		m_pd3dDevice->GetViewport(&m_pTempViewPort);
		/*
		RenderGlareTexture();
		RenderSpecularGlareTexture();
		RenderFullSceneGlare();
		RenderFullSceneAnti();
		RenderFullSceneTextureEnd();
		*/
	}

/**/	if( bRenderEnv && m_pEnvPlaneTex != NULL)
	{
		TLVertex pVertex[8];		

		pVertex[0].v.x=0.0f;
		pVertex[0].tu = 0.0f;
		pVertex[0].tv = 1.0f;

		pVertex[1].v.x=0.0f;
		pVertex[1].tu = 0.0f;
		pVertex[1].tv = 0.0f;

		pVertex[2].v.x=150;
		pVertex[2].tu = 1.0f;
		pVertex[2].tv = 1.0f;

		pVertex[3].v.x=150;
		pVertex[3].tu = 1.0f;
		pVertex[3].tv = 0.0f;
	
		pVertex[1].v.y=0.0f;
		pVertex[3].v.y=0.0f;
		pVertex[0].v.y=150;
		pVertex[2].v.y=150;

		for(int i=0;i<4;i++)
		{
			pVertex[i].w=0.1f;
			pVertex[i].v.z=0.1f;
			pVertex[i].Diffuse.c=0xffffffff;
			pVertex[i].Specular.c=0x0;		
		}			
		CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE,FALSE);
		
		CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);    
		CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);		
		CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE);
		CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP,   D3DTOP_DISABLE);
		CSceneStateMgr::_SetD3DTextureStageState( 3, D3DTSS_COLOROP,   D3DTOP_DISABLE);

		CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);	
		m_pd3dDevice->SetTexture(0,m_pEnvPlaneTex->GetTexture());
		m_pd3dDevice->SetTexture(1,NULL);
		m_pd3dDevice->SetTexture(2,NULL);
		m_pd3dDevice->SetTexture(3,NULL);

		m_pd3dDevice->SetVertexShader(TLVERTEXFVF);		

		CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
		m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));		

		CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE,TRUE);
	}
	if(m_FullSceneFade.c!=0x0)
	{
		TLVertex pVertex[8];		

		pVertex[0].v.x=0.0f;
		pVertex[1].v.x=0.0f;
		pVertex[2].v.x=BaseGraphicsLayer::m_lScreenSx;
		pVertex[3].v.x=BaseGraphicsLayer::m_lScreenSx;

		pVertex[1].v.y=0.0f;
		pVertex[3].v.y=0.0f;
		pVertex[0].v.y=BaseGraphicsLayer::m_lScreenSy;
		pVertex[2].v.y=BaseGraphicsLayer::m_lScreenSy;		
		
		for(int i=0;i<4;i++)
		{
			pVertex[i].w=0.1f;
			pVertex[i].v.z=0.1f;
			pVertex[i].Diffuse.c=m_FullSceneFade.c;
			pVertex[i].Specular.c=0x0;		
		}			
		CSceneStateMgr::_SetD3DTextureStageState(  0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);    
		CSceneStateMgr::_SetD3DTextureStageState(  0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);		
		CSceneStateMgr::_SetD3DTextureStageState(  1, D3DTSS_COLOROP,   D3DTOP_DISABLE);								

		CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_ONE);
		CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_ONE);		

		CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);	
		m_pd3dDevice->SetTexture(0,NULL);
		m_pd3dDevice->SetTexture(1,NULL);
		m_pd3dDevice->SetVertexShader(TLVERTEXFVF);		

		CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
		m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));		
	}
	m_pFullSceneEffect->EndRender();
		
	
	m_pFullSceneEffect->Render(0,Viewport.Width,Viewport.Height,false);
	//=================================================
	// Glare Render 
	static bool bGlare = false; 
	static D3DCOLOR clr;
	static DWORD cA=150; 
	static DWORD cR=150; 
	static DWORD cG=150; 
	static DWORD cB=150; 
	static D3DXVECTOR4 w = m_GlareManager->GetBlendWeight( CGlareManager::GLARE_CHARACTER );    
	if( KeyPressed('R') ) bGlare = false; 
	if( KeyPressed('T') ) bGlare = true; 
	if( KeyPressed(('Z')) ) w.x += 0.02f; 
	if( KeyPressed(('X')) ) w.x -= 0.02f; 
	if( KeyPressed(('C')) ) w.y += 0.02f; 
	if( KeyPressed(('V')) ) w.y -= 0.02f; 
	if( KeyPressed(('B')) ) w.z += 0.02f; 
	if( KeyPressed(('N')) ) w.z -= 0.02f; 
	if( KeyPressed(('Y')) ) w.w += 0.02f; 
	if( KeyPressed(('U')) ) w.w -= 0.02f; 
	if( w.x > 1.0f ) w.x = 1.0f; 
	if( w.x < 0.0f ) w.x = 0.0f; 
	if( w.y > 1.0f ) w.y = 1.0f; 
	if( w.y < 0.0f ) w.y = 0.0f; 
	if( w.z > 1.0f ) w.z = 1.0f; 
	if( w.z < 0.0f ) w.z = 0.0f; 
	if( w.w > 1.0f ) w.w = 1.0f; 
	if( w.w < 0.0f ) w.w = 0.0f; 
	if( KeyPressed(('9')) ) { cA += 5; cR += 5; cG += 5; cB += 5; };
	if( KeyPressed(('0')) ) { cA -= 5; cR -= 5; cG -= 5; cB -= 5; };
	clr = D3DCOLOR_ARGB(cA,cR,cG,cB); 
	if( bGlare ) 
	{

		m_GlareManager->SetBlendWeight( CGlareManager::GLARE_FULLSCENE,w );
		
		//m_GlareManager->SetBlendWeight( CGlareManager::GLARE_FULLSCENE,D3DXVECTOR4(1.0f,1.0f,1.0f,1.0f) );
		//clr = D3DCOLOR_ARGB(m_WeatherManager.m_InterGlareSkyLower.r,cR,cG,cB);
		
		clr = D3DCOLOR_ARGB(m_WeatherManager.m_InterGlareSkyLower.r,
							m_WeatherManager.m_InterGlareSkyUpper.r,
							m_WeatherManager.m_InterGlareSkyUpper.g,
							m_WeatherManager.m_InterGlareSkyUpper.b);
		
		
		CSceneManager::m_GlareManager->SetColor( CGlareManager::GLARE_FULLSCENE, clr);



		m_GlareManager->SetBlendWeight( CGlareManager::GLARE_CHARACTER,w);//D3DXVECTOR4(0.0f,0.0f,1.0f,0.0f) );
		//m_GlareManager->SetBlendWeight( CGlareManager::GLARE_CHARACTER,D3DXVECTOR4(0.0f,0.0f,1.0f,0.0f) );
	//	m_GlareManager->RenderCharacterGlare(); 
		m_GlareManager->RenderFullSceneGlare();
	
	}

	//==================================================

	
	

	//m_GlareTexture.GenerateMipmap(m_pd3dDevice);
	

	CSceneNode CheckNode;

	//m_pd3dDevice->EndScene();
	
	
/*	for(int j=0;j<m_Effect_Map.Effect_Num;j++) {
		CheckNode.m_fRad=100.0f;
		CheckNode.m_AccumulateTM.Translation(m_Effect_Map.m_vecEffectPos[j]);
		
		if(CheckNode.isCulling()) {
*/	
		
	
//		}
//	}

	//matrix *matViewPosition=GetCamera()->GetMatPosition();		
	//m_BspScene.Render(m_pd3dDevice,matViewPosition->GetLoc());	
	
	

	//m_ParticleManager.Render(m_pd3dDevice);		
	
	/*		
	m_CharacterManager.Render(m_pd3dDevice);
	*/
	//m_GrassScene.Render(m_pd3dDevice);
	//m_CharacterManager.CameraTest(m_pd3dDevice);
	/*
	if(SHADOWSIZE!=0)
	{
		m_CharacterManager.HeightFieldShadowRender(m_pd3dDevice);	
		m_CharacterManager.InHouseShadowRender(m_pd3dDevice);
	}
	*/
	
	//m_AniObject.Render(m_pd3dDevice);
	
	
	/*
	matrix mat;
	mat.MakeIdent();
	m_pd3dDevice->SetTransform(D3DTS_WORLD,mat);
	LVertex RayVertex[2];
	RayVertex[0].v=m_vecPickRayStart;
	RayVertex[1].v=m_vecPickRayStart+m_vecPickRayDir*10000.0f;
	
	RayVertex[0].diff.c=0xffffffff;
	RayVertex[1].spec.c=0x0;

	m_pd3dDevice->DrawPrimitiveUP(D3DPT_LINESTRIP,1,RayVertex,sizeof(LVertex));

	m_pd3dDevice->SetTexture(0,NULL);
	m_pd3dDevice->SetTexture(1,NULL);

	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );		
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG2);	
	*/
	//m_ViewCamera->Render(m_pd3dDevice);	
	/*
	static matrix matPos,matRot,mat;
	static vector3 vecPos(1467525.0f,7190.0f,697322.0f);
	vecPos+=vector3(-10.0f,0.0f,7.0f);
	matPos.Translation(vecPos);
	matRot.YRotation(3.14f/6.0f);
	mat=matRot*matPos;
	m_pd3dDevice->SetTransform(D3DTS_WORLD,mat);
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );		
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE);	

	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);	    	
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG2);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
    CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);	
	m_pShip.Render(m_pd3dDevice);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
	*/
	/*
	matPos.Translation(
	mat=matRot*matPos;
	m_pd3dDevice->SetTransform(
	m_pShip.Render(m_pd3dDevice);
	/*
	vector3 vecCharacterPos;
	m_pCharacter->GetPosition(vecCharacterPos.x,vecCharacterPos.y,vecCharacterPos.z);
	List<vector3> CharPoly;
	m_HeightField.GetShadowPoly(vecCharacterPos,CharPoly);
	
	TTVertex *pCharVertex=new TTVertex[CharPoly.num];
	WORD *pCharIndices=new WORD[CharPoly.num];
	for(int cIndices=0;cIndices<CharPoly.num;cIndices++)
	{
		pCharVertex[cIndices].v=CharPoly[cIndices];
		pCharVertex[cIndices].diff.c=0xffff0000;
		pCharIndices[cIndices]=cIndices;
	}
	delete [] pCharVertex;
	delete [] pCharIndices;	
	// make the character's shadow //
	
	//	
	
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);
	//m_pd3dDevice->SetTexture(0,m_HeightField.m_SectorScene->m_ObjectShadowTexture.GetTexture());
	//m_pd3dDevice->SetTexture(0,m_HeightField.m_SectorScene->m_SectorShadowTexture.GetTexture());
	m_pd3dDevice->SetTexture(0,m_pShadowTexture.GetTexture());
	m_pd3dDevice->SetTexture(1,NULL);	
	/*
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );		
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE2X);
	*/		
	//m_ViewCamera->Render(m_pd3dDevice);		

	/////////////////////////////////

	
	//////////////////////////////////
	//m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));		

	//m_pd3dDevice->SetTexture(0,CSceneManager::m_SpGlareTexture.GetTexture());
	//m_pd3dDevice->SetTexture(0,m_SmoothGlareTexture.GetTexture());
	

/*	m_pFullsceneEffect2->BeginRender(0x00000000);		
	m_CharacterManager.Render(m_pd3dDevice);
	m_pFullsceneEffect2->EndRender();*/
	//m_pFullSceneEffect->RenderMulti(m_pFullsceneEffect2);


	m_pd3dDevice->GetViewport(&m_pTempViewPort);
	m_WeatherManager.SecondRender(m_pd3dDevice);
	m_pd3dDevice->GetViewport(&m_pTempViewPort);

}

/*
void CSceneManager::MouseMove(int dx, int dy)
{
	switch(m_ViewerMode)
	{
		case 0:
			if(CSceneManager::m_isCollisionDetection)
			{
				CollisionType CT;
				matrix* matOldMat=m_ViewCamera->GetMatPosition();
				vector3 vecOldPos=matOldMat->GetLoc();
				m_ViewCamera->InterfaceFreelook(dx,dy);
				vector3 vecNewPos=matOldMat->GetLoc();

				vector3 vecVelocity=vecNewPos-vecOldPos;
				vecVelocity.y-=10.0f;
				vecNewPos=m_CollisionDetection.GetPosition(vecOldPos,vecVelocity,CT,false);
				matOldMat->_41=vecNewPos.x;
				matOldMat->_42=vecNewPos.y;
				matOldMat->_43=vecNewPos.z;
				matrix matView;
				matView.Inverse(*matOldMat);
				m_ViewCamera->m_matView=matView;
				m_ViewCamera->MoveFrustum();
			}
			m_ViewCamera->InterfaceFreelook(dx,dy);
			break;
		case 1:
			m_ViewCamera->InterfaceCharlook2(-dx,-dy);
			break;
		case 2:
			m_ViewCamera->InterfaceFreeCamera(-dx,-dy);
			//m_ViewCamera->InterfaceFreelook(dx,dy);
			break;
	}
	/*
	if (m_ViewerMode!=0)
	{			
		
	}
	else
	{		
		if(
		if(CSceneManager::m_isCollisionDetection==false)
			m_ViewCamera->InterfaceFreelook(dx,dy);		
		else
		{
			
			vector3 vecOldPos=(*m_ViewCamera->GetPosition());			
			m_ViewCamera->InterfaceFreelook(dx,dy);
						
			
		}
	}
	*/	

	//m_ViewCamera->InterfaceCharlook(dx,dy,100.0f);
	/*
	D3DXMATRIX *matPosition=(D3DXMATRIX*)m_ViewCamera->GetMatPosition();
	float fDeltaY=dx/300.0f;
	float fDeltaX=dy/300.0f;

	D3DXVECTOR3 vecT(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 vecR(0.0f, 0.0f, 0.0f);

	D3DXMATRIX matT, matR;
	D3DXQUATERNION qR;		
	
	if(KeyPressed(VK_SHIFT))
	{
		if(KeyPressed('A') || KeyPressed(VK_NUMPAD1) || KeyPressed(VK_LEFT))  vecT.x -= 341.0f; // Slide Left			
		if(KeyPressed('D') || KeyPressed(VK_NUMPAD3) || KeyPressed(VK_RIGHT)) vecT.x += 341.0f; // Slide Right
		if(KeyPressed(VK_DOWN))                                       vecT.y += 341.0f; // Slide Down
		if(KeyPressed(VK_UP))                                         vecT.y -= 341.0f; // Slide Up
		if(KeyPressed('W'))
			vecT.z += 341.0f; // Move Forward
		if(KeyPressed('S'))
			vecT.z -= 341.0f; // Move Backward	
	}
	else
	{
		if(KeyPressed('A') || KeyPressed(VK_NUMPAD1) || KeyPressed(VK_LEFT))  vecT.x -= 5.0f; // Slide Left
		if(KeyPressed('D') || KeyPressed(VK_NUMPAD3) || KeyPressed(VK_RIGHT)) vecT.x += 5.0f; // Slide Right
		if(KeyPressed(VK_DOWN))                                       vecT.y += 5.0f; // Slide Down
		if(KeyPressed(VK_UP))                                         vecT.y -= 5.0f; // Slide Up
		if(KeyPressed('W'))
			vecT.z += 5.0f; // Move Forward
		if(KeyPressed('S'))
			vecT.z -= 5.0f; // Move Backward	
	}
	if(KeyPressed('P'))
	{		
		CSceneStateMgr::_SetD3DRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
	}
	if(KeyPressed('O'))
	{
		CSceneStateMgr::_SetD3DRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);		
	}
	vector3 vecOldPos;
	vecOldPos.x=matPosition->_41;
	vecOldPos.y=matPosition->_42;
	vecOldPos.z=matPosition->_43;

	D3DXMatrixTranslation(&matT, vecT.x, vecT.y, vecT.z);
	D3DXMatrixMultiply(matPosition, &matT, matPosition);	
	if(m_ViewerMode!=0)		
	{	
		vector3 vecPos;
		vecPos.x=matPosition->_41;
		vecPos.y=matPosition->_42;
		vecPos.z=matPosition->_43;		
		vector3 vecDir=vecPos-vecOldPos;
		vecDir.y-=10.0f;		
		vecPos=m_CollisionDetection.GetPosition(vecOldPos,vecDir);
		matPosition->_41=vecPos.x;
		matPosition->_42=vecPos.y;
		matPosition->_43=vecPos.z;		
	}

	float fRotationX=m_ViewCamera->GetRotationX();
	float fRotationY=m_ViewCamera->GetRotationY();
	
	D3DXQuaternionRotationYawPitchRoll(&qR, 0.0f,-fRotationX ,0.0f);
	D3DXMatrixRotationQuaternion(&matR, &qR);
	D3DXMatrixMultiply(matPosition, &matR, matPosition);		

	fRotationX-=fDeltaX;
	fRotationY-=fDeltaY;
	
	D3DXQuaternionRotationYawPitchRoll(&qR,-fDeltaY,fRotationX, 0.0f);
	D3DXMatrixRotationQuaternion(&matR, &qR);
	D3DXMatrixMultiply(matPosition, &matR, matPosition);	

	m_ViewCamera->SetRotaitionX(fRotationX);
	m_ViewCamera->SetRotaitionY(fRotationY);
	
	m_ViewCamera->SetVecPosition(vector3(m_ViewCamera->GetMatPosition()->_41,m_ViewCamera->GetMatPosition()->_42,m_ViewCamera->GetMatPosition()->_43));	
	
	matrix *matPos=m_ViewCamera->GetMatPosition();
	matrix matInv;
	matInv.Inverse(*matPos);	
	m_ViewCamera->SetMatView(matInv);
	m_ViewCamera->MoveFrustum();
	*/
//}

void CSceneManager::UpdateScene(float fUpdateFrame)
{	
		
/*	if(m_pResourceLoader)
		m_pResourceLoader->Process();
*/
	//m_WeatherManager.m_CloudScene.Update(m_pd3dDevice,0.0f);
	matrix *matViewPosition=GetCamera()->GetMatPosition();	
	vector3 vecViewPos=matViewPosition->GetLoc();
	
	
	CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();	
	vector3 vecCamera = m_ViewCamera->GetViewTowardVector();
	vector3 UpCamera = m_ViewCamera->GetViewUpVector();
	vecCamera.Normalize();
	UpCamera.Normalize();


	CSectorSoundMap::GetInstance().UpdateListener( vecCamera.x, vecCamera.y, vecCamera.z
							, UpCamera.x, UpCamera.y, UpCamera.z
							, vecViewPos.x, vecViewPos.y, vecViewPos.z );
	CSoundManager::GetInstance().Update();

	if(m_isTessellate==1)
	{
		m_HeightField.CheckingNextTerrain();
		bool bTerrainTessellate=false;
		bTerrainTessellate=m_HeightField.CheckingTessellate();
		if(bTerrainTessellate)
		{
			AllObjectCalcLens();
			m_HeightField.RebuildShadowPoly();
			//m_CharacterManager.HeightFiledOnChrFixPos();
		}
		
	}	

	/*
	static float WeatherTime=0.0f;
	WeatherTime+=0.001f;
	if(WeatherTime>=24.0f)
	{
		WeatherTime=0.0f; 
	}	
	m_ParticleManager.Update(fUpdateFrame+1.0f);
	*/
	if(m_pBspScene==NULL && m_PickHouseScene==NULL)
	{
		/*
		static List<vector3> m_vecBspConvertList;
	static List<CHouseObjectScene*> m_pBspConvertList;
	static List<vector3> m_vecFieldConvertList;
	static CHouseObjectScene *m_pBspScene;
		*/
		vector3 vecLens;
		for(int i=0;i<m_vecBspConvertList.num;i++)
		{
			vecLens=m_vecBspConvertList[i]-vecViewPos;

			if(vecLens.GetLens() <= 500.0f)
			{
				m_pBspScene=m_pBspConvertList[i];
				int cAccBsp=0;
				for(int cBspStartPos=0;cBspStartPos<i+1;cBspStartPos++)
				{
					if(m_pBspConvertList[cBspStartPos]==m_pBspScene)
						cAccBsp++;
				}

				//m_pBspConvertList[i]				
				matrix matToStartPos;
				matToStartPos=m_pBspScene->m_HouseObject->m_pInHouseMap->m_matObjectList[(cAccBsp-1)*4+1]*m_pBspScene->m_AccumulateTM;
				
				matViewPosition->_41=matToStartPos._41;
				matViewPosition->_42=matToStartPos._42;
				matViewPosition->_43=matToStartPos._43;

				m_vecFieldConvertList.num=0;								

				for(int cField=0;cField<m_pBspScene->m_HouseObject->m_pInHouseMap->m_matObjectList.num;cField+=4)
				{
					matToStartPos=m_pBspScene->m_HouseObject->m_pInHouseMap->m_matObjectList[cField+2]*m_pBspScene->m_AccumulateTM;
					m_vecFieldConvertList.Add(matToStartPos.GetLoc());
				}
				break;
			}
		}		
	}
	else if(m_pBspScene && m_PickHouseScene==NULL )
	{
		vector3 vecLens;
		for(int i=0;i<m_vecFieldConvertList.num;i++)
		{
			vecLens=m_vecFieldConvertList[i]-vecViewPos;

			if(vecLens.GetLens() <= 500.0f)
			{
				matrix matExitPos=m_pBspScene->m_HouseObject->m_pInHouseMap->m_matObjectList[i*4+3]*m_pBspScene->m_AccumulateTM;
				m_pBspScene=NULL;

				matViewPosition->_41=matExitPos._41;
				matViewPosition->_42=matExitPos._42;
				matViewPosition->_43=matExitPos._43;
				break;
			}
		}
	}
	CSectorScene::m_fCloudMove+=fUpdateFrame*0.0001f;
	CWaterScene::IncWaterTexture(((int)fUpdateFrame)/2.5f);

	m_WeatherManager.Update((float)((int)fUpdateFrame));

	m_HeightField.Update((float)((int)fUpdateFrame));
	
	m_RBspSceneManager.UpdateBsp();
	
	//m_Boid.Update(fUpdateFrame);

	if(CRenderOption::m_bRain) {
	
		D3DXMATRIX matView,matInvView;

		GetDevice()->GetTransform(D3DTS_VIEW,&matView);
		D3DXMatrixInverse(&matInvView,NULL,&matView);
		D3DXVECTOR3 vecViewPos = D3DXVECTOR3(matInvView._41,matInvView._42,matInvView._43);
		

		m_pRainParticle->CreateRain(vecViewPos.x - 200.0f,vecViewPos.y - 30.0f,vecViewPos.z - 200.0f,	
									vecViewPos.x + 200.0f,vecViewPos.y + 200.0f,vecViewPos.z + 200.0f,
									16.5, 200);
		
		/*
		if((m_pChristmasParticle->m_bStart) && (m_pChristmasParticle->m_fHeight < 500.0f)) {
			m_pChristmasParticle->m_fHeight+= 20.0f;
		}
		
		
		
		if( KeyPressed('Q') ) {
		
		
			vector3 vecDir = m_ViewCamera->GetViewTowardVector();
			vecDir.Normalize();
			vector3 vecUp = m_ViewCamera->GetViewUpVector();
			vecUp.Normalize();
			
			vector3 vecCross = vecDir ^ vecUp;
			vecCross.Normalize();

			vecViewPos.x += vecDir.x * 1500.0f;
			vecViewPos.y = m_CharacterManager.m_CharacterList[0].m_vecRealPosition.y + 100;//m_pChristmasParticle->m_fHeight;

			vecViewPos.z += vecDir.z * 1500.0f;
			
			m_pChristmasParticle->m_vecCenter = D3DXVECTOR3(vecViewPos.x,vecViewPos.y,vecViewPos.z);
			m_pChristmasParticle->m_vecRight = D3DXVECTOR3(vecCross.x,vecCross.y,vecCross.z);
			m_pChristmasParticle->m_vecUp = D3DXVECTOR3(vecUp.x,vecUp.y,vecUp.z);
			m_pChristmasParticle->SetStart(true);

			//m_pChristmasParticle->CreateChristmasParticle(vecViewPos.x,vecViewPos.y,vecViewPos.z,0.0f,350,vecCross.x,vecCross.y,vecCross.z,vecUp.x,vecUp.y,vecUp.z);
		}
		if(m_pChristmasParticle->m_fHeight >= 500.0f) {
			m_pChristmasParticle->SetExtUse(true);
			m_pChristmasParticle->SetStart(false);
			m_pChristmasParticle->SetMaxLife(85.0f);
			
			///Sound
			CEffScript *pCristmas = new CEffScript;
		

			int iRand = rand() % 3;
			
			switch(iRand) {
			case 0:
				m_pChristmasParticle->SetColor((rand() %100 / 100.0f),0.0f,0.0f,(rand() %100 / 100.0f),0.0f,0.0f);
				pCristmas->GetScriptData("ChristParticleR.esf");

				break;
			case 1:
				m_pChristmasParticle->SetColor(0.0f,(rand() %100 / 100.0f),0.0f,0.0f,(rand() %100 / 100.0f),0.0f);
				pCristmas->GetScriptData("ChristParticleG.esf");
				break;
			case 2:
				m_pChristmasParticle->SetColor(0.0f,0.0f,(rand() %100 / 100.0f),0.0f,0.0f,(rand() %100 / 100.0f));
				pCristmas->GetScriptData("ChristParticleB.esf");
				break;
			}
				
			CSceneManager::AddInterfaceScript(pCristmas);
			vector3 *vecCameraPos = CSceneManager::m_ViewCamera->GetPosition();

			pCristmas->SetStartPos(vecCameraPos->x,vecCameraPos->y,vecCameraPos->z);
			pCristmas->SetEndPos(vecCameraPos->x,vecCameraPos->y,vecCameraPos->z);
			
			pCristmas->SetChr(NULL,NULL);
			pCristmas->SetChrFwd(0.0f,0.0f,1.0f);	
							
			

			m_pChristmasParticle->CreateChristmasParticle(m_pChristmasParticle->m_vecCenter.x,
				(m_pChristmasParticle->m_vecCenter.y + (m_pChristmasParticle->m_fHeight * 2.0f)),m_pChristmasParticle->m_vecCenter.z,5.0f,850,
				m_pChristmasParticle->m_vecRight.x,m_pChristmasParticle->m_vecRight.y,m_pChristmasParticle->m_vecRight.z,
				m_pChristmasParticle->m_vecUp.x,m_pChristmasParticle->m_vecUp.y,m_pChristmasParticle->m_vecUp.z,true);

			m_pChristmasParticle->m_fHeight = 0.0f;	
		}
		else if(m_pChristmasParticle->m_bStart) {
			m_pChristmasParticle->SetMaxLife(30.0f);
			m_pChristmasParticle->SetColor(1.0f,1.0f,1.0f,1.0f,1.0f,1.0f);

			m_pChristmasParticle->CreateChristmasParticle(m_pChristmasParticle->m_vecCenter.x,
				(m_pChristmasParticle->m_vecCenter.y + m_pChristmasParticle->m_fHeight),m_pChristmasParticle->m_vecCenter.z,5.0f,10,
				m_pChristmasParticle->m_vecRight.x,m_pChristmasParticle->m_vecRight.y,m_pChristmasParticle->m_vecRight.z,
				m_pChristmasParticle->m_vecUp.x,m_pChristmasParticle->m_vecUp.y,m_pChristmasParticle->m_vecUp.z);

		}*/

	}
	if(m_bChristmas) {
	/*	static bool bPushed = false;
		if( KeyPressed('Q') && !bPushed) {
			if(CSceneManager::m_CharacterManager.m_CharacterList.num > 0) {
				CChristmasParticle *pChristmasParticle = NULL;
				pChristmasParticle = new CChristmasParticle;
				pChristmasParticle->Init(900,"testparticle1.dds");
					
				vector3 vecDir = CSceneManager::m_ViewCamera->GetViewTowardVector();
				vecDir.Normalize();

				D3DXVECTOR3 vecPos;

				vecPos.x = CSceneManager::m_CharacterManager.m_CharacterList[0].m_vecRealPosition.x + vecDir.x * 1500.0f;
				vecPos.y = CSceneManager::m_CharacterManager.m_CharacterList[0].m_vecRealPosition.y + 100;//m_pChristmasParticle->m_fHeight;

				vecPos.z = CSceneManager::m_CharacterManager.m_CharacterList[0].m_vecRealPosition.z + vecDir.z * 1500.0f;


				m_pChristmasParticleManager->AddParticle(pChristmasParticle,vecPos.x,vecPos.y,vecPos.z);
				bPushed = true;
			}

		}
		else {
			bPushed = false;
		}*/
		m_pChristmasParticleManager->ProcessParticle();
	}
	

	int snum = m_EffectManager.GetScriptNum();
	for(int scnt = 0;scnt<snum;scnt++)
		m_EffectManager.ProcessScript(scnt);

	

	for(int cUpdate=1;cUpdate<fUpdateFrame-1;cUpdate++)
	{	
		m_fWeatherTime+=m_fWeatherTimeAdder;
		if(m_fWeatherTime>=24.0f)
			m_fWeatherTime=0.0f;
	}
	m_WeatherManager.SetWeather(m_fWeatherTime,m_pd3dDevice);

	if(fUpdateFrame>=10.0f)
		return;

	if(m_ViewerMode==0)
	{
		vector3 vecPos=m_ViewCamera->m_matPosition.GetLoc();
		//CZ3DSound::SetListenerPosition(vecPos);
		//CZ3DSound::SetListenerDirection(CSceneManager::m_ViewCamera->GetRotationY()+3.14159f);
		//CZ3DSound::Process();

		for(int cUpdate=1;cUpdate<fUpdateFrame-1;cUpdate++)
		{	
			m_CharacterManager.ActionProcess();

			//m_fWeatherTime+=m_fWeatherTimeAdder;
			//if(m_fWeatherTime>=24.0f)
			//	m_fWeatherTime=0.0f;
		}		
		if(fUpdateFrame>=1)
			m_CharacterManager.UpdateFrame(-1);		
	}
	if(m_ViewerMode==1)
	{		
		for(int cUpdate=1;cUpdate<fUpdateFrame-1;cUpdate++)
		{	
			m_CharacterManager.ActionProcess();
			/*
			m_fWeatherTime+=m_fWeatherTimeAdder;
			if(m_fWeatherTime>=24.0f)
				m_fWeatherTime=0.0f;
				*/
		}
		if(fUpdateFrame>=1)
			m_CharacterManager.UpdateFrame(-1);
	}	
	if(m_ViewerMode==2)
	{
		for(int cUpdate=1;cUpdate<fUpdateFrame;cUpdate++)
		{
			m_CharacterManager.ActionProcess();
			/*
			m_fWeatherTime+=m_fWeatherTimeAdder;
			if(m_fWeatherTime>=24.0f)
				m_fWeatherTime=0.0f;
				*/
		}
	}	
	
	/*

	vector3 vecPos=CSceneManager::m_ViewCamera->m_matPosition.GetLoc();	
	CSectorScene *pSector=PickTerrain(vecPos.x,vecPos.y,vecPos.z);
	if(pSector)
	{
		if(pSector->m_MapWater)
		{
			if(pSector->m_MapWater->m_fWaterHeight>vecPos.y)
			{
				m_WeatherManager.m_InterFogFar=1000.0f;					
				m_WeatherManager.m_InterSkyFogFar=1000.0f;
				m_WeatherManager.m_InterFogNear=100.0f;
			}
		}
	}
	*/
	//Landscape effect update
	CSectorScene *tmp_sector = PickTerrain();




	for(cUpdate=0;cUpdate<(int)fUpdateFrame;cUpdate++)
	{
		//Landscape effect
		if(tmp_sector != NULL) {
			//tmp_sector->UpdateLandscapeEffect();
			tmp_sector->UpdateEffect();
		}
		//effect
		m_EffectManager.UpdateFrame();
		////////////Å©¸®½º¸¶½º ´«//
		if(m_bSnowFall) {
			
			D3DXMATRIX tmpview;
			m_pd3dDevice->GetTransform(D3DTS_VIEW,&tmpview);
			D3DXMatrixInverse(&tmpview,NULL,&tmpview);
			
			vector3 tmppos;
			tmppos.x = tmpview._41;
			tmppos.y = tmpview._42;
			tmppos.z = tmpview._43;
			
			vector3 tmptoward = m_ViewCamera->GetViewTowardVector();
			vector3 tmpup = m_ViewCamera->GetViewUpVector();
			tmptoward.Normalize();
			tmpup.Normalize();

			m_SnowFall.Update(tmppos.x + tmptoward.x * 700.0f,tmppos.y,tmppos.z + tmptoward.z * 700.0f,1000.0f,1000.0f,tmppos.y + 700.0f);
			
			//m_SnowFall.Update(tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
		}
	
		///////////////////////////////////////////
		
		//snum = m_EffectManager.GetWScriptNum();
	/*	for(int scnt = 0;scnt<snum;scnt++)
			m_EffectManager.ProcessWScript(scnt);
	*/

	}

		/*
	static DWORD ftime = timeGetTime();
	DWORD fFtime = timeGetTime();

	if((fFtime - ftime) > 20) {
		m_pWaterTexGenerator->Update();
		ftime = fFtime;
	}
	*/
	static bool bq = false;
	if( KeyPressed('Q') ) 
	{
		if(!bq)
		{
			bq = true;
			CRenderOption::m_CharacterPerPixelLighting = !CRenderOption::m_CharacterPerPixelLighting;
		}
	}
	else
	{
		bq = false;
	}


}
void CSceneManager::PickNextObject(int iOrder,int PickMode)
{
	if(PickMode==-1)
		return;
	
	if(m_bPickFix)
	{
		return;
	}
	int cObject;

	if(PickMode==1)
	{
		if(m_pPickSector && m_PickHouseScene)
		{
			
			for(cObject=0;cObject<m_pPickSector->m_HouseObjectNode.num;cObject++)
			{
				if(m_PickHouseScene==m_pPickSector->m_HouseObjectNode[cObject])
				{
					if(iOrder == 0)
					{
						if(cObject != m_pPickSector->m_HouseObjectNode.num - 1)
							m_PickHouseScene=m_pPickSector->m_HouseObjectNode[cObject+1];
						else
							m_PickHouseScene=m_pPickSector->m_HouseObjectNode[0];
					}
					else if(iOrder == 1)
					{
						if(cObject != 0)
							m_PickHouseScene=m_pPickSector->m_HouseObjectNode[cObject-1];
						else
							m_PickHouseScene=m_pPickSector->m_HouseObjectNode[m_pPickSector->m_HouseObjectNode.num - 1];

					}
					break;
				}
				
			}
			m_PickObjectScene=NULL;
		}
	}
	else if(PickMode == 2)
	{
		if(m_pPickSector && m_PickObjectScene)
		{
			
			for(cObject=0;cObject<m_pPickSector->m_ObjectSceneNode.num;cObject++)
			{
				if(m_PickObjectScene==m_pPickSector->m_ObjectSceneNode[cObject])
				{
					if(iOrder == 0)
					{
						if(cObject != m_pPickSector->m_ObjectSceneNode.num - 1)
							m_PickObjectScene=m_pPickSector->m_ObjectSceneNode[cObject+1];
						else
							m_PickObjectScene=m_pPickSector->m_ObjectSceneNode[0];
					}
					else if(iOrder == 1)
					{
						if(cObject != 0)
							m_PickObjectScene=m_pPickSector->m_ObjectSceneNode[cObject-1];
						else
							m_PickObjectScene=m_pPickSector->m_ObjectSceneNode[m_pPickSector->m_ObjectSceneNode.num - 1];

					}

					break;
				}
				
			}
			m_PickHouseScene=NULL;
		}
	}

}
void CSceneManager::PickObject(float fPx, float fPy, float fPz,int PickMode)
{
	
	if(PickMode==-1)
		return;
	
	if(m_bPickFix)
	{
		return;
	}

	float fNearestInterval=LENS_NEAR_OBJECT;
	int ix,iy;
	int cObject;
	// picking pos
	vector3 vecPick(fPx,fPy,fPz);
	vector3 vecLens;
	vector3 vecObjectPos;

	if(m_pBspScene)
	{
		matrix matLightPos;
		matrix matObjectTM;
		vector3 vecObjectPos;
		for(int cLight=0;cLight<m_pBspScene->m_HouseObject->m_pBspObject->m_EditLightList.num;cLight++)
		{
			float fRad=20.0f;
			matLightPos.Translation(m_pBspScene->m_HouseObject->m_pBspObject->m_EditLightList[cLight].m_vecLightPos);

			matObjectTM=matLightPos*m_pBspScene->m_AccumulateTM;			

			vecObjectPos=matObjectTM.GetLoc();

			vector3 vecInter=m_vecPickRayStart-vecObjectPos;

			float fC=(vecInter*vecInter)-fRad;
			float fB=m_vecPickRayDir*(m_vecPickRayStart-vecObjectPos);

			vecObjectPos=m_vecPickRayStart-vecObjectPos;
			
			if(fB*fB-fC>=0.0f)
			{
				if(vecObjectPos.GetLens() <= fNearestInterval) 
				{
					if(PickMode==2)
					{						
						m_pBspScene->m_HouseObject->m_pBspObject->m_SelectLight=cLight;
						fNearestInterval=vecObjectPos.GetLens();
						/*
						m_PickLightScene=m_PickHouseScene->m_HouseObject->m_LightList[cLight];
						m_PickObjectScene=NULL;
						fNearestInterval=vecObjectPos.GetLens();
						*/
					}
				}
			}			
			
		}
		return;
	}
/*	if(PickMode == 7) {
					fNearestInterval=LENS_NEAR_OBJECT;
					for(int i=0;i<m_EffectNum;i++) {

						CX3DEffect *PickEffect = m_EffectManager.m_lstEffect[i];

						vector3 *vecTargetObjectPos = PickEffect->GetCenter();
						vecLens= (*vecTargetObjectPos) - vecPick;
						
						if(	vecLens.GetLens() <= fNearestInterval)
						{
							m_PickEffect = m_EffectManager.m_lstEffect[i];
							m_PickHouseScene=NULL;
							fNearestInterval=vecLens.GetLens();
							m_bPickEffect = TRUE;
						}
					}
					if(fNearestInterval!=LENS_NEAR_OBJECT)
						return;
	}//PickMode == 7*/
	if(m_PickHouseScene)
	{
		fNearestInterval=LENS_NEAR_OBJECT;
		matrix matInvTM,matTM;
		matTM.Translation(vector3(fPx,fPy,fPz));
		matInvTM.Inverse(m_PickHouseScene->m_AccumulateTM);
		matTM=matTM*matInvTM;
		vector3 vecPickPos=matTM.GetLoc();			

		matrix matObjectTM;		
		
		for(int cLight=0;cLight<m_PickHouseScene->m_HouseObject->m_LightList.num;cLight++)
		{
			//vecObjectPos=m_PickHouseScene->m_HouseObject->m_LightList[cLight]->m_TM.GetLoc();
			float fRad=m_PickHouseScene->m_HouseObject->m_LightList[cLight]->m_fRad;
			matObjectTM=m_PickHouseScene->m_HouseObject->m_LightList[cLight]->m_TM*m_PickHouseScene->m_AccumulateTM;
			fRad=m_PickHouseScene->m_HouseObject->m_LightList[cLight]->m_fRad;
			vecObjectPos=matObjectTM.GetLoc();

			vector3 vecInter=m_vecPickRayStart-vecObjectPos;

			float fC=(vecInter*vecInter)-fRad;
			float fB=m_vecPickRayDir*(m_vecPickRayStart-vecObjectPos);

			vecObjectPos=m_vecPickRayStart-vecObjectPos;
			
			if(fB*fB-fC>=0.0f)
			{
				if(vecObjectPos.GetLens() <= fNearestInterval) 
				{
					if(PickMode==2)
					{
						m_PickLightScene=m_PickHouseScene->m_HouseObject->m_LightList[cLight];
						m_PickObjectScene=NULL;
						fNearestInterval=vecObjectPos.GetLens();
					}
				}
			}			
			//vecObjectPos=vecPickPos-vecObjectPos;
			/*
			if(vecObjectPos.GetLens() <= fNearestInterval) 
			{
				if(PickMode==2)
				{
					m_PickLightScene=m_PickHouseScene->m_HouseObject->m_LightList[cLight];
					m_PickObjectScene=NULL;
					fNearestInterval=vecObjectPos.GetLens();
				}
			}
			*/
		}		

		for(int cObject=0;cObject<m_PickHouseScene->m_HouseObject->m_ObjectList.num;cObject++)
		{
			float fRad=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject]->m_fRad;
			matObjectTM=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject]->m_TM*m_PickHouseScene->m_AccumulateTM;
			fRad=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject]->m_fRad;
			vecObjectPos=matObjectTM.GetLoc();

			vector3 vecInter=m_vecPickRayStart-vecObjectPos;

			float fC=(vecInter*vecInter)-fRad;
			float fB=m_vecPickRayDir*(m_vecPickRayStart-vecObjectPos);

			vecObjectPos=m_vecPickRayStart-vecObjectPos;
			
			if(fB*fB-fC>=0.0f)
			{
				if(vecObjectPos.GetLens() <= fNearestInterval) 
				{
					if(PickMode==2)
					{
						m_PickObjectScene=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject];
						m_PickLightScene=NULL;
						fNearestInterval=vecObjectPos.GetLens();
					}
				}
			}			

			/*
			vecObjectPos=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject]->m_TM.GetLoc();							
			vecObjectPos=vecPickPos-vecObjectPos;
			if(vecObjectPos.GetLens() <= fNearestInterval)
			{
				if(PickMode==2)
				{
					m_PickObjectScene=m_PickHouseScene->m_HouseObject->m_ObjectList[cObject];
					m_PickLightScene=NULL;
					fNearestInterval=vecObjectPos.GetLens();
				}
			}
			*/
		}
		if(fNearestInterval!=LENS_NEAR_OBJECT)
			return;
		if(PickMode==2)
			return;					
	}
	fNearestInterval=LENS_NEAR_HOUSE;
	
	for(ix=0;ix<m_HeightField.GetLSizeX();ix++)
	{
		for(iy=0;iy<m_HeightField.GetLSizeY();iy++)
		{	//picking point°¡ sector ³»ºÎÀÎÁö °Ë»ç			
			if( m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_TM._41 <= fPx &&
				m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_TM._41+SECTORSIZE > fPx &&
				m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_TM._43 <= fPz &&
				m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_TM._43+SECTORSIZE > fPz)			
			{	//³»ºÎ
				if(PickMode==1)
				{	//house list Ž»ö
					for(cObject=0;cObject<m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode.num;cObject++)
					{
						vector3 vecTargetObjectPos(
						m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode[cObject]->m_AccumulateTM._41,
						m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode[cObject]->m_AccumulateTM._42,
						m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode[cObject]->m_AccumulateTM._43);
						vecLens=vecTargetObjectPos-vecPick;
						if(	vecLens.GetLens() <= fNearestInterval)
						{	// ÇØ´çÇÏ´Â house m_PickHouseSceneÀ¸·Î º¹»ç
							m_PickHouseScene=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_HouseObjectNode[cObject];
							m_pPickSector = &(m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()]);

							m_PickObjectScene=NULL;
							fNearestInterval=vecLens.GetLens();
						}
					}
					if(fNearestInterval!=LENS_NEAR_HOUSE)
						return;
				}
				if(PickMode==2)
				{
					fNearestInterval=LENS_NEAR_OBJECT;
					for(cObject=0;cObject<m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode.num;cObject++)
					{					
						vector3 vecTargetObjectPos(
						m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode[cObject]->m_TM._41,
						m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode[cObject]->m_TM._42,
						m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode[cObject]->m_TM._43);
						vecLens=vecTargetObjectPos-vecPick;
						if(	vecLens.GetLens() <= fNearestInterval)
						{
							m_PickObjectScene=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_ObjectSceneNode[cObject];							
							m_PickHouseScene=NULL;
							m_pPickSector = &(m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()]);

							fNearestInterval=vecLens.GetLens();
						}
					}
					// object°¡ pickingµÇ¾ú´Ù¸é sound object ÀÎÁö üũ
					if( m_PickObjectScene )
					{
						if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
						{
							CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
							vector3 loc = m_PickObjectScene->m_TM.GetLoc();
							sndMap.PickAmbience( loc.x, loc.y, loc.z );
						}
			
						if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
						{
							CBGMController & BGMC = CBGMController::GetInstance();
							vector3 loc = m_PickObjectScene->m_TM.GetLoc();
							BGMC.SelectClosestPoint( loc.x, loc.y, loc.z, 10.0f );
						}
					}


					if(fNearestInterval!=LENS_NEAR_OBJECT)
						return;
				}
				/*if(PickMode == 7) {
					fNearestInterval=LENS_NEAR_OBJECT;
					for(int i=0;i<m_EffectNum;i++) {

						CX3DEffect *PickEffect = m_EffectManager.m_lstEffect[i];

						vector3 *vecTargetObjectPos = PickEffect->GetCenter();
						vecLens= (*vecTargetObjectPos) - vecPick;
						
						if(	vecLens.GetLens() <= fNearestInterval)
						{
							m_PickEffect = m_EffectManager.m_lstEffect[i];
							m_PickHouseScene=NULL;
							fNearestInterval=vecLens.GetLens();
							m_bPickEffect = TRUE;
						}
					}
					if(fNearestInterval!=LENS_NEAR_OBJECT)
						return;
				}//PickMode == 7*/
			}
		}
	}

	//m_PickEffect = NULL;
	m_PickHouseScene=NULL;
	m_PickLightScene=NULL;
	m_PickObjectScene=NULL;
	m_pPickSector = NULL;
}
void CSceneManager::PickObjectMove(float fMx, float fMy, float fMz,float fAngle,float fAddy,int MoveMode)
{
	if(m_PickLightScene)
	{
		CInHouseObjectMap *InHouseMap=m_MapStorage.FindInHouseMap(m_PickHouseScene->m_strOutName,
																  m_PickHouseScene->m_strMedName,
																  m_PickHouseScene->m_strInName,
																  m_PickHouseScene->m_strBSPName);
		if(InHouseMap==NULL)
			return;
		/*
		if(MoveMode==1)
		{
			matrix AddAngleY;
			AddAngleY.YRotation(fAngle);
			m_PickLightScene->m_TM=AddAngleY*m_PickLightScene->m_TM;			
			
			for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
			{
				if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
				{
					InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
				}
			}			
			return;
		}
		if(MoveMode==2)
		{
			m_PickLightScene->m_TM._42+=fAddy;
			for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
			{
				if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
				{
					InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
				}
			}
			return;
		}
		*/
		if(MoveMode==3)
		{
			if(KeyPressed(VK_LEFT)) m_PickLightScene->m_TM._41+=1.0f;
			if(KeyPressed(VK_RIGHT)) m_PickLightScene->m_TM._41-=1.0f;
			if(KeyPressed(VK_UP)) m_PickLightScene->m_TM._43+=1.0f;
			if(KeyPressed(VK_DOWN)) m_PickLightScene->m_TM._43-=1.0f;
			if(KeyPressed(VK_INSERT)) m_PickLightScene->m_TM._42+=1.0f;
			if(KeyPressed(VK_DELETE)) m_PickLightScene->m_TM._42-=1.0f;

			for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
			{
				if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
				{
					InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
				}
			}
			return;
		}
		/*
		matrix matTM,matInvTM;
		matTM.Translation(vector3(fMx,fMy,fMz));
		matInvTM.Inverse(m_PickHouseScene->m_AccumulateTM);		
		
		matTM=matTM*matInvTM;
		m_PickLightScene->m_TM._41=matTM._41;
		m_PickLightScene->m_TM._42=matTM._42;
		m_PickLightScene->m_TM._43=matTM._43;
		m_bIsPickObjectMoving=MOVE_LIGHT;

		for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
		{
			if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
			{
				InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
			}
		}
		*/
		return;
	}
	if(m_PickObjectScene)
	{
		if(m_PickHouseScene)
		{
			CInHouseObjectMap *InHouseMap=m_MapStorage.FindInHouseMap(m_PickHouseScene->m_strOutName,
																	  m_PickHouseScene->m_strMedName,
																	  m_PickHouseScene->m_strInName,
																	  m_PickHouseScene->m_strBSPName);
			if(InHouseMap==NULL)
				return;
			
			if(MoveMode==1)
			{
				matrix AddAngleY;
				AddAngleY.YRotation(fAngle); 

				if(KeyPressed(VK_LEFT)) fAngle=0.2f;
				if(KeyPressed(VK_RIGHT)) fAngle=-0.2f;

				m_PickObjectScene->m_TM=AddAngleY*m_PickObjectScene->m_TM;

				for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
				{
					if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
					{
						InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
					}
				}
				return;
			}
			/*
			if(MoveMode==2)
			{
				m_PickObjectScene->m_TM._42+=fAddy;

				for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
				{
					if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
					{
						InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
					}
				}

				return;
			}		
			*/
			if(MoveMode==3)
			{
				if(KeyPressed(VK_LEFT)) m_PickObjectScene->m_TM._41+=1.0f;
				if(KeyPressed(VK_RIGHT)) m_PickObjectScene->m_TM._41-=1.0f;
				if(KeyPressed(VK_UP)) m_PickObjectScene->m_TM._43+=1.0f;
				if(KeyPressed(VK_DOWN)) m_PickObjectScene->m_TM._43-=1.0f;
				if(KeyPressed(VK_INSERT)) m_PickObjectScene->m_TM._42+=1.0f;
				if(KeyPressed(VK_DELETE)) m_PickObjectScene->m_TM._42-=1.0f;


				for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
				{
					if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
					{
						InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
					}
				}
				return;
			}
			/*
			matrix matTM,matInvTM;
			matTM.Translation(vector3(fMx,fMy,fMz));
			matInvTM.Inverse(m_PickHouseScene->m_AccumulateTM);		
			matTM=matTM*matInvTM;
			m_bIsPickObjectMoving=MOVE_OBJECT;			
			m_PickObjectScene->m_TM._41=matTM._41;
			m_PickObjectScene->m_TM._42=matTM._42;
			m_PickObjectScene->m_TM._43=matTM._43;


			for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
			{
				if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
				{
					InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
				}
			}
			*/
			return;
		}
	/*	else if(m_bPickEffect) 
		{
			if(m_PickEffect == NULL) 
				return;
		
		/*	if(MoveMode == 3) 
			{
						
				CMainFrame *mf=(CMainFrame*)AfxGetApp()->m_pMainWnd;		
				CWorldCreatorView *av=(CWorldCreatorView *)mf->GetActiveView();
				
				PickMakeRay(point.x,point.y,m_BaseGraphicLayer.m_lScreenSx,m_BaseGraphicLayer.m_lScreenSy);		
				vector3 vecPos=m_SceneManager->PickPointTerrain();
			}
			
		}*/
		else 
		{	
			if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
			{
				RBspScene::RBspR3S *pPick = NULL;
				vector3 vecR3SObject =  vector3(m_PickObjectScene->m_TM._41,
												m_PickObjectScene->m_TM._42,
												m_PickObjectScene->m_TM._43);
				
				int iLeaf = m_RBspSceneManager.m_pCurrentBspScene->FindWorldLeaf(D3DXVECTOR3(vecR3SObject.x,vecR3SObject.y,vecR3SObject.z));
				pPick = m_RBspSceneManager.m_pCurrentBspScene->m_pLeafExs[iLeaf].m_pPickR3SObject;

				if(m_PickObjectScene != NULL && pPick != NULL)
				{
						
					if(MoveMode==1)
					{
						matrix AddAngleY;
						AddAngleY.YRotation(fAngle);
						m_PickObjectScene->m_TM=AddAngleY*m_PickObjectScene->m_TM;				
						//xÃà ȸÀü	
						if(KeyPressed('7'))
						{
							matrix AddAngleX;
							AddAngleX.XRotation(0.05f);
							m_PickObjectScene->m_TM=AddAngleX*m_PickObjectScene->m_TM;
						}
						if(KeyPressed('8'))
						{
							matrix AddAngleX;
							AddAngleX.XRotation(-0.05f);
							m_PickObjectScene->m_TM=AddAngleX*m_PickObjectScene->m_TM;
						}		
						//zÃà ȸÀü
						if(KeyPressed('9'))
						{
							matrix AddAngleZ;
							AddAngleZ.ZRotation(0.05f);
							m_PickObjectScene->m_TM=AddAngleZ*m_PickObjectScene->m_TM;
						}
						if(KeyPressed('0'))
						{
							matrix AddAngleZ;
							AddAngleZ.ZRotation(-0.05f);
							m_PickObjectScene->m_TM=AddAngleZ*m_PickObjectScene->m_TM;
						}	
						// ȸÀü »óź¹±Í
						if(KeyPressed('1'))
						{
							matrix AddAngle;					
							AddAngle.MakeIdent();
							AddAngle._41=m_PickObjectScene->m_TM._41;
							AddAngle._42=m_PickObjectScene->m_TM._42;
							AddAngle._43=m_PickObjectScene->m_TM._43;
							m_PickObjectScene->m_TM=AddAngle;
						}
						
						pPick->m_matTm = m_PickObjectScene->m_TM;
						
						m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
						CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->GenerateR3SObject();
						return;
					}//¼öÁ÷ À̵¿
					if(MoveMode==2)
					{
						m_PickObjectScene->m_TM._42+=fAddy;	
						pPick->m_matTm = m_PickObjectScene->m_TM;

						pPick->m_vecPos.x = pPick->m_matTm._41;
						pPick->m_vecPos.y = pPick->m_matTm._42;
						pPick->m_vecPos.z = pPick->m_matTm._43;

						m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
						CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->GenerateR3SObject();
						return;
					}// x-zÃà À̵¿
					if(MoveMode==3)
					{
						if(KeyPressed(VK_LEFT)) m_PickObjectScene->m_TM._41+=1.0f;
						if(KeyPressed(VK_RIGHT)) m_PickObjectScene->m_TM._41-=1.0f;
						if(KeyPressed(VK_UP)) m_PickObjectScene->m_TM._43+=1.0f;
						if(KeyPressed(VK_DOWN)) m_PickObjectScene->m_TM._43-=1.0f;		

						pPick->m_matTm = m_PickObjectScene->m_TM;
						
						pPick->m_vecPos.x = pPick->m_matTm._41;
						pPick->m_vecPos.y = pPick->m_matTm._42;
						pPick->m_vecPos.z = pPick->m_matTm._43;

						m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
						CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->GenerateR3SObject();
						return; 
					}
					///////
					matrix matTM,matInvTM;
					

					vector3 *vec3Camera = m_ViewCamera->GetPosition();
					D3DXVECTOR3 vecBspStart = D3DXVECTOR3(vec3Camera->x,vec3Camera->y,vec3Camera->z);
					D3DXVECTOR3 vecBspEnd = D3DXVECTOR3(fMx,fMy,fMz);
					// axis º¯È¯
					D3DXVECTOR3 vecPos = vecBspStart;
					D3DXMATRIX matTmp;
					D3DXMATRIX matInv;
				
					D3DXMatrixIdentity(&matTmp);

					matTmp._41 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
					matTmp._42 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
					matTmp._43 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
					D3DXMatrixInverse(&matInv,NULL,&matTmp);
					D3DXMatrixIdentity(&matTmp);
					matTmp._41 = vecPos.x;
					matTmp._42 = vecPos.y;
					matTmp._43 = vecPos.z;
					D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
					vecPos.x = matTmp._41;
					vecPos.y = matTmp._42;
					vecPos.z = matTmp._43;						
					vecBspStart = vecPos;

					////
					vecPos = vecBspEnd;
					D3DXMatrixIdentity(&matTmp);
					matTmp._41 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
					matTmp._42 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
					matTmp._43 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;

					D3DXMatrixInverse(&matInv,NULL,&matTmp);
					D3DXMatrixIdentity(&matTmp);
					matTmp._41 = vecPos.x;
					matTmp._42 = vecPos.y;
					matTmp._43 = vecPos.z;
					D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
					vecPos.x = matTmp._41;
					vecPos.y = matTmp._42;
					vecPos.z = matTmp._43;						
					vecBspEnd = vecPos;
					///
					/// collision check
					D3DXVECTOR3 vecBspLast = m_RBspSceneManager.m_pCurrentBspScene->CollisionPoint(vecBspStart,vecBspEnd,5.0f);
					/// world axis ·Î º¯È¯
					vecPos = vecBspLast;
					D3DXMatrixIdentity(&matTmp);
					matTmp._41 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
					matTmp._42 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
					matTmp._43 = m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
					matInv = matTmp;
					D3DXMatrixIdentity(&matTmp);
					matTmp._41 = vecPos.x;
					matTmp._42 = vecPos.y;
					matTmp._43 = vecPos.z;
					D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
					vecPos.x = matTmp._41;
					vecPos.y = matTmp._42;
					vecPos.z = matTmp._43;						
					vecBspLast = vecPos;
	
					///////
					if(vecBspLast.y <= m_PickObjectScene->m_TM._42)
						matTM.Translation(vector3(vecBspLast.x,m_PickObjectScene->m_TM._42,vecBspLast.z));
					else
						matTM.Translation(vector3(vecBspLast.x,vecBspLast.y,vecBspLast.z));
					
					m_bIsPickObjectMoving=MOVE_OBJECT;

					m_PickObjectScene->m_TM._41=matTM._41;
					m_PickObjectScene->m_TM._42=matTM._42;
					m_PickObjectScene->m_TM._43=matTM._43;
					
					/////
					pPick->m_matTm = m_PickObjectScene->m_TM;
					
					pPick->m_vecPos.x = pPick->m_matTm._41;
					pPick->m_vecPos.y = pPick->m_matTm._42;
					pPick->m_vecPos.z = pPick->m_matTm._43;


					m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
					CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->GenerateR3SObject();

					return;

				}

			}
			else 
			{
				// object mesh informain Àбâ
				CSectorMeshMap *pMapMesh=m_MapStorage.FindMeshMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
				if(pMapMesh==NULL)
					return;
	/*
				int nIndex=-1;
				CSectorSoundMap *pSoundMap=NULL;
				if(strcmp(m_PickObjectScene->m_strObjectName,"Sound.R3S")==0)
				{
					pSoundMap=m_MapStorage.FindSoundMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
					float fLens=10.0f;				
					vector3 vecLens;
					for(int i=0;i<pSoundMap->m_SoundPosList.num;i++)
					{
						vecLens=m_PickObjectScene->m_TM.GetLoc()-pSoundMap->m_SoundPosList[i];
						if(fLens>=vecLens.GetLens())
						{
							fLens=vecLens.GetLens();
							nIndex=i;
						}
					}
					if(nIndex==-1)
						return;
				}
	*/			
				//yÃà ȸÀü
				if(MoveMode==1)
				{
					matrix AddAngleY;
					AddAngleY.YRotation(fAngle);
					m_PickObjectScene->m_TM=AddAngleY*m_PickObjectScene->m_TM;				
					//xÃà ȸÀü	
					if(KeyPressed('7'))
					{
						matrix AddAngleX;
						AddAngleX.XRotation(0.05f);
						m_PickObjectScene->m_TM=AddAngleX*m_PickObjectScene->m_TM;
					}
					if(KeyPressed('8'))
					{
						matrix AddAngleX;
						AddAngleX.XRotation(-0.05f);
						m_PickObjectScene->m_TM=AddAngleX*m_PickObjectScene->m_TM;
					}		
					//zÃà ȸÀü
					if(KeyPressed('9'))
					{
						matrix AddAngleZ;
						AddAngleZ.ZRotation(0.05f);
						m_PickObjectScene->m_TM=AddAngleZ*m_PickObjectScene->m_TM;
					}
					if(KeyPressed('0'))
					{
						matrix AddAngleZ;
						AddAngleZ.ZRotation(-0.05f);
						m_PickObjectScene->m_TM=AddAngleZ*m_PickObjectScene->m_TM;
					}	
					// ȸÀü »óź¹±Í
					if(KeyPressed('1'))
					{
						matrix AddAngle;					
						AddAngle.MakeIdent();
						AddAngle._41=m_PickObjectScene->m_TM._41;
						AddAngle._42=m_PickObjectScene->m_TM._42;
						AddAngle._43=m_PickObjectScene->m_TM._43;
						m_PickObjectScene->m_TM=AddAngle;
					}
					
					for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
					{
						if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
						{
							pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;						
						}
					}

					m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
					/*
					if(pSoundMap && nIndex!=-1)
					{
						pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
						vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
						for(int i=0;i<LSIZEX*LSIZEY;i++)
						{
							if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
							{
								m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex]->SetPosition(vecPos);
								break;
							}
						}					
					}*/
					if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
					{
						CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
						vector3 loc = m_PickObjectScene->m_TM.GetLoc();
						sndMap.MoveAmbience( loc.x, loc.y, loc.z );
					}
					if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
					{
						CBGMController & BGMC = CBGMController::GetInstance();
						vector3 loc = m_PickObjectScene->m_TM.GetLoc();
						BGMC.MovePoint( loc.x, loc.y, loc.z );
					}


					return;
				}//¼öÁ÷ À̵¿
				if(MoveMode==2)
				{
					m_PickObjectScene->m_TM._42+=fAddy;				
					for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
					{
						if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
						{
							pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;
						}
					}
					m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
					/*
					if(pSoundMap && nIndex!=-1)
					{
						pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
						vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
						for(int i=0;i<LSIZEX*LSIZEY;i++)
						{
							if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
							{
								m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex]->SetPosition(vecPos);
								break;
							}
						}					
					}
					*/
					if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
					{
						CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
						vector3 loc = m_PickObjectScene->m_TM.GetLoc();
						sndMap.MoveAmbience( loc.x, loc.y, loc.z );
					}
					if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
					{
						CBGMController & BGMC = CBGMController::GetInstance();
						vector3 loc = m_PickObjectScene->m_TM.GetLoc();
						BGMC.MovePoint( loc.x, loc.y, loc.z );
					}

					return;
				}// x-zÃà À̵¿
				if(MoveMode==3)
				{
					if(KeyPressed(VK_LEFT)) m_PickObjectScene->m_TM._41+=1.0f;
					if(KeyPressed(VK_RIGHT)) m_PickObjectScene->m_TM._41-=1.0f;
					if(KeyPressed(VK_UP)) m_PickObjectScene->m_TM._43+=1.0f;
					if(KeyPressed(VK_DOWN)) m_PickObjectScene->m_TM._43-=1.0f;		

					
					for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
					{
						if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
						{
							pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;
						}
					}
					m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
					/*
					if(pSoundMap && nIndex!=-1)
					{
						pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
						vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
						for(int i=0;i<LSIZEX*LSIZEY;i++)
						{
							if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
							{
								m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex]->SetPosition(vecPos);
								break;
							}
						}					
					}
					*/
					if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
					{
						CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
						vector3 loc = m_PickObjectScene->m_TM.GetLoc();
						sndMap.MoveAmbience( loc.x, loc.y, loc.z );
					}
					if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
					{
						CBGMController & BGMC = CBGMController::GetInstance();
						vector3 loc = m_PickObjectScene->m_TM.GetLoc();
						BGMC.MovePoint( loc.x, loc.y, loc.z );
					}
					return; 
				}

				int indexx=(int)(m_PickObjectScene->m_AccumulateTM._41/SECTORSIZE);
				int indexy=(int)(m_PickObjectScene->m_AccumulateTM._43/SECTORSIZE);
			
				int newindexx=(int)(fMx/SECTORSIZE);
				int newindexy=(int)(fMz/SECTORSIZE);

				if(indexx!=newindexx || indexy!=newindexy)
					return;

				matrix matTM,matInvTM;
				matTM.Translation(vector3(fMx,fMy,fMz));
				m_bIsPickObjectMoving=MOVE_OBJECT;

				m_PickObjectScene->m_TM._41=matTM._41;
				m_PickObjectScene->m_TM._42=matTM._42;
				m_PickObjectScene->m_TM._43=matTM._43;

				for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
				{
					if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
					{
						pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;						
					}
				}
				m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
				/*
				if(pSoundMap && nIndex!=-1)
				{
					pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
					vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
					for(int i=0;i<LSIZEX*LSIZEY;i++)
					{
						if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
						{
							m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex]->SetPosition(vecPos);
							break;
						}
					}					
				}*/
				if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
				{
					CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
					vector3 loc = m_PickObjectScene->m_TM.GetLoc();
					sndMap.MoveAmbience( loc.x, loc.y, loc.z );
				}
				if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
				{
					CBGMController & BGMC = CBGMController::GetInstance();
					vector3 loc = m_PickObjectScene->m_TM.GetLoc();
					BGMC.MovePoint( loc.x, loc.y, loc.z );
				}
				return;
			}
			///////dfgdfgsdrgserg
		}
	}
	if(m_PickHouseScene)
	{			
		if(MoveMode==1)
		{
			float fSaveX,fSaveY,fSaveZ;
			CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
																	  m_PickHouseScene->m_AccumulateTM._43);
			if(SectorHouseMap)
			{
				fSaveX=m_PickHouseScene->m_AccumulateTM._41;
				fSaveY=m_PickHouseScene->m_AccumulateTM._42;
				fSaveZ=m_PickHouseScene->m_AccumulateTM._43;
				m_PickHouseScene->m_AccumulateTM._41=0.0f;
				m_PickHouseScene->m_AccumulateTM._42=0.0f;
				m_PickHouseScene->m_AccumulateTM._43=0.0f;
				matrix AddAngleY;
				AddAngleY.YRotation(fAngle);
				m_PickHouseScene->m_AccumulateTM=m_PickHouseScene->m_AccumulateTM*AddAngleY;
				m_PickHouseScene->m_AccumulateTM._41=fSaveX;
				m_PickHouseScene->m_AccumulateTM._42=fSaveY;
				m_PickHouseScene->m_AccumulateTM._43=fSaveZ;
				for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
				{					
					if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
					{
						SectorHouseMap->m_TM[cObject]=m_PickHouseScene->m_AccumulateTM;						
					}					
				}
			}
			return;
		}
		if(MoveMode==2)
		{
			CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
																	  m_PickHouseScene->m_AccumulateTM._43);
			if(SectorHouseMap)
			{
				for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
				{					
					if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
					{
						m_PickHouseScene->m_AccumulateTM._42+=fAddy;
						SectorHouseMap->m_TM[cObject]=m_PickHouseScene->m_AccumulateTM;						
					}
				}						
			}
			return;
		}		
		if(MoveMode==3)
		{	
			CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
																	  m_PickHouseScene->m_AccumulateTM._43);
			if(SectorHouseMap)
			{
				for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
				{					
					if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
					{
						if(KeyPressed(VK_LEFT)) m_PickHouseScene->m_AccumulateTM._41+=1.0f;
						if(KeyPressed(VK_RIGHT)) m_PickHouseScene->m_AccumulateTM._41-=1.0f;
						if(KeyPressed(VK_UP)) m_PickHouseScene->m_AccumulateTM._43+=1.0f;
						if(KeyPressed(VK_DOWN)) m_PickHouseScene->m_AccumulateTM._43-=1.0f;					

						SectorHouseMap->m_TM[cObject]=m_PickHouseScene->m_AccumulateTM;						
					}
				}						
			}						
			return;
		}
		int indexx=(int)(m_PickHouseScene->m_AccumulateTM._41/SECTORSIZE);
		int indexy=(int)(m_PickHouseScene->m_AccumulateTM._43/SECTORSIZE);
		
		int newindexx=(int)(fMx/SECTORSIZE);
		int newindexy=(int)(fMz/SECTORSIZE);		
		
		CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
																  m_PickHouseScene->m_AccumulateTM._43);
		
		if(SectorHouseMap && newindexx==indexx && newindexy==indexy)
		{
			for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
			{				
				if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
				{
					SectorHouseMap->m_TM[cObject]._41=fMx;
					SectorHouseMap->m_TM[cObject]._42=fMy;
					SectorHouseMap->m_TM[cObject]._43=fMz;
				}
				m_PickHouseScene->m_AccumulateTM._41=fMx;
				m_PickHouseScene->m_AccumulateTM._42=fMy;
				m_PickHouseScene->m_AccumulateTM._43=fMz;
			}
		}
		m_bIsPickObjectMoving=MOVE_HOUSE;				
	}


}

void CSceneManager::CalculateLightmap(int LightmapMode)
{
	if(m_PickHouseScene)
	{
		matrix mat;
		mat=m_PickHouseScene->m_AccumulateTM;
		
		D3DXMATRIX d3dmat;
		d3dmat._11  = mat._11;
		d3dmat._12  = mat._12;
		d3dmat._13  = mat._13;
		d3dmat._14  = mat._14;

		d3dmat._21  = mat._21;
		d3dmat._22  = mat._22;
		d3dmat._23  = mat._23;
		d3dmat._24  = mat._24;

		d3dmat._31  = mat._31;
		d3dmat._32  = mat._32;
		d3dmat._33  = mat._33;
		d3dmat._34  = mat._34;

		d3dmat._41  = mat._41;
		d3dmat._42  = mat._42;
		d3dmat._43  = mat._43;
		d3dmat._44  = mat._44;

		int indexx=(int)(d3dmat._41/SECTORSIZE);
		int indexy=(int)(d3dmat._43/SECTORSIZE);

		CSectorLightManager *pLightManager = NULL;
		for(int ix=0;ix<m_HeightField.GetLSizeX();ix++)
		{
			for(int iy=0;iy<m_HeightField.GetLSizeY();iy++)
			{
				if((m_HeightField.m_SectorScene[ix+iy*(m_HeightField.GetLSizeX())].m_SectorLightManager.m_IndexX == indexx) &&
					(m_HeightField.m_SectorScene[ix+iy*(m_HeightField.GetLSizeX())].m_SectorLightManager.m_IndexY == indexy))
						pLightManager = &(m_HeightField.m_SectorScene[ix+iy*(m_HeightField.GetLSizeX())].m_SectorLightManager);
			}
		}
		
		vector3 vecMin;
		vector3 vecMax;
		
		m_PickHouseScene->m_HouseObject->CalcBox(vecMin,vecMax);

		if(pLightManager == NULL) {
		//	MessageBox(NULL,"Light °¡ ¾ø½À´Ï´Ù.","error",MB_OK);
		//	return;
		}
		else
		{

			pLightManager->SelectLight(D3DXVECTOR3(vecMin.x,vecMin.y,vecMin.z),D3DXVECTOR3(vecMax.x,vecMax.y,vecMax.z),d3dmat);

		}

	

/*			D3DXMATRIX box;
	
		// Min
		D3DXMatrixIdentity(&box);
		
		box._41 = vecMin.x;
		box._42 = vecMin.y;
		box._43 = vecMin.z;
		
		D3DXMatrixMultiply(&box,&box,&d3dmat);
		
		vecMin.x = box._41;
		vecMin.y = box._42;
		vecMin.z = box._43;
		// max
		D3DXMatrixIdentity(&box);
		
		box._41 = vecMax.x;
		box._42 = vecMax.y;
		box._43 = vecMax.z;
		
		D3DXMatrixMultiply(&box,&box,&d3dmat);
		
		vecMax.x = box._41;
		vecMax.y = box._42;
		vecMax.z = box._43;
*/			
		


		if(LightmapMode == 2)	// ¹ã¿ë lightmap generator
		{
			
			if(pLightManager)
				m_PickHouseScene->m_HouseObject->GenerateCaldronPointLightmap(mat,m_PickHouseScene->m_AccumulateTM,pLightManager->m_pSelectLights,pLightManager->m_iSelectLights);
			else
				m_PickHouseScene->m_HouseObject->GenerateCaldronPointLightmap(mat,m_PickHouseScene->m_AccumulateTM,NULL,0);
			if(m_PickHouseScene->m_HouseObject->m_pInHouseObject)
			{
				m_PickHouseScene->m_HouseObject->m_pInHouseObject->MeshReload();
				char strTextureName[256];
					
				sprintf(strTextureName,"%s",m_PickHouseScene->m_strInName);
					
				m_PickHouseScene->m_HouseObject->m_isHaveInLightmap = true;
				m_PickHouseScene->m_HouseObject->m_InLightmap.Unload();
				m_PickHouseScene->m_HouseObject->m_InLightmap.SetPath(LIGHTMAPTEXTUREPATH);
				m_PickHouseScene->m_HouseObject->m_InLightmap.LoadNotCache(strTextureName);
				
				m_PickHouseScene->m_HouseObject->m_nIndices.num=0;
			}

		/*	switch(MessageBox(NULL,"lightmap ¿À·ù ¼öÁ¤(Æò¼Ò¿¡´Â No ÇϽÿÀ. ¶óÀÌÆ® ¸Ê¿¡ ¿¡·¯ÀÖÀ» ½Ã¸¸ »ç¿ë)?","¼±ÅÃ",MB_YESNO))
			{
			case IDNO:

				m_PickHouseScene->m_HouseObject->GenerateNewLightmap(0,mat,m_PickHouseScene->m_AccumulateTM,pLightManager->m_pSelectLights,pLightManager->m_iSelectLights);
			
				break;
			case IDYES:

				m_PickHouseScene->m_HouseObject->GenerateNewLightmap(1,mat,m_PickHouseScene->m_AccumulateTM,pLightManager->m_pSelectLights,pLightManager->m_iSelectLights);
			
				break;
			}
			*/
			/*
			CConvertTexture ConvertTexture;
			ConvertTexture.m_pddTexture=m_PickHouseScene->m_HouseObject->m_BackupLightmap.GetTexture();
			ConvertTexture.m_dwHeight=m_PickHouseScene->m_HouseObject->m_BackupLightmap.m_dwHeight;
			ConvertTexture.m_dwWidth=m_PickHouseScene->m_HouseObject->m_BackupLightmap.m_dwWidth;
			ConvertTexture.GenerateMipMaps(true);
			ConvertTexture.m_pddTexture=ConvertTexture.m_pddNewTexture;
			ConvertTexture.m_pddNewTexture=NULL;
			ConvertTexture.Compress(D3DFMT_DXT3);
			char strDDSName[MAX_NAMEBUFFER];
			char strNewName[MAX_NAMEBUFFER];
			memset(strNewName,0,sizeof(char) * MAX_NAMEBUFFER);
			strcpy(strNewName,m_PickHouseScene->m_strOutName);
			char *ptr = strrchr(strNewName,'.');
			*(ptr++) = '_';
			*(ptr++) = 'N';
			*(ptr++) = '.';
			*(ptr++) = 'D';
			*(ptr++) = 'D';
			*(ptr++) = 'S';

			sprintf(strDDSName,"%s\\%s",LIGHTMAPTEXTUREPATH,strNewName);
	
			ConvertTexture.SaveDDS(strDDSName);


			if(m_PickHouseScene->m_HouseObject->m_pOutHouseObject)		
			{	
				char HouseMeshObjectPath[MAX_NAMEBUFFER] = {0};
				FILE *fp = NULL;

				sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strOutName);			
				int iLength = strlen(HouseMeshObjectPath);
				HouseMeshObjectPath[iLength - 1] = '\0';
				HouseMeshObjectPath[iLength - 2] = 'v';
				HouseMeshObjectPath[iLength - 3] = 'u';
				
				fp = fopen(HouseMeshObjectPath,"wb");
				m_PickHouseScene->m_HouseObject->m_pOutHouseObject->AllLockBuffer();

				fwrite((int *)&(m_PickHouseScene->m_HouseObject->m_pOutHouseObject->m_pVertexBuffer.num),sizeof(int),1,fp);

				for(int i=0;i<m_PickHouseScene->m_HouseObject->m_pOutHouseObject->m_pVertexBuffer.num;i++)
				{
					int iNum  = m_PickHouseScene->m_HouseObject->m_pOutHouseObject->m_nVertex[i];
					fwrite((int *)&(iNum),sizeof(int),1,fp);
					fwrite((m_PickHouseScene->m_HouseObject->m_pBackupVertex[i]),sizeof(MultiVertex)*(m_PickHouseScene->m_HouseObject->m_pOutHouseObject->m_nVertex[i]),1,fp);
				}
				
				m_PickHouseScene->m_HouseObject->m_pOutHouseObject->AllUnlockBuffer();
				m_PickHouseScene->m_HouseObject->m_bConvertNight = false;
				m_PickHouseScene->m_HouseObject->m_bNightUv = true;
				m_PickHouseScene->m_HouseObject->m_bNightMap = true;
				fclose(fp);


			
				
			}*/
			/*if(m_PickHouseScene->m_HouseObject->m_pMedHouseObject)
			{
				sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strMedName);
				m_PickHouseScene->m_HouseObject->m_pMedHouseObject->Save(HouseMeshObjectPath);
			}
			if(m_PickHouseScene->m_HouseObject->m_pInHouseObject)
			{
				sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strInName);
				m_PickHouseScene->m_HouseObject->m_pInHouseObject->Save(HouseMeshObjectPath);
			}*/

			
		}
		else {
			mat._43=mat._42=mat._41=0.0f;
			if(pLightManager)
				m_PickHouseScene->m_HouseObject->GenerateCaldronLightmap(mat,m_PickHouseScene->m_AccumulateTM,pLightManager->m_pSelectLights,pLightManager->m_iSelectLights);
			else
				m_PickHouseScene->m_HouseObject->GenerateCaldronLightmap(mat,m_PickHouseScene->m_AccumulateTM,NULL,0);
			if(m_PickHouseScene->m_HouseObject->m_pOutHouseObject)
			{
				m_PickHouseScene->m_HouseObject->m_pOutHouseObject->MeshReload();
				char strTextureName[256];
					
				sprintf(strTextureName,"%s",m_PickHouseScene->m_strOutName);
					
				m_PickHouseScene->m_HouseObject->m_isHaveLightmap = true;
				m_PickHouseScene->m_HouseObject->m_Lightmap.Unload();
				m_PickHouseScene->m_HouseObject->m_Lightmap.SetPath(LIGHTMAPTEXTUREPATH);
				m_PickHouseScene->m_HouseObject->m_Lightmap.LoadNotCache(strTextureName);
				
				m_PickHouseScene->m_HouseObject->m_nIndices.num=0;
			}
			if(m_PickHouseScene->m_HouseObject->m_pMedHouseObject)
			{
				m_PickHouseScene->m_HouseObject->m_pMedHouseObject->MeshReload();
			}
			/*m_PickHouseScene->m_HouseObject->GenerateLightmap(mat,m_PickHouseScene->m_AccumulateTM,LightmapMode);
			
			char HouseMeshObjectPath[MAX_NAMEBUFFER];
			
			if(m_PickHouseScene->m_HouseObject->m_pOutHouseObject)		
			{			
				sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strOutName);			
				m_PickHouseScene->m_HouseObject->m_pOutHouseObject->Save(HouseMeshObjectPath);
				
			}
			if(m_PickHouseScene->m_HouseObject->m_pMedHouseObject)
			{
				sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strMedName);
				m_PickHouseScene->m_HouseObject->m_pMedHouseObject->Save(HouseMeshObjectPath);
			}
			if(m_PickHouseScene->m_HouseObject->m_pInHouseObject)
			{
				sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_PickHouseScene->m_strInName);
				m_PickHouseScene->m_HouseObject->m_pInHouseObject->Save(HouseMeshObjectPath);
			}
			CConvertTexture ConvertTexture;
			ConvertTexture.m_pddTexture=m_PickHouseScene->m_HouseObject->m_Lightmap.GetTexture();
			ConvertTexture.m_dwHeight=m_PickHouseScene->m_HouseObject->m_Lightmap.m_dwHeight;
			ConvertTexture.m_dwWidth=m_PickHouseScene->m_HouseObject->m_Lightmap.m_dwWidth;
			ConvertTexture.GenerateMipMaps(true);
			ConvertTexture.m_pddTexture=ConvertTexture.m_pddNewTexture;
			ConvertTexture.m_pddNewTexture=NULL;
			ConvertTexture.Compress(D3DFMT_DXT3);
			char strDDSName[MAX_NAMEBUFFER];
			sprintf(strDDSName,"%s\\%s",LIGHTMAPTEXTUREPATH,m_PickHouseScene->m_strOutName);
			strDDSName[strlen(strDDSName)-1]='S';
			strDDSName[strlen(strDDSName)-2]='D';
			strDDSName[strlen(strDDSName)-3]='D';
			ConvertTexture.SaveDDS(strDDSName);
			*/
			
		}
		/*
		CConvertTexture ConvertTexture;
		ConvertTexture.Init(m_pd3dDevice);
		ConvertTexture.m_ptexOrig=m_PickHouseScene->m_HouseObject->m_Lightmap.GetTexture();
		ConvertTexture.m_dwHeight=m_PickHouseScene->m_HouseObject->m_Lightmap.m_dwHeight;
		ConvertTexture.m_dwWidth=m_PickHouseScene->m_HouseObject->m_Lightmap.m_dwWidth;
		ConvertTexture.Compress(D3DFMT_DXT3);
		ConvertTexture.GenerateMipMaps();
		char strDDSName[MAX_NAMEBUFFER];
		sprintf(strDDSName,"%s\\%s",LIGHTMAPTEXTUREPATH,m_PickHouseScene->m_strOutName);
		strDDSName[strlen(strDDSName)-1]='S';
		strDDSName[strlen(strDDSName)-2]='D';
		strDDSName[strlen(strDDSName)-3]='D';
		ConvertTexture.SaveDDS(ConvertTexture.m_ptexNew,strDDSName);
		*/
	}
}

void CSceneManager::CalculateOctree()
{
	if(m_PickHouseScene)
	{
		m_PickHouseScene->m_HouseObject->GenerateOctree();

		FILE *fp;
		char strOctreeFilename[MAX_NAMEBUFFER];
		sprintf(strOctreeFilename,"%s\\%s",OCTREEPATH,m_PickHouseScene->m_strOutName);		

		strOctreeFilename[strlen(strOctreeFilename)-1]='T';
		strOctreeFilename[strlen(strOctreeFilename)-2]='C';
		strOctreeFilename[strlen(strOctreeFilename)-3]='O';

		fp=fopen(strOctreeFilename,"wb");
		//m_PickHouseScene->m_HouseObject->m_pOctree->m_pOctree->Save(fp);
		m_PickHouseScene->m_HouseObject->m_pOctree->Save(fp);
		fclose(fp);
	}
}

void CSceneManager::DeleteAllData()
{
//	m_HeightField.Destroy();

	//=============
	// Glare Test 
	//=============	
	m_GlareManager->Destroy(); 

	for(int ix=0;ix<m_HeightField.GetLSizeX();ix++)
	{
		for(int iy=0;iy<m_HeightField.GetLSizeX();iy++)
		{
			m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].UnloadAllData();
		}
	}
	m_MapStorage.DeleteAllData();

}

CSectorScene* CSceneManager::PickTerrain(float fXp, float fYp, float fZp)
{
	int ix,iy;
	for(ix=0;ix<m_HeightField.GetLSizeX();ix++)
	{
		for(iy=0;iy<m_HeightField.GetLSizeX();iy++)
		{
			if( m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41 <= fXp &&
				m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41 + SECTORSIZE > fXp &&
				m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43 <= fZp &&
				m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43 + SECTORSIZE > fZp)
			{
				return &m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()];
			}
			
		}
	}
	return NULL;
}

void CSceneManager::DeletePickingObject()
{
	if(m_PickObjectScene)
	{	
		if(m_PickHouseScene)
		{
			int HouseSceneID=m_PickHouseScene->m_HouseSceneID;

			
			m_MapStorage.DelInHouseObject(m_PickHouseScene->m_strOutName,
										 m_PickHouseScene->m_strMedName,
										 m_PickHouseScene->m_strInName,
										 m_PickObjectScene->m_ObjectID);
			
			int delindexx=m_PickHouseScene->m_AccumulateTM._41/SECTORSIZE;
			int delindexy=m_PickHouseScene->m_AccumulateTM._43/SECTORSIZE;
			
			for(int i=0;i<m_PickHouseScene->m_HouseObject->m_ObjectList.num;i++)
			{
				if( m_PickHouseScene->m_HouseObject->m_ObjectList[i]->m_ObjectID==
					m_PickObjectScene->m_ObjectID )
				{
					delete m_PickHouseScene->m_HouseObject->m_ObjectList[i];
					m_PickHouseScene->m_HouseObject->m_ObjectList.DelIndex(i);
				}

			}
			 /*
			m_PickHouseScene=NULL;			
			for(int cSector=0;cSector<LSIZEX*LSIZEY;cSector++)
			{
				sectorindexx=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
				sectorindexy=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
				if( delindexx == sectorindexx && delindexy == sectorindexy)
				{
					m_HeightField.m_SectorScene[cSector].GenerateHouseObject();					
					for(int cHouse=0;cHouse<m_HeightField.m_SectorScene[cSector].m_HouseObjectNode.num;cHouse++)
					{
						if(HouseSceneID==m_HeightField.m_SectorScene[cSector].m_HouseObjectNode[cHouse]->m_HouseSceneID)
						{
							m_PickHouseScene=m_HeightField.m_SectorScene[cSector].m_HouseObjectNode[cHouse];
							
						}
					}
				}
			}
			m_PickObjectScene=NULL;
			*/
			m_PickObjectScene=NULL;
		}
		else
		{	
			if(m_RBspSceneManager.m_pCurrentBspScene == NULL)
			{
				/*
				CSectorSoundMap *pSoundMap=NULL;
				int nIndex=-1;
				if(strcmp(m_PickObjectScene->m_strObjectName,"Sound.R3S")==0)
				{
					pSoundMap=m_MapStorage.FindSoundMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
					float fLens=10.0f;
					vector3 vecLens;
					for(int i=0;i<pSoundMap->m_SoundPosList.num;i++)
					{
						vecLens=m_PickObjectScene->m_TM.GetLoc()-pSoundMap->m_SoundPosList[i];
						if(fLens>=vecLens.GetLens())
						{
							fLens=vecLens.GetLens();
							nIndex=i;
						}
					}
					if(nIndex==-1)
						return;
				}
				if(pSoundMap && nIndex!=-1)
				{
					pSoundMap->m_SoundPosList[nIndex]=m_PickObjectScene->m_TM.GetLoc();
					pSoundMap->m_SoundPosList.DelIndex(nIndex);
					pSoundMap->m_SoundMinRangeList.DelIndex(nIndex);
					pSoundMap->m_SoundMaxRangeList.DelIndex(nIndex);
					delete [] pSoundMap->m_strSoundFilenameList[nIndex];
					pSoundMap->m_strSoundFilenameList.DelIndex(nIndex);

					vector3 vecPos=m_PickObjectScene->m_TM.GetLoc();
					for(int i=0;i<LSIZEX*LSIZEY;i++)
					{
						if(m_HeightField.m_SectorScene[i].m_MapSound==pSoundMap)
						{
							delete m_HeightField.m_SectorScene[i].m_SoundObjectNode[nIndex];
							m_HeightField.m_SectorScene[i].m_SoundObjectNode.DelIndex(nIndex);
							break;
						}
					}					
				}			
				*/
				if( strcmp( m_PickObjectScene->m_strObjectName, "Sound.R3S" ) == 0 )
				{
					CSectorSoundMap & sndMap = CSectorSoundMap::GetInstance();
					vector3 loc = m_PickObjectScene->m_TM.GetLoc();
					sndMap.DeleteAmbience( loc.x, loc.y, loc.z );
				}

				if( strcmp( m_PickObjectScene->m_strObjectName, "Cube.R3S" ) == 0 )
				{
					try 
					{
						CBGMController & BGMC = CBGMController::GetInstance();
						vector3 loc = m_PickObjectScene->m_TM.GetLoc();
						BGMC.DeletePoint();
					}
					catch( exception & e )
					{
						MessageBox( NULL, e.what(), "Error!!", MB_OK );
						return;
					}
				}

				m_MapStorage.DelMeshMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._42,m_PickObjectScene->m_TM._43,
										m_PickObjectScene->m_ObjectID);

				int delindexx=m_PickObjectScene->m_TM._41/SECTORSIZE;
				int delindexy=m_PickObjectScene->m_TM._43/SECTORSIZE;
				m_HeightField.GenerateSectorSceneObjects( delindexx, delindexy );

				m_PickObjectScene=NULL;

				/*
				CSectorMeshMap *pMapMesh=CMapStorage::FindMeshMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
				if(pMapMesh==NULL)
					return;

				if(MoveMode==1)
				{
					matrix AddAngleY;
					AddAngleY.YRotation(fAngle);
					m_PickObjectScene->m_TM=AddAngleY*m_PickObjectScene->m_TM;				
					for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
					{
						if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
						{
							pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;						
						}
					}
				
					return;
				}
				*/
			}	// if(m_RBspSceneManager.m_pCurrentBspScene == NULL)
			else
			{
				RBspScene *pScene = m_RBspSceneManager.m_pCurrentBspScene;

				D3DXVECTOR3 vecR3SCenter = D3DXVECTOR3(m_PickObjectScene->m_TM._41,
														m_PickObjectScene->m_TM._42,
														m_PickObjectScene->m_TM._43);

				int iLeaf = pScene->FindWorldLeaf(vecR3SCenter);
				pScene->m_pLeafExs[iLeaf].DeletePickR3SObject();
				pScene->GenerateR3SObject();
				m_PickObjectScene=NULL;
			}
		}
		return;
	}
	if(m_PickLightScene)
	{
		if(m_PickHouseScene==NULL)
			return;
		int HouseSceneID=m_PickHouseScene->m_HouseSceneID;
		m_MapStorage.DelInHouseLight(m_PickHouseScene->m_strOutName,
									 m_PickHouseScene->m_strMedName,
									 m_PickHouseScene->m_strInName,
									 m_PickLightScene->m_LightID);

		for(int i=0;i<m_PickHouseScene->m_HouseObject->m_LightList.num;i++)
		{
			if( m_PickHouseScene->m_HouseObject->m_LightList[i]->m_LightID==
				m_PickLightScene->m_LightID )
			{
				delete m_PickHouseScene->m_HouseObject->m_LightList[i];
				m_PickHouseScene->m_HouseObject->m_LightList.DelIndex(i);
			}
		}
		m_PickLightScene=NULL;
		/*
		int delindexx=m_PickHouseScene->m_AccumulateTM._41/SECTORSIZE;
		int delindexy=m_PickHouseScene->m_AccumulateTM._43/SECTORSIZE;

		int sectorindexx,sectorindexy;
		for(int cSector=0;cSector<LSIZEX*LSIZEY;cSector++)
		{
			sectorindexx=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
			sectorindexy=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
			if( delindexx == sectorindexx && delindexy == sectorindexy)
			{
				m_HeightField.m_SectorScene[cSector].GenerateHouseObject();
				for(int cHouse=0;cHouse<m_HeightField.m_SectorScene[cSector].m_HouseObjectNode.num;cHouse++)
				{
					if(HouseSceneID==m_HeightField.m_SectorScene[cSector].m_HouseObjectNode[cHouse]->m_HouseSceneID)
					{
						m_PickHouseScene=m_HeightField.m_SectorScene[cSector].m_HouseObjectNode[cHouse];
					}
				}
			}
		}
		*/
		return;
	}
	if(m_PickHouseScene)
	{	
		int delindexx=m_PickHouseScene->m_AccumulateTM._41/SECTORSIZE;
		int delindexy=m_PickHouseScene->m_AccumulateTM._43/SECTORSIZE;

		m_MapStorage.DelHouseMap(m_PickHouseScene->m_AccumulateTM._41,
									 m_PickHouseScene->m_AccumulateTM._42,
									 m_PickHouseScene->m_AccumulateTM._43,
									 m_PickHouseScene->m_HouseSceneID);

		m_PickHouseScene=NULL;		
		int sectorindexx,sectorindexy;
		for(int cSector=0;cSector<m_HeightField.GetLSizeX()*m_HeightField.GetLSizeY();cSector++)
		{
			sectorindexx=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
			sectorindexy=m_HeightField.m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
			if( delindexx == sectorindexx && delindexy == sectorindexy)
			{
				m_HeightField.m_SectorScene[cSector].GenerateHouseObject();
			}
		}
		return;
	}
}
	
CZ3DGeneralChrModel* CSceneManager::AddCharacter( const char* szGCMDSName, const char* szFaceType, const char* szHairStyle )
{
	return m_CharacterManager.AddCharacter(szGCMDSName, szFaceType, szHairStyle);
}

void CSceneManager::Undo()
{
	matrix matUndoData=m_matUndo;
	MakeUndoData();
	if(m_PickLightScene)
	{
		m_PickLightScene->m_TM=matUndoData;
		CInHouseObjectMap *InHouseMap=m_MapStorage.FindInHouseMap(m_PickHouseScene->m_strOutName,
																  m_PickHouseScene->m_strMedName,
																  m_PickHouseScene->m_strInName,
																  m_PickHouseScene->m_strBSPName);				
		for(int cLight=0;cLight<InHouseMap->m_LightID.num;cLight++)
		{
			if(m_PickLightScene->m_LightID==InHouseMap->m_LightID[cLight])
			{
				InHouseMap->m_matLightList[cLight]=m_PickLightScene->m_TM;
			}
		}
		return;
	}
	if(m_PickObjectScene)
	{
		if(m_PickHouseScene)
		{
			m_PickObjectScene->m_TM=matUndoData;
			CInHouseObjectMap *InHouseMap=m_MapStorage.FindInHouseMap(m_PickHouseScene->m_strOutName,
																	  m_PickHouseScene->m_strMedName,
																	  m_PickHouseScene->m_strInName,
																	  m_PickHouseScene->m_strBSPName);
			for(int cObject=0;cObject<InHouseMap->m_ObjectID.num;cObject++)
			{
				if(m_PickObjectScene->m_ObjectID==InHouseMap->m_ObjectID[cObject])
				{
					InHouseMap->m_matObjectList[cObject]=m_PickObjectScene->m_TM;
				}
			}
			return;
		}
		else
		{			
			m_PickObjectScene->m_TM=matUndoData;
			CSectorMeshMap *pMapMesh=m_MapStorage.FindMeshMap(m_PickObjectScene->m_TM._41,m_PickObjectScene->m_TM._43);
			if(pMapMesh==NULL)
				return;
			for(int cObject=0;cObject<pMapMesh->m_ObjectSceneID.num;cObject++)
			{
				if(pMapMesh->m_ObjectSceneID[cObject]==m_PickObjectScene->m_ObjectID)
				{
					pMapMesh->m_TM[cObject]=m_PickObjectScene->m_TM;		
				}
			}
			m_PickObjectScene->m_AccumulateTM=m_PickObjectScene->m_TM;
			return;
		}
	}
	if(m_PickHouseScene)
	{			
		CSectorHouseMap *SectorHouseMap=m_MapStorage.FindHouseMap(m_PickHouseScene->m_AccumulateTM._41,
																  m_PickHouseScene->m_AccumulateTM._43);
		m_PickHouseScene->m_AccumulateTM=matUndoData;
		for(int cObject=0;cObject<SectorHouseMap->m_TM.num;cObject++)
		{
			if( SectorHouseMap->m_HouseSceneID[cObject] == m_PickHouseScene->m_HouseSceneID )
			{
				SectorHouseMap->m_TM[cObject]=matUndoData;
			}
		}
	}
}

void CSceneManager::MakeUndoData()
{
	if(m_PickLightScene)
	{
		m_matUndo=m_PickLightScene->m_TM;
	}
	if(m_PickObjectScene)
	{	
		m_matUndo=m_PickObjectScene->m_TM;
	}
	if(m_PickHouseScene && m_PickLightScene==NULL && m_PickObjectScene==NULL)
	{
		m_matUndo=m_PickHouseScene->m_AccumulateTM;
	}
}

void CSceneManager::Create(CInitValue initValue,char *strPath)
{		
	/*
	CRenderOption::m_GrassRendering=1;
	CRenderOption::m_GrassAnimationUseVertexShader=1;
	CRenderOption::m_GrassRenderRange=9;
	CRenderOption::m_RangeGrassRender=0

	CRenderOption::m_FullSceneGlare=1;
	CRenderOption::m_FullSceneAnti=0;
	CRenderOption::m_FullSceneSpecularGlare=1;

	CRenderOption::m_WaterBumpEnvRendering=1;	

	CRenderOption::m_TerrainMultiDetalTexture=1;

	CRenderOption::m_TerrainRange=7;

	CRenderOption::m_BuildingLightmap=1;

	CRenderOption::m_TreeAnimation=1;

	CRenderOption::m_CharacterPerPixelLighting=1;
	CRenderOption::m_CharacterPerPixelSpecularLighting=1;
	CRenderOption::m_CharacterSelfShadow=1;

	CRenderOption::m_DepthOfField=0;
	CRenderOption::m_CharacterProjectShadowTerrain=1;
	CRenderOption::m_CharacterProjectShadowBuilding=1;

	CRenderOption::m_ObjectLOD=4;
	CRenderOption::m_TextureMethod=1;
	CRenderOption::m_strBaseGraphicsDataPath[256];

	CRenderOption::m_ObjectProjectShadow=1;
	CRenderOption::m_TreeProjectShadow=1;
	CRenderOption::m_AllObjectBump=1;
	*/
	CRenderOption::m_AllObjectBump=0;

	CRenderOption::m_ObjectProjectShadow=0;
	CRenderOption::m_TreeProjectShadow=0;
	
	m_bEditor=false;	
	/*
	m_DetailCharShadow=initValue.m_CharShadow;
	m_DetailMapShadow=initValue.m_MapShadow;
	m_DetailBuildShadow=initValue.m_BuildShadow;
	m_DetailTerrain=initValue.m_TerrainDetail;
	m_DetailChrMesh=initValue.m_CharDetail;
	m_DetailViewRange=initValue.m_ViewRange;
	m_DetailWaterReflection=initValue.m_WaterReflection;
	m_DetailLensflare=initValue.m_Lensflare;
	m_DetailTreeDetail=initValue.m_TreeDetail;
	*/
	DETAILGROUND=25;

	switch(CRenderOption::m_ObjectLOD)
	{
		case 0:
			MAX_HOUSEVIEWRANGE=16000.0f;
			MAX_HOUSEDISAPPER=MAX_HOUSEVIEWRANGE-1000.0f;
			MAX_OUTVIEWRANGE=15000.0f;
			MAX_MEDVIEWRANGE=15000.0f;
			MAX_INVIEWRANGE=3000.0f;			
			MAX_OBJECTVIEWRANBE=5000.0f; 
			MAX_OBJECTDISAPPER=MAX_OBJECTVIEWRANBE-400.0f;
			LENS_REALPOLYTREE=5000.0f;
			break;
		case 1:
			MAX_HOUSEVIEWRANGE=30000.0f;
			MAX_HOUSEDISAPPER=MAX_HOUSEVIEWRANGE-2000.0f;
			MAX_OUTVIEWRANGE=15000.0f;
			MAX_MEDVIEWRANGE=15000.0f;
			MAX_INVIEWRANGE=3000.0f;
			MAX_OBJECTVIEWRANBE=5000.0f;
			MAX_OBJECTDISAPPER=MAX_OBJECTVIEWRANBE-1000.0f;
			LENS_REALPOLYTREE=8000.0f;
			break;
		case 2:
			MAX_HOUSEVIEWRANGE=60000.0f;
			MAX_HOUSEDISAPPER=MAX_HOUSEVIEWRANGE-3000.0f;
			MAX_OUTVIEWRANGE=15000.0f;
			MAX_MEDVIEWRANGE=15000.0f;
			MAX_INVIEWRANGE=3000.0f;
			MAX_OBJECTVIEWRANBE=5000.0f;
			MAX_OBJECTDISAPPER=MAX_OBJECTVIEWRANBE-1000.0f;
			LENS_REALPOLYTREE=10000.0f;
			break;
		case 3:
			MAX_HOUSEVIEWRANGE=80000.0f;
			MAX_HOUSEDISAPPER=MAX_HOUSEVIEWRANGE-4000.0f;
			MAX_OUTVIEWRANGE=15000.0f;
			MAX_MEDVIEWRANGE=15000.0f;
			MAX_INVIEWRANGE=3000.0f;
			MAX_OBJECTVIEWRANBE=10000.0f;
			MAX_OBJECTDISAPPER=MAX_OBJECTVIEWRANBE-1000.0f;
			LENS_REALPOLYTREE=12000.0f;
			break;
	}	
	//LogMessage(strPath);	
	/*
	char strNsTexturePath[256];
	
	sprintf(strNsTexturePath,"%s\\Texture\\Interface\\",strPath);
	CTexture::SetPath(strNsTexturePath);	
	*/
	

	if(CRenderOption::m_FullSceneGlare)
	{		
		m_LightEffectManager.Create(m_ScreenSize);		
	}

	CSceneStateMgr::_Init();
	SetSceneManagerPath(strPath);
	
	SHADOWSIZE=256;
	//LogMessage("Perlin Noise Create");
	CPerlinNoise::Init();
	//LogMessage("HeightField Create");	
	//m_HeightField.Create(7,7,&m_MapStorage);
	m_HeightField.Create(CRenderOption::m_TerrainRange,CRenderOption::m_TerrainRange,&m_MapStorage);		
	//LogMessage("WeatherManager Create");	
	m_CollisionDetection.m_HeightField=&m_HeightField;
	//LogMessage("CharacterMan2ger Create");	
	m_InstanceObjectManager.Create(m_pd3dDevice);
	m_WeatherManager.Load();
///////		
	char strTableName[256] = {0,};
	char strBuffer[256] = {0,};
	char *strPtr = NULL;
	strcpy(strTableName,WEATHERPATH);
	strPtr = strrchr(strTableName,'.');
	strPtr++;
	(*strPtr) = 't';
	strPtr++;
	(*strPtr) = 'a';
	strPtr++;
	(*strPtr) = 'b';
	strPtr++;
	(*strPtr) = 'l';
	strPtr++;
	(*strPtr) = 'e';
	strPtr++;
	(*strPtr) = 0;

	FILE *fp = fopen(strTableName,"rt");
	if(fp)
	{
		
		int *iPtr;
		int iPtrNum;
		char *str;
		fgets(strBuffer,256,fp);
		iPtrNum = atoi(strBuffer);
		iPtr = new int[iPtrNum];
		memset(strBuffer,0,sizeof(char) * 256);
		fgets(strBuffer,256,fp);
		int iNum;
	
		for(iNum = 0; iNum < iPtrNum; iNum++)
		{
			if(iNum == 0)
				str = strtok(strBuffer," \n");
			else
				str = strtok(NULL," \n");
			iPtr[iNum] = atoi(str);
		}
		
		fclose(fp);

		m_WeatherManager.LoadSubTable(iPtr,iPtrNum);
		delete[] iPtr;

		
	}
////////
	m_MapStorage.SetLoadMode(1);

	m_EffectManager.SetDevice(m_pd3dDevice);
	//////	

	//CParticle::SetMatPosition(&m_ViewCamera->m_matPosition);

	//SetSceneManagerPath("c:\\MP-Project");	
	strcpy(CRenderOption::m_strBaseGraphicsDataPath,"Zone1");
	///strcpy(CRenderOption::m_strBaseGraphicsDataPath,"");	
	BaseGraphicsDataLoad(CRenderOption::m_strBaseGraphicsDataPath);
	m_WeatherManager.Create();
	m_CharacterManager.Create();
	m_CharacterManager.SetHeightField(&m_HeightField);
	///////////////////Å©¸®½º¸¶½º ´« 
	
	if(m_bSnowFall) {
		D3DXMATRIX tmpview;
		m_pd3dDevice->GetTransform(D3DTS_VIEW,&tmpview);
		D3DXMatrixInverse(&tmpview,NULL,&tmpview);
		
		vector3 tmppos;
		tmppos.x = tmpview._41;
		tmppos.y = tmpview._42;
		tmppos.z = tmpview._43;
		/*m_SnowFall.SetWorldValue(0.0f,-2.0f,0.0f,8.0f,-3.0f,8.0f,"snow.dds");
		//m_SnowFall.Init(GetDevice(),300,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
		m_SnowFall.Init(GetDevice(),500,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 2000.0f);
		*/
		
		m_SnowFall.SetWorldValue(0.0f,-2.0f,0.0f,1.0f,-0.5f,1.0f,"snow.dds");
		//m_SnowFall.Init(GetDevice(),300,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 100.0f);
		m_SnowFall.Init(GetDevice(),100,tmppos.x,tmppos.y,tmppos.z,800.0f,800.0f,tmppos.y + 2000.0f);
	}
	
	//////////////////
/**/	
	if(m_pWaterTexGenerator == NULL) {
		m_pWaterTexGenerator = new WBWaterNormalTexGenerator;
		m_pWaterTexGenerator->Init(GetDevice(),128,128,"Displacement.dds");
	}
	if(m_pEnvPlaneTex != NULL)
		delete m_pEnvPlaneTex;

	m_pEnvPlaneTex = new WBEnvPlaneTex;
	m_pEnvPlaneTex->Init(GetDevice(),256,256);


	if(m_pBlackGlare != NULL)
		delete m_pBlackGlare;
	m_pBlackGlare = new CTexture;
	CTexture::SetPath(EFFECTTEXTUREPATH);
	m_pBlackGlare->Load("spec_black.dds");

/*	if(m_pEsfCasher)
		delete m_pEsfCasher;

	m_pEsfCasher = new CEffectCasher;
	m_pEsfCasher->BuildHashTable(EFFECTSCRIPTPATH);
*/
	if(CRenderOption::m_bRain) {
		m_pRainParticle = new CRainParticle;
		
		m_pRainParticle->Init(1000,"RainPar.dds");
		m_pRainParticle->SetMaxLife(75.0f);
		m_pRainParticle->SetColor(1.0f,1.0f,1.0f,1.0f,1.0f,1.0f);
		m_pRainParticle->SetVisible(1.0f,0.3f);
		m_pRainParticle->SetSize(0.1f,2.5f,0.1f,2.5f);
		m_pRainParticle->SetBaseMass(1.25f);
		m_pRainParticle->SetFraction(0.0f);
		m_pRainParticle->SetGravity( 0.0f, 0.0001f, 0.0f );
		m_pRainParticle->Explode(0.12f, 777 );

	}

}
/*
CParticleSequence * CSceneManager::AddParticle(vector3 vecPos,vector3 vecTarget)
{
	return m_ParticleManager.AddParticle(SMOKE_PARTICLE,vecPos,vecTarget);
	//return m_Particle.
}
*/
void CSceneManager::DeleteCharacter(CZ3DGeneralChrModel *pDelChr)
{
	m_CharacterManager.DeleteCharacter(pDelChr);	
}

int CSceneManager::AddInstanceObject(char *strObjectName, vector3 vecPos)
{
	return m_InstanceObjectManager.AddInstanceObject(strObjectName,vecPos);
}

void CSceneManager::DeleteInstanceObject(int InstanceObjectID)
{
	m_InstanceObjectManager.DeleteInstanceObject(InstanceObjectID);
}

int CSceneManager::MouseOnCheckInstanceObject(int px, int py)
{
	return m_InstanceObjectManager.MouseOnCheckInstanceObject(px,py);
}

void CSceneManager::SetIntanceObjectColor(int ID,color Color)
{
	m_InstanceObjectManager.SetInstanceObjectColor(ID,Color);
}

void CSceneManager::SetAllInstanceObjectColor(color Color)
{
	m_InstanceObjectManager.SetAllObjectColor(Color);
}

void CSceneManager::PickMakeRay(int dx, int dy,int ScreenX,int ScreenY)
{	
	matrix matProj,matView,matInv;
	m_pd3dDevice->GetTransform(D3DTS_PROJECTION,matProj);
	m_pd3dDevice->GetTransform(D3DTS_VIEW,matView);

	vector3 v;
	v.x= ( ( (2.0f*dx) / ScreenX) -1 ) / matProj._11;
	v.y=-( ( (2.0f*dy) / ScreenY) -1 ) / matProj._22;
	v.z= 1.0f;
	
	matInv.Inverse(matView);
	m_vecPickRayStart.x=matInv._41;
	m_vecPickRayStart.y=matInv._42;
	m_vecPickRayStart.z=matInv._43;

	m_vecPickRayDir.x=v.x*matInv._11 + v.y*matInv._21 + v.z*matInv._31;
	m_vecPickRayDir.y=v.x*matInv._12 + v.y*matInv._22 + v.z*matInv._32;
	m_vecPickRayDir.z=v.x*matInv._13 + v.y*matInv._23 + v.z*matInv._33;
}

CSectorScene* CSceneManager::PickTerrain()
{
	m_vecPickRayStart;
	m_vecPickRayDir;

	float fIntersection;

	int ix,iy;
	for(ix=0;ix<m_HeightField.GetLSizeX();ix++)
	{
		for(iy=0;iy<m_HeightField.GetLSizeY();iy++)
		{
			vector3 vecSectorPoly[3];
			vecSectorPoly[0].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
			vecSectorPoly[0].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43;
			vecSectorPoly[0].y=0.0f;

			vecSectorPoly[1].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41+SECTORSIZE;
			vecSectorPoly[1].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43;
			vecSectorPoly[1].y=0.0f;

			vecSectorPoly[2].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
			vecSectorPoly[2].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43+SECTORSIZE;
			vecSectorPoly[2].y=0.0f;

			if(CIntersection::PolygonRay(m_vecPickRayStart,m_vecPickRayStart+m_vecPickRayDir*100000.0f,vecSectorPoly,fIntersection)==1)
			{
				return &m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()];
			}

			vecSectorPoly[0].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41+SECTORSIZE;
			vecSectorPoly[0].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43;
			vecSectorPoly[0].y=0.0f;

			vecSectorPoly[1].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
			vecSectorPoly[1].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43+SECTORSIZE;
			vecSectorPoly[1].y=0.0f;

			vecSectorPoly[2].x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41+SECTORSIZE;
			vecSectorPoly[2].z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43+SECTORSIZE;
			vecSectorPoly[2].y=0.0f;			

			if(CIntersection::PolygonRay(m_vecPickRayStart,m_vecPickRayStart+m_vecPickRayDir*100000.0f,vecSectorPoly,fIntersection)==1)
			{
				return &m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()];
			}
		}
	}
	return NULL;
	/*
	int ix,iy;
	for(ix=0;ix<LSIZEX;ix++)
	{
		for(iy=0;iy<LSIZEY;iy++)
		{
			if( m_HeightField.m_SectorScene[ix+iy*LSIZEX].m_AccumulateTM._41 <= fXp &&
				m_HeightField.m_SectorScene[ix+iy*LSIZEX].m_AccumulateTM._41 + SECTORSIZE > fXp &&
				m_HeightField.m_SectorScene[ix+iy*LSIZEX].m_AccumulateTM._43 <= fZp &&
				m_HeightField.m_SectorScene[ix+iy*LSIZEX].m_AccumulateTM._43 + SECTORSIZE > fZp)
			{
				return &m_HeightField.m_SectorScene[ix+iy*LSIZEX];
			}
			
		}
	}
	*/

	//m_vecPickRayStart=;
	//m_vecPickRayEnd=;
}

int CSceneManager::GetCharacterCount()
{
	//return m_CharacterManager.m_CharacterScreenPositionList.num;
	return m_CharacterManager.m_CharacterList.num;
}

POINT CSceneManager::GetChacterScreenPos(int nCount)
{
	//return m_CharacterManager.m_CharacterScreenPositionList[nCount];
	return m_CharacterManager.m_CharacterList[nCount].m_ptScreenPosition;

}

vector3 CSceneManager::GetCharacterPos(int nCount)
{
	vector3 vecPos;
	m_CharacterManager.m_CharacterList[nCount].m_pChrmodel->GetPosition(vecPos.x,vecPos.y,vecPos.z);

	return vecPos;
}

vector3 CSceneManager::PickPointTerrain()
{
	CSectorScene *pSelectSector=PickTerrain();
	if(pSelectSector==NULL)
		return vector3(0.0f,0.0f,0.0f);
	
	SectorVertex *pEditSectorVertex;	
	pSelectSector->m_pROAMVertex->Lock(0,0,(BYTE**)&pEditSectorVertex,0);	

	vector3 vecTerrainPos,vecLens;
	vector3 vecMousePos;	

	vector3 vecStart=m_vecPickRayStart;
	vector3 vecDir=m_vecPickRayDir;

	float fIntersection;

	vector3 vecIntersectionPoint;
	vecIntersectionPoint.x=-1.0f;

	vector3 vecCollisionVertex[3];

	matrix matTerrainTM,matTM;
	matTerrainTM=pSelectSector->m_AccumulateTM;
	matTM.Translation(vecStart);
	matTerrainTM.Inverse(matTerrainTM);
	matTM=matTM*matTerrainTM;
	vecStart=matTM.GetLoc();

	float fLens=100000000.0f;
	bool bFound=false;

	for(int cIndices=0;cIndices<pSelectSector->m_UsedIndices/3;cIndices++)
	{
		vecCollisionVertex[0]=pSelectSector->m_pDrawVertex[pSelectSector->m_pDrawIndices[cIndices*3+0]].v;
		vecCollisionVertex[1]=pSelectSector->m_pDrawVertex[pSelectSector->m_pDrawIndices[cIndices*3+1]].v;
		vecCollisionVertex[2]=pSelectSector->m_pDrawVertex[pSelectSector->m_pDrawIndices[cIndices*3+2]].v;
	

		if(CIntersection::PolygonRay(vecStart,vecStart+100000.0f*vecDir,vecCollisionVertex,fIntersection)==1)
		{				
			if(fLens>fIntersection)
			{
				vecIntersectionPoint=vecStart+vecDir*fIntersection;
				fLens=fIntersection;
				bFound=true;
			}
		}
	}
	vecIntersectionPoint.x+=pSelectSector->m_AccumulateTM._41;
	vecIntersectionPoint.z+=pSelectSector->m_AccumulateTM._43;
	pSelectSector->m_pROAMVertex->Unlock();
	if(!bFound)
		return vector3(0.0f,0.0f,0.0f);
	return vecIntersectionPoint;
}

void CSceneManager::CharacterSoundPlay(CZ3DGeneralChrModel *pChrmodel, char *strSoundFile)
{
	m_CharacterManager.CharacterSoundPlay(pChrmodel,strSoundFile);
}

void CSceneManager::CharacterHeightFix()
{
	m_CharacterManager.HeightFiledOnChrFixPos();
}

void CSceneManager::LoadMap(char *strFilename)
{
	//m_MapStorage.Load(strFilename);	
	//m_MapStorage.Load(strFilename);
	m_MapStorage.Load(strFilename);
	
	m_HeightField.m_NowPositionX=-100000000;
	m_HeightField.m_NowPositionY=-100000000;
	m_HeightField.m_NowTessellatePosX=-100000000;
	m_HeightField.m_NowTessellatePosY=-100000000;

	
}

void CSceneManager::AllObjectCalcLens()
{
	m_HeightField.AllObjectCalcLens();
}

int CSceneManager::GetCharacterEvent(CZ3DGeneralChrModel *pChrmodel,DWORD Event)
{
	return m_CharacterManager.GetCharacterEvent(pChrmodel,Event);
}

void CSceneManager::AddDelayTimer(CZ3DGeneralChrModel *pChr, int nDelay)
{
	m_CharacterManager.AddDelayTimer(pChr,nDelay);
}

void CSceneManager::AddChrLight(CZ3DGeneralChrModel *pChrmodel,vector3 vecPos, DWORD dwColor, float fLens, DWORD dwTime)
{
	m_CharacterManager.AddChrLight(pChrmodel,vecPos,dwColor,fLens,dwTime);
}

void CSceneManager::PickingObjectReload()
{	
	if(m_PickHouseScene && m_PickObjectScene==NULL)
	{
		if(m_PickHouseScene->m_HouseObject->m_pOutHouseObject)		
			MeshObjectReload(m_PickHouseScene->m_HouseObject->m_pOutHouseObject);		
		if(m_PickHouseScene->m_HouseObject->m_pLodHouseObject)		
			MeshObjectReload(m_PickHouseScene->m_HouseObject->m_pLodHouseObject);		
		if(m_PickHouseScene->m_HouseObject->m_pMedHouseObject)		
			MeshObjectReload(m_PickHouseScene->m_HouseObject->m_pMedHouseObject);		
		if(m_PickHouseScene->m_HouseObject->m_pInHouseObject)		
			MeshObjectReload(m_PickHouseScene->m_HouseObject->m_pInHouseObject);		
	}
	else if(m_PickObjectScene)
	{
		MeshObjectReload(m_PickObjectScene->m_pObject);
	}
	
	//CSceneManager::m_PickObjectScene;
}

void CSceneManager::MeshObjectReload(CMeshObject *pMesh)
{
	CTexture::SetPath(OBJECTTEXTUREPATH);
	char strReload[256];
	for(int i=0;i<pMesh->m_pMat.num;i++)
	{
		if(strstr(pMesh->m_pMat[i]->m_strName,"_Reload")==NULL)
		{			
			sprintf(strReload,"%s%s",pMesh->m_pMat[i]->m_strName," _Reload");
			strcpy(pMesh->m_pMat[i]->m_strName,strReload);
		}
		else
		{
			pMesh->m_pMat[i]->m_pddTexture->Release();
		}
		sscanf(pMesh->m_pMat[i]->m_strName,"%s _Reload",strReload);
		strcpy(pMesh->m_pMat[i]->m_strName,strReload);
		pMesh->m_pMat[i]->ReadDDSTexture(pMesh->m_pMat[i]->m_pddTexture,1);		
		sprintf(strReload,"%s%s",pMesh->m_pMat[i]->m_strName," _Reload");
		strcpy(pMesh->m_pMat[i]->m_strName,strReload);
	}
	pMesh->MeshReload();
}
void CSceneManager::DeleteAllEffect(){

	m_EffectManager.DeleteAllEffect();
	m_EffectManager.DeleteAllWorldScript();
}
void CSceneManager::DeleteAllWorldEffect() {

	m_EffectManager.DeleteAllWorldScript();

}
XEFFECT CSceneManager::AddEffect(CX3DEffect *lpNewEffect)
{
	m_EffectNum++;
	lpNewEffect->SetEffectStart(true);
	return m_EffectManager.AddEffect(lpNewEffect);
}
CEffScript *CSceneManager:: AddEffectScript (CEffScript *lpnewScript) {
	return m_EffectManager.AddEffScript(lpnewScript);
}
void CSceneManager:: AddInterfaceScript (CEffScript *lpnewScript) {
	m_EffectManager.AddInterfaceScript(lpnewScript);

}
void CSceneManager:: AddWorldEffect(CEffScript *lpnewScript) {
	m_EffectManager.AddWorldEffScript(lpnewScript);
}
void CSceneManager::DeleteEffect(XEFFECT hEffect)
{
	m_EffectNum--;
	m_EffectManager.DeleteEffect(hEffect);
}

BOOL CSceneManager::EffectIsLive(XEFFECT hEffect)
{
	return  m_EffectManager.IsLive(hEffect);
}

void CSceneManager::DeleteEffect(CX3DEffect *del)
{
	
	for(int i=0;i<m_EffectNum;i++) {
		if(m_EffectManager.m_lstEffect[i] == del) {
			DeleteEffect(i);
			m_EffectNum--;
			break;
		}
	}
}
void CSceneManager::UnPicking()
{
	m_PickEffect = NULL;
	m_PickHouseScene=NULL;
	m_PickLightScene=NULL;
	m_PickObjectScene=NULL;
	m_pPickSector = NULL;

}
void CSceneManager::UnPickEffect() {
	if(m_PickEffect) {
		m_PickEffect->pick_index = -1;
		m_PickEffect = NULL;
	}
}
void CSceneManager::PickEffect(float fMx,float fMy,float fMz) {
	vector3 vecPos;
	float length = 0.0f;
	float line_length = 0.0f;
	float min = 0.0f;
	float pick_range = 50.0f;
	float e_dot = 0.0f;
	int min_index = -1;
	
	vector3 tmp;
	// ¶óÀο¡¼­ Á¡¿¡ °¡Àå °¡±î¿î À§Ä¡
	vector3 e_Closet;

	vector3 e_RayStart = m_vecPickRayStart;
	vector3 e_RayEnd = e_RayStart + m_vecPickRayDir * pick_range;
	
	vector3 e_vector1,e_vector2,e_vector3;
	vector3 test_vector;
	m_PickEffect = m_MapStorage.FindEffectMap(fMx,fMz);
	
	if(m_PickEffect) {
		for(int i= 0 ;i<m_PickEffect->m_vecEffectPos.num;i++) {
			tmp = m_PickEffect->m_vecEffectPos[i];
			e_vector1 = tmp - e_RayStart;
			e_vector2 = e_RayEnd - e_RayStart;
			line_length = e_vector2.GetLens();

			e_vector2.Normalize();
			
			e_dot = e_vector1 * e_vector2;
			if(e_dot <=0)
				e_Closet = e_RayStart;
			else if(e_dot >= line_length) 
				e_Closet = e_RayEnd;
			// °Å¸®
			else {
				e_vector3 = e_vector2 * e_dot;
				e_Closet =  e_vector1 + e_vector3;
			}
			//·¹ÀÌ¿¡¼­ Æ÷ÀÎÆ® ±îÁöÀÇ vector
			test_vector = tmp - e_Closet;
			length = test_vector.GetLens();

			if(i == 0) {
				min = length;
				min_index = i;
			}
			else if(min >= length) {
				min_index = i;
				min = length;
			}
		}//for		
		if(min_index >=0) {
			m_PickEffect->pick_index = min_index;
		}
	}


//	vecPos.x = fMx;
//	vecPos.y = fMy;
//	vecPos.z = fMz;
	

/*	
	if(m_PickEffect) {
		for(int i= 0 ;i<m_PickEffect->m_vecEffectPos.num;i++) {
			tmp = vecPos - m_PickEffect->m_vecEffectPos[i];
							
			length = tmp.GetLens();
			if(i == 0)
				min = length;
			if(min >= length)
				min_index = i;
		}//for		
	}
	if(min_index >=0) {
		m_PickEffect->pick_index = min_index;
	}
*/

}
void CSceneManager::PickLandscapeEffect(float fPx,float fPy,float fPz,int PickMode)
{
		vector3 vecPos;

		vecPos.x = fPx;
		vecPos.y = fPy;
		vecPos.z = fPz;


		if(PickMode == 0) { // vfog
			float length = 0.0f;
			float min = 0.0f;
			int min_index = -1;
			vector3 tmp;

			m_PickLandscape = m_MapStorage.FindLandscapeEffect(fPx,fPz);
			if(m_PickLandscape) {
				for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
					tmp = vecPos - m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos;
					m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] = false;
							
					length = tmp.GetLens();
					if(i == 0)
						min = length;
					if(min >= length)
						min_index = i;
				}
			}
			if(min_index>=0) { // find closet landeffect
				m_PickLandscape->m_LandscapeEffect[min_index].m_IntParam[1] = true;
			}
		}
		else if(PickMode == 1) {// boid
			float length = 0.0f;
			float min = 0.0f;
			int min_index = -1;
			vector3 tmp;

			m_PickLandscape = m_MapStorage.FindLandscapeEffect(fPx,fPz);
			if(m_PickLandscape) {
				for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
					tmp = vecPos - m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos;
					m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] = false;
							
					length = tmp.GetLens();
					if(i == 0)
						min = length;
					if(min >= length)
						min_index = i;
				}
			}
			if(min_index>=0) { // find closet landeffect
				m_PickLandscape->m_LandscapeEffect[min_index].m_IntParam[1] = true;
			}
		}
		else if(PickMode == 2) { //mesh
			float length = 0.0f;
			float min = 0.0f;
			int min_index = -1;
			vector3 tmp;

			m_PickLandscape = m_MapStorage.FindLandscapeEffect(fPx,fPz);
			if(m_PickLandscape) {
				for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
					tmp = vecPos - m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos;
					m_PickLandscape->m_LandscapeEffect[i].m_IntParam[2] = false;
							
					length = tmp.GetLens();
					if(i == 0)
						min = length;
					if(min >= length)
						min_index = i;
				}
			}
			if(min_index>=0) { // find closet landeffect
				m_PickLandscape->m_LandscapeEffect[min_index].m_IntParam[2] = true;
			}
		}
		else if(PickMode == 3) {// wave
			float length = 0.0f;
			float min = 0.0f;
			int min_index = -1;
			vector3 tmp;

			m_PickLandscape = m_MapStorage.FindLandscapeEffect(fPx,fPz);
			if(m_PickLandscape) {
				for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
					tmp = vecPos - m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos;
					m_PickLandscape->m_LandscapeEffect[i].m_IntParam[0] = false;
							
					length = tmp.GetLens();
					if(i == 0)
						min = length;
					if(min >= length)
						min_index = i;
				}
			}
			if(min_index>=0) { // find closet landeffect
				m_PickLandscape->m_LandscapeEffect[min_index].m_IntParam[0] = true;
			}
		}
}
void CSceneManager::DeletePickingLandscapeEffect() {
	CSectorScene *pSector;

	if(m_PickLandscape != NULL) {
		for(int i = 0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
			if(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod == 1) { 
				// vol-fog
				if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] == 1) {
					m_PickLandscape->m_LandscapeEffect.DelIndex(i);
					break;
				}
			}
			else if(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod == 2) {
				// boid
				if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] == 1) {
					m_PickLandscape->m_LandscapeEffect.DelIndex(i);
					break;
				}
			}
			else if(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod == 3) {
				//mesh ani
				if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[2] == 1) {
					m_PickLandscape->m_LandscapeEffect.DelIndex(i);	
					break;
				}
			}
			else if(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod == 4) {
				// wave
				if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[0] == 1) {
					m_PickLandscape->m_LandscapeEffect.DelIndex(i);
					break;
				}
			}
		}
		if(m_PickLandscape->m_LandscapeEffect.num== 0) {
			m_MapStorage.DeleteLandscapeEffect(m_PickLandscape);
		}

		m_PickLandscape = NULL;
		pSector=PickTerrain();
		pSector->GenerateLandscapeEffect();
	}
	
}
void CSceneManager::DeletePickEffect() {
	CSectorScene *pSector;
	
	vector3 *pvecPos = GetCamera()->GetPosition();
	vector3 vecPos = (*pvecPos);

	pSector=PickTerrain(vecPos.x,vecPos.y,vecPos.z);

	if(m_PickEffect != NULL) {
		m_PickEffect->m_vecEffectPos.DelIndex(m_PickEffect->pick_index);
		m_PickEffect->m_strEffectName.DelIndex(m_PickEffect->pick_index);
		
		m_PickEffect->pick_index = -1;
		m_PickEffect = NULL;

		pSector->GenerateEffect();
	}

}
vector3 CSceneManager::GetPickBspCenter()
{
	if(m_RBspSceneManager.m_pCurrentBspScene != NULL) 
	{
		return (m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos);
	}
	return vector3(0.0f,0.0f,0.0f);
}
void CSceneManager::UnPickRBspScene()
{
	m_PickObjectScene = NULL;

	if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
	{
		
		RBspScene *pScene = m_RBspSceneManager.m_pCurrentBspScene;
		int i;
		for( i = 0; i < pScene->m_iLeafsNum; i++)
		{
			pScene->m_pLeafExs[i].UnPickEventEffect();
			pScene->m_pLeafExs[i].UnPickEventObject();
			pScene->m_pLeafExs[i].UnPickEventSound();
			pScene->m_pLeafExs[i].UnPickLight();
			pScene->m_pLeafExs[i].UnPickTrigger();
			pScene->m_pLeafExs[i].UnPickR3SObject();

		}
		
	}
}
void CSceneManager::PickRBspObject(float x,float y,float z,int iPickValue)
{
	if(m_RBspSceneManager.m_pCurrentBspScene != NULL)
	{
		D3DXVECTOR3 vecPos = D3DXVECTOR3(x,y,z);
		/*
		D3DXVECTOR3 vecLocal = vecPos;
		D3DXMATRIX matTmp;
		D3DXMATRIX matInv;

		D3DXMatrixIdentity(&matTmp);
		matTmp._41 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
		matTmp._42 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
		matTmp._43 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;

		D3DXMatrixInverse(&matInv,NULL,&matTmp);
		D3DXMatrixIdentity(&matTmp);
		matTmp._41 = vecLocal.x;
		matTmp._42 = vecLocal.y;
		matTmp._43 = vecLocal.z;
		D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
		vecLocal.x = matTmp._41;
		vecLocal.y = matTmp._42;
		vecLocal.z = matTmp._43;						
	
		int iLeaf = m_RBspSceneManager.m_pCurrentBspScene->FindLeafNode(vecLocal);
		*/

		int iLeaf = m_RBspSceneManager.m_pCurrentBspScene->m_iRBspLeafIndex;
		int i;
		int iPickIndex = -1;
		float fPickLength = 0.0f;

		RBspScene::RBspLeafEx *pLeaf = &(m_RBspSceneManager.m_pCurrentBspScene->m_pLeafExs[iLeaf]);

		if(iPickValue == 0)				// Object
		{
			for( i= 0; i < pLeaf->m_iEventNum[0]; i++)
			{
				D3DXVECTOR3 vecTmp;
				float fTmp;
				vecTmp = (pLeaf->m_lstObject[i]->m_vecCenter) - vecPos;
				fTmp = D3DXVec3Length(&vecTmp);
				if( i == 0) 
				{
					fPickLength = fTmp;
					iPickIndex = i;
				}
				else if(fTmp < fPickLength)
				{
					fPickLength = fTmp;
					iPickIndex = i;
				}
			}
			pLeaf->m_pPickEventObject = pLeaf->m_lstObject[iPickIndex];
			pLeaf->m_pPickEventEffect = NULL;
			pLeaf->m_pPickEventSound = NULL;
			pLeaf->m_pPickLight = NULL;
			pLeaf->m_pPickTrigger = NULL;

		}
		else if(iPickValue == 1)		// Effect
		{
			for( i= 0; i < pLeaf->m_iEventNum[1]; i++)
			{
				D3DXVECTOR3 vecTmp;
				float fTmp;
				vecTmp = (pLeaf->m_lstEffect[i]->m_vecCenter) - vecPos;
				fTmp = D3DXVec3Length(&vecTmp);
				if( i == 0) 
				{
					fPickLength = fTmp;
					iPickIndex = i;
				}
				else if(fTmp < fPickLength)
				{
					fPickLength = fTmp;
					iPickIndex = i;
				}
			}
			pLeaf->m_pPickEventEffect = pLeaf->m_lstEffect[iPickIndex];
			pLeaf->m_pPickEventObject = NULL;
			pLeaf->m_pPickLight = NULL;
			pLeaf->m_pPickEventSound = NULL;
			pLeaf->m_pPickTrigger = NULL;

		}
		else if(iPickValue == 2)		// Light
		{
			for( i= 0; i < pLeaf->m_iLightNum; i++)
			{
				D3DXVECTOR3 vecTmp;
				float fTmp;
				vecTmp = (pLeaf->m_lstLight[i].m_vecLight) - vecPos;
				fTmp = D3DXVec3Length(&vecTmp);
				if( i == 0) 
				{
					fPickLength = fTmp;
					iPickIndex = i;
				}
				else if(fTmp < fPickLength)
				{
					fPickLength = fTmp;
					iPickIndex = i;
				}
			}
			pLeaf->m_pPickLight = &(pLeaf->m_lstLight[iPickIndex]);
			pLeaf->m_pPickEventEffect = NULL;
			pLeaf->m_pPickEventObject = NULL;
			pLeaf->m_pPickEventSound = NULL;
			pLeaf->m_pPickTrigger = NULL;

		}
	}
}
void CSceneManager::PickRBspObjectMove(float fMx,float fMy,float fMz,float fAngle,float fAddy,int iValue,int MoveMode) 
{
	if(m_RBspSceneManager.m_pCurrentBspScene != NULL) 
	{

		int iLeaf = m_RBspSceneManager.m_pCurrentBspScene->m_iRBspLeafIndex;
		RBspScene::RBspLeafEx *pLeaf = &(m_RBspSceneManager.m_pCurrentBspScene->m_pLeafExs[iLeaf]);
		
		if(iValue == 0)				// Object
		{
			RBspScene::RBspEventObject *pObject = pLeaf->m_pPickEventObject;
			
			if(pObject != NULL) {
				if(MoveMode == 0) {//  ¶¥¿¡¼­ À̵¿
					pObject->m_vecCenter.x = fMx;
					pObject->m_vecCenter.z = fMz;

				}
				else if(MoveMode == 1) {// y Ãà À̵¿
					pObject->m_vecCenter.y += fAddy;
				}
			}
		}
		else if(iValue == 1)				// Effect
		{
			RBspScene::RBspEventEffect *pEffect = pLeaf->m_pPickEventEffect;
			
			if(pEffect != NULL) {
				if(MoveMode == 0) {//  ¶¥¿¡¼­ À̵¿
					pEffect->m_vecCenter.x = fMx;
					pEffect->m_vecCenter.z = fMz;

				}
				else if(MoveMode == 1) {// y Ãà À̵¿
					pEffect->m_vecCenter.y += fAddy;
				}
			}
		}
		else if(iValue == 2)				// Light
		{
			RBspScene::RBspLight *pLight = pLeaf->m_pPickLight;
			
			if(pLight != NULL) {
				if(MoveMode == 0) {//  ¶¥¿¡¼­ À̵¿
					pLight->m_vecLight.x = fMx;
					pLight->m_vecLight.z = fMz;

				}
				else if(MoveMode == 1) {// y Ãà À̵¿
					pLight->m_vecLight.y += fAddy;
				}
			}
		}
	}
}

// Bsp Scene Move
void CSceneManager::PickBspMove(float fMx,float fMy,float fMz,float fAngle,float fAddy,int MoveMode) 
{
	if(m_RBspSceneManager.m_pCurrentBspScene != NULL) 
	{
		if(MoveMode == 0) {//  ¶¥¿¡¼­ À̵¿
			float fx = fMx - m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
			float fz = fMz - m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;

			m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x = fMx;
			m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z = fMz;
			m_RBspSceneManager.m_pCurrentBspScene->UpdateLeafBox(fx,0.0f,fz);

		}
		else if(MoveMode == 1) {// y Ãà À̵¿
			m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y+=fAddy;
			m_RBspSceneManager.m_pCurrentBspScene->UpdateLeafBox(0.0f,fAddy,0.0f);
		}
		
/*		m_RBspSceneManager.m_pCurrentBspScene->SetZeroPosition(m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x,
																m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y,
																m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z);
*/
	}
	else if(m_RBspSceneManager.m_iPickIndex != -1)
	{
		int iPick = m_RBspSceneManager.m_iPickIndex;

		if(MoveMode == 0) {//  ¶¥¿¡¼­ À̵¿
			float fx = fMx - m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.x;
			float fz = fMz - m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.z;

			m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.x = fMx;
			m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.z = fMz;
			m_RBspSceneManager.m_lstBspScene[iPick]->UpdateLeafBox(fx,0.0f,fz);

		}
		else if(MoveMode == 1) {// y Ãà À̵¿
			m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.y += fAddy;
			m_RBspSceneManager.m_lstBspScene[iPick]->UpdateLeafBox(0.0f,fAddy,0.0f);
		}
/*		m_RBspSceneManager.m_lstBspScene[iPick]->SetZeroPosition(m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.x,
																m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.y,
																m_RBspSceneManager.m_lstBspScene[iPick]->m_vecZeroPos.z,true);
*/
	}
	else
	{
		m_RBspSceneManager.m_lstBspScene[0]->SetZeroPosition(fMx,fMy,fMz);

	}
}


void CSceneManager::PickEffectMove(float fMx,float fMy,float fMz,float fAngle,float fAddy,int MoveMode){
	CSectorScene *pSector;

	m_vecPickRayDir.x = 0.0f;
	m_vecPickRayDir.y = -1.0f;
	m_vecPickRayDir.z = 0.0f;

	vector3 *pvecPos = GetCamera()->GetPosition();
	vector3 vecPos = (*pvecPos);

	pSector=PickTerrain(vecPos.x,vecPos.y,vecPos.z);


	if(m_PickEffect) {
		if(MoveMode == 0) {//  ¶¥¿¡¼­ À̵¿
			m_PickEffect->m_vecEffectPos[m_PickEffect->pick_index].x = fMx;
			//m_PickEffect->m_vecEffectPos.x = fMx;
			m_PickEffect->m_vecEffectPos[m_PickEffect->pick_index].z = fMz;
		}
		else if(MoveMode == 1) {// y Ãà À̵¿
			m_PickEffect->m_vecEffectPos[m_PickEffect->pick_index].y+=fAddy;
		}
		pSector->GenerateEffect();
	}
}
void CSceneManager::PickEffectRot(float x,float y,float z,int MoveMode) {
	static float xrot = 0.0f;
	static float yrot = 0.0f;
	static float zrot = 0.0f;

	CSectorScene *pSector;

	m_vecPickRayDir.x = 0.0f;
	m_vecPickRayDir.y = -1.0f;
	m_vecPickRayDir.z = 0.0f;

	vector3 *pvecPos = GetCamera()->GetPosition();
	vector3 vecPos = (*pvecPos);

	pSector=PickTerrain(vecPos.x,vecPos.y,vecPos.z);

	if(m_PickEffect) {
		if(MoveMode == 0) {//  xÃà rot 	
			m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].x +=x;
			if(m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].x >= 360.0f) {
				m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].x = m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].x - 360.0f;
			}
		}
		else if(MoveMode == 1) {// y Ãà rot
			m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].y +=y;
			
			if(m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].y >= 360.0f) {
				m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].y = m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].y - 360.0f;
			}
		}
		else if(MoveMode == 2) { //z Ãà rot
			m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].z +=z;
			
			if(m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].z >= 360.0f) {
				m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].z = m_PickEffect->m_vecEffectRot[m_PickEffect->pick_index].z - 360.0f;
			}
		}
		pSector->GenerateEffect();
	}
}

void CSceneManager::PickLandscapeEffectMove(float fMx,float fMy,float fMz,float fAngle,float fAddy,int MoveMode){
	int i;
	CSectorScene *pSector;
	pSector=PickTerrain();

	if(m_PickLandscape) {
		for(i=0;i<m_PickLandscape->m_LandscapeEffect.num;i++) {
			switch(m_PickLandscape->m_LandscapeEffect[i].m_nEffectMethod) {

			case 1:
				if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[1] == 1) {
					if(MoveMode == 0) { // x,z move
						m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.x =fMx;
						//m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.y =fMy;
						m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.z =fMz;
						
					}
					else if(MoveMode == 1) {// y axis move
						m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.y +=fAddy;
					}
					pSector->GenerateLandscapeEffect();
				}
				break;
			case 3:

				if(m_PickLandscape->m_LandscapeEffect[i].m_IntParam[2] == 1) {
					if(MoveMode == 0) { // x,z move
						m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.x =fMx;
						m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.y =fMy;
						m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.z =fMz;
					}
					else if(MoveMode == 1) {// y axis move
						m_PickLandscape->m_LandscapeEffect[i].m_vecCenterPos.y +=fAddy;
					}
					else if(MoveMode == 2) {//x axis rot
						m_PickLandscape->m_LandscapeEffect[i].m_Param[4] +=fAngle;
						if(m_PickLandscape->m_LandscapeEffect[i].m_Param[4] >360.0f)
							m_PickLandscape->m_LandscapeEffect[i].m_Param[4] = 0.0f;
						pSector->GenerateLandscapeEffect();
					}
					else if(MoveMode == 3) {//y axis rot
						m_PickLandscape->m_LandscapeEffect[i].m_Param[5] +=fAngle;
						if(m_PickLandscape->m_LandscapeEffect[i].m_Param[5] >360.0f)
							m_PickLandscape->m_LandscapeEffect[i].m_Param[5] = 0.0f;
						pSector->GenerateLandscapeEffect();
					}
					else if(MoveMode == 4) {//z axis rot
						m_PickLandscape->m_LandscapeEffect[i].m_Param[6] +=fAngle;					
						if(m_PickLandscape->m_LandscapeEffect[i].m_Param[6] >360.0f)
							m_PickLandscape->m_LandscapeEffect[i].m_Param[6] = 0.0f;
						pSector->GenerateLandscapeEffect();
					}
				}				
				break;
				
			}//switch
		}//for
	}//if
}

void CSceneManager::CharacterMovementVector(CZ3DGeneralChrModel *pChrmodel, vector3 vecMove,float fAccelate)
{
	m_CharacterManager.CharacterMovementVector(pChrmodel,vecMove,fAccelate);
}

vector3 CSceneManager::GetCharacterMovementVector(CZ3DGeneralChrModel *pChrmodel)
{
	return m_CharacterManager.GetCharacterMovementVector(pChrmodel);
}

void CSceneManager::CharacterRandomPos(CZ3DGeneralChrModel *pChrmodel,int nTimer, vector3 vecRand)
{
	m_CharacterManager.CharacterRandomPos(pChrmodel,nTimer,vecRand);
}

void CSceneManager::RenderGlareTexture()
{	
	m_pd3dDevice->EndScene();	

	LPDIRECT3DSURFACE8 m_pTempRenderSurface;		
	LPDIRECT3DSURFACE8 m_pTempRenderZBuffer;	
	m_pd3dDevice->GetRenderTarget(&m_pTempRenderSurface);
	m_pd3dDevice->GetDepthStencilSurface(&m_pTempRenderZBuffer);

	m_pd3dDevice->SetRenderTarget(m_GlareTexture.GetSurface(),m_pTempRenderZBuffer);	
	

	CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);

	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);

	////////////////////////////////////////////
	m_pd3dDevice->BeginScene();
	m_pd3dDevice->Clear(0,NULL,D3DCLEAR_TARGET,0xff000000,1.0f,0);
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2,D3DTA_DIFFUSE);
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG2);

	TLVertex pVertex[8];		
	float fTextureSize=128.0f;

	pVertex[0].v.x=0.0f;
	pVertex[1].v.x=0.0f;
	pVertex[2].v.x=fTextureSize;
	pVertex[3].v.x=fTextureSize;

	pVertex[1].v.y=0.0f;
	pVertex[3].v.y=0.0f;
	pVertex[0].v.y=fTextureSize;
	pVertex[2].v.y=fTextureSize;	
		
	pVertex[0].tu=0.0f;
	pVertex[1].tu=0.0f;

	pVertex[3].tu=1.0f;
	pVertex[2].tu=1.0f;

	pVertex[1].tv=0.0f;
	pVertex[3].tv=0.0f;

	pVertex[0].tv=1.0f;
	pVertex[2].tv=1.0f;		

	for(int i=0;i<4;i++)
	{
		pVertex[i].w=0.1f;
		pVertex[i].v.z=0.1f;
		pVertex[i].Diffuse.c=0xff0000ff;
		pVertex[i].Specular.c=0xffffffff;
	}	

	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);	

	m_pd3dDevice->SetTexture(1,NULL);
	m_pd3dDevice->SetVertexShader(TLVERTEXFVF);				
	//m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));	

	//m_CharacterManager.Render(m_pd3dDevice);

	m_WeatherManager.m_SkyScene.RenderForGlare(m_pd3dDevice);	

	//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);	
	
	
	for(int cGlareNode=0;cGlareNode<m_GlareList.num;cGlareNode++)
	{
		if(m_GlareList[cGlareNode].m_bCubeEnv)
		{			
			CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR|1);
			CSceneStateMgr::_SetD3DTextureStageState( 1,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT3);

			CSceneStateMgr::_SetD3DRenderState(D3DRS_NORMALIZENORMALS,TRUE);
			CSceneStateMgr::_SetD3DRenderState(D3DRS_LOCALVIEWER,TRUE);

			m_pd3dDevice->SetTexture(1,m_DiffuseLightCubeTexture.GetTexture());

			//m_pd3dDevice->SetTexture(1,m_LightCubeTexture);			
			
			CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
			CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG1);					

			CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
			CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,D3DTOP_SELECTARG1);
			CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
			CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
			CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSW, D3DTADDRESS_CLAMP);			

			m_pd3dDevice->SetTransform(D3DTS_WORLD,m_GlareList[cGlareNode].m_matPosition);
			
			m_GlareList[cGlareNode].m_pMeshObject->Render(m_pd3dDevice);			

			CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX,1);
			CSceneStateMgr::_SetD3DTextureStageState(1 ,D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);

			CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
			CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
			CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ADDRESSW, D3DTADDRESS_WRAP);

			CSceneStateMgr::_SetD3DRenderState(D3DRS_NORMALIZENORMALS,FALSE);
			CSceneStateMgr::_SetD3DRenderState(D3DRS_LOCALVIEWER,FALSE);
			
		}
		else
		{

		}
	}
	
	
	m_GlareList.num=0;

	CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);

	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);	

	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);	


	for(int ix=0;ix<m_HeightField.GetLSizeX();ix++)
	{
		for(int iy=0;iy<m_HeightField.GetLSizeY();iy++)
		{				
			if( m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_MapWater)
			{				
				m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].RenderWater(m_pd3dDevice,true);				
			}			
		}
	}	
	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);	

	CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
    CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);

	//m_CharacterManager.RenderGlare(m_pd3dDevice);
	/*
	pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE,TRUE);
	pd3dDevice->SetRenderState( D3DRS_ALPHAREF,0xee);
	*/
	//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);	


	//m_WeatherManager.Render(m_pd3dDevice);

	m_pd3dDevice->EndScene();
	/////////////////////////////////////////////////
	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
	m_pd3dDevice->SetRenderTarget(m_pTempRenderSurface,m_pTempRenderZBuffer);

	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

	m_pTempRenderSurface->Release();
	m_pTempRenderZBuffer->Release();


	m_pd3dDevice->BeginScene();
}

void CSceneManager::RenderFullSceneTextureBegin()
{	
	m_pd3dDevice->GetRenderTarget(&m_pTempRenderSurface);
	m_pd3dDevice->GetDepthStencilSurface(&m_pTempRenderZBuffer);

	m_pd3dDevice->SetRenderTarget(m_FullSceneTexture.GetSurface(),m_FullSceneTexture.GetZBuffer());			
		
	m_pd3dDevice->Clear(0,NULL,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,m_WeatherManager.m_GF3ClareColor.c,1.0f,0);
}

void CSceneManager::RenderFullSceneTextureEnd()
{	
	if(m_FullSceneAnti)
		return;

	m_pd3dDevice->SetRenderTarget(m_pTempRenderSurface,m_pTempRenderZBuffer);
	m_pTempRenderSurface->Release();
	m_pTempRenderZBuffer->Release();
	
	TLVertex pVertex[4];	

	pVertex[0].v.x=0.0f;
	pVertex[1].v.x=0.0f;
	pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
	pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;

	pVertex[1].v.y=0.0f;
	pVertex[3].v.y=0.0f;
	pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
	pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;

	static float fasdf=0.0f;
		
	pVertex[0].tu=0.0f;
	pVertex[1].tu=0.0f;

	pVertex[3].tu=1.0f;
	pVertex[2].tu=1.0f;

	pVertex[1].tv=0.0f;
	pVertex[3].tv=0.0f;

	pVertex[0].tv=1.0f;
	pVertex[2].tv=1.0f;		

	for(int i=0;i<4;i++)
	{
		pVertex[i].w=0.1f;
		pVertex[i].v.z=0.1f;
		pVertex[i].Diffuse.c=0xffffffff;
		pVertex[i].Specular.c=0xffffffff;
	}
	
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );    
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);		
	CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE);

	m_pd3dDevice->SetTexture(0,m_FullSceneTexture.GetTexture());
	m_pd3dDevice->SetTexture(1,NULL);
	m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
	m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));	
}

void CSceneManager::RenderFullSceneGlare()
{
	m_GlareTexture.GenerateMipmap(m_pd3dDevice);

	float fTextureSize=256.0f;
	
	TLVertex pVertex[4];	
	pVertex[0].v.x=0.0f;
	pVertex[1].v.x=0.0f;
	pVertex[2].v.x=(float)fTextureSize;
	pVertex[3].v.x=(float)fTextureSize;

	pVertex[1].v.y=0.0f;
	pVertex[3].v.y=0.0f;
	pVertex[0].v.y=(float)fTextureSize;
	pVertex[2].v.y=(float)fTextureSize;

	static float fasdf=0.0f;
		
	pVertex[0].tu=0.0f;
	pVertex[1].tu=0.0f;

	pVertex[3].tu=1.0f;
	pVertex[2].tu=1.0f;

	pVertex[1].tv=0.0f;
	pVertex[3].tv=0.0f;

	pVertex[0].tv=1.0f;
	pVertex[2].tv=1.0f;		

	for(int i=0;i<4;i++)
	{
		pVertex[i].w=0.1f;
		pVertex[i].v.z=0.1f;
		pVertex[i].Diffuse.c=0xffffffff;
		pVertex[i].Specular.c=0x0;
	}
	
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);    
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE);		
	CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE);

	m_pd3dDevice->SetTexture(1,NULL);
	m_pd3dDevice->SetVertexShader(TLVERTEXFVF);

	CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_ONE);
    CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_ONE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE);	
	//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE);	

	CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);	
	

	m_pd3dDevice->EndScene();				

	m_GlareCompositeTexture.Begin(m_pd3dDevice);

	m_pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET,0x0,1.0f, 0);	

	m_pd3dDevice->BeginScene();

	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);

	color VertexColor;

	for(int cTexture=1;cTexture<m_GlareTexture.GetTextureCount();cTexture++)
	//for(int cTexture=0;cTexture<1;cTexture++)
	{
		VertexColor.r=(unsigned char)(255.0f/((float)m_GlareTexture.GetTextureCount()-1));
		//VertexColor.r=0x80;
		//VertexColor.r=0xff;
		VertexColor.a=VertexColor.b=VertexColor.g=VertexColor.r;
		VertexColor.a=255;
		////////				
		pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
			=VertexColor.c;
		////////
		m_pd3dDevice->SetTexture(0,m_GlareTexture.GetTexture(cTexture));
		m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));	
	}
	
	m_pd3dDevice->EndScene();
	m_GlareCompositeTexture.End(m_pd3dDevice);	

	m_pd3dDevice->BeginScene();			

	if(m_FullSceneAnti)
	{
		pVertex[2].v.x=(float)m_ScreenSize-3;
		pVertex[3].v.x=(float)m_ScreenSize-3;
		
		pVertex[0].v.y=(float)m_ScreenSize-3;
		pVertex[2].v.y=(float)m_ScreenSize-3;
	}
	else
	{	
		pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx-3;
		pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx-3;
		
		pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy-3;
		pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy-3;
	}

	pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
			=0xffaaaaaa;

	m_pd3dDevice->SetTexture(0,m_GlareCompositeTexture.GetTexture());
	//m_pd3dDevice->SetTexture(0,m_GlareTexture.GetTexture(2));
	m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));

	CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_ONE);
    CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_ONE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE);	

	pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
			=0xffffffff;

	m_pd3dDevice->SetTexture(0,m_SpecularGlareTexture.GetTexture());	
	//m_pd3dDevice->SetTexture(0,m_GlareTexture.GetTexture(2));
	m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));

	//m_SmoothGlareTexture.GenerateGlareTexture(m_pd3dDevice,m_SpecularGlareTexture.GetTexture(),);
	
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE);	

	pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
			=0xff555555;

	m_pd3dDevice->SetTexture(0,m_SmoothGlareTexture.GetTexture());	
	//m_pd3dDevice->SetTexture(0,m_GlareTexture.GetTexture(2));
	m_pd3dDevice->SetTexture(1,NULL);
	m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
	m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));

	/*
	for(int ix=0;ix<30;ix++)
	{
		for(int iy=0;iy<1;iy++)
		{
			pVertex[0].v.x=0.0f+ix-15.0f;
			pVertex[1].v.x=0.0f+ix-15.0f;
			pVertex[2].v.x=(float)fTextureSize+ix-15.0f;
			pVertex[3].v.x=(float)fTextureSize+ix-15.0f;

			pVertex[1].v.y=0.0f+iy;
			pVertex[3].v.y=0.0f+iy;
			pVertex[0].v.y=(float)fTextureSize+iy;
			pVertex[2].v.y=(float)fTextureSize+iy;

			m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));
		}
	}
	*/

	////////////////////////

	//m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));	


	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);	
	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
}

void CSceneManager::RenderFullSceneAnti()
{
	if(!m_FullSceneAnti)
		return;

	m_pd3dDevice->SetRenderTarget(m_pTempRenderSurface,m_pTempRenderZBuffer);
	m_pTempRenderSurface->Release();
	m_pTempRenderZBuffer->Release();
	
	TLVertex pVertex[4];	

	pVertex[0].v.x=0.0f;
	pVertex[1].v.x=0.0f;
	pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
	pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;

	pVertex[1].v.y=0.0f;
	pVertex[3].v.y=0.0f;
	pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
	pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;

	pVertex[0].tu=0.0f;
	pVertex[1].tu=0.0f;

	pVertex[3].tu=1.0f;
	pVertex[2].tu=1.0f;

	pVertex[1].tv=0.0f;
	pVertex[3].tv=0.0f;

	pVertex[0].tv=1.0f;
	pVertex[2].tv=1.0f;

	for(int i=0;i<4;i++)
	{
		pVertex[i].w=0.1f;
		pVertex[i].v.z=0.1f;
		pVertex[i].Diffuse.c=0xffffffff;
		pVertex[i].Specular.c=0xffffffff;
	}

	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);

	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);    
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE);		
	CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE);

	m_pd3dDevice->SetTexture(1,NULL);
	m_pd3dDevice->SetVertexShader(TLVERTEXFVF);

	CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_ONE);
    CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_ONE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE);	

	color VertexColor;

	for(int cTexture=0;cTexture<9;cTexture++)	
	{
		VertexColor.r=(unsigned char)(32.0f/(float)8.0f);		
		VertexColor.a=VertexColor.b=VertexColor.g=VertexColor.r;
		VertexColor.a=255;
		////////				
		pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
			=VertexColor.c;
		////////
		m_pd3dDevice->SetTexture(0,m_FullSceneTexture.GetTexture());

		switch(cTexture)
		{
			case 0:
				pVertex[0].Diffuse.c=pVertex[1].Diffuse.c=pVertex[2].Diffuse.c=pVertex[3].Diffuse.c
					=0xffeeeeee;
				pVertex[0].v.x=0.0f;
				pVertex[1].v.x=0.0f;				
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
				pVertex[1].v.y=0.0f;
				pVertex[3].v.y=0.0f;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
				break;
			case 1:
				pVertex[0].v.x=-1;
				pVertex[1].v.x=-1;
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
				pVertex[1].v.y=-1;
				pVertex[3].v.y=-1;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
				break;
			case 2:
				pVertex[0].v.x=0;
				pVertex[1].v.x=0;
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
				pVertex[1].v.y=-1;
				pVertex[3].v.y=-1;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
				break;				
			case 3:
				pVertex[0].v.x=1;
				pVertex[1].v.x=1;
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
				pVertex[1].v.y=-1;
				pVertex[3].v.y=-1;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy-1;
				break;
				////////////
			case 4:
				pVertex[0].v.x=-1;
				pVertex[1].v.x=-1;
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
				pVertex[1].v.y=0;
				pVertex[3].v.y=0;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
				break;
			case 5:
				pVertex[0].v.x=1;
				pVertex[1].v.x=1;
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
				pVertex[1].v.y=0;
				pVertex[3].v.y=0;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy;
				break;
				///
			case 6:
				pVertex[0].v.x=-1;
				pVertex[1].v.x=-1;
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx-1;
				pVertex[1].v.y=1;
				pVertex[3].v.y=1;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
				break;
			case 7:
				pVertex[0].v.x=0;
				pVertex[1].v.x=0;
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx; 
				pVertex[1].v.y=1;
				pVertex[3].v.y=1;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
				break;
			case 8:
				pVertex[0].v.x=1;
				pVertex[1].v.x=1;
				pVertex[2].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
				pVertex[3].v.x=(float)BaseGraphicsLayer::m_lScreenSx+1;
				pVertex[1].v.y=1;
				pVertex[3].v.y=1;
				pVertex[0].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
				pVertex[2].v.y=(float)BaseGraphicsLayer::m_lScreenSy+1;
				break;

		}

		

		m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));	
	}
	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
	/*	
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );    
    CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);		
	CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE);
	*/
	/*
	m_pd3dDevice->SetTexture(0,m_FullSceneTexture.GetTexture());
	m_pd3dDevice->SetTexture(1,NULL);
	m_pd3dDevice->SetVertexShader(TLVERTEXFVF);
	m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));	
	*/
}

void CSceneManager::RenderSpecularGlareTexture()
{
	m_pd3dDevice->EndScene();	

	LPDIRECT3DSURFACE8 m_pTempRenderSurface;		
	LPDIRECT3DSURFACE8 m_pTempRenderZBuffer;	
	m_pd3dDevice->GetRenderTarget(&m_pTempRenderSurface);
	m_pd3dDevice->GetDepthStencilSurface(&m_pTempRenderZBuffer);

	m_pd3dDevice->SetRenderTarget(m_SpecularGlareTexture.GetSurface(),m_pTempRenderZBuffer);	
	

	CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
	CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);

	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);

	////////////////////////////////////////////
	m_pd3dDevice->BeginScene();
	m_pd3dDevice->Clear(0,NULL,D3DCLEAR_TARGET,0xff000000,1.0f,0);
	
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2,D3DTA_DIFFUSE);
	CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG2);

	TLVertex pVertex[8];		
	float fTextureSize=128.0f;

	pVertex[0].v.x=0.0f;
	pVertex[1].v.x=0.0f;
	pVertex[2].v.x=fTextureSize;
	pVertex[3].v.x=fTextureSize;

	pVertex[1].v.y=0.0f;
	pVertex[3].v.y=0.0f;
	pVertex[0].v.y=fTextureSize;
	pVertex[2].v.y=fTextureSize;	
		
	pVertex[0].tu=0.0f;
	pVertex[1].tu=0.0f;

	pVertex[3].tu=1.0f;
	pVertex[2].tu=1.0f;

	pVertex[1].tv=0.0f;
	pVertex[3].tv=0.0f;

	pVertex[0].tv=1.0f;
	pVertex[2].tv=1.0f;		

	for(int i=0;i<4;i++)
	{
		pVertex[i].w=0.1f;
		pVertex[i].v.z=0.1f;
		pVertex[i].Diffuse.c=0xff0000ff;
		pVertex[i].Specular.c=0xffffffff;
	}	

	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);	

	m_pd3dDevice->SetTexture(1,NULL);
	m_pd3dDevice->SetVertexShader(TLVERTEXFVF);				
	//m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,pVertex,sizeof(TLVertex));	

	//m_CharacterManager.Render(m_pd3dDevice);
	

	//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);			
		
	CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);	

	CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
    CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);

	m_CharacterManager.RenderGlare(m_pd3dDevice);
	/*
	pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE,TRUE);
	pd3dDevice->SetRenderState( D3DRS_ALPHAREF,0xee);
	*/
	//CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);	


	//m_WeatherManager.Render(m_pd3dDevice);

	m_pd3dDevice->EndScene();
	/////////////////////////////////////////////////
	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
	m_pd3dDevice->SetRenderTarget(m_pTempRenderSurface,m_pTempRenderZBuffer);

	CSceneStateMgr::_SetD3DRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

	m_pTempRenderSurface->Release();
	m_pTempRenderZBuffer->Release();


	m_pd3dDevice->BeginScene();
}

vector3 CSceneManager::PickMousePos(int nMx, int nMy)
{
	//ÀÌ°Å Á¹¶ó ºñ½Ñ ¿¬»êÀÌ´Ù.. À¯ÀÇÇϽñæ..!!!!!!!!!!!!!!

	PickMakeRay(nMx,nMy,BaseGraphicsLayer::m_lScreenSx,BaseGraphicsLayer::m_lScreenSy);

	CSectorScene *pSector;
	
	SectorVertex *pDrawVertex;
	WORD *pDrawIndices;

	vector3 vecStart,vecEnd;
	vector3 vecDirection;

	vecStart=m_vecPickRayStart;
	vecDirection=m_vecPickRayDir;
	vecDirection.Normalize();	
	vecEnd=vecStart+vecDirection*100000.0f;	
	vecStart=vecStart+vecDirection*100.0f;
	vector3 vecTargetPosition;

	float fInterval,fMinInterval=100000.0f;		

	vector3 vecPoly[3];

	vecTargetPosition=vector3(-1000000000.0f,-100000000000.0f,-100000000.0f);

	vector3 vecMaxBox,vecMinBox;
	
	for(int ix=0;ix<m_HeightField.GetLSizeX();ix++)
	{
		for(int iy=0;iy<m_HeightField.GetLSizeY();iy++)
		{
			vecMinBox.x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
			vecMaxBox.x=vecMinBox.x+SECTORSIZE;

			vecMinBox.y=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_vecMinBox.y;
			vecMaxBox.y=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_vecMaxBox.y;	

			vecMinBox.z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43;
			vecMaxBox.z=vecMinBox.z+SECTORSIZE;
			//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
			if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
				CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
				CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
				CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
			{	
				
			}
			else
			{
				continue;
			}

			pSector=&m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()];
			pSector->m_pROAMVertex;
			pSector->m_pROAMIndices;

			//m_UsedVertex,m_UsedIndices/3;

			pSector->m_pROAMVertex->Lock(0,0,(BYTE**)&pDrawVertex,0);
			pSector->m_pROAMIndices->Lock(0,(SECTORSX-1)*(SECTORSY-1)*ROAMBUFFERSIZE*sizeof(WORD),(BYTE**)&pDrawIndices,0);
			
			for(int cPoly=0;cPoly<pSector->m_UsedIndices/3;cPoly++)
			{
				vecPoly[0]=pDrawVertex[pDrawIndices[cPoly*3+0]].v+pSector->m_AccumulateTM.GetLoc();
				vecPoly[1]=pDrawVertex[pDrawIndices[cPoly*3+1]].v+pSector->m_AccumulateTM.GetLoc();
				vecPoly[2]=pDrawVertex[pDrawIndices[cPoly*3+2]].v+pSector->m_AccumulateTM.GetLoc();

				if(CIntersection::PolygonRay(vecStart,vecEnd,vecPoly,fInterval))
				{
					if(fInterval <= fMinInterval)
					{
						fMinInterval=fInterval;
						vecTargetPosition=vecStart+vecDirection*fMinInterval;
					}
				}
			}
			pSector->m_pROAMVertex->Unlock();
			pSector->m_pROAMIndices->Unlock();
		}
	}

	///////////////////////////////
	//Picking In Building 
	///////////////////////////////
	List<vector3> vecPolyList;
	for(ix=0;ix<m_HeightField.GetLSizeX();ix++)
	{
		for(int iy=0;iy<m_HeightField.GetLSizeY();iy++)
		{
			vecMinBox.x=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._41;
			vecMaxBox.x=vecMinBox.x+SECTORSIZE;

			vecMinBox.y=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_vecMinBox.y;
			vecMaxBox.y=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_vecMaxBox.y;	

			vecMinBox.z=m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].m_AccumulateTM._43;
			vecMaxBox.z=vecMinBox.z+SECTORSIZE;
			//if(m_SectorScene[ix+iy*m_LSizeX].isCulling())
			if( CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumTop,-CSceneManager::GetCamera()->m_vecFrustumNormal[0],vecMaxBox,vecMinBox) < 0.0f &&
				CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumBottom,-CSceneManager::GetCamera()->m_vecFrustumNormal[1],vecMaxBox,vecMinBox) < 0.0f &&
				CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumLeft,-CSceneManager::GetCamera()->m_vecFrustumNormal[2],vecMaxBox,vecMinBox) < 0.0f &&
				CIntersection::PlaneAABBBox(CSceneManager::GetCamera()->m_vecFrustumRight,-CSceneManager::GetCamera()->m_vecFrustumNormal[3],vecMaxBox,vecMinBox) < 0.0f)
			{	
				
			}
			else
			{
				continue;
			}
			
			//GetPickHousePoly(vector3 vecStart,vector3 vecEnd,List<vector3> &vecPolyList)
			m_HeightField.m_SectorScene[ix+iy*m_HeightField.GetLSizeX()].GetPickHousePoly(vecStart,vecEnd,vecPolyList);
			//GetInHouseShadowPoly(vecEnd,vecPolyList,vecStart);

		}
	}
	if(m_CharacterManager.m_CharacterList.num==0)
		return vecTargetPosition;

	vector3 vecChrPos;

	m_CharacterManager.m_CharacterList[0].m_pChrmodel->GetPosition(vecChrPos);

	vecChrPos.y;

	vector3 vecCheckPoly[3];
	float fInterLens;
	float fMaxInterLens=1000000000.0f;
	vecDirection=vecEnd-vecStart;
	vecDirection.Normalize();
	vector3 vecPlaneNormal;

	

	
	
	for(int cPoly=0;cPoly<vecPolyList.num;cPoly+=3)
	{
		vecCheckPoly[0]=vecPolyList[cPoly+0];
		vecCheckPoly[1]=vecPolyList[cPoly+1];
		vecCheckPoly[2]=vecPolyList[cPoly+2];

		vecPlaneNormal=(vecCheckPoly[0]-vecCheckPoly[1])^(vecCheckPoly[2]-vecCheckPoly[1]);
		vecPlaneNormal.Normalize();

		if(fabsf(vecPlaneNormal.y) >= fabsf(vecPlaneNormal.x) && fabsf(vecPlaneNormal.y) >= fabsf(vecPlaneNormal.z))
		{
			if(CIntersection::PolygonRay(vecStart,vecEnd,vecCheckPoly,fInterLens))
			{
				vector3 vecTarPos=vecStart+fInterLens*vecDirection;				

				if(fabsf(vecChrPos.y-vecTarPos.y) < fMaxInterLens)
				{				
					vecTargetPosition=vecStart+fInterLens*vecDirection;				
					fMaxInterLens=fabsf(vecChrPos.y-vecTarPos.y);
				}
			}
		}
	}
	return vecTargetPosition;
}

CollisionType CSceneManager::GetCharacterCollisionType(CZ3DGeneralChrModel *pChrmodel)
{
	return m_CharacterManager.GetCharacterCollisionType(pChrmodel);
}

void CSceneManager::BaseGraphicsDataLoad(char *strZoneName)
{
	if(strcmp(strZoneName,"")==0)
	{
		if(CGrassScene::m_NormalTexture==NULL)
		{
			CTexture::SetPath(NATURETEXTUREPATH);
			CGrassScene::m_NormalTexture=new CTexture();
			CGrassScene::m_NormalTexture->Load("grass.dds");			
		}

		CTexture::SetPath(TERRAINTEXTUREPATH);
		/*
		m_TerrainTexture[0].Load("hig0.dds");
		m_TerrainTexture[1].Load("hig1.dds");
		m_TerrainTexture[2].Load("hig2.dds");
		m_TerrainTexture[3].Load("hig3.dds");	

		m_TerrainTexture[4].Load("med0.dds");		
		m_TerrainTexture[5].Load("med1.dds");
		m_TerrainTexture[6].Load("med2.dds");
		m_TerrainTexture[7].Load("med3.dds");

		m_TerrainTexture[8].Load("low0.dds");
		m_TerrainTexture[9].Load("low1.dds");
		m_TerrainTexture[10].Load("low2.dds");
		m_TerrainTexture[11].Load("low3.dds");
		*/
		CSectorScene::m_DetailTexture.Load("detail.dds");	
		
		if(CRenderOption::m_RangeGrassRender)
		{		
			CTexture::SetPath(NATURETEXTUREPATH);

			CSectorScene::m_LODGrassTexture.Load("LODGrass.dds");

			CSectorScene::m_GrassRangeTexture=new CTexture();
			CSectorScene::m_GrassRangeTexture->Load("GrassRange.dds");
		}

		CTexture::SetPath(NATURETEXTUREPATH);
		CSkyScene::m_CloudTexture.Load("Clouds.dds");	
		// µ¿±â Rain Ãß°¡
		CSkyScene::m_LightLayerTexture[0].Load("lightning.dds");
		CSkyScene::m_LightLayerTexture[1].Load("lightning1.dds");
		CSkyScene::m_LightLayerTexture[2].Load("lightning2.dds");


		if(CTreeScene::m_NormalTreeMesh[0]==NULL)
		{			
			CTexture::SetPath(OBJECTTEXTUREPATH);
			CSceneManager::m_MeshObjectContainer.SetPath(TREEOBJECTPATH);			

			char strName[256];
			for(int i=0;i<MAX_TREEKIND;i++)
			{
				sprintf(strName,"NormalTree%d.R3S",i+1);
				CTreeScene::m_NormalTreeMesh[i]=CSceneManager::m_MeshObjectContainer.GetMeshObject(strName);		
				if(CRenderOption::m_TreeAnimation)
					CTreeScene::m_NormalTreeMesh[i]->ConvertTree();	
				else
					CTreeScene::m_NormalTreeMesh[i]->ConvertNormal();
				if(i+1<10)
					sprintf(strName,"tree0%d_lod_fr.R3S",i+1);
				else
					sprintf(strName,"tree%d_lod_fr.R3S",i+1);				

				CTreeScene::m_NormalTreeMeshLOD[i]=CSceneManager::m_MeshObjectContainer.GetMeshObject(strName);
				if(CRenderOption::m_TreeAnimation)
					CTreeScene::m_NormalTreeMeshLOD[i]->ConvertTree();
				else
					CTreeScene::m_NormalTreeMeshLOD[i]->ConvertNormal();				
			}
			/*
			CTreeScene::m_NormalTreeLeaves[0]=CSceneManager::m_MeshObjectContainer.GetMeshObject("leaves.R3S");
			CTreeScene::m_NormalTreeLeaves[0]->ConvertTree();
			CTreeScene::m_NormalTreeTrunk[0]=CSceneManager::m_MeshObjectContainer.GetMeshObject("trunk.R3S");		
			CTreeScene::m_NormalTreeTrunk[0]->ConvertTree();
			*/

		}		
		m_WeatherManager.Load();
	///////		
		char strTableName[256] = {0,};
		char strBuffer[256] = {0,};
		char *strPtr = NULL;
		strcpy(strTableName,WEATHERPATH);
		strPtr = strrchr(strTableName,'.');
		strPtr++;
		(*strPtr) = 't';
		strPtr++;
		(*strPtr) = 'a';
		strPtr++;
		(*strPtr) = 'b';
		strPtr++;
		(*strPtr) = 'l';
		strPtr++;
		(*strPtr) = 'e';
		strPtr++;
		(*strPtr) = 0;
		
		FILE *fp = fopen(strTableName,"rt");
		if(fp)
		{
			
			int *iPtr;
			int iPtrNum;
			char *str;
			fgets(strBuffer,256,fp);
			iPtrNum = atoi(strBuffer);
			iPtr = new int[iPtrNum];
			memset(strBuffer,0,sizeof(char) * 256);
			fgets(strBuffer,256,fp);
			int iNum;
		
			for(iNum = 0; iNum < iPtrNum; iNum++)
			{
				if(iNum == 0)
					str = strtok(strBuffer," \n");
				else
					str = strtok(NULL," \n");
				iPtr[iNum] = atoi(str);
			}
			
			fclose(fp);

			m_WeatherManager.LoadSubTable(iPtr,iPtrNum);
			delete[] iPtr;
	
		}
		//////
	}
	else
	{
		// 03.03.04 Á¸ ÆÄÀÏ¿¡ µû¶ó ³¯¾¾¿Í culling ´Ù¸£°Ô ÇØÁØ´Ù (Zone5)
		// Init Zone Value
		char strSetPath[256] = {0};

		m_ZoneInfoData.m_bZoneInfo = false;
		memset(m_ZoneInfoData.m_fZoneInfo,0,sizeof(float) * 30);
		memset(m_ZoneInfoData.m_iZoneInfo,0,sizeof(int) * 30);

		if(CRenderOption::LoadZoneInfo(&m_ZoneInfoData))
		{
			// Int 0 : weather time
			//	   1 : House Cull
			//	   2 : Object Cull
			//     3 : Effect Cull
			//	   4 : Path Setting

			// float 0 1 2 ->map min size
			//		 3 4 5 ->map max size
			//		 6 7 ->map Y Bound		
			SetWeatherTime(m_ZoneInfoData.m_iZoneInfo[0]);
			m_HeightField.SetHouseCulling((m_ZoneInfoData.m_iZoneInfo[1]) ? true : false);
			m_HeightField.SetObjectCulling((m_ZoneInfoData.m_iZoneInfo[2]) ? true : false);
			m_HeightField.SetEffectCulling((m_ZoneInfoData.m_iZoneInfo[3]) ? true : false);
			// Map Size Setting
			SetMapSize(vector3(m_ZoneInfoData.m_fZoneInfo[0],m_ZoneInfoData.m_fZoneInfo[1],m_ZoneInfoData.m_fZoneInfo[2]),
						vector3(m_ZoneInfoData.m_fZoneInfo[3],m_ZoneInfoData.m_fZoneInfo[4],m_ZoneInfoData.m_fZoneInfo[5]));
			// Zone Y Bound
			m_CollisionDetection.SetZoneBound(m_ZoneInfoData.m_fZoneInfo[6],m_ZoneInfoData.m_fZoneInfo[7]);
			
			if(m_ZoneInfoData.m_iZoneInfo[4] != 0) {
				sprintf(strSetPath,"Zone%d",m_ZoneInfoData.m_iZoneInfo[4]);
			}
		}
		else {
			m_HeightField.SetHouseCulling(true);
			m_HeightField.SetObjectCulling(true);
			m_HeightField.SetEffectCulling(true);
			m_CollisionDetection.SetZoneBound(-123.0f,-123.0f);
		}
		if(strlen(strSetPath) > 1) { // Á¸ path Setting
			sprintf(WEATHERPATH,"%s\\WeatherColorTable_%s.dat",m_SceneManagerPath,strZoneName);		
			sprintf(TREEOBJECTPATH,"%s\\Objects\\NatureObject\\%s\\",m_SceneManagerPath,strSetPath);		
			sprintf(MAPDATAPATH,"%s\\MapData\\%s",m_SceneManagerPath,strZoneName);		
			if(CRenderOption::m_TextureMethod)
			{		
				sprintf(NATURETEXTUREPATH,"%s\\Texture\\NatureObject\\%s",m_SceneManagerPath,strSetPath);
				sprintf(WIDETEXTUREPATH,"%s\\Texture\\WideTexture\\%s",m_SceneManagerPath,strZoneName);
				sprintf(TERRAINTEXTUREPATH,"%s\\Texture\\Terrain\\%s",m_SceneManagerPath,strSetPath);
				sprintf(UNSHADOWWIDETEXTUREPATH,"%s\\Texture\\UnShadowWideTexture\\%s",m_SceneManagerPath,strSetPath);


			}
			else
			{
				sprintf(NATURETEXTUREPATH,"%s\\LowTexture\\NatureObject\\%s",m_SceneManagerPath,strSetPath);
				sprintf(WIDETEXTUREPATH,"%s\\LowTexture\\WideTexture\\%s",m_SceneManagerPath,strZoneName);
				sprintf(TERRAINTEXTUREPATH,"%s\\LowTexture\\Terrain\\%s",m_SceneManagerPath,strSetPath);
				sprintf(UNSHADOWWIDETEXTUREPATH,"%s\\Texture\\UnShadowWideTexture\\%s",m_SceneManagerPath,strSetPath);
			}		

		}
		else {
			sprintf(WEATHERPATH,"%s\\WeatherColorTable_%s.dat",m_SceneManagerPath,strZoneName);		
			sprintf(TREEOBJECTPATH,"%s\\Objects\\NatureObject\\%s\\",m_SceneManagerPath,strZoneName);		
			sprintf(MAPDATAPATH,"%s\\MapData\\%s",m_SceneManagerPath,strZoneName);
			if(strstr(strZoneName,"Zone8") != NULL)	// Zone 8 Setting
				MAX_OBJECTVIEWRANBE *= 2.0f;

			if(CRenderOption::m_TextureMethod)
			{		
				sprintf(NATURETEXTUREPATH,"%s\\Texture\\NatureObject\\%s",m_SceneManagerPath,strZoneName);
				sprintf(WIDETEXTUREPATH,"%s\\Texture\\WideTexture\\%s",m_SceneManagerPath,strZoneName);
				sprintf(UNSHADOWWIDETEXTUREPATH,"%s\\Texture\\UnShadowWideTexture\\%s",m_SceneManagerPath,strZoneName);
				sprintf(TERRAINTEXTUREPATH,"%s\\Texture\\Terrain\\%s",m_SceneManagerPath,strZoneName);
			}
			else
			{
				sprintf(NATURETEXTUREPATH,"%s\\LowTexture\\NatureObject\\%s",m_SceneManagerPath,strZoneName);
				sprintf(WIDETEXTUREPATH,"%s\\LowTexture\\WideTexture\\%s",m_SceneManagerPath,strZoneName);
				sprintf(TERRAINTEXTUREPATH,"%s\\LowTexture\\Terrain\\%s",m_SceneManagerPath,strZoneName);
				sprintf(UNSHADOWWIDETEXTUREPATH,"%s\\Texture\\UnShadowWideTexture\\%s",m_SceneManagerPath,strZoneName);
			}		
		}
		m_WeatherManager.Load();
///////		
		char strTableName[256] = {0,};
		char strBuffer[256] = {0,};
		char *strPtr = NULL;
		strcpy(strTableName,WEATHERPATH);
		strPtr = strrchr(strTableName,'.');
		strPtr++;
		(*strPtr) = 't';
		strPtr++;
		(*strPtr) = 'a';
		strPtr++;
		(*strPtr) = 'b';
		strPtr++;
		(*strPtr) = 'l';
		strPtr++;
		(*strPtr) = 'e';
		strPtr++;
		(*strPtr) = 0;
		FILE *fp = fopen(strTableName,"rt");
		if(fp)
		{
			
			int *iPtr;
			int iPtrNum;
			char *str;
			fgets(strBuffer,256,fp);
			iPtrNum = atoi(strBuffer);
			iPtr = new int[iPtrNum];
			memset(strBuffer,0,sizeof(char) * 256);
			fgets(strBuffer,256,fp);
			int iNum;
		
			for(iNum = 0; iNum < iPtrNum; iNum++)
			{
				if(iNum == 0)
					str = strtok(strBuffer," \n");
				else
					str = strtok(NULL," \n");
				iPtr[iNum] = atoi(str);
			}
			
			fclose(fp);

			m_WeatherManager.LoadSubTable(iPtr,iPtrNum);
			delete[] iPtr;

			
		}
		//////
		CTexture::SetPath(TERRAINTEXTUREPATH);
		/*
		m_TerrainTexture[0].Load("hig0.dds");
		m_TerrainTexture[1].Load("hig1.dds");
		m_TerrainTexture[2].Load("hig2.dds");
		m_TerrainTexture[3].Load("hig3.dds");	

		m_TerrainTexture[4].Load("med0.dds");		
		m_TerrainTexture[5].Load("med1.dds");
		m_TerrainTexture[6].Load("med2.dds");
		m_TerrainTexture[7].Load("med3.dds");

		m_TerrainTexture[8].Load("low0.dds");
		m_TerrainTexture[9].Load("low1.dds");
		m_TerrainTexture[10].Load("low2.dds");
		m_TerrainTexture[11].Load("low3.dds");
		*/
		CSectorScene::m_DetailTexture.Load("detail.dds");	

		if(CRenderOption::m_GrassRendering)
		{
			if(CGrassScene::m_NormalTexture==NULL)
			{
				CTexture::SetPath(NATURETEXTUREPATH);
				CGrassScene::m_NormalTexture=new CTexture();
				CGrassScene::m_NormalTexture->Load("grass.dds");			
			}
		}
		
		if(CRenderOption::m_RangeGrassRender)
		{		
			CTexture::SetPath(NATURETEXTUREPATH);

			CSectorScene::m_LODGrassTexture.Load("LODGrass.dds");

			CSectorScene::m_GrassRangeTexture=new CTexture();
			CSectorScene::m_GrassRangeTexture->Load("GrassRange.dds");
		}

		CTexture::SetPath(NATURETEXTUREPATH);
		CSkyScene::m_CloudTexture.Load("Clouds.dds");	
		
		// Rain µ¿±â Ãß°¡
		CSkyScene::m_LightLayerTexture[0].Load("lightning.dds");
		CSkyScene::m_LightLayerTexture[1].Load("lightning1.dds");
		CSkyScene::m_LightLayerTexture[2].Load("lightning2.dds");

		if(CTreeScene::m_NormalTreeMesh[0]==NULL)
		{			
			CTexture::SetPath(OBJECTTEXTUREPATH);
			CSceneManager::m_MeshObjectContainer.SetPath(TREEOBJECTPATH);			

			char strName[256];
			for(int i=0;i<MAX_TREEKIND;i++)
			{
				sprintf(strName,"NormalTree%d.R3S",i+1);
				CTreeScene::m_NormalTreeMesh[i]=CSceneManager::m_MeshObjectContainer.GetMeshObject(strName);		
				if(CRenderOption::m_TreeAnimation)
					CTreeScene::m_NormalTreeMesh[i]->ConvertTree();	
				else
					CTreeScene::m_NormalTreeMesh[i]->ConvertNormal();
				if(i+1<10)
					sprintf(strName,"tree0%d_lod_fr.R3S",i+1);
				else
					sprintf(strName,"tree%d_lod_fr.R3S",i+1);				

				CTreeScene::m_NormalTreeMeshLOD[i]=CSceneManager::m_MeshObjectContainer.GetMeshObject(strName);
				if(CRenderOption::m_TreeAnimation)
					CTreeScene::m_NormalTreeMeshLOD[i]->ConvertTree();		
				else
					CTreeScene::m_NormalTreeMeshLOD[i]->ConvertNormal();				
			}
		}

		/*
		CTreeScene::m_NormalTreeLeaves[0]=CSceneManager::m_MeshObjectContainer.GetMeshObject("leaves.R3S");
		CTreeScene::m_NormalTreeLeaves[0]->ConvertTree();
		CTreeScene::m_NormalTreeTrunk[0]=CSceneManager::m_MeshObjectContainer.GetMeshObject("trunk.R3S");		
		CTreeScene::m_NormalTreeTrunk[0]->ConvertTree();
		*/

		char strWaterTextureName[256];

		CTexture::SetPath(NATURETEXTUREPATH);
		
		for(int i=0;i<MAX_WATERTEXTURE;i++)
		{
			sprintf(strWaterTextureName,"water%4d.dds",i);
			int strLens=strlen(strWaterTextureName);
			for(int cStr=0;cStr<strLens;cStr++)
			{
				if(strWaterTextureName[cStr]==' ')
					strWaterTextureName[cStr]='0';
			}
			CWaterScene::m_WaterTexture[i].Load(strWaterTextureName);
		}

	}
}

void CSceneManager::BaseGraphicsDataUnload()
{
	CSectorScene::m_DetailTexture.Unload();	

	if(CRenderOption::m_GrassRendering)
	{
		delete CGrassScene::m_NormalTexture;
		CGrassScene::m_NormalTexture=NULL;	
	}	
	if(CTreeScene::m_NormalTreeMesh[0]!=NULL)
	{	
		char strName[256];
		for(int i=0;i<MAX_TREEKIND;i++)
		{
			sprintf(strName,"NormalTree%d.R3S",i+1);
			m_MeshObjectContainer.DeleteMeshObject(strName);		
			CTreeScene::m_NormalTreeMesh[i]=NULL;
			
			if(i+1<10)
				sprintf(strName,"tree0%d_lod_fr.R3S",i+1);
			else
				sprintf(strName,"tree%d_lod_fr.R3S",i+1);				

			m_MeshObjectContainer.DeleteMeshObject(strName);		

			CTreeScene::m_NormalTreeMeshLOD[i]=NULL;	
		}		
		
	}			
}

void CSceneManager::SetSceneManagerPath(char *strSceneManagerPath)
{
	strcpy(m_SceneManagerPath,strSceneManagerPath);
	sprintf(ROOTPATH,"%s\\",strSceneManagerPath);
	sprintf(CHARACTERDATAPATH,"%s\\Character\\Data\\",strSceneManagerPath);//char CHARACTERDATAPATH[256]="c:\\MP-Project\\Character\\Data\\";
	sprintf(CHARACTERTEXTUREDATAPATH,"%s\\Character\\Data\\tex\\",strSceneManagerPath);//char CHARACTERTEXTUREDATAPATH[256]="c:\\MP-Project\\Character\\Data\\tex\\";
	sprintf(CHARACTERMESHTEX,"%s\\Character\\Data\\meshtex.htable",strSceneManagerPath);//char CHARACTERMESHTEX[256]="c:\\MP-Project\\Character\\Data\\meshtex.htable";
	sprintf(CHARACTERANIPACK,"%s\\Character\\Data\\ani\\APack.ntable",strSceneManagerPath);//char CHARACTERANIPACK[256]="c:\\MP-Project\\Character\\Data\\ani\\APack.ntable";
	sprintf(CHARACTERLODMESH,"%s\\Character\\Data\\mesh\\LODMesh.ntable",strSceneManagerPath);//char CHARACTERLODMESH[256]="c:\\MP-Project\\Character\\Data\\mesh\\LODMesh.ntable";
	sprintf(CHARACTERTEXPIECE,"%s\\Character\\Data\\tex\\Texpiece.ntable",strSceneManagerPath);//char CHARACTERTEXPIECE[256]="c:\\MP-Project\\Character\\Data\\tex\\Texpiece.ntable";
	sprintf(CHARACTERATTACHMENTMESH,"%s\\Character\\Data\\Amesh\\amesh.ntable",strSceneManagerPath);//char CHARACTERATTACHMENTMESH[256]="c:\\MP-Project\\Character\\Data\\Amesh\\amesh.ntable";
	sprintf(CHARACTERTEXTURE,"%s\\Character\\Data\\Texture\\texture.ntable",strSceneManagerPath);//char CHARACTERTEXTURE[256]="c:\\MP-Project\\Character\\Data\\Texture\\texture.ntable";
	
	sprintf(HOUSEOBJECTPATH,"%s\\Objects\\House\\",strSceneManagerPath);//char HOUSEOBJECTPATH[256]="c:\\MP-Project\\Objects\\House\\";
	sprintf(LIGHTOBJECTPATH,"%s\\Objects\\Object\\",strSceneManagerPath);//char LIGHTOBJECTPATH[256]="c:\\MP-Project\\Objects\\Object\\";
	sprintf(TREEOBJECTPATH,"%s\\Objects\\NatureObject\\",strSceneManagerPath);//char TREEOBJECTPATH[256]="c:\\MP-Project\\Objects\\NatureObject\\";
	sprintf(OBJECTPATH,"%s\\Objects\\Object\\",strSceneManagerPath);//char OBJECTPATH[256]="c:\\MP-Project\\Objects\\Object\\";
	sprintf(INSTANCEOBJECTPATH,"%s\\Objects\\Instance\\",strSceneManagerPath);//ect\\Objects\Instance\\;

	if(CRenderOption::m_TextureMethod==1)
	{
		sprintf(CHARACTERTEXTURE,"%s\\Character\\Data\\Texture\\texture.ntable",strSceneManagerPath);//char CHARACTERTEXTURE[256]="c:\\MP-Project\\Character\\Data\\Texture\\texture.ntable";
		sprintf(TERRAINTEXTUREPATH,"%s\\Texture\\Terrain",strSceneManagerPath);//char TERRAINTEXTUREPATH[256]="c:\\MP-project\\Texture\\Terrain";
		sprintf(OBJECTTEXTUREPATH,"%s\\Texture\\Object",strSceneManagerPath);//char OBJECTTEXTUREPATH[256]="c:\\MP-Project\\Texture\\Object";
		sprintf(NATURETEXTUREPATH,"%s\\Texture\\NatureObject",strSceneManagerPath);//char NATURETEXTUREPATH[256]="c:\\MP-project\\Texture\\NatureObject";
		sprintf(WIDETEXTUREPATH,"%s\\Texture\\WideTexture",strSceneManagerPath);//char WIDETEXTUREPATH[256]="C:\\MP-Project\\Texture\\WideTexture";	
		sprintf(INTERFACETEXTUREPATH,"%s\\Texture\\Interface",strSceneManagerPath);//char INTERFACETEXTUREPATH[256]="c:\\MP-Project\\Texture\\Interface";
		sprintf(FXTEXTUREPATH,"%s\\Texture\\FX",strSceneManagerPath);//char FXTEXTUREPATH[256]="c:\\MP-Project\\Texture\\FX";
		sprintf(LIGHTMAPTEXTUREPATH,"%s\\Texture\\Lightmap",strSceneManagerPath);//char LIGHTMAPTEXTUREPATH[256]="c:\\MP-Project\\Texture\\Lightmap";
		sprintf( EFFECTTEXTUREPATH, "%s\\Texture\\Effect\\",strSceneManagerPath );
	}
	else
	{
		sprintf(CHARACTERTEXTURE,"%s\\Character\\Data\\LowTexture\\texture.ntable",strSceneManagerPath);//char CHARACTERTEXTURE[256]="c:\\MP-Project\\Character\\Data\\Texture\\texture.ntable";
		sprintf(TERRAINTEXTUREPATH,"%s\\LowTexture\\Terrain",strSceneManagerPath);//char TERRAINTEXTUREPATH[256]="c:\\MP-project\\Texture\\Terrain";
		sprintf(OBJECTTEXTUREPATH,"%s\\LowTexture\\Object",strSceneManagerPath);//char OBJECTTEXTUREPATH[256]="c:\\MP-Project\\Texture\\Object";
		sprintf(NATURETEXTUREPATH,"%s\\LowTexture\\NatureObject",strSceneManagerPath);//char NATURETEXTUREPATH[256]="c:\\MP-project\\Texture\\NatureObject";
		sprintf(WIDETEXTUREPATH,"%s\\LowTexture\\WideTexture",strSceneManagerPath);//char WIDETEXTUREPATH[256]="C:\\MP-Project\\Texture\\WideTexture";	
		sprintf(INTERFACETEXTUREPATH,"%s\\LowTexture\\Interface",strSceneManagerPath);//char INTERFACETEXTUREPATH[256]="c:\\MP-Project\\Texture\\Interface";
		sprintf(FXTEXTUREPATH,"%s\\LowTexture\\FX",strSceneManagerPath);//char FXTEXTUREPATH[256]="c:\\MP-Project\\Texture\\FX";
		sprintf(LIGHTMAPTEXTUREPATH,"%s\\LowTexture\\Lightmap",strSceneManagerPath);//char LIGHTMAPTEXTUREPATH[256]="c:\\MP-Project\\Texture\\Lightmap";
		sprintf( EFFECTTEXTUREPATH, "%s\\LowTexture\\Effect\\",strSceneManagerPath );
	}
	sprintf(TERRAINVERTEXSHADEROATH,"%s\\VertexShader\\LayerFog\\LayerFogTerrain.vsh",strSceneManagerPath);//char TERRAINVERTEXSHADEROATH[256]="c:\\MP-Project\\VertexShader\\LayerFog\\LayerFogTerrain.vsh";
	sprintf(WEATHERPATH,"%s\\WeatherColorTable.dat",strSceneManagerPath);//char WEATHERPATH[256]="c:\\MP-Project\\WeatherColorTable.dat";
	sprintf(OCTREEPATH,"%s\\Octree",strSceneManagerPath);//char OCTREEPATH[256]="c:\\MP-Project\\Octree";
	sprintf(SOUNDFILEPATH,"%s\\Sound\\",strSceneManagerPath);//char SOUNDFILEPATH[256]="c:\\MP-Project\\Sound\\";

	sprintf( EFFECTPATH, "%s\\Effect\\", strSceneManagerPath );
	sprintf( EFFECTSOUNDSPATH,"%s\\Sound\\Effect\\Ssnd\\",strSceneManagerPath);
	sprintf( EFFECTSOUNDMPATH,"%s\\Sound\\Effect\\Msnd\\",strSceneManagerPath);

	// effect texture path
	
	sprintf( EFFECTSCRIPTPATH,"%s\\Effect\\Esf\\",strSceneManagerPath);
	
	//mesh morph
	sprintf( OBJECTGEMPATH, "%s\\Objects\\Gem\\",strSceneManagerPath );
	
}

void CSceneManager::CharacterFirstAccelate(CZ3DGeneralChrModel *pChrmodel, bool bFirstAccelate)
{
	m_CharacterManager.CharacterFirstAccelate(pChrmodel,bFirstAccelate);
}

CZ3DGeneralChrModel* CSceneManager::PickingCharacter(int MouseX, int MouseY)
{
	PickMakeRay(MouseX,MouseY,BaseGraphicsLayer::m_lScreenSx,BaseGraphicsLayer::m_lScreenSy);

	vector3 vecChrPos;

	
	float fRad=50.0f;
	float fNearestInterval=100.0f;

	CZ3DGeneralChrModel *pResult=NULL;

	vector3 vecMousePos;
	vecMousePos.x=MouseX;
	vecMousePos.y=MouseY;
	vecMousePos.z=0.0f;

	vector3 vecLens;

	vector3 vecViewPos=*CSceneManager::GetCamera()->GetPosition();

	for(int cChr=0;cChr<m_CharacterManager.m_CharacterList.num;cChr++)
	{
		m_CharacterManager.m_CharacterList[cChr].m_pChrmodel->GetPosition(vecChrPos);		
		vecChrPos.y+=100.0f;

		vector3 vecResult;
		float fW;
		if(BaseGraphicsLayer::TransformVector(vecChrPos,vecResult,fW))
		{			
			if(vecResult.z<0.0f || vecResult.z>1.0f)
				continue;

			vecLens=vecViewPos-vecChrPos;

			float fInterCamera=vecLens.GetLens();
			
			float fZRate=-(fInterCamera/10000.0f)+1;

			vecResult.z=0.0f;
			
			vecLens=vecMousePos-vecResult;

			float fTemp=vecLens.GetLens();

			if(fTemp <= fRad*fZRate)
			{
				pResult=m_CharacterManager.m_CharacterList[cChr].m_pChrmodel;
			}		
			
			/*
			float fTransRad=fRad/vecResult.z;
			
			float fTemp=vecResult.z;
			vecResult.z=0.0f;
			vecLens=vecMousePos-vecResult;

			if(vecLens.GetLens() <= fTransRad)
			{
  				pResult=m_CharacterManager.m_CharacterList[cChr].m_pChrmodel;
			}
			*/
			/*
			vecResult.z=0.0f;
			vecLens=vecMousePos-vecResult;
			if(vecLens.GetLens()<=fNearestInterval)
			{
				pResult=m_CharacterManager.m_CharacterList[cChr].m_pChrmodel;
				fNearestInterval=vecLens.GetLens();
			}
			*/
		}
		/*
		vecChrPos.y+=150.0f;
		vector3 vecInter=m_vecPickRayStart-vecChrPos;
		float fC=(vecInter*vecInter)-fRad;
		float fB=m_vecPickRayDir*(m_vecPickRayStart-vecChrPos);

		if(fB*fB-fC>=0.0f)
		{
			if(vecInter.GetLens()<=fNearestInterval)
			{
				pResult=m_CharacterManager.m_CharacterList[cChr].m_pChrmodel;

				fNearestInterval=vecInter.GetLens();
			}
		}
		*/
	}
	return pResult;
	/*

	

	vector3 vecInter=m_vecPickRayStart-vecObjectPos;

			float fC=(vecInter*vecInter)-fRad;
			float fB=m_vecPickRayDir*(m_vecPickRayStart-vecObjectPos);

			vecObjectPos=m_vecPickRayStart-vecObjectPos;
			
			if(fB*fB-fC>=0.0f)
			{
				if(vecObjectPos.GetLens() <= fNearestInterval) 
				{
					if(PickMode==2)
					{						
						m_pBspScene->m_HouseObject->m_pBspObject->m_SelectLight=cLight;
						fNearestInterval=vecObjectPos.GetLens();						
					}
				}
			}			
			*/

}

void CSceneManager::CharacterCollisionAble(CZ3DGeneralChrModel *pChrmodel, bool bCollisionDetectionAble)
{
	m_CharacterManager.CharacterCollisionAble(pChrmodel,bCollisionDetectionAble);
}

void CSceneManager::CharacterGravityAble(CZ3DGeneralChrModel *pChrmodel, bool bGravityAble)
{
	m_CharacterManager.CharacterGravityAble(pChrmodel,bGravityAble);
}

void CSceneManager::ResetTerrain()
{

}

void CSceneManager::SetMapSize(vector3 vecMinSize, vector3 vecMaxSize)
{	
	m_CollisionDetection.m_vecMinMove=vecMinSize;
	m_CollisionDetection.m_vecMaxMove=vecMaxSize;
}

void CSceneManager::CharacterCollisionDetectType(CZ3DGeneralChrModel *pChrmodel, int nType)
{
	m_CharacterManager.CharacterCollisionDetectType(pChrmodel,nType);
}

CCharacterLightShadowManager::CCharacterDataNode CSceneManager::GetCharacterDataNode(CZ3DGeneralChrModel *pChrmodel)
{
	return m_CharacterManager.GetCharacterDataNode(pChrmodel);
}

void CSceneManager::SetCharacterDataNode(CCharacterLightShadowManager::CCharacterDataNode SetNode)
{
	m_CharacterManager.SetCharacterDataNode(SetNode);
}
void CSceneManager::PickSectorEffect(int b) {			// 03.03.04 Ãß°¡
	static int iPickSector = 0;							// Effect Sectormap select
	
	if(iPickSector < 0)									// b°¡ 0 À̸é À妽ºÁõ°¡ 1ÀÌ¸é °¨¼Ò
		iPickSector = 0;

	m_PickEffect = m_MapStorage.FindEffectMap(iPickSector);
	if(!b)
		iPickSector++;
	else
		iPickSector--;


}
void CSceneManager::PickEffect2(int b) {				// 03.03.04 Ãß°¡
	static int iPick = 0;								// m_PickEffect ¾ÈÀÇ effect µéÀ» ¼øȸÇÑ´Ù.
														// b°¡ 0 À̸é À妽ºÁõ°¡ 1ÀÌ¸é °¨¼Ò 
	if(iPick >= m_PickEffect->m_vecEffectPos.num)
		iPick = 0;
	
	else if(iPick < 0)
		iPick = 0;

	m_PickEffect->pick_index = iPick;
	
	if(!b)
		iPick++;
	else
		iPick--;

}
void CSceneManager::RenderInCubemap()
{
	if(CRenderOption::m_WaterBumpEnvRendering)
	{
		D3DXMATRIX matOldProj,matOldView,matOldWorld;

		D3DXMATRIX matProj;
		D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI * 0.5f, 1.0f, 50.0f,620000.0f);

		D3DVIEWPORT8 Viewport;
		D3DVIEWPORT8 CubeViewport;
		   
		CubeViewport.X = 0;
		CubeViewport.Y = 0;
		CubeViewport.Width = 256;
		CubeViewport.Height = 256;
		CubeViewport.MinZ = 0.0f;
		CubeViewport.MaxZ = 1.0f;
		m_pd3dDevice->GetViewport(&Viewport);

		m_pd3dDevice->GetTransform(D3DTS_VIEW,&matOldView);
		m_pd3dDevice->GetTransform(D3DTS_PROJECTION,&matOldProj);
		m_pd3dDevice->GetTransform(D3DTS_WORLD,&matOldWorld);

		vector3 vecCameraPos;
		D3DXMATRIX matInvOldView;
		D3DXMatrixInverse(&matInvOldView,NULL,&matOldView);
		vecCameraPos.x = matInvOldView._41;
		vecCameraPos.y = matInvOldView._42;
		vecCameraPos.z = matInvOldView._43;

		//// Get ViewDir
		D3DXMATRIX matT,matResult;
		D3DXVECTOR3 vecT(0.0f, 0.0f, 1.0f);	
		D3DXMatrixTranslation(&matT, vecT.x, vecT.y, vecT.z);	
		
		D3DXMatrixMultiply(&matResult, &matT, &matOldView);	
		vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
		vector3 vecToward = CSceneManager::GetCamera()->GetViewTowardVector();
		vecToward.Normalize();

		////
		D3DXMATRIX matViewDir( matOldView );
		matViewDir._41 = 0.0f; matViewDir._42 = 0.0f; matViewDir._43 = 0.0f;

		m_pRenderEnvMap->BeginCube( m_pWorldCubemap );
		m_pd3dDevice->SetViewport(&CubeViewport);
		for( UINT i = 0; i < 6; i++ )
		{
			m_pRenderEnvMap->Face( (D3DCUBEMAP_FACES) i );

			// Set the view transform for this cubemap surface
			D3DXMATRIX matView;
			D3DXMATRIX matWorld;
			D3DXMatrixIdentity(&matWorld);
			vector3 vecDir;

			matView = GetCubeMatrix(  i ,vecDir);
			
			//D3DXMatrixMultiply( &matView, &matViewDir, &matView );
	
			D3DXMatrixInverse(&matView,NULL,&matView);
			
			//vector3 *vecViewPos=CSceneManager::GetCamera()->GetPosition();
			//matView._41 = vecViewPos->x;
			//matView._42 = vecViewPos->y;
			///matView._42 = 600.0f;
			//matView._43 = vecViewPos->z;
			matView._41 = vecCameraPos.x;
			matView._42 = vecCameraPos.y;
			matView._43 = vecCameraPos.z;

			D3DXMatrixInverse(&matView,NULL,&matView);
			
			m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET, BaseGraphicsLayer::m_ClearColor.c, 1.0f, 0 );
			m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
			m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
			m_pd3dDevice->SetTransform( D3DTS_WORLD,&matWorld);
			
			if(i == 3)	// Negative Y
				continue;
			else if(i != 2)	// Positive Y always Render
			{	// View Direction Check
				float fDot = vecDir * vecToward;
				if(fDot < 0)
					continue;

			}
			
			
			m_WeatherManager.RenderEnv(m_pd3dDevice);
			//m_WeatherManager.Render(m_pd3dDevice);
			m_HeightField.RenderEnv(m_pd3dDevice);
		//	m_HeightField.Render(m_pd3dDevice,true);
		//	m_WeatherManager.SecondRender(m_pd3dDevice);


		}

		m_pRenderEnvMap->End();
		
		//HRESULT hr = D3DXSaveTextureToFile("c:/testEnv.dds", D3DXIFF_DDS ,m_pWorldCubemap,NULL);

		m_pd3dDevice->SetTransform( D3DTS_VIEW, &matOldView );
		m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matOldProj );
		m_pd3dDevice->SetTransform(D3DTS_WORLD,&matOldWorld);
		m_pd3dDevice->SetViewport(&Viewport);
		}

}
D3DXMATRIX CSceneManager::GetCubeMatrix(int i,vector3 &vecDir)
{
	D3DXVECTOR3 vEyePt   = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
    D3DXVECTOR3 vLookDir;
    D3DXVECTOR3 vUpDir;

    switch( i )
    {
        case 0:
            vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case 1:
            vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case 2:
            vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
            break;
        case 3:
            vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
            break;
        case 4:
            vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
        case 5:
            vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
            vUpDir   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
            break;
    }
	vecDir.x = vLookDir.x;
	vecDir.y = vLookDir.y;
	vecDir.z = vLookDir.z;

    D3DXMATRIX matView;
    D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookDir, &vUpDir );
    return matView;

}
bool CSceneManager::CheckRayCollision(const D3DXVECTOR3 &vecPos1,const D3DXVECTOR3 &vecPos2)
{
	
	return m_HeightField.CheckRayCollision(vecPos1,vecPos2);

}