Leviathan/Client/Game/engine/Renderer/KRenderDeviceDX.cpp

#include "stdafx.h"
//#include <dxsdkver.h>
#include "KRenderDeviceDX.h"
#include "KResourceDX.h"

#include <kfile/KFileManager.h>
//#include <string>

//#include <string>
#include "resource.h"

#include <dxerr9.h>

#ifndef _NOSTREE_
	#include "SSpeedTreeVertexShaders.h"
#endif

#include <SpeedGrass/VertexShaders.h>
#include <toolkit/ILock.h>

#include "SDebug_Util.h"

// 2010.07.07 - prodongi
#include "GameRule.h"

#define SETPOLYCOUNT( n ) m_nPolyCount = n
#define INCPOLYCOUNT( n ) m_nPolyCount += n

XCriticalSection s_lckReloadTexture;
XCriticalSection s_lckVB_Array;

int  K3DRenderDeviceDX::s_nRecycleMaxCount  = 400;
bool K3DRenderDeviceDX::s_bForceTextureNull = false;


K3DRenderDeviceDX::K3DRenderDeviceDX()
{
	m_bIsDeviceLost = false;

	m_pD3D9  = NULL;
	m_d3ddev = NULL;

	m_lpDD7 = NULL;

	m_idxCurRS      = 9999999;
	m_backbuffer    = NULL;
	m_zbuffer       = NULL;
	m_d3dfont       = NULL;
	m_cursorTexture = NULL;
	int i;
	for(i = 0; i < 8; ++i)
		m_curTexture[i] = NULL;

	memset( m_hRS, 0, sizeof(m_hRS) );

	m_nOnePassTexes = 0;
	m_bgcolor.color = 0;

	for(i = 0; i < TS_STAGE_MAX; ++i)  {
		K3DMatrixIdentity(m_arTransformStages[i]); 
	}

	// rendering state
	m_backBufferWriteEnable  = D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE;
	m_depthBufferWriteEnable = true;
	m_depthCompareMode = D3DCMP_LESSEQUAL;
	m_clipPlaneEnabled = 0;
	m_fogMode  = FOGM_NONE;
	m_fillmode = FM_SOLID;
	m_cullmode = KCM_CCW;
	m_textureFactor = KColor(0xFFAAAAAA);
	m_fVertexAspect = 1.0f;
	m_nBeginSceneCount = 0;
	//m_pRenderTarget = NULL;
	m_pRenderTargetSurface = NULL;
	//m_pRenderTargetDepth = NULL;

	//m_pV11_MeshSkin_Decl = NULL;
	m_pEffect = NULL;
	memset(m_pVertexDeclaration, 0, sizeof(m_pVertexDeclaration));

	m_dwBranchVertexShader = NULL;
	m_dwLeafVertexShader   = NULL;
	m_dwSpeedTreeBillboardVertexShader = NULL;	// sonador #2.1.7.1	스피드 트리 퍼포먼스 증가

	m_dwGrassVertexShader = NULL;

	m_bStencilTwo = false;

	m_Campos = K3DVector( 0,0,0 );
	m_fMipBias  = 0.f;//-.9f;
	m_dwAlpharef = 0;

	m_pSwapChain = NULL;

	m_pRenderToEnvMap	= NULL;

	m_d3dQuery					= NULL;
	m_bOcclusionCullingCheck	= false;
	m_bDeviceSupportsVizQuery	= false;

	m_nVertexBufBlendArrayCount = 0;
	m_pVertexBufBlendArray = NULL;

	m_dwPrevDeclaration	=	VTXDECLARATION_MAX;
	m_dwPrevTechnique	=	TECHNIQUE_MAX;
}

K3DRenderDeviceDX::~K3DRenderDeviceDX()
{
	//메모리 Array 삭제
	for( unsigned int i(0); m_nVertexBufBlendArrayCount>i; i++ )
	{
		m_pVertexBufBlendArray[i]->Discard();	//SUN : 추적요망, LEAK발생, AddRef()를 명시적으로 호출하는 부분때문에 최후 삭제시점에서 refcount가1인상태임.
	}
	SAFE_DELETE_ARRAY( m_pVertexBufBlendArray );

	//Recycle VB 삭제
	for( unsigned int i(0); m_vRecycleVBList.size()>i; i++ )
	{
		m_vRecycleVBList[i]->pVtxBuf->Discard();
		delete m_vRecycleVBList[i];
	}
	m_vRecycleVBList.erase( m_vRecycleVBList.begin(), m_vRecycleVBList.end() );

	SAFE_RELEASE(m_pRenderTargetSurface );
	//SAFE_RELEASE(m_pRenderTargetDepth );
	//SAFE_RELEASE(m_pRenderTarget );

	SAFE_RELEASE(m_backbuffer);
	SAFE_RELEASE(m_zbuffer);

	SAFE_RELEASE(m_d3dQuery);

	EndVertexShader();

	EndSpeedTree();

	SAFE_DELETE(m_pSwapChain);

	for( int nRSB = 0; nRSB < MAX_RENDERSTATE_BLOCK; ++nRSB )
	{
		SAFE_RELEASE( m_hRS[nRSB] );
	}

	SAFE_RELEASE(m_lpDD7);

	SAFE_RELEASE( m_pRenderToEnvMap );

	SAFE_RELEASE(m_d3ddev );
	SAFE_RELEASE(m_pD3D9 );
}

void K3DRenderDeviceDX::GetVGAMem( DWORD & dwFree, DWORD & dwTotal )
{
	checkVGAMem();

	dwFree  = m_dwVGA_Free;
	dwTotal = m_dwVGA_Total;
}

void K3DRenderDeviceDX::checkVGAMem()
{
#ifdef _DEBUG
	//=======================================================================
	if( m_lpDD7 )
	{
		DDSCAPS2      ddsCaps2; 
		HRESULT       hr; 

		// Initialize the structure.
		ZeroMemory(&ddsCaps2, sizeof(ddsCaps2));

		ddsCaps2.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM; 
		hr = m_lpDD7->GetAvailableVidMem(&ddsCaps2, &m_dwVGA_Total, &m_dwVGA_Free); 
		if (FAILED(hr))
			return;

//		_oprint( "Device Info - GetAvailableVidMem : [Total %d KB] [Free %d KB]\n", m_dwVGA_Total/1024, m_dwVGA_Free/1024 );
	}
	//=======================================================================	
#endif
}

HRESULT	K3DRenderDeviceDX::TestCooperativeLevel()
{
	return m_d3ddev->TestCooperativeLevel();
}

bool K3DRenderDeviceDX::SetSupportDispMode()
{
	m_pD3D9   = Direct3DCreate9( D3D_SDK_VERSION );
	m_Adapter = D3DADAPTER_DEFAULT;

	// Identify 저장
	m_pD3D9->GetAdapterIdentifier( m_Adapter, 0, &m_Adapter_Identify );

	//current DispMode
	if( FAILED( m_pD3D9->GetAdapterDisplayMode( m_Adapter, &m_d3ddm ) ) )
	{
		return false;
	}

	_GetDisplayModelist();

	SAFE_RELEASE( m_pD3D9 );

	return true;
}

//#define VIEW_MSG_BOX

bool K3DRenderDeviceDX::Create( const CS &cs )
{
	_oprint( "K3DRenderDeviceDX::Create\n" );

	SAFE_RELEASE( m_lpDD7 );
//	{
//		HRESULT       hr; 
//		m_lpDD7 = NULL;
//		hr = DirectDrawCreateEx(NULL, (VOID**)&m_lpDD7, IID_IDirectDraw7, NULL );
//		if (FAILED(hr))
//		{
//			_oprint( "DirectDrawCreateEx Failed : %d\n", hr );
//#ifdef VIEW_MSG_BOX
//			MessageBox( (HWND)m_cs.hWnd, "RenderDevice Create Error 00", "Error", MB_OK );
//#endif
//			return false; 
//		}
//	}

	m_cs = cs;
	m_sizeScreen = m_cs.sizeScreen;
	m_pD3D9 = Direct3DCreate9( D3D_SDK_VERSION );
	m_Adapter = D3DADAPTER_DEFAULT;

	// Identify 저장
	m_pD3D9->GetAdapterIdentifier( m_Adapter, 0, &m_Adapter_Identify );

	//current DispMode
	if( FAILED( m_pD3D9->GetAdapterDisplayMode( m_Adapter, &m_d3ddm ) ) )
	{
#ifdef VIEW_MSG_BOX
		MessageBox( (HWND)m_cs.hWnd, "RenderDevice Create Error 01", "Error", MB_OK );
#endif
		return false;
	}

	//현재 화면 포맷에 대한 해상도 리스트만 얻는다.
	_GetDisplayModelist();

	// Caps에 대한 정보를 얻어서 설정
	_GetCapsInformation();

	if( m_Caps.VertexShaderVersion < D3DPS_VERSION(2,0) || m_Caps.PixelShaderVersion < D3DPS_VERSION(2,0) )
	{
		//return false;
	}

	// 실제로 Device 생성
	if( false == _CreateDevice() )
	{
#ifdef VIEW_MSG_BOX
		MessageBox( (HWND)m_cs.hWnd, "RenderDevice Create Error 02", "Error", MB_OK );
#endif
		return false;
	}

	setupOcclusion();

	int nMaxAllocMem = m_d3ddev->GetAvailableTextureMem();
	_oprint( "Device Info - GetAvailableTextureMem : %d KB\n", nMaxAllocMem/1024 );

	m_fVertexAspect = (float)m_cs.sizeScreen.width / m_cs.sizeScreen.height;

	m_d3ddev->GetRenderTarget( 0, &m_backbuffer );
	m_d3ddev->GetDepthStencilSurface( &m_zbuffer );
	ResetGammaRange();

	//소프트웨어 커서 생기면 삭제 해야 함.
	if( GetCaps().CursorCaps & D3DCURSORCAPS_LOWRES ||
		GetCaps().CursorCaps == 0 )
	{
		m_d3ddev->SetDialogBoxMode( TRUE );
	}

	initializeRenderState();

	//Shader 초기화~
	InitVertexShader();

	InitSpeedTree();
	InitSpeedGrass();
	return true;
}

K3DFORMAT K3DRenderDeviceDX::GetCurrentDisplayModeFormat()
{
	D3DDISPLAYMODE mode;
	m_d3ddev->GetDisplayMode( 0, &mode );

	return (K3DFORMAT)mode.Format;
}

void K3DRenderDeviceDX::_GetDisplayModelist()
{
	assert(m_pD3D9);

	const UINT MIN_WIDTH   = 1024;
	// 2010.07.12 동남아시아에 최저 해상도 조정 - prodongi
	const UINT MIN_HEIGHT  = GameRule::isSoutheastAsia() ? 720 : 768;
	const UINT MAX_WIDTH   = 4096;
	const UINT MAX_HEIGHT  = 4096;
	const UINT REFRESH_MIN = 0;
	const UINT REFRESH_MAX = UINT_MAX;

	UINT numAdapterModes = m_pD3D9->GetAdapterModeCount( m_Adapter, m_d3ddm.Format );
	for (UINT mode = 0; mode < numAdapterModes; mode++)
	{
		D3DDISPLAYMODE displayMode;
		m_pD3D9->EnumAdapterModes( m_Adapter, m_d3ddm.Format, mode, &displayMode );

		if( displayMode.Width < MIN_WIDTH || displayMode.Height < MIN_HEIGHT || 
			displayMode.Width > MAX_WIDTH || displayMode.Height > MAX_HEIGHT || 
			displayMode.RefreshRate < REFRESH_MIN || displayMode.RefreshRate > REFRESH_MAX )
		{
			continue;
		}

		m_DispModeList.push_back( displayMode );

		_oprint( "%dx%d %d\n", displayMode.Width, displayMode.Height, displayMode.RefreshRate );
	}
}
void K3DRenderDeviceDX::_GetCapsInformation()
{

	//Shader 정보 얻기============================================================
	m_pD3D9->GetDeviceCaps( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &m_Caps );
	
	//StretchRect Filter
	m_StretchRectFilterMode = D3DTEXF_NONE;

	if( m_Caps.StretchRectFilterCaps & D3DPTFILTERCAPS_MINFPOINT  ){ m_StretchRectFilterMode = D3DTEXF_POINT ; _oprint( "StretchRect Filter Mode Min Point\n"  ); }
	if( m_Caps.StretchRectFilterCaps & D3DPTFILTERCAPS_MAGFPOINT  ){ m_StretchRectFilterMode = D3DTEXF_POINT ; _oprint( "StretchRect Filter Mode Mag Point\n"  ); }
//	if( m_Caps.StretchRectFilterCaps & D3DPTFILTERCAPS_MINFLINEAR ){ m_StretchRectFilterMode = D3DTEXF_LINEAR; _oprint( "StretchRect Filter Mode Min Linear\n" ); }
//	if( m_Caps.StretchRectFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR ){ m_StretchRectFilterMode = D3DTEXF_LINEAR; _oprint( "StretchRect Filter Mode Mag Linear\n" ); }
	
	m_bIsStretchRect = false;
	//StretchRect H/W Acc
	if( m_Caps.DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES )
	{
		m_bIsStretchRect = true;
		_oprint( "StretchRect H/W 지원\n" );
	}
	
	//UpdateSurface H/W Acc
	if( m_Caps.Caps3 & D3DCAPS3_COPY_TO_VIDMEM )
	{
		_oprint( "UpdateSurface H/W 지원\n" );
	}

	// 양면 스텐실 기능 확인
	if( ( m_Caps.StencilCaps & D3DSTENCILCAPS_TWOSIDED ) )
	{
		_oprint( "D3DSTENCILCAPS_TWOSIDED H/W 지원\n" );
		m_bStencilTwo = true;
	}



	if ( m_Caps.MaxVertexShaderConst > 250 )
		m_cs.dwOption = 1;
	else 
		m_cs.dwOption = 0;

}

#define DEBUG_VS

bool K3DRenderDeviceDX::_CreateDevice()
{
	// 알맞은것 설정
	const int TYPE_COUNT = 3;
	D3DDEVTYPE BEST_FIT_D3DDEV[TYPE_COUNT] =  { D3DDEVTYPE_HAL, D3DDEVTYPE_HAL, D3DDEVTYPE_REF };
	DWORD BEST_FIT_BEHAVIOR[TYPE_COUNT] = { D3DCREATE_HARDWARE_VERTEXPROCESSING, D3DCREATE_SOFTWARE_VERTEXPROCESSING, D3DCREATE_SOFTWARE_VERTEXPROCESSING };	
	int BEST_FIT_KDEV[3] =  { KDEVTYPE_HARDWARE_VTX_PROCESSING, KDEVTYPE_SOFTWARE_VTX_PROCESSING, KDEVTYPE_SOFTWARE_RENDER};

	// 무조건 D3DCREATE_SOFTWARE_VERTEXPROCESSING 로 생성
	if( m_cs.dwOption == 0)
	{
		BEST_FIT_BEHAVIOR[0] = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
		BEST_FIT_KDEV[0] = KDEVTYPE_SOFTWARE_VTX_PROCESSING;
	}

	HRESULT hr = D3D_OK;
	for(int i = 0; i < TYPE_COUNT; ++i)
	{
		m_d3dDevType = (D3DDEVTYPE)BEST_FIT_D3DDEV[i];
#ifdef _COUNTRY_ME_
		m_BeHaviorFlag = BEST_FIT_BEHAVIOR[i] | D3DCREATE_MULTITHREADED | D3DCREATE_FPU_PRESERVE;
#else
		m_BeHaviorFlag = BEST_FIT_BEHAVIOR[i] | D3DCREATE_MULTITHREADED;
#endif

#ifdef DEBUG_VS
		//if( m_d3dDevType != D3DDEVTYPE_REF )
		//{
		//	m_BeHaviorFlag &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
		//	m_BeHaviorFlag &= ~D3DCREATE_PUREDEVICE;                            
		//	m_BeHaviorFlag |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
		//}
#endif
		_SetPresentParam();

		hr = m_pD3D9->CreateDevice( m_Adapter, m_d3dDevType, reinterpret_cast<HWND>( m_cs.hFocusWnd ), m_BeHaviorFlag,
			&m_d3dParam, &m_d3ddev );

		if ( m_d3ddev != NULL && SUCCEEDED(hr) )
		{
			break;
		}
	}

	if ( m_d3ddev == NULL ) 
	{
		assert( 0 && "Device Init Fail!!" );
		return false;
	}

	//기존에 설정 된 값을 얻어 놓는다.
	m_d3ddev->GetGammaRamp( 0, &m_OldD3dgr );

	return true;
}

void K3DRenderDeviceDX::_SetPresentParam()
{
	memset( &m_d3dParam, 0, sizeof(m_d3dParam) );

	if ( m_cs.bFullScreen )  
	{
		switch(m_cs.nBPP) 
		{
			default:
			case 16:
			{
				static D3DFORMAT BEST_FIT_FORMAT[] = { D3DFMT_R5G6B5, D3DFMT_X1R5G5B5 };
				m_d3dParam.BackBufferFormat = _GetValidBackBuffer( &BEST_FIT_FORMAT[0], _countof(BEST_FIT_FORMAT) );
				break;	
			}
			case 32:
			{
				static const D3DFORMAT BEST_FIT_FORMAT[] = { D3DFMT_X8R8G8B8, D3DFMT_R8G8B8 };
				m_d3dParam.BackBufferFormat = _GetValidBackBuffer( &BEST_FIT_FORMAT[0], _countof(BEST_FIT_FORMAT) );
				break;	
			}
		}
		m_d3dParam.BackBufferCount = 1;	
		m_d3dParam.SwapEffect = D3DSWAPEFFECT_DISCARD;
		m_d3dParam.FullScreen_RefreshRateInHz = m_d3ddm.RefreshRate;
		m_d3dParam.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
	}
	else
	{
		m_d3dParam.BackBufferCount = 0;
		m_d3dParam.BackBufferFormat = m_d3ddm.Format;
		m_d3dParam.SwapEffect = D3DSWAPEFFECT_COPY;
		m_d3dParam.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
		m_d3dParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
	}

	m_d3dParam.BackBufferWidth = m_cs.sizeScreen.width;
	m_d3dParam.BackBufferHeight = m_cs.sizeScreen.height;
	m_d3dParam.MultiSampleType = D3DMULTISAMPLE_NONE;
	m_d3dParam.hDeviceWindow = reinterpret_cast<HWND>(m_cs.hWnd);
	m_d3dParam.Windowed = !m_cs.bFullScreen;
	m_d3dParam.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER; //Explorer
	m_d3dParam.EnableAutoDepthStencil = TRUE;
	m_d3dParam.AutoDepthStencilFormat = _GetValidZBuffer();


}

D3DFORMAT K3DRenderDeviceDX::_GetValidBackBuffer(const D3DFORMAT* pCheckType, int nSize)
{

	for(int i = 0; i < nSize; ++i)
	{
		if( SUCCEEDED( m_pD3D9->CheckDeviceType(m_Adapter, m_d3dDevType, pCheckType[i], pCheckType[i], 
			false) ) )
		{
			return pCheckType[i];
		}
	}

	return D3DFMT_UNKNOWN;
}


