#include "StdAfx.h"
#include "RenderSystem.h"

#include "AppWindow.h"
#include "Application.h"
#include "CameraManager.h"
#include "FontAgent.h"
#include "LightAgent.h"
#include "FogAgent.h"
#include "SceneManager.h"
#include "WorldManager.h"
#include "UIManager.h"
#include "OptionManager.h"

#include "stageManager.h"
#include "GameResourceManager.h"


#include "Shader.h"
#include "bandicap.h"

#if (defined(_DEVSYS) || defined(_DEBUG))
#include "DevSystem.h"
#endif

cRenderSystem* cRenderSystem::mpSingleton = 0;


// ..
CBandiCaptureLibrary	 mBandiCaptureLib;

bool g_Restore( bool bBeforeReset, void* pvData )
{
	cRenderSystem* render = (cRenderSystem*)pvData;
	assert(render);

	if( bBeforeReset )
	{
		THEAPP->Invalidate();

		render->GetWindowRef()->AdjustWindowForChange( render->IsFullScreenMode() );
	}
	else
	{
		THEAPP->Restore();

		if( render->IsFullScreenMode() == false )
		{
			if( render->GetScreenWidth() > (unsigned int)GetSystemMetrics(SM_CXSCREEN) || 
				render->GetScreenHeight() > (unsigned int)GetSystemMetrics(SM_CYSCREEN) )
			{
				render->mReCreateContinue = true;
			}
		}

		render->GetWindowRef()->AdjustWindowRect( render->GetScreenWidth(), render->GetScreenHeight() );

		CAMERAMAN->Reset( render->GetScreenWidth(), render->GetScreenHeight() );

		/// ¿É¼Ç ³»¿ëÀº À©µµ¿ì ¸ðµåÀ϶§ GetClientRect¿¡ ÀÇÇØ º¯ÇÒ ¼ö ÀÕ´Ù.
		UIMAN->UpdateScreenSize( render->GetScreenWidth(), render->GetScreenHeight() );
	}

	return true;
}

//////////////////////////////////////////////////////////////////////////
cPostProcess::cPostProcess()
: mpRenderedTexture(0)
, mpRenderTargetGroup(0)
, mPosCoordBuffer( 0 )
, mTexCoordBuffer( 0 )
, mVertexDeclaration( 0 )
{
	mShader = new cBrightShader;
}

cPostProcess::~cPostProcess()
{
	if( mVertexDeclaration )
	{
		mVertexDeclaration->Release();
		mVertexDeclaration = 0;
	}
	if( mPosCoordBuffer )
	{
		mPosCoordBuffer->Release();
		mPosCoordBuffer = 0;
	}
	if( mTexCoordBuffer )
	{
		mTexCoordBuffer->Release();
		mTexCoordBuffer = 0;
	}

	SAFE_DELETE(mShader);

	mpRenderedTexture = 0;
	mpRenderTargetGroup = 0;
}