D3DFORMAT K3DRenderDeviceDX::_GetValidZBuffer()
{

	bool bCreateStencil = false;
	if(bCreateStencil)
	{
		D3DFORMAT bestFitWithZBufferStencil[] = 
		{
			D3DFMT_D16, D3DFMT_D15S1, D3DFMT_D24X8, D3DFMT_D24S8, D3DFMT_D24X4S4, D3DFMT_D32,   
		};

		int nSize = _countof(bestFitWithZBufferStencil);
		for(int i = (nSize-1) ; i >= 0; --i )
		{
			if( _IsDepthFormatOk(bestFitWithZBufferStencil[i]) )
				return bestFitWithZBufferStencil[i];
		}
	}
	else
	{
		D3DFORMAT bestFitWithZBuffer[] = 
		{
			D3DFMT_D16, D3DFMT_D15S1, D3DFMT_D24X8, D3DFMT_D24S8, D3DFMT_D24X4S4, D3DFMT_D32,   
		};

		int nSize = _countof(bestFitWithZBuffer);
		for(int i = (nSize-1) ; i >= 0; --i )
		{
			if( _IsDepthFormatOk(bestFitWithZBuffer[i]) )
				return bestFitWithZBuffer[i];
		}
	}

	return D3DFMT_UNKNOWN;
}
bool K3DRenderDeviceDX::_IsDepthFormatOk(D3DFORMAT DepthFormat)
{
	if( SUCCEEDED(m_pD3D9->CheckDeviceFormat(m_Adapter, m_d3dDevType, 
		m_d3dParam.BackBufferFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, 
		DepthFormat)  ) )
	{

		if( SUCCEEDED( m_pD3D9->CheckDepthStencilMatch(m_Adapter,
			m_d3dDevType,m_d3dParam.BackBufferFormat, m_d3dParam.BackBufferFormat, 
			DepthFormat ) ) )
		{
	return true;

		}
}
	return false;
}


void K3DRenderDeviceDX::ResetScreenSize( int nWidth, int nHeight )
{
	if( m_sizeScreen.cx != nWidth || m_sizeScreen.cy != nHeight )
	{
		//KSize oldsize = m_cs.sizeScreen;
		m_sizeScreen = m_cs.sizeScreen = KSize( nWidth, nHeight );
		m_fVertexAspect = (float)m_cs.sizeScreen.width / m_cs.sizeScreen.height;

		resetDevice(false);
		//if(!resetDevice( false ))
		//{
		//	m_sizeScreen = m_cs.sizeScreen = oldsize;
		//	m_fVertexAspect = (float)m_cs.sizeScreen.width / m_cs.sizeScreen.height;
		//	resetDevice(false, true);
		//}
		reloadDevice();
		setWindowStyle();
	}
}

void K3DRenderDeviceDX::SetRefreshRate( int nRefreshRate )
{
	if( m_cs.nRefreshRate != nRefreshRate )
	{
		//int nOldRefresh = m_cs.nRefreshRate;
		m_cs.nRefreshRate = nRefreshRate;

		resetDevice(false);
		//if(!resetDevice( false ))
		//{
		//	m_cs.nRefreshRate = nOldRefresh;
		//	resetDevice(false, true);
		//}
		reloadDevice();
		setWindowStyle();
	}
}

//기존 상태 해제 후 재 설정
bool K3DRenderDeviceDX::resetDevice( bool bToggleFullScreen/* = true*/, bool bInfiniteTry )
{
	THREAD_SYNCRONIZE( s_lckReloadTexture );

	ResetPrevDeclarationTechnique();

	SAFE_RELEASE(m_backbuffer);
	SAFE_RELEASE(m_zbuffer);

	if ( m_pSwapChain )
		m_pSwapChain->Clear();

	//DYNAMIC 버텍스 릴리즈~ Speed Tree 등
	for( unsigned int i(0); m_vReloadVertexList.size()>i; i++ )
		m_vReloadVertexList[i]->PreReload();
	
	_performance_print( "DYNAMIC VtxCount : %d \n", m_vReloadVertexList.size() );

	for( unsigned int i(0); m_vReloadIndexList.size()>i; i++ )
		m_vReloadIndexList[i]->PreReload();

	_performance_print( "Recycle VtxCount : %d \n", m_vRecycleVBList.size() );
	for( unsigned int i(0); m_vRecycleVBList.size()>i; i++ )
	{
		if( m_vRecycleVBList[i]->usage & D3DUSAGE_DYNAMIC )
		{
			m_vRecycleVBList[i]->pVtxBuf->PreReload();
		}
	}

	//DYNAMIC 텍스쳐 릴리즈
	for( unsigned int i(0); m_vReloadTextureList.size()>i; i++ )
	{
		m_vReloadTextureList[i]->PreReload();
		_oprint( "Device Lost : resetDevice (0x%08X)\n", m_vReloadTextureList[i] );		
	}

	//// FXEffect 릴리즈
	//for( UINT i(0); i < m_vReloadFXEffectList.size(); ++i)
	//	m_vReloadFXEffectList[i]->OnLostDevice();

	EndVertexShader();

 
	if( bToggleFullScreen ) 
		m_cs.bFullScreen = !m_cs.bFullScreen; //한번 Lost되면, 윈도우 모드..


	_SetPresentParam();

	for( int nRSB = 0; nRSB < MAX_RENDERSTATE_BLOCK; ++nRSB )
	{
		SAFE_RELEASE( m_hRS[nRSB] );
	}

	HRESULT hres;

	SAFE_RELEASE( m_d3dQuery );

	//성공 할 때까지 시도...
	while ( (hres = m_d3ddev->Reset( &m_d3dParam )) != D3D_OK ) 
	{
		// by Testors
		Sleep( 100 );

		if(!bInfiniteTry) break;	// device lost 때 호출하는 것이 아니라면 루프에서 빠져나온다.
		//끝나지 않는 다면, 대략 낭패...
	}

	_oprint( "!!!resetDevice()\n" );
	
	if(hres == D3D_OK)
	{
		setupOcclusion();

		m_bIsDeviceLost = false;
		return true;
	}
	else
	{
		m_bIsDeviceLost = true;
		return false;
	}
}

//복구 안되는것 재 설정
void K3DRenderDeviceDX::reloadDevice()
{
	THREAD_SYNCRONIZE( s_lckReloadTexture );

	//DYNAMIC 버퍼들..(Speed Tree 재 설정)
	//DYNAMIC 버텍스 릴리즈~ Speed Tree 등
	for( unsigned int i(0); m_vReloadVertexList.size()>i; i++ )
		m_vReloadVertexList[i]->Reload();

	for( unsigned int i(0); m_vReloadIndexList.size()>i; i++ )
		m_vReloadIndexList[i]->Reload();

	for( unsigned int i(0); m_vRecycleVBList.size()>i; i++ )
	{
		if( m_vRecycleVBList[i]->usage & D3DUSAGE_DYNAMIC )
		{
			m_vRecycleVBList[i]->pVtxBuf->Reload();
		}
	}

	//DYNAMIC 텍스쳐 릴리즈
	for( unsigned int i(0); m_vReloadTextureList.size()>i; i++ )
		m_vReloadTextureList[i]->Reload();

	//for( UINT i(0); i < m_vReloadFXEffectList.size(); ++i)
	//	m_vReloadFXEffectList[i]->OnResetDevice();

	//Back Buffer 재 설정
	m_d3ddev->GetRenderTarget( 0, &m_backbuffer );
    m_d3ddev->GetDepthStencilSurface( &m_zbuffer );
	
	if(m_pSwapChain)
	{
		m_pSwapChain->Reset();
		SetSwapChain(m_pSwapChain);
	}
	
	//순서 있음. initializeRenderState() 보다 먼저 처리
	InitVertexShader();

	initializeRenderState();

	_oprint( "!!!reloadDevice()\n" );
}

//BOOL CALLBACK PaintWindowProc(HWND hwnd, LPARAM lParam)
//{
//	PostMessage(hwnd, WM_PAINT, 0, 0);
//
//	return TRUE;
//}

void K3DRenderDeviceDX::setWindowStyle()
{
	DWORD dwStyle = 0;

	int sx = GetSystemMetrics(SM_CXSCREEN);
	int sy = GetSystemMetrics(SM_CYSCREEN);

	// In fullscreen mode, do not use the caption border
	if(m_cs.bFullScreen)
	{
		dwStyle = WS_POPUPWINDOW;      // Fullscreen mode
		dwStyle &= ~WS_SYSMENU;
	}
#ifdef _DEV
	else if( m_cs.bFullWindow )			// 전체 창 모드
	{
		dwStyle = WS_POPUPWINDOW;      //
		dwStyle &= ~WS_SYSMENU;
	}
#endif
	else
	{
		// Hide the menu bar when the resolution is 1024x768
		if( sx == 1024 && sy == 768 )
		{
			dwStyle = WS_POPUPWINDOW;      //
			dwStyle &= ~WS_SYSMENU;
		}
		else
		{
			dwStyle = WS_OVERLAPPEDWINDOW; // Windowed mode
			dwStyle |= WS_SYSMENU;
			dwStyle |= WS_MINIMIZEBOX;
		}
	}

	dwStyle &= ~WS_THICKFRAME; 
	dwStyle &= ~WS_MAXIMIZEBOX; 

	//Explorer
	dwStyle |= WS_CLIPCHILDREN;
	dwStyle |= WS_CLIPSIBLINGS;

	SetWindowLong((HWND) m_cs.hWnd, GWL_STYLE, dwStyle);
	
	if( false == m_cs.bFullScreen && false == m_cs.bFullWindow) // If not in fullscreen or borderless window mode
	{
		//int x, y, cx, cy, sx, sy;
		int cx, cy;

		cx = m_cs.sizeScreen.width + GetSystemMetrics(SM_CXFIXEDFRAME) * 2;
		cy = m_cs.sizeScreen.height + GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFIXEDFRAME) * 2;

		//SetWindowPos((HWND) m_cs.hWnd, HWND_NOTOPMOST, (sx - cx) / 2, (sy - cy) / 2, cx, cy, SWP_SHOWWINDOW);
		SetWindowPos((HWND) m_cs.hWnd, HWND_NOTOPMOST, (sx - cx) / 2, (sy - cy) / 2, cx, cy, 0);
	}

	if( false == m_cs.bFullScreen && true == m_cs.bFullWindow) // 전체창 모드라면
	{
		int cx, cy;

		cx = GetSystemMetrics(SM_CXSCREEN);
		cy = GetSystemMetrics(SM_CYSCREEN);

		SetWindowPos((HWND) m_cs.hWnd, HWND_NOTOPMOST, 0, 0, cx, cy, 0);
	}
	

	ShowWindow((HWND) m_cs.hWnd, SW_SHOW);

	//EnumWindows(PaintWindowProc, 0);
}

bool K3DRenderDeviceDX::ToggleFullscreen(bool bFullscreen)
{
	if(m_cs.bFullScreen == bFullscreen) return false;

	resetDevice();
	//if(!resetDevice())
	//{
	//	resetDevice(true, true);
	//}
	reloadDevice();
	setWindowStyle();

	 return true;
}

void K3DRenderDeviceDX::ShowCursor( BOOL bShow )
{
	m_d3ddev->ShowCursor( bShow );
}

void K3DRenderDeviceDX::SetCursorPos( int x, int y )
{
	m_d3ddev->SetCursorPosition( x, y, D3DCURSOR_IMMEDIATE_UPDATE );
}


void K3DRenderDeviceDX::SetCursor( K3DTexture *cursor, DWORD dwHotSpotX, DWORD dwHotSpotY )
{
	if ( cursor && cursor->IsValid() )
	{
		//K3DTextureDX *dxtex = static_cast<K3DTextureDX*>( cursor );

		IDirect3DSurface9 *pCursorSurf;
		HRESULT res;
		res = reinterpret_cast<IDirect3DTexture9*>(cursor->GetSurface())->GetSurfaceLevel( 0, &pCursorSurf );
		res = m_d3ddev->SetCursorProperties( dwHotSpotX, dwHotSpotY, pCursorSurf );
		m_d3ddev->ShowCursor( TRUE );

		if ( res =! D3D_OK )
			return;
		
		SAFE_RELEASE( pCursorSurf );	
	}
}

void K3DRenderDeviceDX::AddLostVertexBuffer( K3DVertexBuffer* pVtxBuf )
{
	if( pVtxBuf == NULL )
	{
		return;
	}

	for( unsigned int i(0); m_vReloadVertexList.size()>i; i++ )
	{
		if( m_vReloadVertexList[i] == pVtxBuf)
		{
			return;
		}
	}

	m_vReloadVertexList.push_back(pVtxBuf);
}

void K3DRenderDeviceDX::RemoveLostVertexBuffer( K3DVertexBuffer* pVtxBuf )
{
	DelReloadVertexList( pVtxBuf );
}

void K3DRenderDeviceDX::DelReloadVertexList( class K3DVertexBuffer * pVtx )
{
#ifdef _DEBUG
	int nSize = m_vReloadVertexList.size();
#endif
	for( unsigned int i(0); m_vReloadVertexList.size()>i; i++ )	
	{
		if( m_vReloadVertexList[i] == pVtx)
		{
#ifdef _DEBUG
			K3DVertexBuffer * pDVtx = m_vReloadVertexList[i];
#endif
			m_vReloadVertexList.erase( m_vReloadVertexList.begin()+i );
			return;
		}
	}
}

void K3DRenderDeviceDX::AddLostIndexBuffer( K3DIndexBuffer* pIdxBuf )
{
	if( pIdxBuf == NULL )
	{
		return;
	}

	for( unsigned int i(0); m_vReloadIndexList.size()>i; i++ )
	{
		if( m_vReloadIndexList[i] == pIdxBuf)
		{
			return;
		}
	}

	m_vReloadIndexList.push_back(pIdxBuf);
}

void K3DRenderDeviceDX::RemoveLostIndexBuffer( K3DIndexBuffer* pIdxBuf )
{
	for( unsigned int i(0); m_vReloadIndexList.size()>i; i++ )
	{
		if( pIdxBuf == m_vReloadIndexList[i])
		{
			m_vReloadIndexList.erase( m_vReloadIndexList.begin()+i );
			return;
		}
	}
}

K3DVertexBuffer *K3DRenderDeviceDX::CreateVertexBufferSpeedTree( DWORD stride, DWORD Usage, DWORD vertexformat, DWORD count )
{
	K3DVertexBuffer* pVB = GetRecycleVertexBufferSpeedTree( stride, Usage, vertexformat, count );
	if( pVB ) 
	{
		if(Usage & D3DUSAGE_DYNAMIC)
		{
			AddLostVertexBuffer( pVB );
		}
		return pVB;
	}

	K3DVertexBufferDX *vb = new K3DVertexBufferDX(this);
	if( vb )
	{
		if( vb->CreateNewSpeedTree( stride, Usage, count, vertexformat ) == false )
		{
			vb->Discard();
			return NULL;
		}

		if(Usage & D3DUSAGE_DYNAMIC)
		{
			AddLostVertexBuffer( vb );
		}

		return vb;
	}

	return NULL;
}

K3DVertexBuffer *K3DRenderDeviceDX::CreateVertexBufferUsePoolDefault( DWORD stride, DWORD vertexformat, DWORD count, DWORD Usage )
{
	K3DVertexBuffer* pVB = GetRecycleVertexBufferUsePoolDefault( stride, vertexformat, count, Usage );
	if( pVB ) 
	{
		AddLostVertexBuffer( pVB );
		return pVB;
	}

	K3DVertexBufferDX *vb = new K3DVertexBufferDX(this);
	if( vb )
	{
		if( vb->CreateNewPoolDefault( stride, count, vertexformat, Usage ) == false )
		{
			vb->Discard();
			return NULL;
		}
		
		AddLostVertexBuffer( vb );
		return vb;
	}

	return NULL;
}

K3DVertexBuffer *K3DRenderDeviceDX::CreateVertexBufferBlend( DWORD stride, DWORD vertexformat, DWORD count )
{
	K3DVertexBuffer* pVB = GetRecycleVertexBufferBlend( stride, vertexformat, count );
	if( pVB ) return pVB;

	K3DVertexBufferDX *vb = new K3DVertexBufferDX(this);
	if( vb )
	{
		if( vb->CreateNewBlend( stride, count, vertexformat ) == false )
		{
			vb->Discard();
			return NULL;
		}

		//AddLostVertexBuffer( vb );
		return vb;
	}

	return NULL;
}

K3DVertexBuffer *K3DRenderDeviceDX::CreateVertexBufferSpeedGrass( DWORD stride, DWORD Usage, DWORD vertexformat, DWORD count )
{
	K3DVertexBuffer* pVB = GetRecycleVertexBufferSpeedGrass( stride, Usage, vertexformat, count );
	if( pVB ) 
	{
		if(Usage & D3DUSAGE_DYNAMIC)
		{
			AddLostVertexBuffer( pVB );
		}

		return pVB;
	}

	K3DVertexBufferDX *vb = new K3DVertexBufferDX(this);
	if( vb )
	{
		if( vb->CreateNewSpeedGrass( stride, Usage, count, vertexformat ) == false )
		{
			vb->Discard();
			return NULL;
		}

		if(Usage & D3DUSAGE_DYNAMIC)
		{
			AddLostVertexBuffer( vb );
		//	m_vReloadVertexList.push_back(vb);
		}

		return vb;
	}

	return NULL;
}

KFXEffect*	K3DRenderDeviceDX::CreateFXEffect(KStream& stream)
{
	//KFXEffectDX* pEffect = new KFXEffectDX( this );
	//pEffect->Initialize( stream );

	//m_vReloadFXEffectList.push_back( pEffect );
	//return pEffect;

	return NULL;
}

K3DVertexBuffer *K3DRenderDeviceDX::CreateVertexBuffer( DWORD vertexformat, DWORD count )
{
	K3DVertexBuffer* pVB = GetRecycleVertexBuffer( vertexformat, count );
	if( pVB ) return pVB;

	K3DVertexBufferDX *vb = new K3DVertexBufferDX(this);
	if( vb )
	{
		if( vb->CreateNew( vertexformat, count ) == false )
		{
			vb->Discard();
			return NULL;
		}

		//AddLostVertexBuffer( vb );
		return vb;
	}

	return NULL;
}

// Vertex Buffer Array
bool K3DRenderDeviceDX::CreateVertexBufferBlendArray( DWORD array_count, DWORD stride, DWORD vertexformat, DWORD count )
{
	if( m_pVertexBufBlendArray != NULL )
	{
		return false;
	}
	
	m_nVertexBufBlendArrayCount = array_count;
	m_pVertexBufBlendArray = new K3DVertexBuffer*[m_nVertexBufBlendArrayCount];

	for( unsigned int i(0); m_nVertexBufBlendArrayCount>i; i++ )
	{
		m_pVertexBufBlendArray[i] = CreateVertexBufferBlend( stride, vertexformat, count );
	//	m_pVertexBufBlendArray[i]->AddRef();
		m_pVertexBufBlendArray[i]->SetUseRecycle(false); //알아서 재사용 함.
		m_queueFreeVB.push( i );
	}

	return true;
}

K3DVertexBuffer* K3DRenderDeviceDX::GetFreeVertexBufferBlend( int &nIndex )
{
	THREAD_SYNCRONIZE( s_lckVB_Array );

	if( !m_queueFreeVB.empty() )
	{
		nIndex = m_queueFreeVB.front();
		m_queueFreeVB.pop();

		//m_pVertexBufBlendArray[nIndex]->AddRef();

		return m_pVertexBufBlendArray[nIndex];
	}
	else
	{
	//	assert( 0 && "empty Free VB" );
		nIndex = -1;
	}

	return NULL;
}

int K3DRenderDeviceDX::ReleaseVertexBufferBlend( int nIndex )
{
	THREAD_SYNCRONIZE( s_lckVB_Array );

	if( nIndex >= 0 && nIndex < (int)m_nVertexBufBlendArrayCount )
	{
		m_pVertexBufBlendArray[nIndex]->Release();

		m_queueFreeVB.push( nIndex );
	}
	
	if( m_queueFreeVB.empty() )
		return 0;

	return m_queueFreeVB.size();
}

bool K3DRenderDeviceDX::ResizeVertexBufferBlendArray( DWORD array_count, DWORD stride, DWORD vertexformat, DWORD count )
{
	THREAD_SYNCRONIZE( s_lckVB_Array );

	if( m_nVertexBufBlendArrayCount > array_count )
		return false;

	K3DVertexBuffer** pVBArray = new K3DVertexBuffer*[array_count];

	for( unsigned int i(0); array_count>i; i++ )
	{
		//늘어난 곳만 할당
		if( i >= m_nVertexBufBlendArrayCount )
		{	
			pVBArray[i] = CreateVertexBufferBlend( stride, vertexformat, count );
		//	pVBArray[i]->AddRef();
			pVBArray[i]->SetUseRecycle(false);

			m_queueFreeVB.push( i );
		}
		else
		{	//기존것 받음.
			pVBArray[i] = m_pVertexBufBlendArray[i];
		}
	}

	m_nVertexBufBlendArrayCount = array_count;

	//포인터만 삭제
	SAFE_DELETE_ARRAY( m_pVertexBufBlendArray );

	//새 배열 설정
	m_pVertexBufBlendArray = pVBArray;

	return true;
}