bool cPostProcess::Init( cRenderer* r )
{
	///
	NiTexture::FormatPrefs prefs;
	const NiRenderTargetGroup* pkRTGroup = r->GetDefaultRenderTargetGroup();
	const NiPixelFormat* pkPixelFormat = pkRTGroup->GetPixelFormat(0);
	if (pkPixelFormat->GetBitsPerPixel() == 16)
		prefs.m_ePixelLayout = NiTexture::FormatPrefs::HIGH_COLOR_16;
	else
		prefs.m_ePixelLayout = NiTexture::FormatPrefs::TRUE_COLOR_32;

	prefs.m_eAlphaFmt = NiTexture::FormatPrefs::NONE;
	prefs.m_eMipMapped = NiTexture::FormatPrefs::NO;

	mpRenderedTexture = NiRenderedTexture::Create( pkRTGroup->GetWidth(0), pkRTGroup->GetHeight(0), r, prefs );
	if( mpRenderedTexture == 0 )
		return false;

	mpRenderTargetGroup = NiRenderTargetGroup::Create( mpRenderedTexture->GetBuffer(), r, true, false );

	/// create Quad point
	mShader->Init( r->GetBrightEffect() );

	/// Á¤Á¡ ¼±¾ðÀ» »ý¼º
	D3DVERTEXELEMENT9 decl[] =
	{
		{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
		{ 1, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
		D3DDECL_END()
	};

	LPDIRECT3DDEVICE9 device = r->GetD3DDevice();
	device->CreateVertexDeclaration( decl, &mVertexDeclaration );

	/// Á¤Á¡ ¹öÆÛ¸¦ »ý¼º

	NiPoint3 vBuffer[4] = { NiPoint3(0.0f, 0.0f, 1.0f),NiPoint3(1.0f, 0.0f, 1.0f), NiPoint3(0.0f, 1.0f, 1.0f), NiPoint3(1.0f, 1.0f, 1.0f) };
	mPosCoordBuffer = r->CreateVertexBuffer( 4, sizeof(NiPoint3), vBuffer );
	if( mPosCoordBuffer == 0 )
		return false;

	NiPoint2 tBuffer[4] = { NiPoint2(0.0f, 0.0f), NiPoint2(1.0f, 0.0f), NiPoint2(0.0f, 1.0f), NiPoint2(1.0f, 1.0f) };
	mTexCoordBuffer = r->CreateVertexBuffer( 4, sizeof(NiPoint2), tBuffer );
	if( mTexCoordBuffer == 0 )
		return false;

	return true;
}

void cPostProcess::Recreate( cRenderer* r, unsigned int width, unsigned int height, unsigned char bpp )
{
	mpRenderedTexture = 0;
	mpRenderTargetGroup = 0;

	///
	NiTexture::FormatPrefs prefs;
	if (bpp == 16)
		prefs.m_ePixelLayout = NiTexture::FormatPrefs::HIGH_COLOR_16;
	else
		prefs.m_ePixelLayout = NiTexture::FormatPrefs::TRUE_COLOR_32;

	prefs.m_eAlphaFmt = NiTexture::FormatPrefs::NONE;
	prefs.m_eMipMapped = NiTexture::FormatPrefs::NO;

	mpRenderedTexture = NiRenderedTexture::Create( width, height, r, prefs );
	mpRenderTargetGroup = NiRenderTargetGroup::Create( mpRenderedTexture->GetBuffer(), r, true, false );
}

void cPostProcess::RenderImmediate( cRenderer* r )
{
//	if( r->IsDeviceLost() )
//		return;

	LPDIRECT3DDEVICE9 device = r->GetD3DDevice();
	IDirect3DVertexDeclaration9* oldVertDecl = 0;
	device->GetVertexDeclaration( &oldVertDecl );

	/// ¼ÎÀÌ´õ¸¦ ½ÃÀÛ
	if( mShader->Begin( r->GetD3DViewProj() ) == true )
	{
		mShader->CommitChanges();

		bool bS0Mipmap, bNonPow2, bChanged; 
		D3DBaseTexturePtr pkD3DTexture = r->GetTextureManager()->PrepareTextureForRendering( mpRenderedTexture, bChanged, bS0Mipmap, bNonPow2 );

		///
		device->SetTexture( 0, pkD3DTexture );
		device->SetVertexDeclaration( mVertexDeclaration );
		device->SetStreamSource( 0, mPosCoordBuffer, 0, sizeof(NiPoint3) );
		device->SetStreamSource( 1, mTexCoordBuffer, 0, sizeof(NiPoint2) );

		device->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );

		mShader->End();
	}

	/// ÀåÄ¡ ¼³Á¤À» º¹¿ø
	if( oldVertDecl )
		device->SetVertexDeclaration( oldVertDecl );
}

void cPostProcess::Render( cRenderer* r )
{
	if( r->BeginUsingDefaultRenderTargetGroup( NiRenderer::CLEAR_ALL ) == true )
	{
		r->SetScreenSpaceCameraData();

		RenderImmediate( r );

		UIMAN->Render();

#if (defined(_DEVSYS) || defined(_DEBUG))
		DEVSYSTEM->DrawDevInfo();
#endif
		r->EndUsingRenderTargetGroup();
	}
}


//////////////////////////////////////////////////////////////////////////
cRenderSystem::cRenderSystem( cAppWindow* pwindow )
: mpWindowRef(pwindow)
{
	assert( mpSingleton == 0 && "bad singleton!" );
	mpSingleton = this;


	/// Áß°³ÀÚµéÀ» »ý¼º
	mpFontAgent = new cFontAgent;
	mpLightAgent = new cLightAgent;
	mpFogAgent = new cFogAgent;

	mPostProcess = new cPostProcess;

	mClearColor = NiColorA(0.2f,0.1f,0.1f,0.0f);

	/// It can filter flat images into mipmap pyramids, and can convert 
	/// from standard Gamebryo pixel formats (PAL8, PALA8, RGB24, RGBA32, etc)
	/// to non-standard formats, and from non-standard formats to a few standard formats
	NiImageConverter::SetImageConverter( NiNew NiDevImageConverter );
	NiTexture::SetMipmapByDefault( true );

	/// ÀåÄ¡ ¼³Á¤
	mCurrentAdapter = 0;
	mCurrentDevice = 0;
	mCurrentMode = 0;

	mReCreateContinue = false;
	mReCreateTime = 0;
	mWorldRendering = true;
}

cRenderSystem::~cRenderSystem()
{
	Exit();

	mBandiCaptureLib.Destroy();
	mVideoCaptureTime = 0;

	/// Áß°³ÀÚµéÀ» Á¦°Å
	SAFE_DELETE( mPostProcess );
	SAFE_DELETE( mpFogAgent );
	SAFE_DELETE( mpLightAgent );
	SAFE_DELETE( mpFontAgent );

	mRenderer = 0;

	mpSingleton = 0;
}

HWND cRenderSystem::GetHWND()
{ 
	return (mpWindowRef)? mpWindowRef->GetHWND():NULL; 
}

bool cRenderSystem::Init()
{
	DEVMODE dm;
	ZeroMemory(&dm, sizeof(dm));
	dm.dmSize = sizeof(dm);
	EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm );

	mMonWidth = dm.dmPelsWidth;
	mMonHeight = dm.dmPelsHeight;
	mMonBpp = dm.dmBitsPerPel;

//	mMonWidth = ::GetSystemMetrics(SM_CXSCREEN);
//	mMonHeight = ::GetSystemMetrics(SM_CYSCREEN);

	/// DirectX ÀνºÅϽº »ý¼º..
	/// RenderingÀ» ÁÖ°üÇØÁÙ Renderer »ý¼º..
	/// ¿£Áø¿¡¼­ Á¦°øÇÏ´Â NiRenderer¸¦ È°¿ë
	if( CreateRenderer() == false )
	{
		return false;
	}

	if( mRenderer->Init() == false )
	{
		assert( 0 );
		return false;
	}

//	unsigned int verVS = mRenderer->GetShaderLibraryVersion()->GetSystemVertexShaderVersion();
//	unsigned int verPS = mRenderer->GetShaderLibraryVersion()->GetSystemPixelShaderVersion();

	if( mPostProcess->Init( mRenderer ) == false )
	{
		assert(0);
		return false;
	}

	/// FontAgent ÃʱâÈ­
	if( mpFontAgent->Init() == false )
	{
		return false;
	}

	/// LIghtAgent ÃʱâÈ­
	if( mpLightAgent->Init() == false )
	{
		return false;
	}

	mRenderer->AddResetNotificationFunc( g_Restore, this );

	SetBrightness( OPTIONMAN->GetGammaPer() );

	return true;
}