//Serarch 가 빨라야 한다.
void K3DRenderDeviceDX::AddRecycleVertexBuffer( K3DVertexBuffer* pVtxBuf, DWORD vtxformat, DWORD usage, DWORD stride, DWORD count )
{
	THREAD_SYNCRONIZE( s_lckReloadTexture );
	
	if( (int)m_vRecycleVBList.size() < s_nRecycleMaxCount )
	{
		RECYCLE_VB* pRecycleVB = new RECYCLE_VB;
		pRecycleVB->usage     = usage    ;
		pRecycleVB->vtxformat = vtxformat;
		pRecycleVB->stride    = stride   ;
		pRecycleVB->count     = count    ;
		pRecycleVB->pVtxBuf   = pVtxBuf  ;

		m_vRecycleVBList.push_back( pRecycleVB );
	}
	else
	{	//
//		_performance_print( "Recycle VB Over %d\n", m_vRecycleVBList.size() );
		if( pVtxBuf ) pVtxBuf->Discard();
	}
}

K3DVertexBuffer* K3DRenderDeviceDX::getRecycleVB( DWORD stride, DWORD Usage, DWORD vertexformat, DWORD count )
{
//	return NULL;

	THREAD_SYNCRONIZE( s_lckReloadTexture );

	if( m_vRecycleVBList.empty() )
		return NULL;

	std::vector< RECYCLE_VB* >::iterator it = m_vRecycleVBList.begin();
	
	for( ; it != m_vRecycleVBList.end(); it++ )
	{
		RECYCLE_VB* pReVB = (*it);
		if( pReVB->usage == Usage && pReVB->vtxformat == vertexformat && pReVB->stride == stride )
		{
			if( pReVB->count == count )
			{
//				_performance_print( "Recycle Hit 01 - %d\n", m_vRecycleVBList.size() );
				K3DVertexBuffer* pVB = pReVB->pVtxBuf;
				delete (*it);
				m_vRecycleVBList.erase(it);
				return pVB;
			}
			else 
			{
				//약간 큰것이라면, 준다.
				int nTime = pReVB->count/count;
				if( nTime == 1 )
				{
//					_performance_print( "Recycle Hit 02 기본:%d 요구:%d - %d\n", pReVB->count, count, m_vRecycleVBList.size() );
					K3DVertexBuffer* pVB = pReVB->pVtxBuf;
					delete (*it);
					m_vRecycleVBList.erase(it);
					return pVB;
				}
			}
		}
	}

	return NULL;
}

K3DVertexBuffer* K3DRenderDeviceDX::GetRecycleVertexBuffer( DWORD vertexformat, DWORD count )
{
	DWORD usage  = D3DUSAGE_WRITEONLY;
	DWORD stride = K3DVertexBuffer::CalcVertexStride( vertexformat );

	return getRecycleVB( stride, usage, vertexformat, count );
}

K3DVertexBuffer* K3DRenderDeviceDX::GetRecycleVertexBufferBlend( DWORD stride, DWORD vertexformat, DWORD count )
{
	DWORD usage  = D3DUSAGE_WRITEONLY;
	
	return getRecycleVB( stride, usage, vertexformat, count );
}

K3DVertexBuffer* K3DRenderDeviceDX::GetRecycleVertexBufferSpeedTree( DWORD stride, DWORD Usage, DWORD vertexformat, DWORD count )
{
	return getRecycleVB( stride, Usage, vertexformat, count );
}

K3DVertexBuffer* K3DRenderDeviceDX::GetRecycleVertexBufferSpeedGrass( DWORD stride, DWORD Usage, DWORD vertexformat, DWORD count )
{
	return getRecycleVB( stride, Usage, vertexformat, count );
}

K3DVertexBuffer* K3DRenderDeviceDX::GetRecycleVertexBufferUsePoolDefault( DWORD stride, DWORD vertexformat, DWORD count, DWORD Usage )
{
	return getRecycleVB( stride, Usage, vertexformat, count );
}

// Index Buffer
K3DIndexBuffer *K3DRenderDeviceDX::CreateIndexBuffer( DWORD count, bool use32bit )
{
	K3DIndexBufferDX *ib = new K3DIndexBufferDX(this);
	if( ib )
	{
		if( ib->CreateNew( count, use32bit ) == false )
		{
			ib->Discard();
			return NULL;
		}

		return ib;
	}

	return NULL;
}

// Texture
K3DTexture *K3DRenderDeviceDX::CreateTexture( KStream &stream, int nQuality )
{
	K3DTextureDX *tex = new K3DTextureDX(this);
	if( tex )
	{
		if( tex->Initialize( stream, nQuality ) == false )
		{
			tex->Discard();
			return NULL;
		}

		//AddLostTexture(tex);
		return tex;
	}

	return NULL;
}
K3DTexture *K3DRenderDeviceDX::CreateTexture( int width, int height, K3DFORMAT format, D3DPOOL pool/* = D3DPOOL_MANAGED*/, int nLevel /*= 1*/ )
{
	K3DTextureDX *tex = new K3DTextureDX(this);		// [MEMORY_LEAK] 2012. 3. 2 - marine 스마트 포인터로 릭 아님..
	if( tex )
	{
		if( tex->CreateNew( width, height, format, pool, nLevel ) == false )
		{
			tex->Discard();
			return NULL;
		}

		//AddLostTexture(tex);
		return tex;
	}

	return NULL;
}

void K3DRenderDeviceDX::AddLostTexture( K3DTexture * tex )
{
	if( tex == NULL )
	{
		return;
	}

	THREAD_SYNCRONIZE( s_lckReloadTexture );
	
	for( unsigned int i(0); m_vReloadTextureList.size()>i; i++ )
	{
		if( m_vReloadTextureList[i] == tex)
		{
			return;
		}
	}

	m_vReloadTextureList.push_back(tex);
}

void K3DRenderDeviceDX::RemoveTexture( K3DTexture * tex )
{
	THREAD_SYNCRONIZE( s_lckReloadTexture );

	for( unsigned int i(0); m_vReloadTextureList.size()>i; i++ )
	{
		if( tex == m_vReloadTextureList[i])
		{
			m_vReloadTextureList.erase( m_vReloadTextureList.begin()+i );
			return;
		}
	}
}

K3DRenderTargetCube *K3DRenderDeviceDX::CreateRenderCube( int size, UINT nLevels, K3DFORMAT format, DWORD dwDepthUsage )
{
	K3DRenderTargetCubeDX *pRenderCubeTex = new K3DRenderTargetCubeDX( this );
	if( pRenderCubeTex )
	{
		if( pRenderCubeTex->CreateNew( size, nLevels, format, dwDepthUsage ) == false )
		{
			pRenderCubeTex->Discard();
			return NULL;
		}

		AddLostTexture( pRenderCubeTex );
		return pRenderCubeTex;
	}

	return NULL;
}

//K3DRenderTarget *K3DRenderDeviceDX::CreateRenderTarget( int width, int height, UINT nLevels, K3DFORMAT format, bool bUseDepth )
K3DRenderTarget *K3DRenderDeviceDX::CreateRenderTarget( int width, int height, UINT nLevels, K3DFORMAT format, DWORD dwDepthUsage, bool bDepth16Bit/*=false*/ )
{
//	_oprint( "Device Lost : CreateRenderTarget\n" );

	K3DRenderTargetDX *surf = new K3DRenderTargetDX(this);
	if( surf )
	{
		//Device Lost 처리

	//	_oprint( "Device Lost : Size : %d : CreateRenderTarget (0x%08X)\n", m_vReloadTextureList.size(), surf );

		//if ( surf->CreateNew( width, height, nLevels, format, bUseDepth ) )
		if ( surf->CreateNew( width, height, nLevels, format, dwDepthUsage, bDepth16Bit ) == false )
		{
			surf->Discard();
			return NULL;
		}

		AddLostTexture(surf);
		return surf;
	}

	return NULL;
}

K3DTexture * K3DRenderDeviceDX::CreateTexture( int width, int height, DWORD usage, K3DFORMAT format, D3DPOOL pool/* = D3DPOOL_DEFAULT*/ )
{
//	_oprint( "Device Lost : CreateRenderTarget\n" );
	K3DTextureDX *tex = new K3DTextureDX(this);
	if( tex )
	{
		if( tex->CreateNew( width, height, usage, format, pool ) == false )
		{
			tex->Discard();
			return NULL;
		}

		//Device Lost 처리
		AddLostTexture(tex);
		//	_oprint( "Device Lost : Size %d : CreateTexture (0x%08X)\n", m_vReloadTextureList.size(), tex );
		return tex;
	}

	return NULL;
}

HRESULT K3DRenderDeviceDX::UpdateSurface( K3DTexture * pSrc, const RECT * pSrcRect, K3DTexture * pDst, const POINT * pDstPoint )
{
	if( !pSrc || !pDst ) return S_FALSE;
	if( !pSrc->IsValid() || !pDst->IsValid() ) return S_FALSE;

	IDirect3DSurface9 *pSrcSurf = NULL;
	reinterpret_cast<IDirect3DTexture9*>(pSrc->GetSurface())->GetSurfaceLevel( 0, &pSrcSurf );
	
	IDirect3DSurface9 *pDstSurf = NULL;
	reinterpret_cast<IDirect3DTexture9*>(pDst->GetSurface())->GetSurfaceLevel( 0, &pDstSurf );

	HRESULT hr = m_d3ddev->UpdateSurface( pSrcSurf, pSrcRect, pDstSurf, pDstPoint );

	SAFE_RELEASE( pSrcSurf );
	SAFE_RELEASE( pDstSurf );

	return hr;
}

HRESULT K3DRenderDeviceDX::StretchRect( K3DTexture * pSrc, const RECT * pSrcRect, K3DTexture * pDst, const RECT * pDstRect )
{
	if( !m_bIsStretchRect ) return D3DERR_INVALIDCALL; //하드웨어에서 지원 안됨.

	if( !pSrc || !pDst ) return S_FALSE;
	if( !pSrc->IsValid() || !pDst->IsValid() ) return S_FALSE;

	IDirect3DSurface9 *pSrcSurf = NULL;
	reinterpret_cast<IDirect3DTexture9*>(pSrc->GetSurface())->GetSurfaceLevel( 0, &pSrcSurf );
	
	IDirect3DSurface9 *pDstSurf = NULL;
	reinterpret_cast<IDirect3DTexture9*>(pDst->GetSurface())->GetSurfaceLevel( 0, &pDstSurf );

	HRESULT hr = m_d3ddev->StretchRect( pSrcSurf, pSrcRect, pDstSurf, pDstRect, m_StretchRectFilterMode );

	SAFE_RELEASE( pSrcSurf );
	SAFE_RELEASE( pDstSurf );

	return hr;
}

bool K3DRenderDeviceDX::SetRenderTarget( int nLevel, K3DRenderTarget *target )
{
	SAFE_RELEASE(m_pRenderTargetSurface);
	//SAFE_RELEASE(m_pRenderTargetDepth)
	//SAFE_RELEASE(m_pRenderTarget);

	if ( target == NULL || !target->IsValid() ) return false;

	K3DRenderTargetDX* pTDX = static_cast<K3DRenderTargetDX*>(target);
	pTDX->GetD3DTexture()->GetSurfaceLevel( nLevel, &m_pRenderTargetSurface );
	if ( m_d3ddev->SetRenderTarget( 0, m_pRenderTargetSurface ) == S_OK )  {
		m_d3ddev->SetDepthStencilSurface( NULL );
		return true;
	}
	
	return false;
}

bool K3DRenderDeviceDX::SetRenderTarget( K3DRenderTarget *target )
{
	SAFE_RELEASE(m_pRenderTargetSurface);
	//SAFE_RELEASE(m_pRenderTargetDepth);
	//SAFE_RELEASE(m_pRenderTarget);

	if ( target == NULL )
	{
		if ( m_d3ddev->SetRenderTarget( 0, m_backbuffer ) != S_OK )
			return false;

		if ( m_d3ddev->SetDepthStencilSurface( m_zbuffer ) != S_OK )
			return false;

		return true;
	}
	else
	{
		if( target->IsValid() )
		{
			K3DRenderTargetDX* pTDX = static_cast<K3DRenderTargetDX*>(target);
			
			if( pTDX->GetD3DTexture()  )
			{
				pTDX->GetD3DTexture()->GetSurfaceLevel( 0, &m_pRenderTargetSurface );
			}
			
			//if( pTDX->GetDepthUsage() == K3DRenderTargetDX::DEPTH_ENABLE || pTDX->GetDepthUsage() == K3DRenderTargetDX::DEPTH_USEASTEXTURE )
			//{
			//	if( pTDX->GetDepth() )
			//	{
			//		pTDX->GetDepth()->GetSurfaceLevel( 0, &m_pRenderTargetDepth );
			//	}
			//}

			if( pTDX->GetDepthUsage() == K3DRenderTarget::DEPTH_ENABLE )
			{
				if( m_d3ddev->SetRenderTarget( 0, m_pRenderTargetSurface ) != S_OK )
					return false;

				if( m_d3ddev->SetDepthStencilSurface( pTDX->GetDepth() ) != S_OK )
					return false;

				return true;
			}
			else
			{
				if ( m_d3ddev->SetRenderTarget( 0, m_pRenderTargetSurface ) == S_OK )  {
					m_d3ddev->SetDepthStencilSurface( NULL );
					return true;
				}
			}

			//if( pTDX->GetDepthUsage() == K3DRenderTargetDX::DEPTH_ENABLE || pTDX->GetDepthUsage() == K3DRenderTargetDX::DEPTH_USEASTEXTURE )
			//{
			//	if( m_d3ddev->SetRenderTarget( 0, m_pRenderTargetSurface ) != S_OK )
			//		return false;

			//	if( m_d3ddev->SetDepthStencilSurface( m_pRenderTargetDepth ) != S_OK )
			//		return false;

			//	return true;
			//}
			//else
			//{
			//	if ( m_d3ddev->SetRenderTarget( 0, m_pRenderTargetSurface ) == S_OK )  {
			//		m_d3ddev->SetDepthStencilSurface( NULL );
			//		return true;
			//	}
			//}
		}
	}
	return false;
}

bool K3DRenderDeviceDX::SetRenderTargetCube( K3DRenderTargetCube* pTargetCube, int nCubeFace, int nLevel /*= 0*/ )
{
	SAFE_RELEASE(m_pRenderTargetSurface);

	if ( pTargetCube == NULL )
	{
		if ( m_d3ddev->SetRenderTarget( 0, m_backbuffer ) != S_OK )
			return false;

		if ( m_d3ddev->SetDepthStencilSurface( m_zbuffer ) != S_OK )
			return false;

		return true;
	}
	else
	{
		if( pTargetCube->IsValid() )
		{
			K3DRenderTargetCubeDX* pTDX = static_cast<K3DRenderTargetCubeDX*>(pTargetCube);
			
			if( pTDX->GetD3DCubeTexture() && nCubeFace < 6)
			{
				pTDX->GetD3DCubeTexture()->GetCubeMapSurface( (D3DCUBEMAP_FACES)nCubeFace, nLevel, &m_pRenderTargetSurface );
			}
			
			if( pTDX->GetDepthUsage() == K3DRenderTarget::DEPTH_ENABLE )
			{
				if( m_d3ddev->SetRenderTarget( 0, m_pRenderTargetSurface ) != S_OK )
					return false;

				if( m_d3ddev->SetDepthStencilSurface( pTDX->GetDepth() ) != S_OK )
					return false;

				return true;
			}
			else
			{
				if ( m_d3ddev->SetRenderTarget( 0, m_pRenderTargetSurface ) == S_OK )  {
					m_d3ddev->SetDepthStencilSurface( NULL );
					return true;
				}
			}
		}
	}

	return false;
}

void K3DRenderDeviceDX::SaveRenderTargetSurface( K3DIMAGE_FILEFORMAT nImageFileFormat )
{
	if( m_pRenderTargetSurface )
	{
		D3DXIMAGE_FILEFORMAT fileformat;
		std::string str = "rendertarget";
		switch( nImageFileFormat )
		{
		case K3DIFF_BMP: 
			{
				str += ".bmp";
				fileformat	=	D3DXIFF_BMP;
			}
			break;
		case K3DIFF_JPG: 
			{
				str += ".jpg";
				fileformat	=	D3DXIFF_JPG;
			}
			break;
		case K3DIFF_TGA: 
			{
				str += ".tga";
				fileformat	=	D3DXIFF_TGA;
			}
			break;
		case K3DIFF_PNG: 
			{
				str += ".png";
				fileformat	=	D3DXIFF_PNG;
			}
			break;
		case K3DIFF_DDS: 
			{
				str += ".dds";
				fileformat	=	D3DXIFF_DDS;
			}
			break;
		case K3DIFF_PPM: 
			{
				str += ".ppm";
				fileformat	=	D3DXIFF_PPM;
			}
			break;
		case K3DIFF_DIB: 
			{
				str += ".dib";
				fileformat	=	D3DXIFF_DIB;
			}
			break;
		case K3DIFF_HDR: 
			{
				str += ".hdr";
				fileformat	=	D3DXIFF_HDR;
			}
			break;
		case K3DIFF_PFM: 
			{
				str += ".pfm";
				fileformat	=	D3DXIFF_PFM;
			}
			break;
		default:
			assert( false && "지원하지 않는 파일 포맷입니다." );
			return;
		}
		
		D3DXSaveSurfaceToFile( str.c_str(), fileformat, m_pRenderTargetSurface, NULL, NULL);
	}
}

bool K3DRenderDeviceDX::SetSwapChain(KSwapChainDX* pSwapChain)
{
	m_pSwapChain = pSwapChain;

	if(!pSwapChain)
	{
		if(m_d3ddev->SetRenderTarget(0, m_backbuffer) != S_OK)
			return false;

		if(m_d3ddev->SetDepthStencilSurface(m_zbuffer) != S_OK)
			return false;

		return true;
	}
	else
	{
		if(m_d3ddev->SetRenderTarget(0, pSwapChain->GetBackBuffer()) != S_OK)
			return false;

		if(pSwapChain->DoesUseDepthBuffer())
		{
            if(m_d3ddev->SetDepthStencilSurface(pSwapChain->GetDepthBuffer()) != S_OK)
                return false;
		}
		else
		{
			if(m_d3ddev->SetDepthStencilSurface(NULL) != S_OK)
				return false;
		}

		return true;
	}

	return false;
}

K3DTexture *K3DRenderDeviceDX::SetTexture( int stage, K3DTexture *tex )
{
	if( s_bForceTextureNull )
	{
		m_stageTextures[stage] = NULL;
		HRESULT hres = m_d3ddev->SetTexture( stage, NULL );
		return NULL;
	}

	K3DTexture *old = m_stageTextures[stage];
	m_stageTextures[stage] = tex;
	HRESULT hres;
	if ( tex && tex->IsValid() == true )
		hres = m_d3ddev->SetTexture( stage, reinterpret_cast<IDirect3DTexture9*>(tex->GetSurface()) );
	else
		hres = m_d3ddev->SetTexture( stage, NULL );

	assert( hres == D3D_OK );
	return old;
}

//
// Light
// 
void K3DRenderDeviceDX::EnableLightEffect( bool enable )
{
	K3DRenderDevice::EnableLightEffect( enable );
	m_d3ddev->SetRenderState( D3DRS_LIGHTING, enable ? TRUE : FALSE );
}

void K3DRenderDeviceDX::SetLight( int index, const K3DLight *light )
{
	memcpy( &m_arLights[index], light, sizeof(m_arLights[index]) );
	m_d3ddev->SetLight( index, (const D3DLIGHT9*)light );
}

void K3DRenderDeviceDX::SetLightEnable( int index, bool enable )
{
	m_bEnLight[index] = enable;
	m_d3ddev->LightEnable( index, enable );
}

void K3DRenderDeviceDX::SetBright(float bright)
{
	//m_fBright = bright;
	//BYTE highGamma = (BYTE) (255.0f * bright);
	//float grey = 255.0f * 0.2125f + 255.0f * 0.7154f + 255.0f * 0.0721f;
	//float fGamma = grey + bright * (255.0f - grey);
	//if(fGamma < 0.0f) fGamma = 0.0f;
	//else if(fGamma > 255.0f) fGamma = 255.0f;
	//BYTE highGamma = (BYTE) fGamma;

	//SetGammaRange(KColor(0), KColor(highGamma, highGamma, highGamma, highGamma), m_nContrast);
	SetGammaRange(m_lowGamma, m_highGamma, m_nContrast, bright);
}
void K3DRenderDeviceDX::SetContrast(int contrast)
{
	SetGammaRange(m_lowGamma, m_highGamma, contrast, m_fBright);
}

void K3DRenderDeviceDX::SetGammaRange( const KColor &low, const KColor &high, int contrast /* = 1  */, float bright)
{
	m_highGamma = high;
	m_lowGamma = low;
	m_nContrast = contrast;
	m_fBright = bright;

	if ( m_cs.bFullScreen )	// 임시로 없앰 by blackfish
	{
		D3DGAMMARAMP d3dgr;
		//::ZeroMemory(&d3dgr, sizeof(D3DGAMMARAMP));

		int r, g, b;
		for ( int i=0 ; i<256; i+= contrast )
		{
			//r = (int)(((1-i/255.f) * low.r + i/255.f*high.r) * 257.f );
			//g = (int)(((1-i/255.f) * low.g + i/255.f*high.g) * 257.f );
			//b = (int)(((1-i/255.f) * low.b + i/255.f*high.b) * 257.f );
			
			//r = (int)(((1-i/255.f) * low.r + i/255.f*400) * 257.f );
			//g = (int)(((1-i/255.f) * low.g + i/255.f*400) * 257.f );
			//b = (int)(((1-i/255.f) * low.b + i/255.f*400) * 257.f );

			r = (int)(((1-i/255.f) * low.r + i/255.f*high.r) * 257.f * bright);
			g = (int)(((1-i/255.f) * low.g + i/255.f*high.g) * 257.f * bright);
			b = (int)(((1-i/255.f) * low.b + i/255.f*high.b) * 257.f * bright);

			if(r > 65535) r = 65535;
			if(g > 65535) g = 65535;
			if(b > 65535) b = 65535;

			for ( int j=0 ; j<contrast && i+j < 256 ; ++j )
			{
				d3dgr.red[i+j] = (unsigned short)r;
				d3dgr.green[i+j] = (unsigned short)g;
				d3dgr.blue[i+j] = (unsigned short)b;
			}
		}
		m_d3ddev->SetGammaRamp( 0, D3DSGR_CALIBRATE, &d3dgr );
		//m_d3ddev->SetGammaRamp( 1, D3DSGR_NO_CALIBRATION, &d3dgr );
	}
}

void K3DRenderDeviceDX::SetDefaultGammaRange()
{
	if ( m_cs.bFullScreen )	
	{
		D3DGAMMARAMP d3dgr;
		memcpy(&d3dgr, &m_OldD3dgr, sizeof(d3dgr));

		float rate0, rate1, rate2;
		WORD  RED, GREEN, BLUE;

		for ( int i=0 ; i<256; i++)
		{
			rate0 = float(i);
			rate1 = float(i);
			rate2 = float(i);

			RED   = WORD(256 * rate0);
			GREEN = WORD(256 * rate1);
			BLUE  = WORD(256 * rate2);

			if(RED   > 65535) RED   = 65535;
			if(GREEN > 65535) GREEN = 65535;
			if(BLUE  > 65535) BLUE  = 65535;

			d3dgr.red[i]   = RED;
			d3dgr.green[i] = GREEN;
			d3dgr.blue[i]  = BLUE;
		}

		m_d3ddev->SetGammaRamp( 0, D3DSGR_CALIBRATE, &d3dgr );
	}
}

bool K3DRenderDeviceDX::SetRenderState( DWORD stateindex )
{
	if( stateindex == m_idxCurRS ) return false;

	if(m_hRS[stateindex]->Apply() != S_OK)
		return false;
	else  {
		m_idxCurRS = stateindex;
		return true;
	}
}

void K3DRenderDeviceDX::SetTransform( int stage, const K3DMatrix *mat, int count )
{
	K3DRenderDevice::SetTransform(stage, mat, count);

	switch( stage )
	{
	case TS_WORLD:
		m_d3ddev->SetTransform( D3DTS_WORLD, (const D3DXMATRIX *)mat );
		//SetVertexShaderMatrix( MATRIX_WORLD, &mat );
		SetMatrixArray((const D3DXMATRIX *)mat, count);
		break;
	case TS_VIEW:
		m_d3ddev->SetTransform( D3DTS_VIEW, (const D3DXMATRIX *)mat );
		SetVertexShaderMatrix( MATRIX_VIEW, mat );
		K3DMatrixMultiply( m_VPMat, *mat, *GetTransform(TS_PROJECTION)  );
		SetVertexShaderMatrix( MATRIX_VIEWPROJECTION, &m_VPMat );
		break;
	case TS_PROJECTION:
		m_d3ddev->SetTransform( D3DTS_PROJECTION, (const D3DXMATRIX *)mat );
		SetVertexShaderMatrix( MATRIX_PROJECTION, mat );
		K3DMatrixMultiply( m_VPMat, *GetTransform(TS_VIEW), *mat );
		SetVertexShaderMatrix( MATRIX_VIEWPROJECTION, &m_VPMat );
		break;
	case TS_TEXTURE0:
		m_d3ddev->SetTransform( D3DTS_TEXTURE0, (const D3DXMATRIX *)mat );
		break;
/*	case TS_TEXTURE1:
		m_d3ddev->SetTransform( D3DTS_TEXTURE1, (const D3DXMATRIX *)mat );
		break;
	case TS_TEXTURE2:
		m_d3ddev->SetTransform( D3DTS_TEXTURE2, (const D3DXMATRIX *)mat );
		break;
	case TS_TEXTURE3:
		m_d3ddev->SetTransform( D3DTS_TEXTURE3, (const D3DXMATRIX *)mat );
		break;
	case TS_TEXTURE4:
		m_d3ddev->SetTransform( D3DTS_TEXTURE4, (const D3DXMATRIX *)mat );
		break;
	case TS_TEXTURE5:
		m_d3ddev->SetTransform( D3DTS_TEXTURE5, (const D3DXMATRIX *)mat );
		break;
	case TS_TEXTURE6:
		m_d3ddev->SetTransform( D3DTS_TEXTURE6, (const D3DXMATRIX *)mat );
		break;
	case TS_TEXTURE7:
		m_d3ddev->SetTransform( D3DTS_TEXTURE7, (const D3DXMATRIX *)mat );
		break;*/
	}

}

void K3DRenderDeviceDX::SetTransformIdentity( int stage )
{
	K3DMatrixIdentity( m_arTransformStages[stage] );
	switch( stage )
	{
	case TS_WORLD:
		m_d3ddev->SetTransform( D3DTS_WORLD, m_arTransformStages[stage] );
		break;
	case TS_VIEW:
		m_d3ddev->SetTransform( D3DTS_VIEW, m_arTransformStages[stage] );
		break;
	case TS_PROJECTION:
		m_d3ddev->SetTransform( D3DTS_PROJECTION, m_arTransformStages[stage] );
		break;
	case TS_WORLD1:
		m_d3ddev->SetTransform( D3DTS_WORLD1, m_arTransformStages[stage] );
		break;
	case TS_WORLD2:
		m_d3ddev->SetTransform( D3DTS_WORLD2, m_arTransformStages[stage] );
		break;
	case TS_WORLD3:
		m_d3ddev->SetTransform( D3DTS_WORLD3, m_arTransformStages[stage] );
		break;
	case TS_TEXTURE0:
		m_d3ddev->SetTransform( D3DTS_TEXTURE0, m_arTransformStages[stage] );
		break;
	case TS_TEXTURE1:
		m_d3ddev->SetTransform( D3DTS_TEXTURE1, m_arTransformStages[stage] );
		break;
	case TS_TEXTURE2:
		m_d3ddev->SetTransform( D3DTS_TEXTURE2, m_arTransformStages[stage] );
		break;
	case TS_TEXTURE3:
		m_d3ddev->SetTransform( D3DTS_TEXTURE3, m_arTransformStages[stage] );
		break;
	case TS_TEXTURE4:
		m_d3ddev->SetTransform( D3DTS_TEXTURE4, m_arTransformStages[stage] );
		break;
	case TS_TEXTURE5:
		m_d3ddev->SetTransform( D3DTS_TEXTURE5, m_arTransformStages[stage] );
		break;
	case TS_TEXTURE6:
		m_d3ddev->SetTransform( D3DTS_TEXTURE6, m_arTransformStages[stage] );
		break;
	case TS_TEXTURE7:
		m_d3ddev->SetTransform( D3DTS_TEXTURE7, m_arTransformStages[stage] );
		break;
	}
}

// material
void K3DRenderDeviceDX::SetMaterial( const K3DMaterial *mat )
{
	memcpy( &m_curMaterial, mat, sizeof(m_curMaterial) );
	m_d3ddev->SetMaterial( (const D3DMATERIAL9*)mat );
}

// Shader 
void K3DRenderDeviceDX::SetVertexShaderConstant( DWORD Register, CONST void* pConstantData, DWORD  ConstantCount )
{
	m_d3ddev->SetVertexShaderConstantF( Register, (CONST float*)pConstantData, ConstantCount );
}

//
// Drawing
//
void K3DRenderDeviceDX::DrawPoints( int vtxFormat, void* vtx, int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT(1);
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP( D3DPT_POINTLIST, vtxCount, vtx, vtxStride );
}

void K3DRenderDeviceDX::DrawLine( int vtxFormat, void* vtx, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT(1);
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP ( D3DPT_LINELIST, 1, vtx, vtxStride );
}

void K3DRenderDeviceDX::DrawTriangle( int vtxFormat, void* vtx, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT(1);
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP ( D3DPT_TRIANGLELIST, 1, vtx, vtxStride );
}

void K3DRenderDeviceDX::DrawLines(int vtxFormat, void* vtx, int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount/2 );
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP ( D3DPT_LINELIST, vtxCount/2, vtx, vtxStride );
}

void K3DRenderDeviceDX::DrawTriangles( int vtxFormat, void* vtxBuf, int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	SetVertexShaderDefault();
	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_LINEAR );

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount/3 );
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP( D3DPT_TRIANGLELIST, vtxCount/3, vtxBuf, vtxStride );
}

void K3DRenderDeviceDX::DrawTriangles( int vtxFormat, void* vtxBuf, int vtxCount, int vtxStride, const unsigned short* indexBuf, int indexCount )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	SetVertexShaderDefault();
	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_LINEAR );

	++m_nDPCount;
	INCPOLYCOUNT( indexCount/3 );

	SetFVF(vtxFormat);
	HRESULT hres = m_d3ddev->DrawIndexedPrimitiveUP( D3DPT_TRIANGLELIST, 0, vtxCount, indexCount/3, indexBuf, D3DFMT_INDEX16, vtxBuf, vtxStride );
	if ( hres != D3D_OK )
	{
		assert( 0 );
	}
}

void K3DRenderDeviceDX::DrawLineStrip(int vtxFormat, void* vtx, int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount-1 );
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP ( D3DPT_LINESTRIP, vtxCount - 1, vtx, vtxStride );
}

void K3DRenderDeviceDX::DrawTriangleFan( int vtxFormat, void* vtxBuf, int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	//m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_LINEAR );	// sonador #2.1.7.1	스피드 트리 퍼포먼스 증가

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount-2 );
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP( D3DPT_TRIANGLEFAN, vtxCount - 2, vtxBuf, vtxStride);
}

void K3DRenderDeviceDX::DrawTriangleFan_VS( int vtxFormat, void* vtxBuf, int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	//m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_LINEAR );
	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount-2 );
	SetFVF(vtxFormat);

	HRESULT hres;

	unsigned int uPasses, uPass;
	if( m_pEffect->Begin(&uPasses, 0 ) == D3D_OK )
	{
		for( uPass = 0; uPass < uPasses; uPass++)
		{
			// Set the state for a particular pass in a technique.
			m_pEffect->BeginPass(uPass);

			hres = m_d3ddev->DrawPrimitiveUP( D3DPT_TRIANGLEFAN, vtxCount - 2, vtxBuf, vtxStride);
			if ( hres != D3D_OK )
			{
				assert( 0 );
			}

			m_pEffect->EndPass();
		}
		m_pEffect->End();
	}
}

void K3DRenderDeviceDX::DrawTriangleStrip( int vtxFormat, void* vtxBuf, int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_LINEAR );
	
	++m_nDPCount;
	INCPOLYCOUNT( vtxCount-2 );
	SetVertexShaderDefault();
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, vtxCount-2, vtxBuf, vtxStride);
}


void K3DRenderDeviceDX::DrawTriangleStrip_VS( int vtxFormat, void* vtxBuf, int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	//m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_LINEAR );
	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount-2 );
	SetVertexShaderDefault();
	SetFVF(vtxFormat);
	
	HRESULT hres;

	unsigned int uPasses, uPass;
	if( m_pEffect->Begin(&uPasses, 0 ) == D3D_OK )
	{
		for( uPass = 0; uPass < uPasses; uPass++)
		{
			// Set the state for a particular pass in a technique.
			m_pEffect->BeginPass(uPass);

			hres = m_d3ddev->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, vtxCount - 2, vtxBuf, vtxStride);
			if ( hres != D3D_OK )
			{
				assert( 0 );
			}

			m_pEffect->EndPass();
		}
		m_pEffect->End();
	}
}

void K3DRenderDeviceDX::DrawTriangleVB(const K3DVertexBuffer *vb, int vtxCount)
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount ? vtxCount/3 : vb->GetVertexCount()/3 );
	SetFVF(vb->GetVertexFormat());	
	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0, vb->GetVertexStride());
	if( vtxCount ) 
		m_d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, vtxCount / 3);
	else 
		m_d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, vb->GetVertexCount() / 3);
}

void K3DRenderDeviceDX::DrawTriangleFanVB(const K3DVertexBuffer *vb)
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vb->GetVertexCount()-2 );
	SetFVF(vb->GetVertexFormat());
	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0,  vb->GetVertexStride());
	m_d3ddev->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, vb->GetVertexCount()-2);
}

void K3DRenderDeviceDX::DrawTriangleFanVB_VS(const K3DVertexBuffer *vb, UINT nStartVertex, UINT nPrimitiveCount )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vb->GetVertexCount()-2 );
	SetFVF(vb->GetVertexFormat());
	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0,  vb->GetVertexStride());
	
	HRESULT hres;
	unsigned int uPasses, uPass;
	if( m_pEffect->Begin(&uPasses, 0 ) == D3D_OK )
	{
		for( uPass = 0; uPass < uPasses; uPass++)
		{
			m_pEffect->BeginPass(uPass);
			
			if( nStartVertex != 0 && nPrimitiveCount != 0 )		
				hres = m_d3ddev->DrawPrimitive(D3DPT_TRIANGLEFAN, nStartVertex, nPrimitiveCount );
			else						
				hres = m_d3ddev->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, vb->GetVertexCount()-2);

			if ( hres != D3D_OK )
			{
				assert( 0 );
			}
			m_pEffect->EndPass();
		}
		m_pEffect->End();
	}	
}

void K3DRenderDeviceDX::DrawIndexedTriangleFanVB_VS(const K3DVertexBuffer *vb, const K3DIndexBuffer *ib )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vb->GetVertexCount()-2 );
	SetFVF(vb->GetVertexFormat());

	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0,  vb->GetVertexStride());
	m_d3ddev->SetIndices(static_cast<const K3DIndexBufferDX*>(ib)->GetD3DIndexBuffer());
	
	HRESULT hres;
	unsigned int uPasses, uPass;
	if( m_pEffect->Begin(&uPasses, 0 ) == D3D_OK )
	{
		for( uPass = 0; uPass < uPasses; uPass++)
		{
			m_pEffect->BeginPass(uPass);
			hres = m_d3ddev->DrawIndexedPrimitive( D3DPT_TRIANGLEFAN, 0, 0, vb->GetVertexCount(), 0, ib->GetIndexCount()-2 );
			if ( hres != D3D_OK )
			{
				assert( 0 );
			}
			m_pEffect->EndPass();
		}
		m_pEffect->End();
	}	
}

void K3DRenderDeviceDX::DrawTriangleStripVB(const K3DVertexBuffer *vb, int vtxCount)
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount ? vtxCount-2 : vb->GetVertexCount()-2 );
	SetFVF(vb->GetVertexFormat());
	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0, vb->GetVertexStride());
	if( vtxCount )
		m_d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, vtxCount-2 );
	else
		m_d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, vb->GetVertexCount()-2);
}

void K3DRenderDeviceDX::DrawTriangleStripVB_VS(const K3DVertexBuffer *vb, int vtxCount)
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount ? vtxCount-2 : vb->GetVertexCount()-2 );
	SetFVF(vb->GetVertexFormat());
	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0, vb->GetVertexStride());
	
	HRESULT hres;

	unsigned int uPasses, uPass;
	if( m_pEffect->Begin(&uPasses, 0 ) == D3D_OK )
	{
		for( uPass = 0; uPass < uPasses; uPass++)
		{
			m_pEffect->BeginPass(uPass);

			if( vtxCount )
				hres = m_d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, vtxCount-2 );
			else
				hres = m_d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, vb->GetVertexCount()-2);

			if ( hres != D3D_OK )
			{
				assert( 0 );
			}

			m_pEffect->EndPass();
		}

		m_pEffect->End();
	}
}

void K3DRenderDeviceDX::DrawIndexedTriangleVB(const K3DVertexBuffer *vb, const K3DIndexBuffer *ib)
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( ib->GetIndexCount()/3 );
	HRESULT hres;
	SetFVF(vb->GetVertexFormat());
	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0, vb->GetVertexStride());
	m_d3ddev->SetIndices(static_cast<const K3DIndexBufferDX*>(ib)->GetD3DIndexBuffer());
	hres = m_d3ddev->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, vb->GetVertexCount(), 0, ib->GetIndexCount()/3 );
	if ( hres != D3D_OK )
	{
		assert( 0 );
	}
}

//Speed Tree
void K3DRenderDeviceDX::DrawIndexedTriangleStripVB(const K3DVertexBuffer *vb, const K3DIndexBuffer *ib, UINT nVtxCnt, UINT nPriCnt )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( nPriCnt );
	HRESULT hres;

//	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_LINEAR );

	SetFVF(vb->GetVertexFormat());
	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0, vb->GetVertexStride());
	m_d3ddev->SetIndices(static_cast<const K3DIndexBufferDX*>(ib)->GetD3DIndexBuffer());
	hres = m_d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, nVtxCnt, 0, nPriCnt);
	if ( hres != D3D_OK )
	{
		assert( 0 );
	}
}

void K3DRenderDeviceDX::DrawPrimitiveUP( int vtxFormat, void* vtxBuf,int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount/3 );
	SetFVF(vtxFormat);
	m_d3ddev->DrawPrimitiveUP( D3DPT_TRIANGLELIST, vtxCount, vtxBuf, vtxStride );
}

void K3DRenderDeviceDX::DrawIndexedPrimitiveUP( int vtxFormat, void* vtxBuf,int vtxCount, int vtxStride, unsigned short* indexBuf, int indexCount )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( indexCount/3 );
	SetFVF(vtxFormat);
	m_d3ddev->DrawIndexedPrimitiveUP( D3DPT_TRIANGLELIST, 0, vtxCount, indexCount/3, indexBuf, D3DFMT_INDEX16, vtxBuf, vtxStride );
}