void cRenderSystem::Exit()
{
	/// 1. Á¾·á½Ã¿¡ ÇöÀç Àû¿ëµÈ ÃÖÁ¾ Render ¿É¼ÇÀ» ÀúÀåÇÑ´Ù.
	if( mpFontAgent )
		mpFontAgent->Exit();
}

/// ÁÖÀÇ »çÇ× : ºÒÇÊ¿äÇÑ ÄÚµåÀÇ »ðÀÔÀ» ±ÝÁöÇÑ´Ù.
void cRenderSystem::Render()
{
	if( mReCreateContinue == true )
	{
		mReCreateTime += THEAPP->GetWorldDeltaTime();
		if( mReCreateTime >= 30000 )
		{
			NiMessageBox("Window reset fail. Game exit.", "Error");
			::SendMessage( THEAPP->GetHWND(), WM_CLOSE, 0, 0 );
		}

		mReCreateContinue = false;
		THEAPP->UpdateScreenSize( mRenderOption.Width, mRenderOption.Height, mRenderOption.Bpp, OPTIONMAN->IsWindowed() );
		return;
	}

	if( mRenderer->BeginFrame() == false )
	{
		assert(0);
		return;
	}

	{
		/// ¹öÆÛ Å¬¸®¾î Ä÷¯ ÁöÁ¤
		mRenderer->SetBackgroundColor( mClearColor );

		///
		SCENEMAN->PreRender2D();
		UIMAN->PreRender();

		if( mRenderer->BeginUsingRenderTargetGroup( mPostProcess->GetRenderTarget(), NiRenderer::CLEAR_ALL ) == true )
		{
			if( mWorldRendering )
			{
				/// D3DTS_VIEW & D3DTS_PROJECTION ¼ÂÆÃ
				mRenderer->SetCameraData( CAMERAMAN->GetCurrentNi() );

				WORLDMAN->RenderSkyDome();

				WORLDMAN->Render();

				SCENEMAN->Render();
			}

			mRenderer->SetScreenSpaceCameraData();
			SCENEMAN->Render2D();

			mRenderer->SetCameraData( CAMERAMAN->GetCurrentNi() );
			SCENEMAN->RenderZFalseDamage();

			mRenderer->EndUsingRenderTargetGroup();

			mPostProcess->Render( mRenderer );
		}
//		mRenderer->EndFrame();
	}

	if( mBandiCaptureLib.IsCapturing() )
	{

		LPDIRECT3DDEVICE9 device = mRenderer->GetD3DDevice();
		mBandiCaptureLib.Work( (LONG_PTR)device );

		/// 1/1000 sec
		mVideoCaptureTime = mBandiCaptureLib.GetCaptureTime();

		unsigned int restTime = (unsigned int)(mVideoCaptureTime * 0.001f);
		unsigned int h = restTime / 3600;
		unsigned int m = restTime / 60;
		unsigned int s = restTime % 60 + 1;

		float captureSize = (float)mBandiCaptureLib.GetCaptureFileSize();
		captureSize = captureSize / (1024.0f*1024.0f);

		POINT pos;
		pos.x = 1;
		pos.y = 1;

		cStringT str;
		str.Format( GAMERESOURCEMAN->GetGameText(10002), h, m, s, captureSize );

//		if( mRenderer->BeginFrame() == true )
//		{
			FONTAGENT->DrawText( cFontAgent::eFont_System, (LPTSTR)str.Cstr(), str.GetSize(), &pos, 0xFFFFFC31 );

//		}
	}
	mRenderer->EndFrame();


	mRenderer->DisplayFrame();
}