void K3DRenderDeviceDX::DrawPrimitiveUP_VS( int vtxFormat, void* vtxBuf,int vtxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vtxCount/3 );
	SetFVF(vtxFormat);

	HRESULT hres;

	unsigned int uPasses, uPass;
	if( m_pEffect->Begin(&uPasses, 0 ) == D3D_OK )
	{
		for( uPass = 0; uPass < uPasses; uPass++)
		{
			// Set the state for a particular pass in a technique.
			m_pEffect->BeginPass(uPass);
			hres = m_d3ddev->DrawPrimitiveUP( D3DPT_TRIANGLELIST, vtxCount, vtxBuf, vtxStride );
			if ( hres != D3D_OK )
			{
				assert( 0 );
			}
			m_pEffect->EndPass();
		}
		m_pEffect->End();
	}
}

void K3DRenderDeviceDX::DrawIndexedPrimitiveUP_VS( int vtxFormat, void* vtxBuf, int vtxCount, int vtxStride, const unsigned short* indexBuf, int indexCount )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( indexCount/3 );
	SetFVF(vtxFormat);

	HRESULT hres;

	unsigned int uPasses, uPass;
	if( m_pEffect->Begin(&uPasses, 0 ) == D3D_OK )
	{
		for( uPass = 0; uPass < uPasses; uPass++)
		{
			// Set the state for a particular pass in a technique.
			m_pEffect->BeginPass(uPass);
			hres = m_d3ddev->DrawIndexedPrimitiveUP( D3DPT_TRIANGLELIST, 0, vtxCount, indexCount/3, indexBuf, D3DFMT_INDEX16, vtxBuf, vtxStride );
			if ( hres != D3D_OK )
			{
				assert( 0 );
			}
			m_pEffect->EndPass();
		}
		m_pEffect->End();
	}
}

void K3DRenderDeviceDX::DrawIndexedPrimitiveUPLine( int vtxFormt, void* vtxBuf, void* vIdxBuf, int vtxCount, int vtxIdxCount, int vtxStride )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	++m_nDPCount;
	INCPOLYCOUNT( vtxIdxCount/2 );
	SetFVF(vtxFormt);
	m_d3ddev->DrawIndexedPrimitiveUP(D3DPT_LINELIST, 0, vtxCount, vtxIdxCount, vIdxBuf, D3DFMT_INDEX16, vtxBuf, vtxStride);
}

void K3DRenderDeviceDX::DrawIndexedTriangleVB_VS(const K3DVertexBuffer *vb, const K3DIndexBuffer *ib, int primcount, int s_framecount)
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;


	//매트릭스 설정을 하는데..., 
	if( !m_pEffect ) return;

	if(primcount == 0)  {
		primcount = ib->GetIndexCount()/3;
		s_framecount = 1;
	}
	++m_nDPCount;
	INCPOLYCOUNT( primcount*s_framecount );

	int vtx_count = vb->GetVertexCount();

	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );

	m_d3ddev->SetStreamSource(0, static_cast<const K3DVertexBufferDX*>(vb)->GetD3DVertexBuffer(), 0, vb->GetVertexStride());
	m_d3ddev->SetIndices(static_cast<const K3DIndexBufferDX*>(ib)->GetD3DIndexBuffer());
	
	HRESULT hres;

	unsigned int uPasses, uPass;
	if( m_pEffect->Begin(&uPasses, 0 ) == D3D_OK )
	{
		for( uPass = 0; uPass < uPasses; uPass++)
		{
			// Set the state for a particular pass in a technique.
			m_pEffect->BeginPass(uPass);
			hres = m_d3ddev->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, vtx_count, 0, primcount );
			if ( hres != D3D_OK )
			{
				assert( 0 );
			}
			m_pEffect->EndPass();
		}
		m_pEffect->End();
	}
}

void K3DRenderDeviceDX::SetTechnique( int nTechniqueIndex )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	if( !m_pEffect ) return;

	m_pEffect->SetTechnique( m_pTechHandles[nTechniqueIndex] );
}

void K3DRenderDeviceDX::SetVertexShaderConstant( const TCHAR *dcl, const float *value, DWORD count )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	if( !m_pEffect ) return;

#ifdef _DEBUG
	D3DXHANDLE hParameter = m_pEffect->GetParameterByName(NULL, dcl);
#endif
	HRESULT hr = m_pEffect->SetValue(dcl, (const void*)value, count*sizeof(float));
	assert(hr == S_OK && "선언부가 틀린듯하다.");
}

void K3DRenderDeviceDX::SetVertexShaderMaterialLight( const K3DMaterial *mat, const K3DLight *light )
{
	if( light == NULL ) return;

	//K3DLight Matrial_Light;

	//Matrial_Light = (*light);

	//Matrial_Light.ambient.r = mat->Ambient.r * light->ambient.r;
	//Matrial_Light.ambient.g = mat->Ambient.g * light->ambient.g;
	//Matrial_Light.ambient.b = mat->Ambient.b * light->ambient.b;

	//Matrial_Light.diffuse.r = mat->Diffuse.r * light->diffuse.r;
	//Matrial_Light.diffuse.g = mat->Diffuse.g * light->diffuse.g;
	//Matrial_Light.diffuse.b = mat->Diffuse.b * light->diffuse.b;
	
	SetVertexShaderLight( light );
}

void K3DRenderDeviceDX::SetVertexShaderLight( const K3DLight *light )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	if( !m_pEffect || !light ) return;

	K3DVector  g_fLightDir         = K3DVector(0,-1,-1);
	K3DVector  g_fLightPos         = K3DVector(0,-1,-1);
	K3DVector  g_fLightAttenuation = K3DVector(0.f, 0.1f, 0.f);

	float ambient[4]  = {0.3f, 0.3f, 0.3f, 1.0f};
	float diffuse[4]  = {1.0f, 1.0f, 1.0f, 1.0f};
	float specular[4] = {1.0f, 1.0f, 1.0f, 1.0f};


	//매트릭스 설정을 하는데..., 

	{
		g_fLightDir     = light->direction;
		g_fLightPos     = light->position;
	
		Normalize( g_fLightDir );

		ambient[0] = light->ambient.r/2;
		ambient[1] = light->ambient.g/2;
		ambient[2] = light->ambient.b/2;
		
		ambient[3] = light->attenuation1;

		diffuse[0] = light->diffuse.r/2;
		diffuse[1] = light->diffuse.g/2;
		diffuse[2] = light->diffuse.b/2;
		diffuse[3] = light->diffuse.a;

		//스페큘러는 광역만 설정 가능하다. 각 개개별 오브젝트 설정 불가
		specular[0] = light->specular.r;
		specular[1] = light->specular.g;
		specular[2] = light->specular.b;
		specular[3] = light->specular.a;
	}

	D3DXHANDLE hParameter = NULL;
	D3DXHANDLE hTechnique = NULL;

	//위에서 한번만 하면 되는 것들...////////////////////////////////////////////////////////////////
	//Light Position
	hParameter = m_pEffect->GetParameterByName(NULL,"Light_position");
	{
		m_pEffect->SetValue("Light_position", (void*)g_fLightPos, sizeof(g_fLightPos));
	}

	//Light Ambient
	hParameter = m_pEffect->GetParameterByName(NULL,"Light_ambient");
	{
		m_pEffect->SetValue("Light_ambient", (void*)ambient, sizeof(ambient));
	}

	//Light Diffuse
	hParameter = m_pEffect->GetParameterByName(NULL,"Light_diffuse");
	{
		m_pEffect->SetValue("Light_diffuse", (void*)diffuse, sizeof(diffuse));
	}

	//초기화 해줘야 될 수도 있다. nVidia 테스트 끝나고, ATI 쪽에서 안된다면 초기화 해주자.

	hParameter = m_pEffect->GetParameterByName(NULL,"Light_specular");
	HRESULT hr;
	if( hParameter )
	{
		hr = m_pEffect->SetValue("Light_specular", (void*)specular, sizeof(specular));
	}
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

// Present

void K3DRenderDeviceDX::BeginScene()
{
	if ( m_nBeginSceneCount == 0 )
		m_d3ddev->BeginScene();
	++m_nBeginSceneCount;
	assert( m_nBeginSceneCount > 0 );
}

void K3DRenderDeviceDX::EndScene()
{
	assert( m_nBeginSceneCount > 0 );
	--m_nBeginSceneCount;
	if ( m_nBeginSceneCount == 0 )
		m_d3ddev->EndScene();
}

HRESULT  K3DRenderDeviceDX::Render()
{
	HRESULT hr = S_OK;

	if ( m_nBeginSceneCount == 0 )
	{
		if ( m_cs.bFullScreen )
		{
			if(m_pSwapChain)
			{
				hr = m_pSwapChain->GetInterface()->Present(NULL, NULL, NULL, NULL, 0);
			}
			else
			{
                hr = m_d3ddev->Present( NULL, NULL, NULL, NULL );
			}
		}
		else
		{
			RECT srt;
			RECT drt;

			srt.left = srt.top = 0; 
			srt.right = m_viewport.Width; srt.bottom = m_viewport.Height;
			drt.top = m_viewport.Y; drt.bottom = m_viewport.Height;
			drt.left = m_viewport.X; drt.right = m_viewport.Width;

			if(m_pSwapChain)
			{
                hr = m_pSwapChain->GetInterface()->Present( &srt, &drt, m_pSwapChain->GetHwnd(), NULL, 0 );
			}
			else
			{
				hr = m_d3ddev->Present( &srt, &drt, (HWND)m_cs.hFocusWnd, NULL );
			}
		}
		m_nDPCount = 0;
		SETPOLYCOUNT( 0 );

		ResetPrevDeclarationTechnique();
	}


	switch(hr) 
	{
	case D3D_OK	:
		m_bOcclusionCullingCheck = true;
		break;
	case D3DERR_DRIVERINTERNALERROR :
	case D3DERR_INVALIDCALL :
		{
			//처리 불가...
			m_bOcclusionCullingCheck = false;
		}
		break;
	case D3DERR_DEVICELOST :
		{
			//resetDevice();
			//resetDevice(false, true);
			resetDevice(false);
			reloadDevice();
			m_bOcclusionCullingCheck = false;
		}
		break;
	}

	return hr;
}

void K3DRenderDeviceDX::SetMipBias( float fBias )
{
	if ( m_fMipBias != fBias )
	{
		K3DRenderDevice::SetMipBias( fBias );
		//initializeRenderState();

		m_d3ddev->SetSamplerState(0, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&fBias);
		m_d3ddev->SetSamplerState(1, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&fBias);
		m_d3ddev->SetSamplerState(2, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&fBias);
		m_d3ddev->SetSamplerState(3, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&fBias);
		m_d3ddev->SetSamplerState(4, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&fBias);
		m_d3ddev->SetSamplerState(5, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&fBias);
		m_d3ddev->SetSamplerState(6, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&fBias);
		m_d3ddev->SetSamplerState(7, D3DSAMP_MIPMAPLODBIAS, *(DWORD *)&fBias);

		//m_d3ddev->SetSamplerState(0, D3DSAMP_MAXMIPLEVEL, (DWORD) fBias);
		//m_d3ddev->SetSamplerState(1, D3DSAMP_MAXMIPLEVEL, (DWORD) fBias);
		//m_d3ddev->SetSamplerState(2, D3DSAMP_MAXMIPLEVEL, (DWORD) fBias);
		//m_d3ddev->SetSamplerState(3, D3DSAMP_MAXMIPLEVEL, (DWORD) fBias);
		//m_d3ddev->SetSamplerState(4, D3DSAMP_MAXMIPLEVEL, (DWORD) fBias);
		//m_d3ddev->SetSamplerState(5, D3DSAMP_MAXMIPLEVEL, (DWORD) fBias);
		//m_d3ddev->SetSamplerState(6, D3DSAMP_MAXMIPLEVEL, (DWORD) fBias);
		//m_d3ddev->SetSamplerState(7, D3DSAMP_MAXMIPLEVEL, (DWORD) fBias);

		m_fMipBias = fBias;
	}
}

void K3DRenderDeviceDX::SetAlpharef( DWORD dwAlpharef )
{
	//if ( m_dwAlpharef != dwAlpharef ) 버그의 온상
	{
		K3DRenderDevice::SetAlpharef( dwAlpharef );
		m_d3ddev->SetRenderState( D3DRS_ALPHAREF, dwAlpharef );
	}
}

// 주의 : 이걸 편집하면 모든 스테이트 블럭에 영향을 미칠 수 있다.
void K3DRenderDeviceDX::setToDefaultRenderState()
{
	// light enable
	m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

	// alpha blend
	m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
	m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
	m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

	m_d3ddev->SetRenderState( D3DRS_ZENABLE,	    TRUE  );
	m_d3ddev->SetRenderState( D3DRS_STENCILENABLE,	FALSE );

	// alpha test
	m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
	m_d3ddev->SetRenderState( D3DRS_ALPHAREF, 0 );
	m_d3ddev->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATER );

	// vertex material source
	m_d3ddev->SetRenderState( D3DRS_COLORVERTEX, FALSE );
	m_d3ddev->SetRenderState( D3DRS_DIFFUSEMATERIALSOURCE,  D3DMCS_COLOR1 );
	m_d3ddev->SetRenderState( D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2 );
	m_d3ddev->SetRenderState( D3DRS_AMBIENTMATERIALSOURCE,  D3DMCS_MATERIAL );
	m_d3ddev->SetRenderState( D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL );

	// set to default	
	for(int i = 0; i < 8 ; ++i)
	{
		m_d3ddev->SetTextureStageState( i, D3DTSS_COLOROP, D3DTOP_DISABLE );
		m_d3ddev->SetTextureStageState( i, D3DTSS_RESULTARG, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( i, D3DTSS_ALPHAOP, D3DTOP_DISABLE );

		m_d3ddev->SetSamplerState( i, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
		m_d3ddev->SetSamplerState( i, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
		m_d3ddev->SetSamplerState( i, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( i, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( i, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		

	}

	// texture state
	m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_RESULTARG, D3DTA_CURRENT );

	m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_CURRENT );


	m_d3ddev->SetRenderState(D3DRS_WRAP1, 0); //speed tree

	//m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPMAPLODBIAS, *(DWORD*)&m_fMipBias );5
}

void K3DRenderDeviceDX::initializeRenderState()
{
	DWORD nOnePass;
	SetFVF( D3DFVF_XYZ | D3DFVF_TEX1 );
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();
	}
	m_d3ddev->EndStateBlock( &m_hRS[K3DRenderDevice::RS_DEFAULT] );


	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_DOTPRODUCT3 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 0 );
		
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP,   D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
		//m_d3ddev->SetTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 0 );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);

	}
	m_d3ddev->EndStateBlock( &m_hRS[K3DRenderDevice::RS_DEFAULT_NORMAL] );

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
		//m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_MODULATEALPHA_ADDCOLOR );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 | D3DTSS_TCI_SPHEREMAP );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_TEXTURE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[K3DRenderDevice::RS_DEFAULT_SPECULAR] );

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_DOTPRODUCT3 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 0 );

		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP,   D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
		//m_d3ddev->SetTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 0 );

		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLOROP,   D3DTOP_MODULATEALPHA_ADDCOLOR );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
		//m_d3ddev->SetTextureStageState( 3, D3DTSS_TEXCOORDINDEX, 1 | D3DTSS_TCI_SPHEREMAP );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );

		m_d3ddev->SetTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_ALPHAARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_ALPHAARG2, D3DTA_CURRENT );

		m_d3ddev->SetTextureStageState( 3, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_ALPHAARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_ALPHAARG2, D3DTA_TEXTURE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[K3DRenderDevice::RS_DEFAULT_NORMAL_SPECULAR] );

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		//m_d3ddev->SetRenderState( D3DRS_COLORVERTEX, TRUE );
		//m_d3ddev->SetRenderState( D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_COLOR1 );
		//m_d3ddev->SetRenderState( D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1 );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_DISABLE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_NOLIGHT_VTXCOLOR]);

	m_d3ddev->ValidateDevice( &nOnePass );
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		//알파 테스트를 약간 변경
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetRenderState( D3DRS_ZWRITEENABLE, false );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_BILLBOARD ]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SPRITE]);

#ifdef _KUI_INVALIDATION
	// { [sonador] 
	m_d3ddev->ValidateDevice( &nOnePass );
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetRenderState( D3DRS_SEPARATEALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLENDALPHA, D3DBLEND_ONE );
		m_d3ddev->SetRenderState( D3DRS_DESTBLENDALPHA, D3DBLEND_ONE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_SPRITE_RENDERTARGET ] );
	// }
#endif
	
	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TEXT_LAYER]);
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TRANSPARENT_MESH]);
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_TEXTURE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_TRANSPARENT_MESH_NOALPHAUVANI ] );
	m_d3ddev->ValidateDevice( &nOnePass );

	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_TRANSPARENT_MESH_NOCOLORUVANI ] );
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_ALPHAREF, 255 );
		m_d3ddev->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_EQUAL );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_ALPHABLEND_1STPASS ] );

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_ALPHAREF, 255 );
		m_d3ddev->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_LESS );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_ALPHABLEND_2NDPASS ] );

		m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_MODULATE2X]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_CURRENT );

		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_ALPHAARG2, D3DTA_CURRENT );

		m_d3ddev->SetSamplerState( 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );

		//m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		//m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_SPECULAR );
		//m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_OBJECTSHADOW_SPECULAR2X]);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();
		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		for(int i = 0; i < 4; ++i)
			m_d3ddev->SetTextureStageState( i, D3DTSS_TEXCOORDINDEX,i );

		// 0: lightmap
		// arg0 + arg1 * arg2
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MULTIPLYADD);
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG0, D3DTA_TFACTOR );
		
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );

		// 1: diffuse
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_CURRENT );

		m_d3ddev->SetSamplerState( 1, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
		m_d3ddev->SetSamplerState( 1, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
		
		// 2,3: shadow map
		for(int i = 2; i < 4; ++i)
		{
			m_d3ddev->SetTextureStageState( i, D3DTSS_COLOROP, D3DTOP_MODULATE);
			m_d3ddev->SetTextureStageState( i, D3DTSS_COLORARG1, D3DTA_TEXTURE );
			m_d3ddev->SetTextureStageState( i, D3DTSS_COLORARG2, D3DTA_CURRENT );
			m_d3ddev->SetTextureStageState( i, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
			m_d3ddev->SetTextureStageState( i, D3DTSS_ALPHAARG2, D3DTA_CURRENT );

			m_d3ddev->SetSamplerState( i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
			m_d3ddev->SetSamplerState( i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
		}
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_OBJECTSHADOW_LIGHTMAP]);
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();
	
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_ADDITIVE_MESH]);
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_TEXTURE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_ADDITIVE_MESH_NOALPHAUVANI ] );
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_ADDITIVE_MESH_NOCOLORUVANI ] );

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_ADDITIVE_MESH_WITHOUT_DEFAULT]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetRenderState( D3DRS_COLORVERTEX, TRUE );
		m_d3ddev->SetRenderState( D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1 );
		m_d3ddev->SetRenderState( D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR1 );
		m_d3ddev->SetRenderState( D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_COLOR1 );
		m_d3ddev->SetRenderState( D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_COLOR1 );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_ADDITIVE_PARTICLE]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		// texture state
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_LIGHTMAP_ADDITIVE]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ZERO );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_ADD );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
		//m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_CURRENT );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_LIGHTMAP_MODULATE]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE);
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_VOLUME_FOG]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2 );
		//m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_SINGLETILE]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_LERP );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG0, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_BLENDDIFFUSEALPHA );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT );
		/*m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_LERP );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG0, D3DTA_DIFFUSE | D3DTA_ALPHAREPLICATE );*/
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG1, D3DTA_SPECULAR );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG2, D3DTA_CURRENT );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_3TILE_LERP]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 4, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 4, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 4, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );


		// mod texture
		m_d3ddev->SetTextureStageState( 0, D3DTSS_RESULTARG, D3DTA_TEMP );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );

		// base texture
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );

		// deco1 texture
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_LERP );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG0, D3DTA_TEMP );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT );
		//m_d3ddev->SetTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
		//m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT );

		// deco2 texture
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_LERP );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG0, D3DTA_TEMP | D3DTA_ALPHAREPLICATE );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG2, D3DTA_CURRENT );
		//m_d3ddev->SetTextureStageState( 3, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
		//m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG2, D3DTA_CURRENT );

		// vertex color
		m_d3ddev->SetTextureStageState( 4, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState( 4, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 4, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 4, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
		m_d3ddev->SetTextureStageState( 4, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );

		//// terrain specular
		//m_d3ddev->SetTextureStageState( 4, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		//m_d3ddev->SetTextureStageState( 4, D3DTSS_COLORARG1, D3DTA_SPECULAR );
		//m_d3ddev->SetTextureStageState( 4, D3DTSS_COLORARG2, D3DTA_CURRENT );

	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_3TILE_WITH_SHADOW]);
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 4, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 4, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 4, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );

		// mod texture
		m_d3ddev->SetTextureStageState( 0, D3DTSS_RESULTARG, D3DTA_TEMP );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );

		// base texture
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );

		// deco1 texture
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_LERP );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG0, D3DTA_TEMP );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT );

		// deco2 texture
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_LERP );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG0, D3DTA_TEMP | D3DTA_ALPHAREPLICATE );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_RESULTARG, D3DTA_TEMP );

		//// lightmap
		m_d3ddev->SetSamplerState( 4, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 4, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
	
		//// arg0 + arg1 * arg2
		m_d3ddev->SetTextureStageState( 4, D3DTSS_COLOROP, D3DTOP_MULTIPLYADD);
		m_d3ddev->SetTextureStageState( 4, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		m_d3ddev->SetTextureStageState( 4, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 4, D3DTSS_COLORARG0, D3DTA_TFACTOR);
		m_d3ddev->SetTextureStageState( 4, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 4, D3DTSS_ALPHAARG1, D3DTA_TEMP );

		m_d3ddev->SetTextureStageState( 5, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
		m_d3ddev->SetTextureStageState( 5, D3DTSS_COLORARG1, D3DTA_TEMP );
		m_d3ddev->SetTextureStageState( 5, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 5, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 5, D3DTSS_ALPHAARG1, D3DTA_TEMP );

	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_3TILE_WITH_LIGHTMAP]);
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		//m_d3ddev->SetRenderState( D3DRS_LIGHTING, TRUE );
		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
		
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);

		//m_d3ddev->SetRenderState( D3DRS_FOGENABLE, FALSE );
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		
		// mod texture
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		
		// deco1 texture
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_FOR_2SAMPLER_1STPASS]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		//m_d3ddev->SetRenderState( D3DRS_LIGHTING, TRUE );
		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		//m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
		m_d3ddev->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD);
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE);
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);

		//m_d3ddev->SetRenderState( D3DRS_FOGENABLE, FALSE );
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );

		// mod texture
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT );
		//m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);

		// base texture
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT | D3DTA_COMPLEMENT );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_FOR_2SAMPLER_2NDPASS]);
	
	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

/*		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND,	D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND,	D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP,		D3DTOP_ADD );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1,	D3DTA_TEXTURE | D3DTA_ALPHAREPLICATE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2,	D3DTA_DIFFUSE );*/

		m_d3ddev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
		m_d3ddev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
		m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
		m_d3ddev->SetRenderState(D3DRS_ALPHAREF, 0x00);
		m_d3ddev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE );

		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG1, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_TEXTURE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
	}

	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_LQWATER]);

	m_d3ddev->ValidateDevice(&nOnePass);
	//m_d3ddev->BeginStateBlock();
	//{
	//	setToDefaultRenderState();

	//	//m_d3ddev->SetRenderState( D3DRS_LIGHTING, TRUE );
	//	m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
	//	m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

	//	//m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
	//	m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
	//	//m_d3ddev->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_REVSUBTRACT);
	//	m_d3ddev->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD);
	//	//m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR);
	//	m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ZERO);
	//	//m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);
	//	m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCCOLOR);

	//	//m_d3ddev->SetRenderState( D3DRS_FOGENABLE, FALSE );
	//	m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );

	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

	//	// mod texture
	//	m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
	//	m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_ALPHAREPLICATE );
	//}
	//m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_FOR_2SAMPLER_3RDPASS]);
	//
	//m_d3ddev->ValidateDevice(&nOnePass);
	//m_d3ddev->BeginStateBlock();
	//{
	//	setToDefaultRenderState();

	//	//m_d3ddev->SetRenderState( D3DRS_LIGHTING, TRUE );
	//	m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
	//	m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

	//	//m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
	//	m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
	//	m_d3ddev->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD);
	//	m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE);
	//	m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);

	//	//m_d3ddev->SetRenderState( D3DRS_FOGENABLE, FALSE );
	//	m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );

	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
	//	m_d3ddev->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
	//	m_d3ddev->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
	//	m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );

	//	// mod texture
	//	m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
	//	m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_ALPHAREPLICATE );
	//	
	//	// deco2 texture
	//	m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE );
	//	m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
	//	m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
	//}
	//m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_FOR_2SAMPLER_4THPASS]);

	//m_d3ddev->ValidateDevice(&nOnePass);
	//m_d3ddev->BeginStateBlock();
	//{
	//	setToDefaultRenderState();

	//	//m_d3ddev->SetRenderState( D3DRS_LIGHTING, TRUE );
	//	m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
	//	m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

	//	//m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
	//	m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
	//	m_d3ddev->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD);
	//	m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE);
	//	m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);

	//	m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );
	//}
	//m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_FOR_2SAMPLER_5THPASS]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		//m_d3ddev->SetRenderState( D3DRS_LIGHTING, TRUE );
		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		//m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
		m_d3ddev->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD);
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE);
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

		//m_d3ddev->SetRenderState( D3DRS_FOGENABLE, FALSE );
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );

		// mod texture
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_ALPHAREPLICATE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
		
		// deco2 texture
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAARG2, D3DTA_CURRENT );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_FOR_2SAMPLER_3RDPASS]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		//m_d3ddev->SetRenderState( D3DRS_LIGHTING, TRUE );
		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		//m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE);
		m_d3ddev->SetRenderState( D3DRS_BLENDOP, D3DBLENDOP_ADD);
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE);
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);

		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_FOR_2SAMPLER_4THPASS]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_TERRAIN_ATTRIBUTE]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{	
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_BUMPENVMAP );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );

		//m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );

		//m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_BUMPENVMAPLUMINANCE );

		//m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		//m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT );

		////////// Set up texture stage 1's states for the environment map
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
		//m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );	

//		m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3|D3DTTFF_PROJECTED );
//		m_d3ddev->SetTextureStageState( 1, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION | 1 );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_WATER]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		//setToDefaultRenderState();
		// alpha test
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3|D3DTTFF_PROJECTED );
		//m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_UVWRAP]);
	
	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{	
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_LENSFLARE]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{	
		setToDefaultRenderState();

#ifdef CLOUD_LUA
		m_d3ddev->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
#endif
		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
		m_d3ddev->SetRenderState( D3DRS_ZENABLE, TRUE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE   );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE   );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP  , D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE   );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE   );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP  , D3DTOP_MODULATE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_CLOUD]);

	// { [sonador][2007.03.23] RS_WEATHER 
	m_d3ddev->ValidateDevice( &nOnePass );
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
		m_d3ddev->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
		
		m_d3ddev->SetRenderState( D3DRS_COLORVERTEX, TRUE );
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATER );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE   );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE   );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP  , D3DTOP_MODULATE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_WEATHER ] );
	// } [sonador][2007.03.23] RS_WEATHER

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
		m_d3ddev->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );

		// TEXTUREFACTOR 를 색상으로 사용해서 단색 렌더링을 할것임.
		m_d3ddev->SetRenderState( D3DRS_TEXTUREFACTOR, D3DCOLOR_ARGB(255,0,0,0) );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP  , D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP  , D3DTOP_SELECTARG1);
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SHADOW_PROJECTION]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ZERO );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP  , D3DTOP_SELECTARG1 );
		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE     );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP  , D3DTOP_MODULATE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE     );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT     );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP  , D3DTOP_DISABLE );
		m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP  , D3DTOP_DISABLE );

		m_d3ddev->SetTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
		m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE );
		m_d3ddev->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_DISABLE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SHADOW_MESH]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

		/*m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPMAPLODBIAS, 0 );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPMAPLODBIAS, 0 );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MIPMAPLODBIAS, 0 );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MIPMAPLODBIAS, 0 );*/
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_NO_MIPMAP]);
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		// setup general graphics states
        //m_d3ddev->SetRenderState(D3DRS_LIGHTING, TRUE);
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
        m_d3ddev->SetRenderState(D3DRS_COLORVERTEX, FALSE);

		m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
		m_d3ddev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);
		m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
		m_d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

#ifdef WRAPPER_RENDER_SELF_SHADOWS
		m_d3ddev->SetRenderState(D3DRS_WRAP1, D3DWRAP_U | D3DWRAP_V);
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MODULATE);
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TEXTURE);
		m_d3ddev->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
#endif
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SPEED_TREE]);
	m_d3ddev->ValidateDevice(&nOnePass);


	// Non-alphablending shading mode for trees
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		// setup general graphics states
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
		m_d3ddev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
		m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);

		m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
		m_d3ddev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);

		m_d3ddev->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );

		m_d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

//#ifdef WRAPPER_RENDER_SELF_SHADOWS
//		m_d3ddev->SetRenderState(D3DRS_WRAP1, D3DWRAP_U | D3DWRAP_V);
//		m_d3ddev->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MODULATE);
//		m_d3ddev->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_CURRENT);
//		m_d3ddev->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TEXTURE);
//		m_d3ddev->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
//		m_d3ddev->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
//		m_d3ddev->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
//#endif
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SPEED_TREE_NONALPHABLEND]);
	m_d3ddev->ValidateDevice(&nOnePass);


	// Alphablending shading mode for trees
	m_d3ddev->BeginStateBlock();	// SpeedTree render state with alpha blending
	{
		setToDefaultRenderState();

#ifndef _RAC
		// setup general graphics states
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
		//m_d3ddev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
		//m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
#else
		// setup general graphics states
		m_d3ddev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
		m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

		m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
		m_d3ddev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);

		m_d3ddev->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );		// Do not write Zbuffer for transparent polygons
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );	// sonador #2.1.7.1	스피드 트리 퍼포먼스 증가
		m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
#endif

		m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
		m_d3ddev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);

		m_d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SPEED_TREE_ALPHABLEND]);
	m_d3ddev->ValidateDevice(&nOnePass);



	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		// setup rendering states
		m_d3ddev->SetRenderState(D3DRS_ALPHAREF, 84);
		m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
		m_d3ddev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );

		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);

		// clamp textures
		m_d3ddev->SetRenderState(D3DRS_WRAP0, 0);
		m_d3ddev->SetRenderState(D3DRS_WRAP1, 0);
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);	// added by blackfish

		m_d3ddev->SetRenderState(D3DRS_COLORVERTEX, TRUE);
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SPEED_GRASS]);
	m_d3ddev->ValidateDevice(&nOnePass);

	m_d3ddev->BeginStateBlock();
	{
		// setup general graphics states
		m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_DISABLE_UVTRANSFORM]);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		// etc. render state
		m_d3ddev->SetRenderState(D3DRS_DITHERENABLE   , false);
		m_d3ddev->SetRenderState(D3DRS_ZENABLE        , false);
		m_d3ddev->SetRenderState(D3DRS_FOGENABLE      , FALSE);

		m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, true);

		m_d3ddev->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
		m_d3ddev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
		m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

//		m_d3ddev->SetRenderState(D3DRS_TEXTUREFACTOR, 0x78787878);

		m_d3ddev->SetTextureStageState(0, D3DTSS_RESULTARG, D3DTA_CURRENT);
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP  , D3DTOP_SELECTARG2);
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP  , D3DTOP_MODULATE);
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);

		m_d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		m_d3ddev->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

		//float mipbias = 0.f;
		//m_d3ddev->SetSamplerState(0, D3DSAMP_MIPMAPLODBIAS, *((DWORD*)&mipbias));

		//m_d3ddev->SetRenderState(D3DRS_LASTPIXEL, FALSE);
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SHADOW_MAP]);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR);
		m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);

		m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_JITTER]);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		// diffuse texture를 지닌 material 세팅
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState(0, D3DTSS_RESULTARG, D3DTA_CURRENT  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP  , D3DTOP_MODULATE);
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE  );
		// specular level을 곱한다.
		m_d3ddev->SetTextureStageState(1, D3DTSS_RESULTARG, D3DTA_TEMP     );
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLOROP  , D3DTOP_MODULATE);
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_SPECULAR );
		m_d3ddev->SetTextureStageState(1, D3DTSS_ALPHAOP  , D3DTOP_DISABLE );
		// specular의 texture 맵을 더한다.
		m_d3ddev->SetTextureStageState(2, D3DTSS_RESULTARG, D3DTA_CURRENT     );
		m_d3ddev->SetTextureStageState(2, D3DTSS_COLOROP  , D3DTOP_MULTIPLYADD);
		m_d3ddev->SetTextureStageState(2, D3DTSS_COLORARG0, D3DTA_CURRENT     );
		m_d3ddev->SetTextureStageState(2, D3DTSS_COLORARG1, D3DTA_TEXTURE     );
		m_d3ddev->SetTextureStageState(2, D3DTSS_COLORARG2, D3DTA_TEMP        );
		m_d3ddev->SetTextureStageState(2, D3DTSS_ALPHAOP  , D3DTOP_SELECTARG2 );
		m_d3ddev->SetTextureStageState(2, D3DTSS_ALPHAARG2, D3DTA_CURRENT     );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_MESH_SPECULAR]);

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();
		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ZENABLE, FALSE );
		m_d3ddev->SetRenderState( D3DRS_DITHERENABLE, FALSE );
	}
	m_d3ddev->EndStateBlock( &m_hRS[ K3DRenderDevice::RS_HDR ] );        // HDR Blur

	if (S_OK == m_d3ddev->BeginStateBlock())
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState(D3DRS_LIGHTING, false);
		m_d3ddev->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
		m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, true);
		m_d3ddev->SetRenderState(D3DRS_FOGENABLE, FALSE);
		m_d3ddev->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
		m_d3ddev->SetRenderState(D3DRS_ZWRITEENABLE, false);
		m_d3ddev->SetRenderState(D3DRS_ZENABLE, false);

		m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_NO_TEX]);
	}

	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SELECT_OUTLINE_MESH]);

	//m_d3ddev->BeginStateBlock();
	//{
	//	setToDefaultRenderState();
	//	m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

	//	m_d3ddev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	//	m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);

	//	m_d3ddev->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_MAX);
	//	m_d3ddev->SetRenderState(D3DRS_SRCBLEND     , D3DBLEND_ONE  );
	//	m_d3ddev->SetRenderState(D3DRS_DESTBLEND    , D3DBLEND_ONE  );

	//	m_d3ddev->SetRenderState(D3DRS_ZENABLE      , FALSE         );
	//	m_d3ddev->SetRenderState(D3DRS_DITHERENABLE , FALSE         );

	//	m_d3ddev->SetTextureStageState(0, D3DTSS_RESULTARG, D3DTA_CURRENT    );
	//	m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP  , D3DTOP_SELECTARG1);
	//	m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE    );
	//	m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP  , D3DTOP_DISABLE   );
	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR      );
	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR      );
	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE        );
	//}
	//m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_HDR_BLUR01_1]);        //HDR Blur one pass
	//
	//m_d3ddev->BeginStateBlock();
	//{
	//	setToDefaultRenderState();
	//	m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

	//	m_d3ddev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	//	m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);

	//	m_d3ddev->SetRenderState(D3DRS_BLENDOP  , D3DBLENDOP_ADD);
	//	m_d3ddev->SetRenderState(D3DRS_SRCBLEND , D3DBLEND_ONE);
	//	m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);

	//	m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP  , D3DTOP_SELECTARG1);
	//	m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TEXTURE    );
	//}
	//m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_HDR_BLUR01_2]);        //HDR Blur two pass

	//m_d3ddev->BeginStateBlock();
	//{
	//	setToDefaultRenderState();
	//	m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

	//	m_d3ddev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	//	m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);

	//	m_d3ddev->SetRenderState(D3DRS_BLENDOP  , D3DBLENDOP_ADD);
	//	m_d3ddev->SetRenderState(D3DRS_SRCBLEND , D3DBLEND_DESTCOLOR);
	//	m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);

	//	m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP  , D3DTOP_SELECTARG2);
	//	m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TFACTOR    );
	//	m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP  , D3DTOP_DISABLE   );
	//	m_d3ddev->SetTextureStageState(1, D3DTSS_COLOROP  , D3DTOP_DISABLE   );
	//	m_d3ddev->SetTextureStageState(1, D3DTSS_ALPHAOP  , D3DTOP_DISABLE   );
	//	m_d3ddev->SetTextureStageState(2, D3DTSS_COLOROP  , D3DTOP_DISABLE   );
	//	m_d3ddev->SetTextureStageState(2, D3DTSS_ALPHAOP  , D3DTOP_DISABLE   );
	//	m_d3ddev->SetTextureStageState(3, D3DTSS_COLOROP  , D3DTOP_DISABLE   );
	//	m_d3ddev->SetTextureStageState(3, D3DTSS_ALPHAOP  , D3DTOP_DISABLE   );
	//}
	//m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_HDR_BLUR02]);        //HDR Blur one pass
	
	//m_d3ddev->BeginStateBlock();
	//{
	//	setToDefaultRenderState();
	//	m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

	//	m_d3ddev->SetRenderState(D3DRS_ZENABLE      , FALSE         );

	//	m_d3ddev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	//	m_d3ddev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);

	//	m_d3ddev->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
	//	m_d3ddev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
	//	m_d3ddev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);

	//	m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
	//	m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
	//	m_d3ddev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//	m_d3ddev->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//	m_d3ddev->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//	m_d3ddev->SetTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//	m_d3ddev->SetTextureStageState( 2, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//	m_d3ddev->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//	m_d3ddev->SetTextureStageState( 3, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
	//	m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );		
	//}
	//m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_HDR_END]);        //HDR Blur End

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
		m_d3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0 );
		m_d3ddev->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, 0 );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_SELECT_EFFECT]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_LOWSHADOW]);


	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_LOWSHADOW]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState(0, D3DTSS_RESULTARG, D3DTA_CURRENT  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP  , D3DTOP_MODULATE);
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE  );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_ALPHATEX]);


	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		setToDefaultRenderState();

		m_d3ddev->SetRenderState( D3DRS_LIGHTING, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_d3ddev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );

		m_d3ddev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
		m_d3ddev->SetTextureStageState(0, D3DTSS_RESULTARG, D3DTA_CURRENT  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAOP  , D3DTOP_MODULATE);
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE  );

		m_d3ddev->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );

		m_d3ddev->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 2, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
		m_d3ddev->SetSamplerState( 3, D3DSAMP_MIPFILTER, D3DTEXF_NONE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_ALPHATEX_ADD]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		//MTE
		m_d3ddev->SetTextureStageState(3, D3DTSS_RESULTARG, D3DTA_CURRENT     );
		m_d3ddev->SetTextureStageState(3, D3DTSS_COLOROP  , D3DTOP_MODULATE4X );
		m_d3ddev->SetTextureStageState(3, D3DTSS_COLORARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(3, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState(3, D3DTSS_ALPHAOP  , D3DTOP_DISABLE );

	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_MTE]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		//MTE
		m_d3ddev->SetTextureStageState(1, D3DTSS_RESULTARG, D3DTA_CURRENT     );
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLOROP  , D3DTOP_MODULATE4X );
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE  );
		m_d3ddev->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT );
		m_d3ddev->SetTextureStageState(1, D3DTSS_ALPHAOP  , D3DTOP_DISABLE );

	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_MTE_S1]);

	m_d3ddev->ValidateDevice(&nOnePass);
	m_d3ddev->BeginStateBlock();
	{
		//gmpbigsun( 20130404 ) : 알파 몬스터로 인해 제거댐.
		//m_d3ddev->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
		//m_d3ddev->SetRenderState( D3DRS_ALPHAREF, 0x88 );
		//m_d3ddev->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATER );

		m_d3ddev->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
	}
	m_d3ddev->EndStateBlock(&m_hRS[K3DRenderDevice::RS_ALPHATEST]);

	SetFillColor( KColor(0,0,0,0) );
	SetBackBufferWriteEnable(BW_ALPHA | BW_RED | BW_GREEN | BW_BLUE);
	//SetBackBufferWriteEnable( BW_RED | BW_GREEN | BW_BLUE );
	SetDepthBufferWriteEnable(true);
	SetDepthBufferCompareMode(DCM_LESSEQUAL);

	m_d3ddev->SetRenderState(D3DRS_TEXTUREFACTOR, m_textureFactor.color);
	m_d3ddev->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
	m_d3ddev->SetRenderState(D3DRS_SPECULARENABLE, FALSE);
	
	m_d3ddev->BeginScene();
	//m_d3ddev->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	m_d3ddev->SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_DISABLE );
	m_d3ddev->SetTextureStageState(2, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(3, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(3, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(4, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(4, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(5, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(5, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(6, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(6, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(7, D3DTSS_COLOROP, D3DTOP_DISABLE );
	//m_d3ddev->SetTextureStageState(7, D3DTSS_ALPHAOP, D3DTOP_DISABLE );

	// dither
	m_d3ddev->SetRenderState( D3DRS_DITHERENABLE, TRUE );
	m_d3ddev->EndScene();
}

void K3DRenderDeviceDX::SetBackBufferWriteEnable ( DWORD stat )
{
	if ( m_backBufferWriteEnable == stat ) return;
	m_backBufferWriteEnable = stat;
	m_d3ddev->SetRenderState( D3DRS_COLORWRITEENABLE, stat );
}

void K3DRenderDeviceDX::SetDepthBufferWriteEnable ( bool enable )
{
	if ( m_depthBufferWriteEnable == enable ) return;
	m_depthBufferWriteEnable = enable;
	m_d3ddev->SetRenderState( D3DRS_ZWRITEENABLE, enable );
}

void K3DRenderDeviceDX::SetDepthBufferCompareMode( int depthcmp )
{
	if( m_depthCompareMode == depthcmp ) return;
	m_depthCompareMode = depthcmp;

	switch( depthcmp )
	{
	case DCM_NONE:
		m_d3ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_NEVER );
		break;
	case DCM_LESS:
		m_d3ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_LESS );
		break;
	case DCM_LESSEQUAL:
		m_d3ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_LESSEQUAL );
		break;
	case DCM_EQUAL:
		m_d3ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_EQUAL );
		break;
	case DCM_GREATEREQUAL:
		m_d3ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_GREATEREQUAL );
		break;
	case DCM_GREATER:
		m_d3ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_GREATER );
		break;
	case DCM_ALWAYS:
		m_d3ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_ALWAYS );
		break;
	}
}

void K3DRenderDeviceDX::SetClipPlaneMode( DWORD state )
{
	m_clipPlaneEnabled = state;
	m_d3ddev->SetRenderState( D3DRS_CLIPPLANEENABLE, state );
}

void K3DRenderDeviceDX::SetClipPlane( DWORD n, const K3DPlane &plane )
{
	m_clipPlane[n] = plane;
	m_d3ddev->SetClipPlane( n, plane );
}

void K3DRenderDeviceDX::SetFogColor(KColor fogcolor)
{
	m_fogColor = fogcolor;

	m_d3ddev->SetRenderState( D3DRS_FOGCOLOR, m_fogColor.color );
}

void K3DRenderDeviceDX::SetFogMode(DWORD fogmode, KColor fogcolor, float p1, float p2, float p3, float p4)
{
	//if ( m_fogMode == fogmode &&
	//	m_fogColor.color == fogcolor.color &&
	//	m_fogFactor1 == p1 && m_fogFactor2 == p2 &&
	//	m_fogFactor3 == p3 && m_fogFactor4 == p4 )
	//{
	//	return;
	//}
	m_fogMode = fogmode;
	m_fogColor = fogcolor;
	m_fogFactor1 = p1;
	m_fogFactor2 = p2;
	m_fogFactor3 = p3;
	m_fogFactor4 = p4;

	m_d3ddev->SetRenderState( D3DRS_FOGCOLOR, m_fogColor.color );

	if(fogmode & FOGM_LINEAR)  {
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
		m_d3ddev->SetRenderState( D3DRS_FOGSTART, *((DWORD*)&m_fogFactor1) );
		m_d3ddev->SetRenderState( D3DRS_FOGEND, *((DWORD*)&m_fogFactor2) );

		SetVertexShaderConstant(CONSTANT_DISTANCEFOGSTART, &p1, 1);
		SetVertexShaderConstant(CONSTANT_DISTANCEFOGEND, &p2, 1);
	}
	if(fogmode & FOGM_HEIGHT)  {
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
		SetVertexShaderConstant(CONSTANT_HEIGHTFOGSTART, &p3, 1);
		SetVertexShaderConstant(CONSTANT_HEIGHTFOGEND, &p4, 1);
	}
	else
	{	
		m_fogFactor3 = 100.f;
		m_fogFactor4 = 1000000.f;	// sonador 1.1.18	환경 효과 오류 수정
		SetVertexShaderConstant(CONSTANT_HEIGHTFOGSTART, &m_fogFactor3, 1);
		SetVertexShaderConstant(CONSTANT_HEIGHTFOGEND, &m_fogFactor4, 1);
	}

	if(fogmode == FOGM_NONE)  {
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, FALSE );
	}

	/*switch( fogmode )
	{
	case FOGM_NONE:
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, FALSE );
		m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
		m_d3ddev->SetRenderState( D3DRS_FOGVERTEXMODE, D3DFOG_NONE );
		//m_d3ddev->SetRenderState( D3DRS_RANGEFOGENABLE, FALSE );
		break;
	case FOGM_LINEAR:
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_FOGCOLOR, m_fogColor.color );
		//m_d3ddev->SetRenderState( D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR );
		m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE,   D3DFOG_NONE );
		//m_d3ddev->SetRenderState( D3DRS_RANGEFOGENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_FOGSTART, *((DWORD*)&m_fogFactor1) );
		m_d3ddev->SetRenderState( D3DRS_FOGEND, *((DWORD*)&m_fogFactor2) );

		m_d3ddev->
		break;
	//case FOGM_EXP:
	//	m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );
	//	m_d3ddev->SetRenderState( D3DRS_FOGCOLOR, m_fogColor.color );
	//	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_EXP );
	//	//m_d3ddev->SetRenderState( D3DRS_FOGVERTEXMODE, D3DFOG_NONE );
	//	//m_d3ddev->SetRenderState( D3DRS_RANGEFOGENABLE, TRUE );
	//	m_d3ddev->SetRenderState( D3DRS_FOGDENSITY, *((DWORD*)&m_fogFactor1) );
	//	break;
	//case FOGM_EXP2:
	//	m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );
	//	m_d3ddev->SetRenderState( D3DRS_FOGCOLOR, m_fogColor.color );
	//	m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_EXP2 );
	//	//m_d3ddev->SetRenderState( D3DRS_FOGVERTEXMODE, D3DFOG_NONE );
	//	//m_d3ddev->SetRenderState( D3DRS_RANGEFOGENABLE, TRUE );
	//	m_d3ddev->SetRenderState( D3DRS_FOGDENSITY, *((DWORD*)&m_fogFactor1) );
	//	break;
	case FOGM_HEIGHT:	// VS 전용
		m_d3ddev->SetRenderState( D3DRS_FOGENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_FOGCOLOR, m_fogColor.color );
		//m_d3ddev->SetRenderState( D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR );
		m_d3ddev->SetRenderState( D3DRS_FOGTABLEMODE,   D3DFOG_NONE );
		//m_d3ddev->SetRenderState( D3DRS_RANGEFOGENABLE, TRUE );
		m_d3ddev->SetRenderState( D3DRS_FOGSTART, *((DWORD*)&m_fogFactor1) );
		m_d3ddev->SetRenderState( D3DRS_FOGEND, *((DWORD*)&m_fogFactor2) );
		break;

	}*/
}