void cRenderSystem::Invalidate()
{
	mpFontAgent->Invalidate();
	mRenderer->OnLostDevice();
}

void cRenderSystem::Restore()
{
	mRenderer->OnResetDevice();
	mpFontAgent->Restore();
}

bool cRenderSystem::Reset( unsigned int width, unsigned int height, unsigned char bpp, bool winmode )
{
	NiDX9Renderer* pkD3drenderer = NiDynamicCast(NiDX9Renderer, NiDX9Renderer::GetRenderer());
	if( pkD3drenderer == 0 )
	{
		assert(0);
		return false;
	}

	NiWindowRef handle = mpWindowRef->GetHWND();
	if( handle == 0 )
	{
		assert(0);
		return false;
	}

	NiWindowRef kWndDevice, kWndFocus;
	pkD3drenderer->GetCreationParameters( mRenderOption.Width, mRenderOption.Height, mRenderOption.Flags, 
		kWndDevice, kWndFocus, mRenderOption.Adapter, mRenderOption.DevDesc, mRenderOption.FBformat, mRenderOption.DSformat, 
		mRenderOption.Interval, mRenderOption.Swapeffect, mRenderOption.FBmode, mRenderOption.Backbuffercount, mRenderOption.Refreshrate );

	mRenderOption.Width = width;
	mRenderOption.Height = height;
	mRenderOption.Bpp = bpp;

	///
	if( winmode == false )
	{
		mRenderOption.Flags = mRenderOption.Flags | NiDX9Renderer::USE_FULLSCREEN;
		mRenderOption.Interval = NiDX9Renderer::PRESENT_INTERVAL_ONE;
	}
	else
	{
		if( mMonWidth < mRenderOption.Width || mMonHeight < mRenderOption.Height )
		{
			OPTIONMAN->SetWindowedNoReset( false );

			mRenderOption.Flags = mRenderOption.Flags | NiDX9Renderer::USE_FULLSCREEN;
			mRenderOption.Interval = NiDX9Renderer::PRESENT_INTERVAL_ONE;
		}
		else
		{
			mRenderOption.Flags = mRenderOption.Flags & ~(NiDX9Renderer::USE_FULLSCREEN);
			mRenderOption.Interval = NiDX9Renderer::PRESENT_INTERVAL_IMMEDIATE;
		}
	}

	EnumResolutions( width, height, bpp, winmode );
	if( mCurrentMode == 0 )
	{
		assert(0);
		return false;
	}

	mRenderOption.FBformat = NiDX9Renderer::GetNiFBFormat( mCurrentMode->m_eD3DFormat );
	mRenderOption.DSformat = NiDX9Renderer::DSFMT_UNKNOWN;
	mRenderOption.FBmode = NiDX9Renderer::FBMODE_LOCKABLE;
//	mRenderOption.Refreshrate = NiDX9Renderer::REFRESHRATE_DEFAULT;
	mRenderOption.Backbuffercount = 1;

	NiDX9Renderer::RecreateStatus eStatus = pkD3drenderer->Recreate( mRenderOption.Width, mRenderOption.Height, mRenderOption.Flags, 
		handle, mRenderOption.FBformat, mRenderOption.DSformat, mRenderOption.Interval, 
		mRenderOption.Swapeffect, mRenderOption.FBmode, mRenderOption.Backbuffercount, mRenderOption.Refreshrate );

	if( eStatus == NiDX9Renderer::RECREATESTATUS_FAILED )
	{
		mReCreateContinue = true;
		return false;
	}

	mPostProcess->Recreate( mRenderer,  mRenderOption.Width, mRenderOption.Height, bpp );

	mReCreateTime = 0;
	return true;
}