void K3DRenderDeviceDX::SetFillMode(DWORD mode)
{
	//if ( m_fillmode == mode ) return;
	//m_fillmode = mode;
	switch( mode ) 
	{
	case FM_POINT:
		m_d3ddev->SetRenderState( D3DRS_FILLMODE, D3DFILL_POINT );
		break;
	case FM_WIREFRAME:
		m_d3ddev->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
		break;
	case FM_SOLID:
		m_d3ddev->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
		break;
	}
}

void K3DRenderDeviceDX::SetCullMode( DWORD mode )
{
	//if ( m_cullmode == mode ) return;
	//m_cullmode = mode;
	switch( mode )
	{
	case KCM_NONE:
		m_d3ddev->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
		break;
	case KCM_CW:
		m_d3ddev->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW );
		break;
	case KCM_CCW:
		m_d3ddev->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
		break;
	}
}

void K3DRenderDeviceDX::SetSceneAmbientLight( const KColor &color )
{
	m_sceneambient = color;
	m_d3ddev->SetRenderState( D3DRS_AMBIENT, color.color );
}

void K3DRenderDeviceDX::SetViewport( const KViewportStruct &vp )
{
	HRESULT hr = m_d3ddev->SetViewport( vp );
	m_viewport = vp;
	assert( hr == S_OK );
}

void K3DRenderDeviceDX::SetBumpState( K3DMatrix * BumpMat )
{
	//Bump Map
	m_d3ddev->SetTextureStageState( 0, D3DTSS_BUMPENVMAT00,   F2DW( BumpMat->_11 ) );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_BUMPENVMAT01,   F2DW( BumpMat->_12 ) );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_BUMPENVMAT10,   F2DW( BumpMat->_21 ) );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_BUMPENVMAT11,   F2DW( BumpMat->_22 ) );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_BUMPENVLSCALE,  F2DW(0.8f) );
	m_d3ddev->SetTextureStageState( 0, D3DTSS_BUMPENVLOFFSET, F2DW(0.0f) );


	static K3DMatrix mat;
	mat._11 = 0.8f; mat._12 = 0.0f; mat._13 = 0.0f;
	mat._21 = 0.0f; mat._22 = 0.8f; mat._23 = 0.0f;
	mat._31 = 0.5f; mat._32 =-0.5f; mat._33 = 1.0f;
	mat._41 = 0.0f; mat._42 = 0.0f; mat._43 = 0.0f;

	SetTransform( TS_TEXTURE1, &mat );
}

void K3DRenderDeviceDX::SetTextureFactor( DWORD dwFactor )
{
	m_d3ddev->SetRenderState( D3DRS_TEXTUREFACTOR, dwFactor );
}

void K3DRenderDeviceDX::SetTextureFactor( const K3DVector &vFactor )
{
	K3DVector vec;
	K3DVectorNormalize( vec, vFactor );
	DWORD r = (DWORD)( 127.0f * -vec.x + 128.0f );
	DWORD g = (DWORD)( 127.0f * -vec.y + 128.0f );
	DWORD b = (DWORD)( 127.0f * -vec.z + 128.0f );
	DWORD a = 0;
	m_d3ddev->SetRenderState( D3DRS_TEXTUREFACTOR, ( (a<<24L) + (r<<16L) + (g<<8L) + (b<<0L) ) );
}

void K3DRenderDeviceDX::EndVertexShader()
{
	for(int i = 0; i < MAX_VERTEXT_DECLARATION; ++i)  {
		SAFE_RELEASE( m_pVertexDeclaration[i] );
	}

	SAFE_RELEASE( m_pEffect );
}