bool cRenderSystem::CreateRenderer()
{
	/// ·£´õ·¯ ÃʱâÈ­¸¦ À§ÇÑ ¿É¼ÇÁ¤º¸..
	/// ´ÙÀÌ·ºÆ® ¿¢½º ÃʱâÈ­
	/// °ÔÀӺ긮¿À ·£´õ·¯ ÃʱâÈ­

	NiWindowRef handle = mpWindowRef->GetHWND();

	mRenderOption.Width = OPTIONMAN->GetWindowWidth();
	mRenderOption.Height = OPTIONMAN->GetWindowHeight();
	mRenderOption.Bpp = OPTIONMAN->GetWindowBpp();

	/// »ý¼º ¿É¼Ç Àû¿ë
	if( OPTIONMAN->IsWindowed() == false )
	{
		mRenderOption.Flags = mRenderOption.Flags | NiDX9Renderer::USE_FULLSCREEN;
		mRenderOption.Interval = NiDX9Renderer::PRESENT_INTERVAL_ONE;
	}
	else
	{
		if( mMonWidth < mRenderOption.Width || mMonHeight < mRenderOption.Height )
		{
			OPTIONMAN->SetWindowedNoReset( false );

			mRenderOption.Flags = mRenderOption.Flags | NiDX9Renderer::USE_FULLSCREEN;
			mRenderOption.Interval = NiDX9Renderer::PRESENT_INTERVAL_ONE;
		}
		else
		{
			mRenderOption.Flags = mRenderOption.Flags & ~(NiDX9Renderer::USE_FULLSCREEN);
			mRenderOption.Interval = NiDX9Renderer::PRESENT_INTERVAL_IMMEDIATE;
		}
	}

	/// main window update
	mpWindowRef->AdjustWindowForChange( IsFullScreenMode() );

	EnumAdapters();
	EnumResolutions( mRenderOption.Width, mRenderOption.Height, mRenderOption.Bpp, OPTIONMAN->IsWindowed() );

	if( mCurrentAdapter == 0  || mCurrentDevice == 0 || mCurrentMode == 0 )
	{
		/// message box ¶ç¿ìÀÚ!! Default°ªÀ¸·Î »ý¼ºÇÑ´Ù!!
		NiMessageBox( "Failed Device create!! Default option create!!", "Error Info" );

		/// ±âº» Çػ󵵷Π»ý¼ºÇØ º»´Ù.
		mRenderOption.Width = 1024;
		mRenderOption.Height = 768;
		mRenderOption.Bpp = 32;

		/// main window update
		EnumAdapters();
		EnumResolutions( mRenderOption.Width, mRenderOption.Height, mRenderOption.Bpp, OPTIONMAN->IsWindowed() );
		if( mCurrentAdapter == 0 || mCurrentDevice == 0  || mCurrentMode == 0 )
		{
			NiMessageBox( "Failed Device create!! ShotDown Application.", "Error Info" );
			return false;
		}
	}

	NiDX9Renderer::DeviceDesc eDesc = NiDX9Renderer::DEVDESC_PURE;
	if( mCurrentDevice->GetDeviceType() == D3DDEVTYPE_REF )
		eDesc = NiDX9Renderer::DEVDESC_REF;

	/// Renderer Create
	mRenderer = cRenderer::Create( 1024, 768,
		(NiDX9Renderer::FlagType)mRenderOption.Flags &~NiDX9Renderer::USE_FULLSCREEN,
		handle,
		handle,
		mCurrentAdapter->GetAdapterIndex(),
		eDesc,
		NiDX9Renderer::GetNiFBFormat( mCurrentMode->m_eD3DFormat ),
		NiDX9Renderer::DSFMT_UNKNOWN,
		NiDX9Renderer::PRESENT_INTERVAL_IMMEDIATE,
		NiDX9Renderer::SWAPEFFECT_DISCARD,
		mRenderOption.FBmode );

	// dialog ¾ÕÀ¸·Î º¸³»±â
	LPDIRECT3DDEVICE9 device = mRenderer->GetD3DDevice();
	device->SetDialogBoxMode( true );
/*
	if( IsFullScreenMode() )
	{
		if( mCurrentAdapter && mCurrentDevice && mCurrentMode )
		{
			NiDX9Renderer::DeviceDesc eDesc = NiDX9Renderer::DEVDESC_PURE;
			if( mCurrentDevice->GetDeviceType() == D3DDEVTYPE_REF )
				eDesc = NiDX9Renderer::DEVDESC_REF;

			/// Renderer Create
			mRenderer = cRenderer::Create( mRenderOption.Width, mRenderOption.Height,
				(NiDX9Renderer::FlagType)mRenderOption.Flags,
				handle,
				handle,
				mCurrentAdapter->GetAdapterIndex(),
				eDesc,
				NiDX9Renderer::GetNiFBFormat( mCurrentMode->m_eD3DFormat ),
				NiDX9Renderer::DSFMT_UNKNOWN,
				NiDX9Renderer::PRESENT_INTERVAL_IMMEDIATE,
				NiDX9Renderer::SWAPEFFECT_DISCARD,
				mRenderOption.FBmode );
		}
		else
		{
			/// message box ¶ç¿ìÀÚ!! Default°ªÀ¸·Î »ý¼ºÇÑ´Ù!!
			NiMessageBox( "Failed Device create!! Default option create!!", "Error Info" );

			/// ±âº» Çػ󵵷Π»ý¼ºÇØ º»´Ù.
			mRenderOption.Width = 1024;
			mRenderOption.Height = 768;
			mRenderOption.Bpp = 32;

			/// main window update
			EnumAdapters();
			EnumResolutions( mRenderOption.Width, mRenderOption.Height, mRenderOption.Bpp, OPTIONMAN->IsWindowed() );
			if( mCurrentAdapter == 0 || mCurrentDevice == 0  || mCurrentMode == 0 )
			{
				NiMessageBox( "Failed Device create!! ShotDown Application.", "Error Info" );
				return false;
			}

			NiDX9Renderer::DeviceDesc eDesc = NiDX9Renderer::DEVDESC_PURE;
			if( mCurrentDevice->GetDeviceType() == D3DDEVTYPE_REF )
				eDesc = NiDX9Renderer::DEVDESC_REF;

			/// Renderer Create
			mRenderer = cRenderer::Create( mRenderOption.Width, mRenderOption.Height,
				(NiDX9Renderer::FlagType)mRenderOption.Flags,
				handle,
				handle,
				mCurrentAdapter->GetAdapterIndex(),
				eDesc,
				NiDX9Renderer::GetNiFBFormat( mCurrentMode->m_eD3DFormat ),
				NiDX9Renderer::DSFMT_UNKNOWN,
				NiDX9Renderer::PRESENT_INTERVAL_IMMEDIATE,
				NiDX9Renderer::SWAPEFFECT_DISCARD,
				mRenderOption.FBmode );
		}
	}
	else
	{
		NiDX9Renderer::DeviceDesc eDesc = NiDX9Renderer::DEVDESC_PURE;
		if( mCurrentDevice->GetDeviceType() == D3DDEVTYPE_REF )
			eDesc = NiDX9Renderer::DEVDESC_REF;

		// create and return the renderer
		mRenderer = cRenderer::Create( mRenderOption.Width, mRenderOption.Height,
			(NiDX9Renderer::FlagType)mRenderOption.Flags,
			handle,
			handle,
			mCurrentAdapter->GetAdapterIndex(),
			eDesc,
			NiDX9Renderer::GetNiFBFormat( mCurrentMode->m_eD3DFormat ), 
			NiDX9Renderer::DSFMT_UNKNOWN,
			NiDX9Renderer::PRESENT_INTERVAL_IMMEDIATE,
			NiDX9Renderer::SWAPEFFECT_DISCARD,
			mRenderOption.FBmode );
	}
*/
	if( mRenderer == NULL )
	{
		NiMessageBox( "DX9 Renderer Creation Failed", "Error Info" );
		return false;
	}

//	mpWindowRef->AdjustWindowForChange( IsFullScreenMode() );
//	mpWindowRef->AdjustWindowRect( mRenderOption.Width, mRenderOption.Height, true );

	/// Setting dx background color
	mRenderer->SetBackgroundColor( mClearColor );

	return true;
}

void cRenderSystem::ToggleFullScreenMode()
{
	if( IsFullScreenMode() )
		mRenderOption.Flags = mRenderOption.Flags & ~(NiDX9Renderer::USE_FULLSCREEN);
	else
		mRenderOption.Flags = mRenderOption.Flags | NiDX9Renderer::USE_FULLSCREEN;
}

//////////////////////////////////////////////////////////////////////////
bool cRenderSystem::EnumAdapters()
{
	mCurrentAdapter = 0;
	mCurrentDevice = 0;

	const NiDX9SystemDesc* pSystem = NiDX9Renderer::GetSystemDesc();
	unsigned int adapterCount = pSystem->GetAdapterCount();

	bool checkAdapter = false;
	for ( unsigned int i = 0; i < adapterCount; i++ )
	{
		const NiDX9AdapterDesc* pAdapter = pSystem->GetAdapter(i);
		assert(pAdapter);

		const NiDX9DeviceDesc* pDevice = pAdapter->GetDevice( D3DDEVTYPE_HAL );
		if( !pDevice )
			continue;

		/// À©µµ¿ì ¸ðµå Áö¿ø üũ.
		if( pAdapter->CanDeviceRenderWindowed( D3DDEVTYPE_HAL ) == false )
			continue;

		/// ¹è¿­¿¡ ´ã¾Æ µÎÀÚ
		mAdapterArr.PushBack( (void*)pAdapter );

		checkAdapter = true;
	}

	if( checkAdapter )
	{
		mCurrentAdapter = (NiDX9AdapterDesc*)mAdapterArr[0];
		if( mCurrentAdapter == 0 )
			return false;

		mCurrentDevice = (NiDX9DeviceDesc*)mCurrentAdapter->GetDevice( D3DDEVTYPE_HAL );
		assert( mCurrentDevice );
	}

	return checkAdapter;
}

void cRenderSystem::EnumResolutions( unsigned int curWidth, unsigned int curheight, unsigned int curBpp, bool windowed )
{
	if( mCurrentAdapter == 0 )
		return;

	mCurrentMode = 0;
	mResolutionArr.Clear();

	unsigned int modeCount = mCurrentAdapter->GetModeCount();

	for( unsigned int i=0; i<modeCount; i++ )
	{
		const NiDX9AdapterDesc::ModeDesc* pMode = mCurrentAdapter->GetMode( i );

		if( pMode == 0 )
			continue;

		/// Ãß°¡·Î ºÒÇÊ¿äÇÑ ¸ðµå´Â Á¦¿Ü½ÃŲ´Ù.
		if( pMode->m_uiWidth <= 800 )
			continue;
		if( pMode->m_uiHeight <= 600 )
			continue;

		/// ¹è¿­¿¡ ´ã¾Æ µÎÀÚ
		mResolutionArr.PushBack( (void*)pMode );

		/// ÇöÀç ¸ðµå üũ
		if( pMode->m_uiWidth == curWidth && pMode->m_uiHeight == curheight )
		{
			if( pMode->m_uiBPP == curBpp )
				mCurrentMode = (NiDX9AdapterDesc::ModeDesc*)pMode;
		}
	}

	if( mResolutionArr.GetSize() > 1)
		::Sort( mResolutionArr.Begin(), mResolutionArr.End(), cResolutionCompare() );
}