void K3DRenderDeviceDX::InitVertexShader()
{
	//Test 중... BERSERK
	LPD3DXBUFFER pErrorMsgs;
	HRESULT      hr;

	//SAFE_RELEASE( m_pV11_MeshSkin_Decl );
	for(int i = 0; i < MAX_VERTEXT_DECLARATION; ++i)  {
		SAFE_RELEASE( m_pVertexDeclaration[i] );
	}

	D3DVERTEXELEMENT9 decl_skinmesh_bump[] =
	{
		{ 0,  0, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION    , 0 },//size=12
		{ 0, 12, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL      , 0 },//size=12
		{ 0, 24, D3DDECLTYPE_UBYTE4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR	   , 0 },//size=4
		{ 0, 28, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD    , 0 },//size=8
		{ 0, 36, D3DDECLTYPE_FLOAT4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT     , 0 },//size=16
		{ 0, 52, D3DDECLTYPE_UBYTE4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 },//size=4
		{ 0, 56, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT , 0 },//size=8
		D3DDECL_END()
	};

	D3DVERTEXELEMENT9 decl_skinmesh[] =
	{
		{ 0,  0, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION    , 0 },//size=12
		{ 0, 12, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL      , 0 },//size=12
		{ 0, 24, D3DDECLTYPE_UBYTE4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR	   , 0 },//size=4
		{ 0, 28, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD    , 0 },//size=8
		{ 0, 36, D3DDECLTYPE_UBYTE4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 },//size=4
		{ 0, 40, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT , 0 },//size=8
		D3DDECL_END()
	};

	D3DVERTEXELEMENT9 decl_terrain[] =
	{
		{ 0,  0, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION		, 0 },//size=12
		{ 0, 12, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL		, 0 },//size=12
		{ 0, 24, D3DDECLTYPE_UBYTE4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR		, 0 },//size=4
		D3DDECL_END()
	};

	D3DVERTEXELEMENT9 decl_water[] =
	{
		{ 0,  0, D3DDECLTYPE_FLOAT4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION		, 0 },//size=16
		{ 0, 16, D3DDECLTYPE_UBYTE4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR		, 0 },//size=4
//		{ 0, 20, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL		, 0 },//size=12
		{ 0, 20, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD     , 0 },//size=8
		{ 0, 28, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD     , 1 },//size=8
		
		D3DDECL_END()
	};

	// { [sonador]
	D3DVERTEXELEMENT9 decl_cloud[] = 
	{
		{ 0,  0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION	, 0 }, 
		{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL	 	, 0 }, 
		{ 0, 24, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR	 	, 0 }, 
		{ 0, 28, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD	, 0 }, 
		/*{ 0, 36, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD	, 1 }, */
		D3DDECL_END()
	};

	D3DVERTEXELEMENT9 decl_weather[] =
	{
		{ 0,  0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION	, 0 },
		{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL		, 0 },
		{ 0, 24, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR	 	, 0 },
		{ 0, 28, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD	, 0 }, 		 
		D3DDECL_END()
	};
	// }

#ifdef _DEBUG
	D3DVERTEXELEMENT9 decl_env[] =
	{
		{ 0,  0, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION		, 0 },//size=12
		{ 0, 12, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL       , 0 },//size=12
		{ 0, 24, D3DDECLTYPE_UBYTE4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR		, 0 },//size=4
		{ 0, 28, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD     , 0 },//size=8
		{ 0, 36, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD     , 1 },//size=8
	
		D3DDECL_END()
	};
#endif

	hr = m_d3ddev->CreateVertexDeclaration( decl_skinmesh_bump, &m_pVertexDeclaration[VTXDECLARATION_SKINMESH] );
	hr = m_d3ddev->CreateVertexDeclaration( decl_skinmesh_bump, &m_pVertexDeclaration[VTXDECLARATION_OBJECTMESH] );
	hr = m_d3ddev->CreateVertexDeclaration( decl_skinmesh_bump, &m_pVertexDeclaration[VTXDECLARATION_BUMPSKINMESH] );
	hr = m_d3ddev->CreateVertexDeclaration( decl_terrain, &m_pVertexDeclaration[VTXDECLARATION_TERRAIN] );
	hr = m_d3ddev->CreateVertexDeclaration( decl_water, &m_pVertexDeclaration[ VTXDECLARATION_WATER ] );
	hr = m_d3ddev->CreateVertexDeclaration( decl_cloud, &m_pVertexDeclaration[ VTXDECLARATION_CLOUD ] );
	hr = m_d3ddev->CreateVertexDeclaration( decl_weather, &m_pVertexDeclaration[ VTXDECLARATION_WEATHER ] );
#ifdef _DEBUG
	hr = m_d3ddev->CreateVertexDeclaration( decl_env, &m_pVertexDeclaration[ VTXDECLARATION_ENVMAP ] );
#endif

	// Alpha-tex
	D3DVERTEXELEMENT9 decl_alphatex[] = 
	{
		{ 0,  0, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION		, 0 },//size=12
		{ 0, 12, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL		, 0 },//size=12
		{ 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR		, 0 },//size=4
		{ 0, 28, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR		, 1 },//size=4
		{ 0, 32, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD		, 0 },//size=8
		{ 0, 40, D3DDECLTYPE_FLOAT2  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD		, 1 },//size=8
		{ 0, 48, D3DDECLTYPE_UBYTE4  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES , 0 },//size=4
		{ 0, 52, D3DDECLTYPE_FLOAT3  , D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT , 0 },//size=12

		D3DDECL_END()
	};
	hr = m_d3ddev->CreateVertexDeclaration( decl_alphatex, &m_pVertexDeclaration[ VTXDECLARATION_ALPHATEX ] );
	//	hr = m_d3ddev->CreateVertexDeclaration( DynamicVertex::vertexDeclaration, &m_pVertexDeclaration[ VTXDECLARATION_ALPHATEX ] );
			// See KResourceDXDynamic.cpp for declaration


	//const char * pstrFile[] =
	//{
	//	"DefaultEffect.fx", //캐릭터
	//	"ObjectEffect.fx",  //Object Mesh 
	//	"SkyEffect.fx",     //Sky
	//	"TerrainEffect.fx", //Terrain
	//	"SpecularEffect.fx",//Specular
	//	"BumpEffect.fx",    //Bump
	//}

	//for( int i(0); 6>i; i++ )
	//{
	//	std::string strFile = KResourceManager::GetTempFileName( pstrFile[i] );
	//	LPD3DXEFFECT tempEffect;
	//	if(FAILED(hr = D3DXCreateEffectFromFile( m_d3ddev, strFile.c_str(), NULL, NULL, 0, NULL, &tempEffect, &pErrorMsgs )))
	//	{
	//		if(pErrorMsgs)
	//		{
	//			char * pErrStr = (char*)pErrorMsgs->GetBufferPointer();
	//			OutputDebugString(pErrStr);
	//			OutputDebugString("\n");
	//		}
	//		for(int i = 0; i < MAX_VERTEXT_DECLARATION; ++i)  {
	//			SAFE_RELEASE( m_pVertexDeclaration[i] );
	//		}
	//		return;
	//	}
	//	else
	//	{
	//		SAFE_RELEASE( m_pEffect );
	//		m_pEffect = tempEffect;

	//		//Effect Technique
	//		//unsigned int i;
	//		m_pEffect->GetDesc(&(m_pFXDesc));
	//		m_nTechNum = m_pFXDesc.Techniques;
	//		/*for(i = 0; i < m_nTechNum; ++i)
	//		{
	//		m_pTechHandles[i] = m_pEffect->GetTechnique(i);
	//		m_pEffect->GetTechniqueDesc(m_pTechHandles[i], m_TechDesc[i]);
	//		}*/
	//		m_pTechHandles[TECHNIQUE_SKINMESH]					= m_pEffect->GetTechniqueByName("DefaultTech_2x");
	//		m_pTechHandles[TECHNIQUE_SKINMESH_SPECULAR]			= m_pEffect->GetTechniqueByName("BumpTech_2x");
	//		m_pTechHandles[TECHNIQUE_SKINMESH_BUMP_SPECULAR]	= m_pEffect->GetTechniqueByName("BumpTech_2x");
	//		m_pTechHandles[TECHNIQUE_OBJECTMESH]				= m_pEffect->GetTechniqueByName("ObjectTech_2x");
	//		m_pTechHandles[TECHNIQUE_OBJECTMESH_NOLIGHT]		= m_pEffect->GetTechniqueByName("ObjectNoLightTech_2x");
	//		m_pTechHandles[TECHNIQUE_TERRAIN]					= m_pEffect->GetTechniqueByName("TerrainTech");
	//		m_pTechHandles[TECHNIQUE_TERRAINSHADOW]				= m_pEffect->GetTechniqueByName("TerrainShadowTech");
	//		m_pTechHandles[TECHNIQUE_SKYBOX]					= m_pEffect->GetTechniqueByName("SkyBox_Tech");
	//		m_pTechHandles[TECHNIQUE_CLOUDSPREAD]				= m_pEffect->GetTechniqueByName("CloudSpread_Tech");
	//		m_pTechHandles[TECHNIQUE_GLOWSCREEN]				= m_pEffect->GetTechniqueByName("GlowScreenTech");
	//	}
	//}

	/*
		2012.07.06 클라이언트가 동시에 실행될 때, 파일 생성에 실패 할 수 가 있다.
		DefaultEffect.fx가 팩킹되어 있기 때문에 임시 위치에 저장 시켰다가
		D3DXCreateEffectFromFile에서 쓰이고 있는 것 같음.
		파일로 불러오지 말고 메모리 상의 fx데이타를 불러오도록 하면 될 것 같다.
		가끔 처음 접속해서 로비화면으로 갔을 때 이런경우에 캐릭터가 안보이는 경우가 발생하고 게임을 시작하면
		뻑이 난다. - prodongi
	*/
	std::string strFile = KFileManager::Instance().CreateTemporaryFileFromResource( "DefaultEffect.fx" );
	OutputDebugString(strFile.c_str());
	OutputDebugString("\n");

	assert( strFile.length() && "Effect FX File Not Found!!!" );

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

    LPD3DXEFFECT tempEffect;
#ifdef D3DXSHADER_USE_LEGACY_D3DX9_31_DLL
	DWORD dwFlag = D3DXSHADER_USE_LEGACY_D3DX9_31_DLL;
#else
	DWORD dwFlag = 0;
#endif
#ifdef _SHADER_DEBUG_MODE
	dwFlag |= D3DXSHADER_DEBUG;
#endif
	if(FAILED(hr = D3DXCreateEffectFromFile( m_d3ddev, strFile.c_str(), NULL, NULL, dwFlag, NULL, &tempEffect, &pErrorMsgs )))
	{
		if(pErrorMsgs)
		{
			char * pErrStr = (char*)pErrorMsgs->GetBufferPointer();
			OutputDebugString(pErrStr);
			OutputDebugString("\n");
		}
		for(int i = 0; i < MAX_VERTEXT_DECLARATION; ++i)  {
			SAFE_RELEASE( m_pVertexDeclaration[i] );
		}

		assert( 0 );

		return;
	}
	else
	{
		SAFE_RELEASE( m_pEffect );
		m_pEffect = tempEffect;

		m_pEffect->GetDesc(&(m_pFXDesc));
		m_nTechNum = m_pFXDesc.Techniques;

		m_pTechHandles[TECHNIQUE_SKINMESH]							= m_pEffect->GetTechniqueByName("DefaultTech_2x");
		m_pTechHandles[ TECHNIQUE_SKINMESH_NOUVANIIN2NDTEX ]		= m_pEffect->GetTechniqueByName( "DefaultTechNoUvAni2nd_2x" );
		m_pTechHandles[TECHNIQUE_SKINMESH_SPECULAR]					= m_pEffect->GetTechniqueByName("SpecularTech_2x");
		m_pTechHandles[TECHNIQUE_SKINMESH_BUMP_SPECULAR]			= m_pEffect->GetTechniqueByName("BumpTech_2x");
		m_pTechHandles[TECHNIQUE_SKINMESH_BUMP_SPECULAR_SELFSHADOW]	= m_pEffect->GetTechniqueByName("BumpSSTech_2x");
		m_pTechHandles[TECHNIQUE_OBJECTMESH]						= m_pEffect->GetTechniqueByName("ObjectTech_2x");
		m_pTechHandles[TECHNIQUE_OBJECTMESH_LIGHTMAP]				= m_pEffect->GetTechniqueByName("ObjectTech_LightMap");
		m_pTechHandles[TECHNIQUE_TERRAIN]							= m_pEffect->GetTechniqueByName("TerrainTech");
		m_pTechHandles[TECHNIQUE_TERRAIN_LIGHTMAP]					= m_pEffect->GetTechniqueByName("TerrainLightmapTech" );
		m_pTechHandles[TECHNIQUE_TERRAIN_1STPASS]					= m_pEffect->GetTechniqueByName("TerrainTech_1stPass");
		m_pTechHandles[TECHNIQUE_TERRAIN_2NDPASS]					= m_pEffect->GetTechniqueByName("TerrainTech_2ndPass");
		m_pTechHandles[TECHNIQUE_TERRAIN_3RDPASS]					= m_pEffect->GetTechniqueByName("TerrainTech_3rdPass");
		m_pTechHandles[TECHNIQUE_TERRAIN_4THPASS]					= m_pEffect->GetTechniqueByName("TerrainTech_4thPass");
		//m_pTechHandles[TECHNIQUE_TERRAIN_5THPASS]					= m_pEffect->GetTechniqueByName("TerrainTech_5thPass");
		m_pTechHandles[TECHNIQUE_TERRAINSHADOW]						= m_pEffect->GetTechniqueByName("TerrainShadowTech");
		m_pTechHandles[TECHNIQUE_SKYBOX]							= m_pEffect->GetTechniqueByName("SkyBox_Tech");
		m_pTechHandles[TECHNIQUE_CLOUDSPREAD]						= m_pEffect->GetTechniqueByName("CloudSpread_Tech");
		m_pTechHandles[TECHNIQUE_WEATHER]							= m_pEffect->GetTechniqueByName("WeatherTech");
		m_pTechHandles[TECHNIQUE_SHADOWBUFFER]						= m_pEffect->GetTechniqueByName("ShadowBuffer_Tech");
		//m_pTechHandles[TECHNIQUE_GLOWSCREEN]						= m_pEffect->GetTechniqueByName("GlowScreen_Tech");
		//m_pTechHandles[TECHNIQUE_GLOWWHITESCREEN]					= m_pEffect->GetTechniqueByName("GlowWhiteScreen_Tech");
		m_pTechHandles[ TECHNIQUE_BLURSCREEN ]						= m_pEffect->GetTechniqueByName( "Blur_Tech" );
		m_pTechHandles[ TECHNIQUE_TONEMAPPING ]						= m_pEffect->GetTechniqueByName( "Tone_Tech" );
		m_pTechHandles[TECHNIQUE_WATER_SPECULAR]					= m_pEffect->GetTechniqueByName("WaterSpecular_Tech");
		m_pTechHandles[ TECHNIQUE_HQWATER ]							= m_pEffect->GetTechniqueByName( "HqWater_Tech" );
		m_pTechHandles[ TECHNIQUE_ALPHATEX ]						= m_pEffect->GetTechniqueByName( "AlphaTex_Tech" );
		m_pTechHandles[ TECHNIQUE_ALPHATEX_EDGEENHANCE ]			= m_pEffect->GetTechniqueByName( "AlphaTex_EdgeEnhance_Tech" );
		m_pTechHandles[ TECHNIQUE_ALPHATEX_EDGEENHANCE_BLEND ]		= m_pEffect->GetTechniqueByName( "AlphaTex_EdgeEnhance_Blend_Tech" );
		m_pTechHandles[ TECHNIQUE_SELECT_TARGET_FX ]				= m_pEffect->GetTechniqueByName( "SelectTargetFx" );	
#ifdef _DEBUG
		m_pTechHandles[ TECHNIQUE_ENVMAP ]							= m_pEffect->GetTechniqueByName( "EnvMap_Tech" );
#endif
		m_pTechHandles[TECHNIQUE_OUTLINE] = m_pEffect->GetTechniqueByName("OutLineTech");
		m_pTechHandles[TECHNIQUE_OUTLINE_BLEND] = m_pEffect->GetTechniqueByName("OutLineBlendTech");
		m_pTechHandles[TECHNIQUE_NO_TEX] = m_pEffect->GetTechniqueByName("NoTexTech");
	}

#ifdef _RAC

	if(pErrorMsgs)
	{
		char * pErrStr = (char*)pErrorMsgs->GetBufferPointer();
		OutputDebugString(pErrStr);
		OutputDebugString("\n");
	}

	//임시 화일은 삭제.
	if( strstr( strFile.c_str(), "_tmp" ) )
		DeleteFile( strFile.c_str() );
#endif
}

void K3DRenderDeviceDX::InitSpeedTree()
{
#ifndef _NOSTREE_
	//Speed Tree
	m_dwBranchVertexShader = LoadBranchShader(m_d3ddev);
	m_dwLeafVertexShader   = LoadLeafShader(m_d3ddev);
	m_dwSpeedTreeBillboardVertexShader = LoadSpeedTreeBillboardShader(m_d3ddev);	// sonador #2.1.7.1	스피드 트리 퍼포먼스 증가
#endif

#ifdef _DEBUG
    if( FAILED( D3DXCreateRenderToEnvMap( m_d3ddev, 256, 1, m_d3dParam.BackBufferFormat, TRUE, 
										  m_d3dParam.AutoDepthStencilFormat, &m_pRenderToEnvMap ) ) )
    {
        assert( false );
    }
#endif
}

void K3DRenderDeviceDX::EndSpeedTree()
{
#ifndef _NOSTREE_
	SAFE_RELEASE(m_dwBranchVertexShader);
	SAFE_RELEASE(m_dwLeafVertexShader);
	SAFE_RELEASE(m_dwSpeedTreeBillboardVertexShader);	// sonador #2.1.7.1	스피드 트리 퍼포먼스 증가
	SAFE_RELEASE(m_dwGrassVertexShader);
#endif
}

void K3DRenderDeviceDX::InitSpeedGrass()
{
	m_dwGrassVertexShader = LoadGrassShader(m_d3ddev);
}

void K3DRenderDeviceDX::SetMatrixArray( CONST D3DXMATRIX* pMatrix, UINT Count )
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	if( !m_pEffect ) return;
	D3DXHANDLE hParameter = NULL;
    D3DXHANDLE hTechnique = NULL;

	hParameter = m_pEffect->GetParameterByName(NULL,"blendMatrices");
	{
		m_pEffect->SetMatrixArray(hParameter, pMatrix, Count);
	}
}

void K3DRenderDeviceDX::Fill( int flags )
{
	DWORD ddflag = 0;
	if ( flags & FILL_COLOR   ) ddflag |= D3DCLEAR_TARGET;
	if ( flags & FILL_DEPTH   ) ddflag |= D3DCLEAR_ZBUFFER;
	if ( flags & FILL_STENCIL ) ddflag |= D3DCLEAR_STENCIL;

	HRESULT hr = m_d3ddev->Clear( 0, NULL, ddflag, m_colorFill.color, 1.0f, 0L );
	if( hr != S_OK )
	{
		assert( 0 && "Fill Fail..." );
	}
}

void K3DRenderDeviceDX::SetVertexShaderDefault()
{
	m_d3ddev->SetVertexShader( NULL );

	ResetPrevDeclarationTechnique();
}

void K3DRenderDeviceDX::SetFVF( DWORD dwFVF )
{
	if( dwFVF != NULL )
	{
		ResetPrevDeclarationTechnique();
	}

	if( m_d3ddev->SetFVF( dwFVF ) != S_OK )
	{
		assert( 0 );
	}
}

void K3DRenderDeviceDX::SetVertexShader(DWORD decl, DWORD tech)
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	if( GetPrevDeclaration() == decl && GetPrevTechnique() == tech )
	{
		return;
	}

	if (!m_pEffect) return ;

	SetPrevDeclaration( decl );
	SetPrevTechnique( tech );

	SetFVF( NULL );

	HRESULT hr;
	if(m_pVertexDeclaration[decl])
		m_d3ddev->SetVertexDeclaration(m_pVertexDeclaration[decl]);
	hr = m_pEffect->SetTechnique(  m_pTechHandles[tech] );

	assert(hr == S_OK && "선언부 에러");
}

void K3DRenderDeviceDX::SetVertexShaderMatrix(const TCHAR *dcl, const K3DMatrix *mat)
{
	TestCooperativeLevel() == S_OK ? m_bIsDeviceLost = false : m_bIsDeviceLost = true;
	if( m_bIsDeviceLost ) return;

	if(m_pEffect == NULL) return;

	m_pEffect->SetMatrix(dcl, (D3DXMATRIX*)mat);
}

void K3DRenderDeviceDX::SetVertexShaderBranch()
{
	HRESULT hr = m_d3ddev->SetVertexShader( m_dwBranchVertexShader );
	if( hr != S_OK )
	{
		assert( 0 && "Failed!!! - SetVertexShaderBranch()" );
	}
}

void K3DRenderDeviceDX::SetVertexShaderLeaf()
{
	HRESULT hr = m_d3ddev->SetVertexShader( m_dwLeafVertexShader );
	if( hr != S_OK )
	{
		assert( 0 && "Failed!!! - SetVertexShaderLeaf()" );
	}
}

// sonador #2.1.7.1	스피드 트리 퍼포먼스 증가
void K3DRenderDeviceDX::SetVertexShaderSpeedTreeBillboard()
{
	HRESULT hr = m_d3ddev->SetVertexShader( m_dwSpeedTreeBillboardVertexShader );
	if( hr != S_OK )
	{
		assert( 0 && "Failed!!! - SetVertexShaderSpeedTreeBillboard()" );
	}
}

void K3DRenderDeviceDX::SetVertexShaderGrass()
{
    HRESULT hr = m_d3ddev->SetVertexShader( m_dwGrassVertexShader );
	if( hr != S_OK )
	{
		assert( 0 && "Failed!!! - SetVertexShaderGrass()" );
	}
}

void K3DRenderDeviceDX::SetLocalCoordOffset( K3DVector vOffset )
{
	m_LocalCoordOffset = vOffset;

	K3DVector4 vec4( vOffset.x, vOffset.y, vOffset.z, 0.0f );
	SetVertexShaderConstant( CONSTANT_LOCALCOORD_OFFSET, ( float* ) &vec4, 4);
}

K3DVector K3DRenderDeviceDX::GetLocalCoordOffset()
{
	return m_LocalCoordOffset;
}

HRESULT K3DRenderDeviceDX::setupOcclusion()
{
	// Create the query
	HRESULT hr = m_d3ddev->CreateQuery( D3DQUERYTYPE_OCCLUSION, &m_d3dQuery );
	if( hr == S_OK )
	{
		m_bDeviceSupportsVizQuery = true;
	}

	return hr;
}

bool K3DRenderDeviceDX::VizQueryIssueBegin()
{
	if( m_bDeviceSupportsVizQuery )
	{
		if( m_d3dQuery->Issue( D3DISSUE_BEGIN ) == D3D_OK )
		{
			return true;
		}
	}

	return false;
}

bool K3DRenderDeviceDX::VizQueryIssueEnd()
{
	if( m_bDeviceSupportsVizQuery )
	{
		if( m_d3dQuery->Issue( D3DISSUE_END ) == D3D_OK )
		{
			DWORD dwVizData = 0;
			while (m_d3dQuery->GetData((void *) &dwVizData, sizeof(DWORD), D3DGETDATA_FLUSH) == S_FALSE)
			{

			}

			if( dwVizData > 0 ) return true;

			return false;
		}
	}

	return true;
}

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

#pragma comment(lib, "dxerr9.lib")


KSwapChainDX::KSwapChainDX()
{
	m_pInterface = NULL;
	m_pBackBuffer = NULL;
	m_pDepthBuffer = NULL;

	m_pRenDev = NULL;
	m_hWnd = NULL;
	m_bUseDepth = FALSE;
}

KSwapChainDX::~KSwapChainDX()
{
	Clear();
}

BOOL KSwapChainDX::Create(K3DRenderDeviceDX* pRenDev, HWND hWnd, BOOL bUseDepth)
{
	IDirect3D9* pD3d = pRenDev->GetD3D();
	IDirect3DDevice9* pD3dDev = pRenDev->GetD3DDevice();

	if(!pD3d || !pD3dDev) return FALSE;

	K3DRenderDeviceDX::CS cs = pRenDev->GetCS();

	D3DDISPLAYMODE d3ddm;
	if(FAILED(pD3d->GetAdapterDisplayMode(cs.nAdopter, &d3ddm))) return FALSE;

	RECT rc;
	::GetClientRect(hWnd, &rc);
	
	D3DPRESENT_PARAMETERS d3dpp; 
	ZeroMemory(&d3dpp, sizeof(d3dpp));
	d3dpp.BackBufferWidth  = rc.right;
	d3dpp.BackBufferHeight = rc.bottom;
	d3dpp.BackBufferFormat = d3ddm.Format;
	d3dpp.BackBufferCount  = 1;
	d3dpp.MultiSampleType  = D3DMULTISAMPLE_NONE;
	d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
	d3dpp.hDeviceWindow    = hWnd;
	d3dpp.Windowed         = !cs.bFullScreen;
	//d3dpp.EnableAutoDepthStencil = FALSE;
	//d3dpp.AutoDepthStencilFormat = (D3DFORMAT) K3DFMT_D24X8;//K3DFMT_D16;;
	//d3dpp.Flags            = 0;

	IDirect3DSwapChain9* pInterface = NULL;
	HRESULT hres = pD3dDev->CreateAdditionalSwapChain(&d3dpp, &pInterface);
	if(FAILED(hres))
	{
		const TCHAR* szError = DXGetErrorString9(hres);
		assert(0 && "CreateAdditionalSwapChain() failed");
        
		if(szError)
		{
            assert(0 && szError);
		}

		return FALSE;
	}

	IDirect3DSurface9* pBackBuffer = NULL;

	hres = pInterface->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
	if(FAILED(hres))
	{
		const TCHAR* szError = DXGetErrorString9(hres);
		assert(0 && "GetBackBuffer() failed");

		if(szError)
		{
			assert(0 && szError);
		}

		SAFE_RELEASE(pInterface);
		
		return FALSE;
	}

	IDirect3DSurface9* pDepthBuffer = NULL;

	if(bUseDepth)
	{
		hres = pD3dDev->CreateDepthStencilSurface(rc.right, rc.bottom, D3DFMT_D24X8, D3DMULTISAMPLE_NONE, 0, TRUE, &pDepthBuffer, NULL);
        if(FAILED(hres))
		{
			const TCHAR* szError = DXGetErrorString9(hres);
			assert(0 && "CreateDepthStencilSurface() failed");

            if(szError)
			{
                assert(0 && szError);
			}
		
			SAFE_RELEASE(pInterface);
			SAFE_RELEASE(pBackBuffer);

			return FALSE;
		}
	}

	m_pInterface = pInterface;
	m_pBackBuffer = pBackBuffer;
	m_pDepthBuffer = pDepthBuffer;

	m_pRenDev = pRenDev;
	m_hWnd = hWnd;
	m_bUseDepth = bUseDepth;

	return TRUE;
}

void KSwapChainDX::Clear()
{
	SAFE_RELEASE(m_pInterface);
	SAFE_RELEASE(m_pBackBuffer);
	SAFE_RELEASE(m_pDepthBuffer);
}

void KSwapChainDX::Reset()
{
	Clear();
	Create(m_pRenDev, m_hWnd, m_bUseDepth);
}

IDirect3DSwapChain9* KSwapChainDX::GetInterface()
{
	return m_pInterface;
}

IDirect3DSurface9* KSwapChainDX::GetBackBuffer()
{
	return m_pBackBuffer;
}

IDirect3DSurface9* KSwapChainDX::GetDepthBuffer()
{
	return m_pDepthBuffer;
}

BOOL KSwapChainDX::DoesUseDepthBuffer()
{
	return m_bUseDepth;
}

HWND KSwapChainDX::GetHwnd()
{
	return m_hWnd;
}