void cRenderSystem::EnumMultisamples()
{
/*
	if( mCurrentDevice == 0 )
		return;

	D3DFORMAT eformat;
	if( mCurrentMode )
	{
		NiDX9AdapterDesc::ModeDesc* pMode = (NiDX9AdapterDesc::ModeDesc*)mCurrentMode;
		eformat = pMode->m_eD3DFormat;
	}
	else
	{
		unsigned int bitdepth = 

	}
*/
}

#include "PlaneObject.h"
bool cRenderSystem::RenderOnce( NiTexture* tex )
{
	cPlaneObject* pPlane = new cPlaneObject;
	if( pPlane->Create( tex, 0, 0, (unsigned short)GetScreenWidth(), (unsigned short)GetScreenHeight(),
		0, 0, (unsigned short)tex->GetWidth(), (unsigned short)tex->GetHeight() ) == false )
	{
		return true;
	}

	if( mRenderer == 0 || mRenderer->BeginFrame() == false )
	{
		SAFE_DELETE(pPlane);
		return false;
	}

	mRenderer->SetBackgroundColor( mClearColor );
	if( mRenderer->BeginUsingDefaultRenderTargetGroup( NiRenderer::CLEAR_ALL ) == true )
	{
		mRenderer->SetScreenSpaceCameraData();
		pPlane->Draw();

		mRenderer->EndUsingRenderTargetGroup();
	}
	mRenderer->EndFrame();

	if( mRenderer->DisplayFrame() == false )
	{
		SAFE_DELETE(pPlane);
		return false;
	}

	SAFE_DELETE(pPlane);
	return true;
}

void cRenderSystem::SetBrightness( float br )
{
	if( mPostProcess )
		mPostProcess->mShader->SetBright( br );
}

void cRenderSystem::SetMonitorDisplay( unsigned int width, unsigned int height, unsigned int bpp )
{
	if( mMonWidth == width && mMonHeight == height && mMonBpp == bpp )
		return;

	if( IsFullScreenMode() == false )
		mReCreateContinue = true;
	else
		return;

	mMonWidth = width; 
	mMonHeight = height;
	mMonBpp = bpp;
}


void cRenderSystem::ToggleVideoCapture()
{
	if( mRenderer == 0 )
		return;

	LPDIRECT3DDEVICE9 device = mRenderer->GetD3DDevice();
	if( device == 0 )
		return;

	// ĸó¸¦ ½ÃÀÛÇÕ´Ï´Ù.
	if( mBandiCaptureLib.IsCapturing() == FALSE )
	{
		// ÃÖÃÊ ½ÇÇà½Ã DLL À» ·ÎµåÇÏ°í ³»ºÎ ÀνºÅϽº¸¦ »ý¼ºÇÕ´Ï´Ù. 
		if( mBandiCaptureLib.IsCreated() == FALSE )
		{
			// ½ÇÆнà DLL°ú .HÆÄÀÏÀÇ ¹öÀüÀÌ µ¿ÀÏÇÑÁö ¿©ºÎµîÀ» È®ÀÎÇØ º¸½Ã±â ¹Ù¶ø´Ï´Ù.
			if( FAILED(mBandiCaptureLib.Create(BANDICAP_RELEASE_DLL_FILE_NAME)) )
			{
				assert(0);
				return;
			}

//			// ÀÎÁõÀ» ¹ÞÁö ¾ÊÀ¸¸é ÀÎÄÚµùµÈ µ¿¿µ»ó »ó´Ü¿¡ ·Î°í°¡ Ç¥½ÃµË´Ï´Ù. 
//			// Á¤½Ä±¸¸ÅÈÄ ¹ß±Þ¹ÞÀº Å°¸¦ »ç¿ëÇϰųª, ȨÆäÀÌÁö¿¡¼­ µ¥¸ð¿ëÀ¸·Î °ø°³µÈ Å°¸¦ »ç¿ëÇؼ­ ÀÎÁõÀ» ¹Þ½À´Ï´Ù. 
			if( FAILED(mBandiCaptureLib.Verify( "EYA_IRIS_20091228", "74f9454b" )) )
			{
				assert(0);
			}
		}

		if( mBandiCaptureLib.IsCreated() )
		{
			BCAP_CONFIG cfg;

			/// option mode check...
			int videoMode = OPTIONMAN->GetVideoMode();
			switch( videoMode )
			{
			case BCAP_PRESET_320x240:
			case BCAP_PRESET_640x480:
			case BCAP_PRESET_800x600:
			case BCAP_PRESET_1024x768:
			case BCAP_PRESET_1280x720:
			case BCAP_PRESET_GAME:
				break;
			default:
				videoMode = BCAP_PRESET_GAME;
			}

			// ÇÁ¸®¼ÂÀ» ÅëÇؼ­ ¼Õ½±°Ô ¼³Á¤ÀÌ °¡´ÉÇϸç, Á÷Á¢ ÆĶó¹ÌÅÍ ¼³Á¤À» ¹Ù²Ü ¼öµµ ÀÖ½À´Ï´Ù.
			BCapConfigPreset(&cfg, (BCAP_PRESET)videoMode ); 
			if( videoMode == BCAP_PRESET_GAME )
			{
				cfg.VideoSizeW = mRenderOption.Width;
				cfg.VideoSizeH = mRenderOption.Height;
			}

			mBandiCaptureLib.CheckConfig(&cfg);       // À߸øµÈ ¼³Á¤ ¹Ù·Î Àâ±â
			mBandiCaptureLib.SetConfig(&cfg);         // ¼³Á¤ Àû¿ë

			mBandiCaptureLib.SetMinMaxFPS(30, 60);    // ÃÖ¼Ò, ÃÖ´ë ÇÁ·¹ÀÓ ¼³Á¤

			if( FileExist("VideoCapture") == false )
			{
				::CreateDirectory( L"VideoCapture", 0 );
			}

			// ÇöÀç½Ã°£À» ÀÌ¿ëÇؼ­ ÆÄÀϸíÀ» ¸¸µì´Ï´Ù. 
			mBandiCaptureLib.MakePathnameByDate( _T(".\\VideoCapture"), _T("IrisOnline"), _T("avi"), mVideoPathName, MAX_PATH );

			// ĸó¸¦ ½ÃÀÛÇÕ´Ï´Ù.
			HRESULT hr = mBandiCaptureLib.Start(mVideoPathName, NULL, BCAP_MODE_D3D9_SCALE, (LONG_PTR)device);
			if( FAILED(hr) )
			{
				ASSERT(0);
				return;
			}

			mVideoCaptureTime = 0;
		}
	}
	else
	{
		mBandiCaptureLib.Stop();

		if( STAGEMAN &&  mVideoCaptureTime != 0 )
			STAGEMAN->AddVideoCaptureMsg( mVideoPathName );

		mVideoCaptureTime = 0;
	}
}

bool cRenderSystem::IsVideoCapturing()
{
	if( mBandiCaptureLib.IsCreated() && mBandiCaptureLib.IsCapturing() )
		return true;
	else
		return false;
}

void cRenderSystem::SaveScreenShot()
{
	if( mRenderer == 0 )
		return;

	LPDIRECT3DDEVICE9 device = mRenderer->GetD3DDevice();
	if( device == 0 )
		return;

	if( mBandiCaptureLib.IsCreated() == FALSE )
	{
		// ½ÇÆнà DLL°ú .HÆÄÀÏÀÇ ¹öÀüÀÌ µ¿ÀÏÇÑÁö ¿©ºÎµîÀ» È®ÀÎÇØ º¸½Ã±â ¹Ù¶ø´Ï´Ù.
		if( FAILED(mBandiCaptureLib.Create(BANDICAP_RELEASE_DLL_FILE_NAME)) )
		{
			assert(0);
			return;
		}

//		// ÀÎÁõÀ» ¹ÞÁö ¾ÊÀ¸¸é ÀÎÄÚµùµÈ µ¿¿µ»ó »ó´Ü¿¡ ·Î°í°¡ Ç¥½ÃµË´Ï´Ù. 
//		// Á¤½Ä±¸¸ÅÈÄ ¹ß±Þ¹ÞÀº Å°¸¦ »ç¿ëÇϰųª, ȨÆäÀÌÁö¿¡¼­ µ¥¸ð¿ëÀ¸·Î °ø°³µÈ Å°¸¦ »ç¿ëÇؼ­ ÀÎÁõÀ» ¹Þ½À´Ï´Ù. 
		if( FAILED(mBandiCaptureLib.Verify( "EYA_IRIS_20091228", "74f9454b" )) )
			assert(0);
	}

	///
	if( ::FileExist( "ScreenShot" ) == false )
	{
		::CreateDirectory( L"ScreenShot", 0 );
	}

	// get (target directory + filename by date)
	TCHAR szCaptureFilePathName[MAX_PATH*2];
	mBandiCaptureLib.MakePathnameByDate(_T(".\\ScreenShot"), _T("Capture"), _T("jpg"), szCaptureFilePathName, MAX_PATH*2);

	INT nQuality = 100;
	if( FAILED(mBandiCaptureLib.CaptureImage(szCaptureFilePathName, BCAP_IMAGE_JPG, nQuality, BCAP_MODE_D3D9, FALSE, (LONG_PTR)device)) )
		return;

	STAGEMAN->AddScreenShotMsg( szCaptureFilePathName );
}