#include "stdafx.h"

#include "SViewPort.h"

#include "k3dcamera.h"

#include "KPrimitive.h"

#include "TerrainPrimitive.h"

#include "KRenderDeviceDX.h"
#include "KRenderObject.h"

//#include "SEnvPrimitive.h"

#include "SSpeedTreeVertexShaders.h"

#include <dump/XException.h>
#include "GameDefine.h"
#include "KResourceManager.h"

//#include "KPrimitiveSpeedGrass.h"
#include "KSeqSpeedGrass.h"
#include <SpeedGrass/VertexShaders.h>
//#include <SpeedGrass/SpeedGrassConstants.h>
/// 2010.11.10 - prodongi
#include "SItemDB.h"
#include "SGameLobbyDefine.h"

#ifdef CLOUD_LUA
#include "SGameCloud.h"
#endif

#ifdef _DEBUG_DPCOUNT
	bool __output_dp = false;

	enum
	{
		__TYPE_ITEM = 0,
		__TYPE_VIEWPORT,
	};

	struct __RENDER_ITEM_INFO
	{
		std::string Name;
		int			Type;
		int			DP;
		int			Face;
		LONGLONG	Time;
	};
	std::vector<__RENDER_ITEM_INFO> __vtRenderItem;

	float __getCountPerMesc()
	{
		LARGE_INTEGER counter;
		QueryPerformanceFrequency( &counter);
		return static_cast<float>( counter.LowPart )/ 1000.f;
	}

	void __outputResult(LPCSTR name, int DP, int face, LONGLONG time, DWORD Ratio)
	{
		const static float COUNT_PER_MESC = __getCountPerMesc();
		static char buf[1024];
		std::string ouput_str = name;
		size_t tabCount = 10 - ouput_str.size() / 4;
		ouput_str.append(tabCount, '\t');

		std::string tabAlignDP = "\t\t";
		if(DP > 99)
			tabAlignDP ="\t";

		std::string tabAlignFace = "\t\t";
		if(face > 1000)
			tabAlignFace ="\t";

		_oprint("%s - DP: %d, %sFace: %d, %sAverage Face: %.2f, \tTime: %.2fms, \tPercent: %d%%\n",ouput_str.c_str(),DP, tabAlignDP.c_str(), face, tabAlignFace.c_str(),
			static_cast<float>(face) / DP, static_cast<float>(time) / COUNT_PER_MESC , Ratio);
	}


	void __startOneFrame()
	{
		__vtRenderItem.clear();
		__output_dp = 0 != HIBYTE(GetAsyncKeyState(VK_RSHIFT));
	}

	void __endOneFrame()
	{
		if(false == __output_dp)
			return;

		_oprint("*************************************************Start One Frame*************************************************\n");

		DWORD totalTime =0;
		int totalDP = 0;
		int totalFace = 0;
		for(size_t i = 0; i < __vtRenderItem.size(); ++i)
		{
			if(__TYPE_ITEM == __vtRenderItem.at(i).Type )
			{
				totalTime += __vtRenderItem.at(i).Time;
				totalDP += __vtRenderItem.at(i).DP;
				totalFace += __vtRenderItem.at(i).Face;
			}
		}

		bool bRenderViewport = false;
		for(size_t i = 0; i < __vtRenderItem.size(); ++i)
		{
			const __RENDER_ITEM_INFO& info = __vtRenderItem.at(i);

			if(__TYPE_VIEWPORT == info.Type )
			{
				// 예전에 찍던게 있으면
				if(bRenderViewport)
				{
					_oprint("-------------------------------------------------------------------------------------------------------------------\n");
				}

				bRenderViewport = true;
				_oprint("-------------------------------------------------------------------------------------------------------------------\n");
				_oprint("Start printing DP for %s\n",info.Name.c_str());
				continue;
			}
			__outputResult(info.Name.c_str(), info.DP, info.Face, info.Time, static_cast<float>(info.Time)/ totalTime * 100.f );
		}
		const static float COUNT_PER_MESC = __getCountPerMesc();
		
		_oprint("-------------------------------------------------------------------------------------------------------------------\n");
		_oprint("Total DP: %d, Total Face: %d, Total Time: %.2fms\n", totalDP, totalFace, static_cast<float>(totalTime) / COUNT_PER_MESC );
		_oprint("*************************************************End One Frame*************************************************\n");
	}

	void __startRenderToViewport(LPCSTR viewportName)
	{
		if(false == __output_dp)
			return;

		__RENDER_ITEM_INFO item;
		item.Type = __TYPE_VIEWPORT;
		item.Name = viewportName;
		__vtRenderItem.push_back(item);
	}

	void __addRenderItem(LPCSTR name,int DP, int face, LARGE_INTEGER counter1, LARGE_INTEGER counter2)
	{
		if(false == __output_dp || DP == 0)
			return;

		__RENDER_ITEM_INFO item;
		item.DP = DP;
		item.Name = name;
		item.Face = face;
		item.Time = counter2.QuadPart - counter1.QuadPart;
		item.Type = __TYPE_ITEM;
		__vtRenderItem.push_back(item);

	}
#endif



SViewPort::SViewPort( DWORD attr, bool bClearColorBuffer, bool bClearDepthBuffer)
: KViewportObject( attr, bClearColorBuffer, bClearDepthBuffer )
{
	ClearRegisteredList();

	int n = 0xffffffff;
	m_nRenderFlag.CopyFrom( &n );

	K3DMatrixIdentity( m_matProjection );
	K3DMatrixIdentity( m_matView );
	K3DMatrixIdentity( m_matInvView );
	
//#ifndef NDEBUG
//	m_bDebugMode       = false;
//#endif

	//m_bLocalCoord = true;

	m_bRenderSelfShadow = false;	// true 로 바꾸지 말 것 (워터뷰포트에도 적용되는 불상사가 일어남) by blackfish
	m_bRenderBumpMap = false;		// true 로 바꾸지 말 것 (워터뷰포트에도 적용되는 불상사가 일어남) by blackfish
	m_nUseSpecular = 0;			// true 로 바꾸지 말 것 (워터뷰포트에도 적용되는 불상사가 일어남) by blackfish

	m_fSelfShadowAmbientFactor = 1.f;
}

SViewPort::~SViewPort()
{
}

void SViewPort::SetRenderFlag( int nFlag )
{
	if( m_nRenderFlag.IsOn(nFlag) )
		m_nRenderFlag.Off(nFlag);
	else
		m_nRenderFlag.On(nFlag);
}

void SViewPort::Initilaize( K3DRenderDevice *dev, const KViewportStruct &viewarea, float nearClip, float farClip )
{
	KViewportObject::Initilaize( dev, viewarea, nearClip, farClip );
}

void SViewPort::ClearRegisteredList()
{
	KViewportObject::ClearRegisteredList();
}

void SViewPort::Register( K3DPrimitive *pr, DWORD flag )
{
	//if( !m_bUseSpecular && pr->IsSpecular() ) //스페큘러 지원 안하는 클라이언트는 강제로 끈다.
	//	pr->SetSpecular( m_bUseSpecular );

	//if( m_bUseSpecular && pr->IsSpecular() )
	//	pr->SetSpecular( true );
	//else
	//	pr->SetSpecular( false );

	//if( pr->IsSpecular() )
	//	pr->SetSpecular( true );
	//else
	//	pr->SetSpecular( false );

	// 어차피 Shader에서 Point Light 지원을 현재 안하고 있기 때문에 사용하나 마나 (attenuation 설정때문에 걸리지도 않는다)
	int usablelit = 0;
	if( pr->IsPosition() && m_pLightList.size() )
	{
		//사용할 Light Index 구하기
		float distance = 9999999;
		for(int i = 1 ; i < m_pLightList.size(); ++i)  
		{
			const K3DLight *lit = m_pLightList[i];
			K3DVector * pos = (K3DVector *)&pr->GetTransform()->_41;
			float tdist = K3DVectorLength((lit->position - *pos));

			if(tdist < lit->range && tdist < distance && 1.f/(1+tdist*lit->attenuation1) > 0.05f)  
			{
				distance = tdist;
				usablelit = i;
			}
		}
	}
	pr->SetLightIndex( usablelit );


	// 투명 오브젝트의 경우는 포그에서 항상 제외
	switch ( LOWORD(flag) )
	{
	/*case KRenderObject::RENDEREFX_NONE:
		{
		}
		break;
	case KRenderObject::RENDEREFX_NOFOG:
		{

		}
		break;
	case KRenderObject::RENDEREFX_NOLIGHT:
		{

		}
		break;*/
	case KRenderObject::RENDEREFX_SKY:
		{
			pr->SetSpecular(false);
			m_prListSky.push_back( pr );
		}
		break;
	case KRenderObject::RENDEREFX_CLOUD:
		{
			pr->SetSpecular(false);
			m_prListCloud.push_back( pr );
		}
		break;
		// { [sonador]
	case KRenderObject::RENDEREFX_LIGHTNING:
		{
			pr->SetSpecular( false );
			m_prListLightning.push_back( pr );
		}
		break;
		// }
	case KRenderObject::RENDEREFX_LENSFLARE:
		{
			pr->SetSpecular(false);
			m_prListLensFlare.push_back( pr );
		}
		break;
		// { [sonador][2007.03.19]
	case KRenderObject::RENDEREFX_WEATHER:
		{
			pr->SetSpecular( false );
			m_prListWeather.push_back( pr );
		}
		break;
		// }
	case KRenderObject::RENDEREFX_TERRAIN:
		{
			pr->SetSpecular(false);

			m_prListTerrain.push_back( pr );
		}
		break;
	case KRenderObject::RENDEREFX_SHADOW_TERRAIN:
		{
			//스페큘러도 꺼지면, 그림자는 찍지 않는다.
			//if( m_bUseSpecular == false ) return;

			m_prListTerrainShadow.push_back( pr );
		}
		break;
	/*case KRenderObject::RENDEREFX_BUILDING:
	case KRenderObject::RENDEREFX_BUILDING_HAS_STOOL:
		{
		}
		break;
	case KRenderObject::RENDEREFX_PROP:
	case KRenderObject::RENDEREFX_PROP_HAS_STOOL    :
		{
		}
		break;
	case KRenderObject::RENDEREFX_PROP_NOMIP:
		{

		}
		break;*/


	case KRenderObject::RENDEREFX_SPEEDTREE_BRANCH :
		{
			pr->SetSpecular(true);
			m_prListBranch.push_back( pr );
		}
		break;

	case KRenderObject::RENDEREFX_SPEEDTREE_FROND :
		{
			pr->SetSpecular(false);
			m_prListFrond.push_back( pr );
		}
		break;
	case KRenderObject::RENDEREFX_SPEEDTREE_LEAF :
		{
			pr->SetSpecular(false);
			//잎 사귀는 반투명 안 한다. 안 이쁨.
			m_prListLeaf.push_back( pr );
		}
		break;
	case KRenderObject::RENDEREFX_SPEEDTREE_BILLBOARD :
		{
			pr->SetSpecular(false);
			//잎 사귀는 반투명 안 한다. 안 이쁨.
			m_prListTreeBillboard.push_back( pr );
		}
		break;
	case KRenderObject::RENDEREFX_SPEEDGRASS :
		{
			pr->SetSpecular(false);
			m_prListSpeedGrass.push_back( pr );
		}
		break;

	//case KRenderObject::RENDEREFX_PATHEFFECT:
	//	{
	//		pr->SetSpecular(false);
	//		m_prListPathEffect.push_back(pr);
	//	}
	//	break;
	case KRenderObject::RENDEREFX_QUAD:
		{
			pr->SetSpecular(false);
			m_prListQuad.push_back(pr);
		}
		break;

	case KRenderObject::RENDEREFX_LINE:
		{
			pr->SetSpecular(false);
			m_prListLine.push_back(pr);
		}
		break;

	case KRenderObject::RENDEREFX_POLYLINE:
		{
			pr->SetSpecular(false);
			m_prListPolyLine.push_back(pr);
		}
		break;

	case KRenderObject::RENDEREFX_WATER:
		{	
			// { sonador 7.0.14	카메라 위치에 따른 물효과 컬링 문제 수정			
			bool valid = false;
			if ( pr->IsTransparent() == false )
			{
				RENDER_MESHEX container;
				float depth = pr->GetMagicNumber() + usablelit;
				valid = AllocNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth, 0, true );
				if( valid ) m_prMesh.push_back( container );
			}
			else
			{
				const K3DVector& pos = pr->GetCenterPosition();
				float depth = K3DVectorLength( pos - GetCameraTargetPos() ); // sonador 1.6.2	프랍 렌더링시 정렬 문제 해결 

				RENDER_MESHEX container;
				valid = AllocNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth, 0, true );
				if( valid )
				{
					m_prTransMesh.push_back( container );

					if( pr->GetBlendMode() == K3DMaterial::MBM_ALPHABLENDTWOPASS )
					{
						valid = AllocNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth, 1, true );
						if( valid ) m_prTransMesh.push_back( container );
					}
				}
			}
			// }
		}
		break;
	/*case KRenderObject::RENDEREFX_SHADOW:
		{
		}
		break;*/
	case KRenderObject::RENDEREFX_AFTER_SPRITE:
		{
			bool valid = false;

			if ( pr->IsTransparent() == false )
			{
				float depth = pr->GetMagicNumber() + usablelit;
				RENDER_MESHEX container;
				valid = AllocAfterSpriteNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth );
				if( valid ) 
					m_prAfterSpriteMesh.push_back( container );
			}
			else
			{
				const K3DVector& pos = pr->GetCenterPosition();
				float depth = K3DVectorLength( pos - GetCameraTargetPos() ); // sonador 1.6.2	프랍 렌더링시 정렬 문제 해결
				RENDER_MESHEX container;
				valid = AllocAfterSpriteNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth );
				if( valid ) 
					m_prAfterSpriteTransMesh.push_back( container );

				if( pr->GetBlendMode() == K3DMaterial::MBM_ALPHABLENDTWOPASS )
				{
					valid = AllocAfterSpriteNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth, 1 );
					if( valid ) 
						m_prAfterSpriteTransMesh.push_back( container );
				}
			}
		}
		break;
	case KRenderObject::RENDEREFX_SELECT:
		{
			RENDER_MESHEX container;
			float depth = pr->GetMagicNumber() + usablelit;
			bool valid = AllocNewMeshEX( container, pr, LOWORD( flag ), usablelit, false, false, pr->GetVSMode(), false, false );
			if( valid ) m_prSelectMesh.push_back( container );
		}
		break;
	default:
		{
			bool valid = false;
			if ( pr->IsTransparent() == false )
			{
				RENDER_MESHEX container;
				float depth = pr->GetMagicNumber() + usablelit;
				valid = AllocNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth );
				if( valid ) m_prMesh.push_back( container );
			}
			else
			{
				const K3DVector& pos = pr->GetCenterPosition();
				float depth = K3DVectorLength( pos - GetCameraTargetPos() ); // sonador 1.6.2	프랍 렌더링시 정렬 문제 해결

				RENDER_MESHEX container;
				valid = AllocNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth );
				if( valid )
				{
					m_prTransMesh.push_back( container );

					if( pr->GetBlendMode() == K3DMaterial::MBM_ALPHABLENDTWOPASS )
					{
						valid = AllocNewMeshEX( container, pr, LOWORD( flag ), usablelit, pr->IsBump(), pr->IsSpecular(), pr->GetVSMode(), pr->IsUseLightMap(), depth, 1 );
						if( valid ) m_prTransMesh.push_back( container );
					}
				}
			}
		}
		break;
	}
}

void SViewPort::Render( K3DRenderTarget *pRT, DWORD flag, bool bClearRegister )
{
	//	m_useRenderTarget = true;
	if( flag == SHADOW_DEFAULT )
	{
		KViewportStruct backview = m_viewport;
		m_dev->BeginScene();
		m_dev->SetRenderTarget( pRT );
		m_viewport.X = m_viewport.Y = 0;
		m_viewport.Width = pRT->GetWidth();
		m_viewport.Height = pRT->GetHeight();

		this->Render( bClearRegister, false );
		m_dev->SetRenderTarget( NULL );
		m_dev->EndScene();
		m_viewport = backview;
	}

	//	m_useRenderTarget = false;
}


void SViewPort::RenderSky()
{
	//////////////////////////////////////////////////////////////////////////
	//하늘
	if ( m_prListSky.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_SKY) )
		{
			m_dev->ResetPrevDeclarationTechnique();

			START_DPCOUNT("Sky");
			m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
			m_dev->SetDepthBufferWriteEnable( false );
			m_dev->SetRenderState( K3DRenderDevice::RS_NOLIGHT_VTXCOLOR );

			// sonador 4.2.1	스카이 박스 포그 오류 수정
			m_dev->SetFogMode( K3DRenderDevice::FOGM_HEIGHT, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );

			float TopColor[4]    = { m_SkyColorStart.r, m_SkyColorStart.g, m_SkyColorStart.b, m_SkyColorStart.a };
			float MidColor[4]    = { m_SkyColorMid.r  , m_SkyColorMid.g  , m_SkyColorMid.b  , m_SkyColorMid.a   };
			float BottomColor[4] = { m_SkyColorEnd.r  , m_SkyColorEnd.g  , m_SkyColorEnd.b  , m_SkyColorEnd.a   };
			m_dev->SetVertexShaderConstant( CONSTANT_SKYCOLORBALANCE_TOP   , TopColor   , 4 );
			m_dev->SetVertexShaderConstant( CONSTANT_SKYCOLORBALANCE_MID   , MidColor   , 4 );
			m_dev->SetVertexShaderConstant( CONSTANT_SKYCOLORBALANCE_BOTTOM, BottomColor, 4 );

			float fMaxHeight = (m_vTarPos.z + m_fSkyMaxHeight);
			float fMinHeight = (m_vTarPos.z - m_fSkyMinHeight);
			float fMidHeight = fMaxHeight * m_fSKyMidPercent;
			m_dev->SetVertexShaderConstant( CONSTANT_SKYMAX_HEIGHT, &fMaxHeight, 1 );
			m_dev->SetVertexShaderConstant( CONSTANT_SKYMID_HEIGHT, &fMidHeight, 1 );
			m_dev->SetVertexShaderConstant( CONSTANT_SKYMIN_HEIGHT, &fMinHeight, 1 );

			m_dev->SetVertexShader(VTXDECLARATION_OBJECTMESH, TECHNIQUE_SKYBOX);

 			KCustomVector<K3DPrimitive*>::iterator it = m_prListSky.begin();
			for ( ; it != m_prListSky.end() ; ++it )
			{
				(*it)->Render( this, m_dev );
			}

			// restore fog mode
			m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );

			END_DPCOUNT();
		}
	}
}

void SViewPort::RenderCloud()
{
	//////////////////////////////////////////////////////////////////////////
	//구름
	if ( m_prListCloud.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_CLOUD) )
		{
#ifdef CLOUD_LUA
		//	m_dev->SetVertexShaderDefault();
			m_dev->ResetPrevDeclarationTechnique();
#else
			m_dev->ResetPrevDeclarationTechnique();
#endif

			START_DPCOUNT("Cloud");
			m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_ALWAYS );
			m_dev->SetDepthBufferWriteEnable( false );

			m_dev->SetRenderState( K3DRenderDevice::RS_CLOUD );

			// { [sonador]
			//m_dev->SetVertexShader(VTXDECLARATION_OBJECTMESH, TECHNIQUE_CLOUDSPREAD);
			m_dev->SetVertexShader(VTXDECLARATION_CLOUD, TECHNIQUE_CLOUDSPREAD);			
			// }

			K3DVector4 uvani(0, 0, 0, 1);
			m_dev->SetVertexShaderConstant(CONSTANT_UVANIMATION, (float *)&uvani, 4);

			if( m_bLocalCoord )
			{
				BackUpViewCamera();
				K3DVector vCampos, vCamtargetpos;
				vCampos			=	m_ViewCamera.GetCamPos();
				vCamtargetpos	=	m_ViewCamera.GetTargetPos();
				vCamtargetpos	=	vCamtargetpos	-	vCampos;

				m_ViewCamera.SetCamPos( 0.f, 0.f, 0.f );
				m_ViewCamera.SetTargetPos( vCamtargetpos.x, vCamtargetpos.y, vCamtargetpos.z );

				SetCamera( &m_ViewCamera );
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);

				// [sonador][1.1.4]구름 효과 오류 수정
				float campos[4] = { 0.f, 0.f, 0.f, 0.f };
				m_dev->SetVertexShaderConstant(CONSTANT_CLOUDSPREADCENTER, campos, 4);

				KCustomVector<K3DPrimitive*>::iterator it = m_prListCloud.begin();
				for ( ; it != m_prListCloud.end() ; ++it )
				{
#ifdef CLOUD_LUA
#else		
					K3DMatrix	matTrans		 = *(*it)->GetTransform();
					K3DVector	vOripos			 = K3DVector( matTrans._41, matTrans._42, matTrans._43 );
					vOripos						 = vOripos - vCampos;

					// [sonador][1.1.4]구름 효과 오류 수정
					K3DMatrixTranslation( matTrans, 0.f, 0.f, 0.f );
					m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &matTrans );
#endif
					(*it)->Render( this, m_dev );
				}

				RestoreBackUpViewCamera();
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);

				m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );
			}
			else
			{
				float campos[4] = { m_ViewCamera.GetTargetPos().x, m_ViewCamera.GetTargetPos().y, m_ViewCamera.GetTargetPos().z, 0.f };
				m_dev->SetVertexShaderConstant(CONSTANT_CLOUDSPREADCENTER, campos, 4);

				KCustomVector<K3DPrimitive*>::iterator it = m_prListCloud.begin();
				for ( ; it != m_prListCloud.end() ; ++it )
				{
					K3DMatrix	matTrans		 = *(*it)->GetTransform();
					m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &matTrans );

					(*it)->Render( this, m_dev );
				}
			}
			END_DPCOUNT();
		}
	}
}

// { [sonador][2007.04.12] 번개 효과 렌더링
void SViewPort::RenderLightning()
{
	if( m_prListLightning.size() > 0 )
	{
		START_DPCOUNT("Lightning");

		m_dev->SetVertexShaderDefault();
		m_dev->ResetPrevDeclarationTechnique();

		// set render state

		m_dev->SetCullMode( K3DRenderDevice::KCM_NONE );
		m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
		m_dev->SetDepthBufferWriteEnable( true );
		m_dev->SetRenderState( K3DRenderDevice::RS_WEATHER );
		
		// call render method

		KCustomVector<K3DPrimitive*>::iterator it, itEnd = m_prListLightning.end();

		for( it = m_prListLightning.begin(); it != itEnd; ++it )
		{
			K3DPrimitive* pPrim = *it;
			if( pPrim )
			{
				pPrim->Render( this, m_dev );
			}
		}

		END_DPCOUNT();
	}
}
// }

// { [sonador][2007.03.19] 비 효과 랜더링
void SViewPort::RenderWeather()
{
	if( m_prListWeather.size() > 0 )
	{
		START_DPCOUNT("Weather");

		m_dev->SetVertexShaderDefault();
		m_dev->ResetPrevDeclarationTechnique();

		// set render state

		m_dev->SetCullMode( K3DRenderDevice::KCM_NONE );
		m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
		m_dev->SetDepthBufferWriteEnable( true );
		m_dev->SetRenderState( K3DRenderDevice::RS_WEATHER );
		m_dev->SetVertexShader( VTXDECLARATION_WEATHER, TECHNIQUE_WEATHER );
		
		// call render method

		KCustomVector<K3DPrimitive*>::iterator it, itEnd = m_prListWeather.end();

		for( it = m_prListWeather.begin(); it != itEnd; ++it )
		{
			(*it)->Render( this, m_dev );
		}

		END_DPCOUNT();
	}
}
// }

/// 2010.11.10 - prodongi
//#ifdef _DEV
//extern bool g_bDebugMode;
//#endif

void SViewPort::RenderTerrain( bool bCheckOcclusionCull )
{
	if( !m_nRenderFlag.IsOn(RENDER_TERRAIN) || m_prListTerrain.size() <= 0 ) return;

	m_dev->ResetPrevDeclarationTechnique();

	int nAllCount  = m_prListTerrain.size();
	int nDrawCount = 0;

	START_DPCOUNT("Terrain");
	m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
	m_dev->SetDepthBufferWriteEnable( true );
	m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 ); 

		K3DCamera camTemp;
		K3DVector vecCam;
		K3DVector vecTar;
		K3DMatrix* pRootMat;
		K3DVector vecTrans;
		//K3DVector4 vec4;

		if(m_bLocalCoord)
		{
			BackUpViewCamera();
			camTemp = m_ViewCamera;
			vecCam = camTemp.GetCamPos();
			vecTar = camTemp.GetTargetPos();
			vecTar -= vecCam;
			camTemp.SetCamPos(0.0f, 0.0f, 0.0f);
			camTemp.SetTargetPos(vecTar.x, vecTar.y, vecTar.z);
			SetCamera(&camTemp);
			m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);

			//vec4.x = vecCam.x;
			//vec4.y = vecCam.y;
			//vec4.z = vecCam.z;
			//vec4.w = 0.0f;

			//m_dev->SetVertexShaderConstant(CONSTANT_LOCALCOORD_OFFSET, (float*) &vec4, 4);
			m_dev->SetLocalCoordOffset( vecCam );
	}
	else
	{
		//vec4.x = 0.0f; vec4.y = 0.0f; vec4.z = 0.0f; vec4.w = 0.0f;
		//m_dev->SetVertexShaderConstant(CONSTANT_LOCALCOORD_OFFSET, (float*) &vec4, 4);
		vecCam.x = 0.0f; vecCam.y = 0.0f; vecCam.z = 0.0f;
		m_dev->SetLocalCoordOffset( vecCam );
	}

		const K3DLight* pLight = GetLight();

		if(pLight != NULL)
		{
			KColor color = (pLight->ambient) / 2.f;
			m_dev->SetTextureFactor(color.color);
		}

	KCustomVector<K3DPrimitive*>::iterator it = m_prListTerrain.begin();

	CTerrainPrimitive* pTerrainPrimitive = static_cast<CTerrainPrimitive*>(*it);
	pTerrainPrimitive->PreRenderPrimitiveGroup(m_dev, this );

	for ( ; it != m_prListTerrain.end() ; ++it )
	{
		if( bCheckOcclusionCull && (*it)->IsOcclusioCulled() ) 
			continue;

		++nDrawCount;

		if(m_bLocalCoord)
		{				
			pRootMat = (*it)->GetRootMat();
			K3DMatrixGetPosVector(vecTrans, *pRootMat);
			vecTrans -= vecCam;
			pRootMat->SetPosVector(vecTrans);

			(*it)->Render( this, m_dev );

			vecTrans += vecCam;
			pRootMat->SetPosVector(vecTrans);
		}
		else
		{
			(*it)->Render( this, m_dev );
		}
	}

	if( m_bLocalCoord )
	{
		RestoreBackUpViewCamera();
		m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
	}
	
	//pTerrainPrimitive->PostRenderPrimitiveGroup(m_dev, this );

	/// 2010.11.10 - prodongi
//#ifdef _DEV
	if (g_UserInfo.isMonkeyTail())
	{
		extern bool g_bDebugMode;
		if( bCheckOcclusionCull && g_bDebugMode && 0 != HIBYTE(GetAsyncKeyState(VK_SHIFT)) && 0 != HIBYTE(GetAsyncKeyState(VK_DOWN)) )
			_oprint( "OcclusionCulling : All[%d] Drawed[%d]\n", nAllCount, nDrawCount );
	}
//#endif
	END_DPCOUNT();
}

void SViewPort::RenderTerrainShadow(SRenderTargetContainer *cont1, SRenderTargetContainer *cont2)
{
	if( m_prListTerrainShadow.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_TERRAIN_SHADOW) )
		{
			m_dev->ResetPrevDeclarationTechnique();

			START_DPCOUNT("Terrain Shadow");
			m_dev->SetRenderState( K3DRenderDevice::RS_SHADOW_MESH );
			m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
			m_dev->SetDepthBufferWriteEnable( true );
			m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 ); 

			m_dev->SetVertexShaderLight( GetLight() );

				K3DCamera camTemp;
				K3DVector vecCam;
				K3DVector vecTar;
				K3DMatrix* pRootMat;
				K3DVector vecTrans;
			//K3DVector4 vec4;

				if(m_bLocalCoord)
				{
					BackUpViewCamera();
					camTemp = m_ViewCamera;
					vecCam = camTemp.GetCamPos();
					vecTar = camTemp.GetTargetPos();
					vecTar -= vecCam;
					camTemp.SetCamPos(0.0f, 0.0f, 0.0f);
					camTemp.SetTargetPos(vecTar.x, vecTar.y, vecTar.z);
					SetCamera(&camTemp);
					m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);

				//vec4.x = vecCam.x;
				//vec4.y = vecCam.y;
				//vec4.z = vecCam.z;
				//vec4.w = 0.0f;

				//m_dev->SetVertexShaderConstant(CONSTANT_LOCALCOORD_OFFSET, (float*) &vec4, 4);
				m_dev->SetLocalCoordOffset( vecCam );
			}
			else
			{
				//vec4.x = 0.0f; vec4.y = 0.0f; vec4.z = 0.0f; vec4.w = 0.0f;
				//m_dev->SetVertexShaderConstant(CONSTANT_LOCALCOORD_OFFSET, (float*) &vec4, 4);
				vecCam.x = 0.0f; vecCam.y = 0.0f; vecCam.z = 0.0f;
				m_dev->SetLocalCoordOffset( vecCam );
			}

			KCustomVector<K3DPrimitive*>::iterator it = m_prListTerrainShadow.begin();
			for ( ; it != m_prListTerrainShadow.end() ; ++it )
			{
				m_dev->SetTexture( 0, cont1 ? cont1->GetRenderTarget(0, (*it)) : NULL );
				m_dev->SetTexture( 1, cont2 ? cont2->GetRenderTarget(0, (*it)) : NULL );
				m_dev->SetTexture( 3, NULL );

				if(m_bLocalCoord)
				{				
					pRootMat = (*it)->GetRootMat();
					K3DMatrixGetPosVector(vecTrans, *pRootMat);
					vecTrans -= vecCam;
					pRootMat->SetPosVector(vecTrans);

					(*it)->Render( this, m_dev );

					vecTrans += vecCam;
					pRootMat->SetPosVector(vecTrans);
				}
				else
				{
					(*it)->Render( this, m_dev );
				}
			}

			if( m_bLocalCoord )
			{
				RestoreBackUpViewCamera();
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
			}

			m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 ); 

			END_DPCOUNT();
		}
	}
}

namespace
{

	enum 
	{
		_STATE_INVALID = 0,
		_STATE_NORMAL_OBJECT,
		_STATE_NORMAL_SKINMESH,
		_STATE_LIGHTMAP,
		_STATE_SPECULAR,
		_STATE_BUMP,
	};

	inline int getStateByOption( bool bUseBump, bool bUseSpecular, bool bSkinMesh, bool bUseLightmap  )
	{
		if(bUseBump)
			return _STATE_BUMP;
		else if( bUseSpecular )
			return _STATE_SPECULAR;
		else if(bUseLightmap)
			return _STATE_LIGHTMAP;
		else if( bSkinMesh )
			return _STATE_NORMAL_SKINMESH;
		else
			return _STATE_NORMAL_OBJECT;
	}

	enum PRALPHALIST_FLAG
	{
		DEFAULT_AHLPHA_BUMP_MAP					= 1 << 1,
		DEFAULT_AHLPHA_BUMP_MAP_SELFSHADOW		= 1 << 2,
		DEFAULT_AHLPHA_BUMP_MAP_NOT_SELFSHADOW	= 1 << 3,
		DEFAULT_AHLPHA_SPECULAR_MAP				= 1 << 4,
		DEFAULT_AHLPHA_LIGHT_MAP				= 1 << 5,
		DEFAULT_AHLPHA_DEFAULT_MAP				= 1 << 6,
		DEFAULT_AHLPHA_DEFAULT_MAP_VSMODE		= 1 << 7,
		DEFAULT_AHLPHA_DEFAULT_MAP_NOT_VSMODE	= 1 << 8,

		ALPHABLENDTWOPASS_BUMP_MAP					= 1 << 9,
		ALPHABLENDTWOPASS_BUMP_MAP_SELFSHADOW		= 1 << 10,
		ALPHABLENDTWOPASS_BUMP_MAP_NOT_SELFSHADOW	= 1 << 11,
		ALPHABLENDTWOPASS_SPECULAR_MAP				= 1 << 12,
		ALPHABLENDTWOPASS_LIGHT_MAP					= 1 << 13,
		ALPHABLENDTWOPASS_DEFAULT_MAP				= 1 << 14,
		ALPHABLENDTWOPASS_DEFAULT_MAP_VSMODE		= 1 << 15,
		ALPHABLENDTWOPASS_DEFAULT_MAP_NOT_VSMODE	= 1 << 16,

		ADDITIVE_SPECULAR_MAP	= 1 << 17,
		ADDITIVE_LIGHT_MAP		= 1 << 18,
		ADDITIVE_DEFAULT_MAP	= 1 << 19,

	};
}

void SViewPort::RenderPrList(vec_rendermesh& renderlist, SRenderTargetContainer *cont1, SRenderTargetContainer *cont2)
{
	if(renderlist.size() <= 0) return;

	std::sort( renderlist.begin(), renderlist.end(), MeshLess() );

	if( m_nRenderFlag.IsOn(RENDER_PRIMITIVE) )
	{
		m_dev->ResetPrevDeclarationTechnique();

		START_DPCOUNT("Normal Primitive");
		m_dev->SetDepthBufferWriteEnable( true );
		m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );

		K3DCamera camTemp;
		K3DVector vecCam;
		K3DVector vecTar;
		K3DMatrix* pRootMat;
		K3DVector vecTrans;
		//K3DVector4 vec4;
		
		if(m_bLocalCoord)
		{
			BackUpViewCamera();
			camTemp = m_ViewCamera;
			vecCam = camTemp.GetCamPos();
			vecTar = camTemp.GetTargetPos();
			vecTar -= vecCam;
			camTemp.SetCamPos(0.0f, 0.0f, 0.0f);
			camTemp.SetTargetPos(vecTar.x, vecTar.y, vecTar.z);
			SetCamera(&camTemp);

			m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
			m_dev->SetLocalCoordOffset( vecCam );
		}
		else
		{
			vecCam.x = 0.0f; vecCam.y = 0.0f; vecCam.z = 0.0f;
			m_dev->SetLocalCoordOffset( vecCam );
		}

		// 현재는 이런 코드로 땜빵하지만, State별로 Sort 하는게 필요할듯..
		DWORD oldState = _STATE_INVALID;
		int	  oldLightIndex = -1;

		const K3DLight* pLight = GetLight();

		if(pLight != NULL)
		{
			KColor color = (pLight->ambient) / 2.f;
			m_dev->SetTextureFactor(color.color);
		}

 		// sonador 1.6.2	프랍 렌더링시 정렬 문제 해결
		int primCount = 0;
		vec_rendermesh::iterator it;
		for ( it = renderlist.begin(); it != renderlist.end() && primCount < MESH_POOL_COUNT; ++it, ++primCount )
		{
			RENDER_MESHEX* pRenderMesh = it;
/*			if( m_dev->VizQueryIssueBegin() && it->primitive->SupportsBoundOcclusion() )
			{
				K3DMatrix world_mat;
				K3DMatrixIdentity( world_mat );

				if(m_bLocalCoord)
				{
					world_mat = *it->primitive->GetRootMat();
					K3DMatrixGetPosVector(vecTrans, world_mat );
					vecTrans -= vecCam;
					world_mat.SetPosVector(vecTrans);
				}

				m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &world_mat );
				it->primitive->RenderBoundOcclusion( this, m_dev );

				if( m_dev->VizQueryIssueEnd() == false )
				{
					oldState = _STATE_INVALID;
					oldLightIndex = -1;
					m_dev->ResetPrevDeclarationTechnique();

					continue;
				}
			}*/

#ifdef _SPECULAR_EDITING_
			DWORD newState = getStateByOption(
				pRenderMesh->bUseBump, 
				pRenderMesh->bUseSpecular,
				pRenderMesh->primitive->GetVSMode(),
				pRenderMesh->bUseLightmap );
#else
			DWORD newState = getStateByOption( pRenderMesh->bUseBump && m_bRenderBumpMap, 
				( pRenderMesh->bUseSpecular || ( pRenderMesh->bUseBump && !m_bRenderBumpMap ) ) && m_nUseSpecular,
				 pRenderMesh->primitive->GetVSMode(),
				 pRenderMesh->bUseLightmap );
#endif

//			if(newState != oldState)
			{
				oldState = newState;

				switch(newState)
				{
				case _STATE_NORMAL_OBJECT:
					m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );
					m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
					m_dev->SetRenderState( K3DRenderDevice::RS_OBJECTSHADOW_SPECULAR2X );
					m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_OBJECTMESH);
					break;

				case _STATE_NORMAL_SKINMESH:
					m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );
					m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
					m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH);
					m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
					break;
				case _STATE_LIGHTMAP:
					m_dev->SetRenderState( K3DRenderDevice::RS_OBJECTSHADOW_LIGHTMAP);
					m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_OBJECTMESH_LIGHTMAP);
					break;

				case _STATE_SPECULAR:
					m_dev->SetRenderState( K3DRenderDevice::RS_MESH_SPECULAR );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
					m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_SPECULAR);
					m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
					break;
				
				case _STATE_BUMP:
					m_dev->SetRenderState( K3DRenderDevice::RS_MESH_SPECULAR );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );

					if(m_bRenderSelfShadow)
					{
						m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_BUMP_SPECULAR_SELFSHADOW );
						m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_SELFSHADOW_AMBIENT_FACTOR, (float*) &m_fSelfShadowAmbientFactor, 1);
					}
					else
					{
						m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_BUMP_SPECULAR );
						m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
					}
					break;
				}
			}

			// 이건 매번 해줘야 하므로..(ATI 때문에-_-)
			switch(newState)
			{
				case _STATE_NORMAL_OBJECT:
					m_dev->SetTexture( 1, cont1 ? cont1->GetRenderTarget(0, pRenderMesh->primitive) : NULL );
					m_dev->SetTexture( 2, cont2 ? cont2->GetRenderTarget(0, pRenderMesh->primitive) : NULL );
					break;
				case _STATE_NORMAL_SKINMESH:
					break;
				 case _STATE_LIGHTMAP:
					 m_dev->SetTexture( 2, cont1 ? cont1->GetRenderTarget(0, pRenderMesh->primitive) : NULL );
					 m_dev->SetTexture( 3, cont2 ? cont2->GetRenderTarget(0, pRenderMesh->primitive) : NULL );
					 break;
				case _STATE_SPECULAR:
					m_dev->SetTexture( 3, cont1 ? cont1->GetRenderTarget(1, pRenderMesh->primitive) : NULL );
					break;
				case _STATE_BUMP:
					if(m_bRenderSelfShadow)
						m_dev->SetTexture( 3, cont1 ? cont1->GetRenderTarget(1, pRenderMesh->primitive) : NULL );
					break;
			}

			//MTE
			if( pRenderMesh->primitive->GetEnableMTE() )
			{
				if( pRenderMesh->primitive->IsSpecular() )
 					m_dev->SetRenderState( K3DRenderDevice::RS_MTE );
				else 
				    m_dev->SetRenderState( K3DRenderDevice::RS_MTE_S1 );
			}

			if(oldLightIndex != pRenderMesh->nLitIndex)
			{
				oldLightIndex = pRenderMesh->nLitIndex;
				m_dev->SetVertexShaderLight(GetLight(oldLightIndex) ) ;
			}

			if(m_bLocalCoord)
			{
				pRootMat = pRenderMesh->primitive->GetRootMat();
				K3DMatrixGetPosVector(vecTrans, *pRootMat);
				vecTrans -= vecCam;
				pRootMat->SetPosVector(vecTrans);
			
				pRenderMesh->primitive->Render( this, m_dev );

				vecTrans += vecCam;
				pRootMat->SetPosVector(vecTrans);
			}
			else
			{
				pRenderMesh->primitive->Render( this, m_dev );
			}
			
			m_dev->SetTexture( 0, NULL );
			m_dev->SetTexture( 1, NULL );
			m_dev->SetTexture( 2, NULL );
			m_dev->SetTexture( 3, NULL );
		}

		if( m_bLocalCoord )
		{
			RestoreBackUpViewCamera();
			m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
		}

		END_DPCOUNT();
	}
}

void SViewPort::RenderPrAlphaList( vec_rendermesh& renderlist, SRenderTargetContainer *cont1, SRenderTargetContainer *cont2)
{
	if(renderlist.size() <= 0) return;

	std::sort( renderlist.begin(), renderlist.end(), TransMeshLess() );

	if( !m_nRenderFlag.IsOn(RENDER_PRIMITIVE_ALPHA) ) return;

	START_DPCOUNT("Primitive Alpha");
	m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );

	m_dev->ResetPrevDeclarationTechnique();

	K3DCamera camTemp;
	K3DVector vecCam;
	K3DVector vecTar;
	K3DMatrix* pRootMat = NULL;

	if(m_bLocalCoord)
	{
		BackUpViewCamera();
		camTemp = m_ViewCamera;
		vecCam = camTemp.GetCamPos();
		vecTar = camTemp.GetTargetPos();
		vecTar -= vecCam;
		camTemp.SetCamPos(0.0f, 0.0f, 0.0f);
		camTemp.SetTargetPos(vecTar.x, vecTar.y, vecTar.z);
		SetCamera(&camTemp);
		m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);

		m_dev->SetLocalCoordOffset( vecCam );
	}
	else
	{
		vecCam.x = 0.0f; vecCam.y = 0.0f; vecCam.z = 0.0f;
		m_dev->SetLocalCoordOffset( vecCam );
	}

	KCustomVector< const RENDER_MESHEX* > m_TopTransMesh;
	KCustomVector< const RENDER_MESHEX* > m_MidTransMesh;
	KCustomVector< const RENDER_MESHEX* > m_BotTransMesh;


	vec_rendermesh::iterator iter = renderlist.begin();
	for( ; iter != renderlist.end() ; )	
	{
		const RENDER_MESHEX *mesh = iter;

		if( mesh->primitive->GetBlendMode() == K3DMaterial::MBM_LQ_WATER ||
			mesh->primitive->GetBlendMode() == K3DMaterial::MBM_HQ_WATER )
		{
			m_MidTransMesh.push_back( mesh );
		}
		else
		{
			//물 높이가 존재 한다면
			if( m_bExistenceWaterHeight )
			{
				const K3DVector &pos = mesh->primitive->GetCenterPosition();
				if( m_fWaterHeight < pos.z )	m_TopTransMesh.push_back( mesh );
				else							m_BotTransMesh.push_back( mesh );
			}
			else
				m_TopTransMesh.push_back( mesh );
		}
		++iter;
	}

	const K3DLight* pLight = GetLight();

	if(pLight != NULL)
	{
		KColor color = (pLight->ambient) / 2.f;
		m_dev->SetTextureFactor(color.color);
	}

	SetOldBlendMode( K3DMaterial::MBM_MAX, true );

	if( m_bInsideWater )
	{
		RenderPrAlphaList( cont1, cont2, m_TopTransMesh, vecCam, false );
		RenderPrAlphaList( cont1, cont2, m_MidTransMesh, vecCam, false );
		RenderPrAlphaList( cont1, cont2, m_BotTransMesh, vecCam, false );

		RenderPrAlphaList( cont1, cont2, m_TopTransMesh, vecCam, true  );
		RenderPrAlphaList( cont1, cont2, m_MidTransMesh, vecCam, true  );
		RenderPrAlphaList( cont1, cont2, m_BotTransMesh, vecCam, true  );
	}
	else
	{
		RenderPrAlphaList( cont1, cont2, m_BotTransMesh, vecCam, false );
		RenderPrAlphaList( cont1, cont2, m_MidTransMesh, vecCam, false );
		RenderPrAlphaList( cont1, cont2, m_TopTransMesh, vecCam, false );

		RenderPrAlphaList( cont1, cont2, m_BotTransMesh, vecCam, true  );
		RenderPrAlphaList( cont1, cont2, m_MidTransMesh, vecCam, true  );
		RenderPrAlphaList( cont1, cont2, m_TopTransMesh, vecCam, true  );
	}

	if( m_bLocalCoord )
	{
		RestoreBackUpViewCamera();
		m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
	}

	m_TopTransMesh.clear();
	m_MidTransMesh.clear();
	m_BotTransMesh.clear();

	END_DPCOUNT();
}

void SViewPort::RenderPrAlphaList(SRenderTargetContainer *cont1, SRenderTargetContainer *cont2, KCustomVector< const RENDER_MESHEX* > & vMesh, K3DVector & vecCam, bool bEnableAdditive )
{
	DWORD old_cull_mode;

	int nBlendMode = K3DMaterial::MBM_MAX;
	for( int it = 0; it < vMesh.size(); it++ )
	{
		K3DVector vecTrans;
		K3DMatrix* pRootMat;

		const RENDER_MESHEX *mesh = vMesh[it];
		const RENDER_MESHEX *render_mesh;

/*		if( m_dev->VizQueryIssueBegin() && mesh->primitive->SupportsBoundOcclusion() )
		{
			K3DMatrix world_mat;
			K3DMatrixIdentity( world_mat );

			if(m_bLocalCoord)
			{
				world_mat = *mesh->primitive->GetRootMat();
				K3DMatrixGetPosVector(vecTrans, world_mat );
				vecTrans -= vecCam;
				world_mat.SetPosVector(vecTrans);
			}

			m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &world_mat );
			mesh->primitive->RenderBoundOcclusion( this, m_dev );

			if( m_dev->VizQueryIssueEnd() == false )
			{
				m_dev->ResetPrevDeclarationTechnique();

				continue;
			}
		}*/

		SetOldBlendMode( nBlendMode ); //이전 BlendMode 저장
		nBlendMode = mesh->primitive->GetBlendMode();

		if( bEnableAdditive )
		{
			if( nBlendMode != K3DMaterial::MBM_ADDITIVE &&
			    nBlendMode != K3DMaterial::MBM_ADDTIVE_BILLBOARD &&
			    nBlendMode != K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_ADD &&
			    nBlendMode != K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_BLEND_ADD )
			{
				SetOldBlendFlag();
				continue;				
			}
		}
		else
		{
			if( nBlendMode == K3DMaterial::MBM_ADDITIVE ||
				nBlendMode == K3DMaterial::MBM_ADDTIVE_BILLBOARD ||
				nBlendMode == K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_ADD ||
				nBlendMode == K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_BLEND_ADD )
			{
				SetOldBlendFlag();
				continue;
			}
		}

		if( nBlendMode == K3DMaterial::MBM_DEFAULT || nBlendMode == K3DMaterial::MBM_ALPHABLEND )
		{
			if( m_nOldBlendMode != K3DMaterial::MBM_DEFAULT &&
				m_nOldBlendMode != K3DMaterial::MBM_ALPHABLEND )
			{
				if ( m_fogMode != K3DRenderDevice::FOGM_NONE )
					m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
			}

			if( m_nOldBlendMode != nBlendMode )
			{
				if( nBlendMode == K3DMaterial::MBM_DEFAULT )
					m_dev->SetDepthBufferWriteEnable( true );
				else
					m_dev->SetDepthBufferWriteEnable( false );
			}

			if( mesh->bUseBump && m_bRenderBumpMap )
			{
				if( ( m_nOldBlend_Flag & DEFAULT_AHLPHA_BUMP_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_MESH_SPECULAR );
					m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );

					m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR,		&m_fSkinAmbientFactor,	1);
					m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR,		&m_fSkinDiffuseFactor,	1);
					m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR,	&m_fSkinSpecularFactor, 1);
				}

				if( m_bRenderSelfShadow )
				{
					m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_BUMP_SPECULAR_SELFSHADOW );
					if( ( m_nOldBlend_Flag & DEFAULT_AHLPHA_BUMP_MAP_SELFSHADOW ) == false )
					{
						m_dev->SetVertexShaderConstant(CONSTANT_SELFSHADOW_AMBIENT_FACTOR, (float*) &m_fSelfShadowAmbientFactor, 1);
					}

					m_dev->SetTexture( 1, NULL );
					m_dev->SetTexture( 2, NULL );
					m_dev->SetTexture( 3, cont1 ? cont1->GetRenderTarget(1, mesh->primitive) : NULL );

					SetOldBlendFlag( DEFAULT_AHLPHA_BUMP_MAP | DEFAULT_AHLPHA_BUMP_MAP_SELFSHADOW );
				}
				else
				{
					m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_BUMP_SPECULAR );
					
					m_dev->SetTexture( 1, NULL );
					m_dev->SetTexture( 2, NULL );
					m_dev->SetTexture( 3, NULL );

					SetOldBlendFlag( DEFAULT_AHLPHA_BUMP_MAP | DEFAULT_AHLPHA_BUMP_MAP_NOT_SELFSHADOW );
				}
			}
			else if( ( mesh->bUseSpecular || ( mesh->bUseBump && !m_bRenderBumpMap ) ) && m_nUseSpecular )
			{
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_SPECULAR);
				if( ( m_nOldBlend_Flag & DEFAULT_AHLPHA_SPECULAR_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_MESH_SPECULAR );
					m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH );
				//	m_dev->SetRenderState( K3DRenderDevice::RS_ALPHATEST );				//gmbpigsun( 20130117 )
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
										
					m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
				}

				m_dev->SetTexture( 1, NULL );
				m_dev->SetTexture( 2, NULL );
				m_dev->SetTexture( 3, cont1 ? cont1->GetRenderTarget(1, mesh->primitive) : NULL );

				SetOldBlendFlag( DEFAULT_AHLPHA_SPECULAR_MAP );
				
			}
			else if(mesh->bUseLightmap)
			{
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_OBJECTMESH_LIGHTMAP);
				if( ( m_nOldBlend_Flag & DEFAULT_AHLPHA_LIGHT_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_OBJECTSHADOW_LIGHTMAP);
					m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH );
				}

				m_dev->SetTexture( 2, cont1 ? cont1->GetRenderTarget(0, mesh->primitive) : NULL );
				m_dev->SetTexture( 3, cont2 ? cont2->GetRenderTarget(0, mesh->primitive) : NULL );

				SetOldBlendFlag( DEFAULT_AHLPHA_LIGHT_MAP );
			}
			else
			{
				if( ( m_nOldBlend_Flag & DEFAULT_AHLPHA_DEFAULT_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );
					m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
				}

				if(mesh->primitive->GetVSMode())
				{
					m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH);
					if( ( m_nOldBlend_Flag & DEFAULT_AHLPHA_DEFAULT_MAP_VSMODE ) == false )
					{
						m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
						m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
					}

					SetOldBlendFlag( DEFAULT_AHLPHA_DEFAULT_MAP | DEFAULT_AHLPHA_DEFAULT_MAP_VSMODE );
				}
				else
				{
					m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_OBJECTMESH);
					if( ( m_nOldBlend_Flag & DEFAULT_AHLPHA_DEFAULT_MAP_NOT_VSMODE ) == false )
					{
						m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
						m_dev->SetRenderState( K3DRenderDevice::RS_OBJECTSHADOW_SPECULAR2X );
					}

					m_dev->SetTexture( 1, cont1 ? cont1->GetRenderTarget(0, mesh->primitive) : NULL );
					m_dev->SetTexture( 2, cont2 ? cont2->GetRenderTarget(0, mesh->primitive) : NULL );
					m_dev->SetTexture( 3, NULL );

					SetOldBlendFlag( DEFAULT_AHLPHA_DEFAULT_MAP | DEFAULT_AHLPHA_DEFAULT_MAP_NOT_VSMODE  );
				}
			}
		}
		else if( nBlendMode == K3DMaterial::MBM_ALPHABLEND_NOALPHAUVANI )
		{
			m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_NOUVANIIN2NDTEX );
			if( m_nOldBlendMode != nBlendMode )
			{
				if( m_fogMode != K3DRenderDevice::FOGM_NONE )
					m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );

				m_dev->SetDepthBufferWriteEnable( false );

				m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );
				m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH_NOALPHAUVANI );
				m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );

				m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
				m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
				m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
			}

			SetOldBlendFlag();
		}
		else if( nBlendMode == K3DMaterial::MBM_ALPHABLEND_NOCOLORUVANI )
		{
			m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_NOUVANIIN2NDTEX );
			if( m_nOldBlendMode != nBlendMode )
			{
				if( m_fogMode != K3DRenderDevice::FOGM_NONE )
					m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );

				m_dev->SetDepthBufferWriteEnable( false );

				m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );
				m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH_NOCOLORUVANI );
				m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );

				m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
				m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
				m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
			}

			SetOldBlendFlag();
		}
		else if( nBlendMode == K3DMaterial::MBM_ALPHABLENDTWOPASS )
		{
			if( m_nOldBlendMode != nBlendMode )
			{
				if ( m_fogMode != K3DRenderDevice::FOGM_NONE )
				{
					m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
				}
			}

			if( mesh->bUseBump && m_bRenderBumpMap )
			{
				if( ( m_nOldBlend_Flag & ALPHABLENDTWOPASS_BUMP_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_MESH_SPECULAR );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
					//m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH );
				}

				if( m_bRenderSelfShadow )
				{
					m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_BUMP_SPECULAR_SELFSHADOW );
					if( ( m_nOldBlend_Flag & ALPHABLENDTWOPASS_BUMP_MAP_SELFSHADOW ) == false )
					{
						m_dev->SetVertexShaderConstant(CONSTANT_SELFSHADOW_AMBIENT_FACTOR, (float*) &m_fSelfShadowAmbientFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
					}

					m_dev->SetTexture( 1, NULL );
					m_dev->SetTexture( 2, NULL );
					m_dev->SetTexture( 3, cont1 ? cont1->GetRenderTarget(1, mesh->primitive) : NULL );

					SetOldBlendFlag( ALPHABLENDTWOPASS_BUMP_MAP | ALPHABLENDTWOPASS_BUMP_MAP_SELFSHADOW );
				}
				else
				{
					m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_BUMP_SPECULAR );
					if( ( m_nOldBlend_Flag & ALPHABLENDTWOPASS_BUMP_MAP_NOT_SELFSHADOW ) == false )
					{
						m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
					}

					m_dev->SetTexture( 1, NULL );
					m_dev->SetTexture( 2, NULL );
					m_dev->SetTexture( 3, NULL );

					SetOldBlendFlag( ALPHABLENDTWOPASS_BUMP_MAP | ALPHABLENDTWOPASS_BUMP_MAP_NOT_SELFSHADOW );
				}
			}
			else if( ( mesh->bUseSpecular || ( mesh->bUseBump && !m_bRenderBumpMap ) ) && m_nUseSpecular )
			{
				//헤어
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_SPECULAR);
				if( ( m_nOldBlend_Flag & ALPHABLENDTWOPASS_SPECULAR_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_MESH_SPECULAR );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
					//m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH );		
				
					m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
				}

				m_dev->SetTexture( 1, NULL );
				m_dev->SetTexture( 2, NULL );
				m_dev->SetTexture( 3, cont1 ? cont1->GetRenderTarget(1, mesh->primitive) : NULL );

				SetOldBlendFlag( ALPHABLENDTWOPASS_SPECULAR_MAP );
			}
			else if(mesh->bUseLightmap)
			{
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_OBJECTMESH_LIGHTMAP);
				if( ( m_nOldBlend_Flag & ALPHABLENDTWOPASS_LIGHT_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_OBJECTSHADOW_LIGHTMAP);
					//m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH );
				}

				m_dev->SetTexture( 2, cont1 ? cont1->GetRenderTarget(0, mesh->primitive) : NULL );
				m_dev->SetTexture( 3, cont2 ? cont2->GetRenderTarget(0, mesh->primitive) : NULL );

				SetOldBlendFlag( ALPHABLENDTWOPASS_LIGHT_MAP );
			}
			else
			{
				if( ( m_nOldBlend_Flag & ALPHABLENDTWOPASS_DEFAULT_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
					//m_dev->SetRenderState( K3DRenderDevice::RS_TRANSPARENT_MESH );
				}
								
				if(mesh->primitive->GetVSMode())
				{
					m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH);
					if( ( m_nOldBlend_Flag & ALPHABLENDTWOPASS_DEFAULT_MAP_VSMODE ) == false )
					{
						m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
						m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
						m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
					}

					SetOldBlendFlag( ALPHABLENDTWOPASS_DEFAULT_MAP | ALPHABLENDTWOPASS_DEFAULT_MAP_VSMODE );
				}
				else
				{
					m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_OBJECTMESH);
					if( ( m_nOldBlend_Flag & ALPHABLENDTWOPASS_DEFAULT_MAP_NOT_VSMODE ) == false )
					{
						m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
						m_dev->SetRenderState( K3DRenderDevice::RS_OBJECTSHADOW_SPECULAR2X );
					}

					m_dev->SetTexture( 1, cont1 ? cont1->GetRenderTarget(0, mesh->primitive) : NULL );
					m_dev->SetTexture( 2, cont2 ? cont2->GetRenderTarget(0, mesh->primitive) : NULL );
					m_dev->SetTexture( 3, NULL );

					SetOldBlendFlag( ALPHABLENDTWOPASS_DEFAULT_MAP | ALPHABLENDTWOPASS_DEFAULT_MAP_NOT_VSMODE );
				}
			}

			//이건 그냥 매번해주자
			if( mesh->nPass == 0 )
			{
				m_dev->SetDepthBufferWriteEnable( true );
				m_dev->SetRenderState( K3DRenderDevice::RS_ALPHABLEND_1STPASS );
			}
			else
			{
				m_dev->SetDepthBufferWriteEnable( false );
				m_dev->SetRenderState( K3DRenderDevice::RS_ALPHABLEND_2NDPASS );
			}
		}
		else if( nBlendMode == K3DMaterial::MBM_ADDITIVE)
		{
			if( m_nOldBlendMode != nBlendMode )
			{
				m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
				m_dev->SetDepthBufferWriteEnable( false );
			}

			if(mesh->bUseSpecular)
			{
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_SPECULAR);
				if( ( m_nOldBlend_Flag & ADDITIVE_SPECULAR_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_ADDITIVE_MESH );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
					m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );

					m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
				}

				m_dev->SetTexture( 1, NULL );
				m_dev->SetTexture( 2, NULL );
				m_dev->SetTexture( 3, NULL );

				SetOldBlendFlag( ADDITIVE_SPECULAR_MAP );
			}
			else if(mesh->bUseLightmap)
			{
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_OBJECTMESH_LIGHTMAP);
				if( ( m_nOldBlend_Flag & ADDITIVE_LIGHT_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_OBJECTSHADOW_LIGHTMAP);
					m_dev->SetRenderState( K3DRenderDevice::RS_ADDITIVE_MESH_WITHOUT_DEFAULT );
					m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );
				}

				m_dev->SetTexture( 2, cont1 ? cont1->GetRenderTarget(0, mesh->primitive) : NULL );
				m_dev->SetTexture( 3, cont2 ? cont2->GetRenderTarget(0, mesh->primitive) : NULL );

				SetOldBlendFlag( ADDITIVE_LIGHT_MAP );
			}
			else
			{
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH);
				if( ( m_nOldBlend_Flag & ADDITIVE_DEFAULT_MAP ) == false )
				{
					m_dev->SetRenderState( K3DRenderDevice::RS_ADDITIVE_MESH );
					m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
					m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );

					m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
					m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
				}

				m_dev->SetTexture( 1, cont1 ? cont1->GetRenderTarget(0, mesh->primitive) : NULL );
				m_dev->SetTexture( 2, cont2 ? cont2->GetRenderTarget(0, mesh->primitive) : NULL );
				m_dev->SetTexture( 3, NULL );

				SetOldBlendFlag( ADDITIVE_DEFAULT_MAP );
			}
		}
		else if( nBlendMode == K3DMaterial::MBM_ADDITIVE_NOALPHAUVANI )
		{
			SetOldBlendFlag();

			m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_NOUVANIIN2NDTEX );
			if( m_nOldBlendMode != nBlendMode )
			{
				m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
				m_dev->SetDepthBufferWriteEnable( false );

				m_dev->SetRenderState( K3DRenderDevice::RS_ADDITIVE_MESH_NOALPHAUVANI );
				m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
				m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );

				m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
				m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
				m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
			}
		}
		else if( nBlendMode == K3DMaterial::MBM_ADDITIVE_NOCOLORUVANI )
		{
			m_dev->SetVertexShader( VTXDECLARATION_SKINMESH, TECHNIQUE_SKINMESH_NOUVANIIN2NDTEX );
			if( m_nOldBlendMode != nBlendMode )
			{
				m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
				m_dev->SetDepthBufferWriteEnable( false );

				m_dev->SetRenderState( K3DRenderDevice::RS_ADDITIVE_MESH_NOCOLORUVANI );
				m_dev->SetRenderState( K3DRenderDevice::RS_DISABLE_UVTRANSFORM );
				m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );

				m_dev->SetVertexShaderConstant(CONSTANT_AMBIENT_FACTOR, &m_fSkinAmbientFactor, 1);
				m_dev->SetVertexShaderConstant(CONSTANT_DIFFUSE_FACTOR, &m_fSkinDiffuseFactor, 1);
				m_dev->SetVertexShaderConstant(CONSTANT_SPECULAR_FACTOR, &m_fSkinSpecularFactor, 1);
			}

			SetOldBlendFlag();
		}
		else if( nBlendMode == K3DMaterial::MBM_BILLBOARD)
		{
			SetOldBlendFlag();

			if( m_nOldBlendMode != nBlendMode )
			{
				m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
				m_dev->SetDepthBufferWriteEnable( false );
				m_dev->SetRenderState( K3DRenderDevice::RS_BILLBOARD );
			}

			m_dev->SetTransformIdentity( K3DRenderDevice::TS_WORLD );
		}
		else if( nBlendMode == K3DMaterial::MBM_ADDTIVE_BILLBOARD)
		{
			SetOldBlendFlag();

			if( m_nOldBlendMode != nBlendMode )
			{
				m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
				m_dev->SetDepthBufferWriteEnable( false );
				m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
				m_dev->SetRenderState( K3DRenderDevice::RS_ADDITIVE_PARTICLE );
			}

			m_dev->SetTransformIdentity( K3DRenderDevice::TS_WORLD );
		}
		else if( nBlendMode == K3DMaterial::MBM_SELECT_FX)
		{
			SetOldBlendFlag();

			render_mesh = mesh;

			if( m_nOldBlendMode != nBlendMode )
			{
				m_dev->SetRenderState(K3DRenderDevice::RS_DEFAULT);
				m_dev->SetDepthBufferWriteEnable( false );
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_SELECT_TARGET_FX);
				m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
		
				m_dev->SetRenderState( K3DRenderDevice::RS_SELECT_EFFECT );
				K3DVector4 uvani(0.f, 0.f, 0, 1.f );
				m_dev->SetVertexShaderConstant(CONSTANT_UVANIMATION, (float *)&uvani, 4);
			}

			pRootMat = render_mesh->primitive->GetRootMat();
			K3DMatrixGetPosVector(vecTrans, *pRootMat);
			vecTrans -= vecCam;
			K3DMatrix matWorld;
			K3DMatrixTranslation( matWorld, vecTrans.x, vecTrans.y, vecTrans.z );
			m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &matWorld );

			render_mesh->primitive->Render( this, m_dev );

			//m_dev->SetRenderState(K3DRenderDevice::RS_DEFAULT);

			//continue;
			goto SET_NULLTEXTURE;
		}
		else if( nBlendMode == K3DMaterial::MBM_LQ_WATER)
		{
			SetOldBlendFlag();

			render_mesh = mesh;

			//if( !m_bLocalCoord ) continue;
			if( !m_bLocalCoord ) goto SET_NULLTEXTURE;

			old_cull_mode = m_dev->GetCullMode();
			m_dev->SetCullMode( K3DRenderDevice::KCM_NONE );

			//IDirect3DDevice9* pD3dDevice = ((K3DRenderDeviceDX*) m_dev)->GetD3DDevice();
			//pD3dDevice->SetRenderState( D3DRS_FOGENABLE, TRUE );

			if( m_nOldBlendMode != nBlendMode )
			{
				if ( m_fogMode != K3DRenderDevice::FOGM_NONE )
				{
					m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
				}

				m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );
				m_dev->SetRenderState( K3DRenderDevice::RS_LQWATER );
				m_dev->SetDepthBufferWriteEnable( false );
				m_dev->SetVertexShader(VTXDECLARATION_WATER, TECHNIQUE_WATER_SPECULAR);
				m_dev->SetVertexShaderLight( GetLight() );
			}

			K3DMatrix mat;
			K3DMatrixIdentity(mat);
			m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &mat );
			K3DMatrix	matWorld	= *mesh->primitive->GetTransform();;
			K3DVector	vOripos		= K3DVector( matWorld._41, matWorld._42, matWorld._43 );
			vOripos					= vOripos - vecCam;

			K3DMatrixTranslation( matWorld, vOripos.x, vOripos.y, vOripos.z );
			m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &matWorld );

			render_mesh->primitive->Render( this, m_dev );

			//m_dev->SetRenderState(K3DRenderDevice::RS_DEFAULT);
			m_dev->SetCullMode( old_cull_mode );

			//continue;
			goto SET_NULLTEXTURE;
		}
		else if( nBlendMode == K3DMaterial::MBM_HQ_WATER )
		{
			SetOldBlendFlag();

			//if( !DrawWater() ) continue;
			if( !DrawWater() ) goto SET_NULLTEXTURE;

			m_dev->SetDepthBufferWriteEnable( false );
			m_dev->SetVertexShader( VTXDECLARATION_WATER, TECHNIQUE_HQWATER );
			//m_dev->SetVertexShaderDefault();

			IDirect3DDevice9* pD3dDevice = ((K3DRenderDeviceDX*) m_dev)->GetD3DDevice();
			pD3dDevice->SetRenderState( D3DRS_FOGENABLE, TRUE );

			//K3DMatrix matWorld, matView, matProj;
			//matWorld	= *m_dev->GetTransform( K3DRenderDevice::TS_WORLD );
			//matView		= *m_dev->GetTransform( K3DRenderDevice::TS_VIEW );
			//matProj		= *m_dev->GetTransform( K3DRenderDevice::TS_PROJECTION );

			//K3DMatrix matIdent;
			//K3DMatrixIdentity( matIdent );
			//m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &matIdent );
			//m_dev->SetTransform( K3DRenderDevice::TS_VIEW, &matIdent );
			//m_dev->SetTransform( K3DRenderDevice::TS_PROJECTION, &matIdent );

			//m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &matWorld );
			//m_dev->SetTransform( K3DRenderDevice::TS_VIEW, &matView );
			//m_dev->SetTransform( K3DRenderDevice::TS_PROJECTION, &matProj );

			pRootMat = mesh->primitive->GetRootMat();
			K3DMatrixGetPosVector(vecTrans, *pRootMat);
			vecTrans -= vecCam;
			pRootMat->SetPosVector(vecTrans);

			render_mesh = mesh;
			render_mesh->primitive->Render( this, m_dev );

			vecTrans += vecCam;
			pRootMat->SetPosVector(vecTrans);

			//m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &matWorld );
			//m_dev->SetTransform( K3DRenderDevice::TS_VIEW, &matView );
			//m_dev->SetTransform( K3DRenderDevice::TS_PROJECTION, &matProj );

			//반사맵 렌더 후 디폴트로 설정
			m_dev->SetRenderState( K3DRenderDevice::RS_DEFAULT );

			//위에 디폴트땜시 다시 설정해 줘야 한다
			m_dev->SetDepthBufferWriteEnable( false );
			m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
			m_dev->SetCullMode(K3DRenderDevice::KCM_CCW);

			//continue;
			goto SET_NULLTEXTURE;
		}
		else if( nBlendMode == K3DMaterial::MBM_CIRCLE_FX)
		{
			SetOldBlendFlag();

			if( m_nOldBlendMode != nBlendMode )
			{
				m_dev->SetRenderState( K3DRenderDevice::RS_LOWSHADOW);
				m_dev->SetDepthBufferWriteEnable( false );
				m_dev->SetVertexShader(VTXDECLARATION_SKINMESH, TECHNIQUE_OBJECTMESH);
				m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );		
			}

			render_mesh = mesh;
		}
#ifdef _DEBUG
		else if( nBlendMode == K3DMaterial::MBM_ENVMAP) 
		{
			SetOldBlendFlag();

			render_mesh = mesh;
			m_dev->SetRenderState(K3DRenderDevice::RS_DEFAULT);

			if( !DrawWater() ) goto SET_NULLTEXTURE;

			m_dev->SetDepthBufferWriteEnable( false );
			m_dev->SetVertexShader(VTXDECLARATION_ENVMAP, TECHNIQUE_ENVMAP);
			m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );

			pRootMat = render_mesh->primitive->GetRootMat();
			K3DMatrixGetPosVector(vecTrans, *pRootMat);
			vecTrans -= vecCam;
			K3DMatrix matWorld;
			K3DMatrixTranslation( matWorld, vecTrans.x, vecTrans.y, vecTrans.z );
			m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &matWorld );

			render_mesh->primitive->Render( this, m_dev );

			vecTrans += vecCam;
			pRootMat->SetPosVector(vecTrans);

			m_dev->SetRenderState(K3DRenderDevice::RS_DEFAULT);

			continue;
		}
#endif
		else if (  (nBlendMode == K3DMaterial::MBM_ALPHATEX )
				|| (nBlendMode == K3DMaterial::MBM_ALPHATEX_EDGEENHANCE)
				|| (nBlendMode == K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_BLEND)
				|| (nBlendMode == K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_ADD)
				|| (nBlendMode == K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_BLEND_ADD)) {
			// Colored-textured and alpha blended, with fog

			SetOldBlendFlag();

			if( m_nOldBlendMode != nBlendMode )
			{
				// TEMPORARY : disable fog for alpha-...
				m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
				m_dev->SetDepthBufferWriteEnable( false );		// Disable depth buffer modification

				switch ( nBlendMode ) {
					case K3DMaterial::MBM_ALPHATEX_EDGEENHANCE:
						m_dev->SetRenderState(K3DRenderDevice::RS_ALPHATEX);
						m_dev->SetVertexShader(VTXDECLARATION_ALPHATEX, TECHNIQUE_ALPHATEX_EDGEENHANCE);
						break;

					case K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_BLEND:
						m_dev->SetRenderState(K3DRenderDevice::RS_ALPHATEX);
						m_dev->SetVertexShader(VTXDECLARATION_ALPHATEX, TECHNIQUE_ALPHATEX_EDGEENHANCE_BLEND);
						break;

					case K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_ADD:
						m_dev->SetRenderState(K3DRenderDevice::RS_ALPHATEX_ADD);
						m_dev->SetVertexShader(VTXDECLARATION_ALPHATEX, TECHNIQUE_ALPHATEX_EDGEENHANCE);
						break;

					case K3DMaterial::MBM_ALPHATEX_EDGEENHANCE_BLEND_ADD:
						m_dev->SetRenderState(K3DRenderDevice::RS_ALPHATEX_ADD);
						m_dev->SetVertexShader(VTXDECLARATION_ALPHATEX, TECHNIQUE_ALPHATEX_EDGEENHANCE_BLEND);
						break;

					case K3DMaterial::MBM_ALPHATEX:
					default:
						m_dev->SetRenderState(K3DRenderDevice::RS_ALPHATEX);
						m_dev->SetVertexShader(VTXDECLARATION_ALPHATEX, TECHNIQUE_ALPHATEX);
				}
			}

			m_dev->SetTexture( 1, NULL );
			m_dev->SetTexture( 2, NULL );
			m_dev->SetTexture( 3, NULL );
			m_dev->SetTexture( 4, NULL );
		}

		//MTE
		if( mesh->primitive->GetEnableMTE() )
		{
			if( mesh->primitive->IsSpecular() )
				m_dev->SetRenderState( K3DRenderDevice::RS_MTE );
			else 
			    m_dev->SetRenderState( K3DRenderDevice::RS_MTE_S1 );
		}
		

		render_mesh = mesh;

		//  KMeshPrimitive에서 매번해주는걸 뺐기 때문에.
		m_dev->SetVertexShaderLight(GetLight(render_mesh->nLitIndex ) );

		if(m_bLocalCoord)
		{
			pRootMat = (render_mesh->primitive)->GetRootMat();
			K3DMatrixGetPosVector(vecTrans, *pRootMat);
			vecTrans -= vecCam;
			pRootMat->SetPosVector(vecTrans);

			render_mesh->primitive->Render( this, m_dev );

			vecTrans += vecCam;
			pRootMat->SetPosVector(vecTrans);
		}
		else
		{
			render_mesh->primitive->Render( this, m_dev );
		}

SET_NULLTEXTURE:
		m_dev->SetTexture( 0, NULL );
		m_dev->SetTexture( 1, NULL );
		m_dev->SetTexture( 2, NULL );
		m_dev->SetTexture( 3, NULL );
	}
}

void SViewPort::SetOldBlendMode( int nBlendMode, bool bReset )
{
	if( bReset )
	{
		m_nOldBlendMode		= K3DMaterial::MBM_MAX;
		m_nOldBlend_Flag	= 0;
	}
	else
	{
		if( ( m_nOldBlendMode == K3DMaterial::MBM_ALPHABLEND || m_nOldBlendMode == K3DMaterial::MBM_DEFAULT ) &&
			( nBlendMode == K3DMaterial::MBM_ALPHABLEND || nBlendMode == K3DMaterial::MBM_DEFAULT ) )
		{
		}
		else if( m_nOldBlendMode != K3DMaterial::MBM_MAX && 
				 m_nOldBlendMode != nBlendMode )
		{
			SetOldBlendFlag( 0 );
		}

		m_nOldBlendMode = nBlendMode;
	}
}

void SViewPort::SetOldBlendFlag( int nFlag )
{
	m_nOldBlend_Flag = nFlag;
}

void SViewPort::RenderPrAdditiveList(SRenderTargetContainer *cont1, SRenderTargetContainer *cont2)
{
}

void SViewPort::RenderBranch(bool renderTransparentOrOpaque)	// true : render opqaue only, false : render transparent only
{
	if( m_prListBranch.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_SPEED_TREE) )
		{
			m_dev->ResetPrevDeclarationTechnique();

			START_DPCOUNT("Branch");

			if (renderTransparentOrOpaque) {
				// Transparent polygon
				m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_TREE_ALPHABLEND );
			} else {
				// Opaque polygon
				m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_TREE_NONALPHABLEND );
			}

//			m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
			((K3DRenderDeviceDX*)m_dev)->SetVertexShaderBranch();

			//K3DMatrix TrBlendShaderMatrix;
			//K3DMatrixTranspose( &TrBlendShaderMatrix, &m_matBlendShader );
			//m_dev->SetVertexShaderConstant( c_nVertexShader_CompoundMatrix, &TrBlendShaderMatrix, 4 );

			K3DCamera camTemp;
			K3DVector vecCam;
			K3DVector vecTar;
			K3DMatrix* pRootMat;
			K3DVector vecTrans;
			K3DVector4 vec4;
			float fFogOfsZ = 0.0f;

			if( m_bLocalCoord )
			{
				BackUpViewCamera();
				camTemp = m_ViewCamera;
				vecCam = camTemp.GetCamPos();
				vecTar = camTemp.GetTargetPos();
				vecTar -= vecCam;
				camTemp.SetCamPos(0.0f, 0.0f, 0.0f);
				camTemp.SetTargetPos(vecTar.x, vecTar.y, vecTar.z);
				SetCamera(&camTemp);
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
				
				K3DMatrix BlendShaderMatrix, TrBlendShaderMatrix;
				K3DMatrixMultiply(BlendShaderMatrix, m_matView, m_matProjection);
				K3DMatrixTranspose( TrBlendShaderMatrix, BlendShaderMatrix );
				m_dev->SetVertexShaderConstant( c_nVertexShader_CompoundMatrix, &TrBlendShaderMatrix, 4 );

				fFogOfsZ = vecCam.z;
			}

#ifdef WRAPPER_USE_FOG
			D3DXVECTOR4 vecConstant1(m_fogFactor1, m_fogFactor2, (1.0f / (m_fogFactor2 - m_fogFactor1)), 0.0f);
			m_dev->SetVertexShaderConstant( c_nVertexShader_Fog1, (float*)&vecConstant1, 1 );
			D3DXVECTOR4 vecConstant2(m_fogFactor3 - fFogOfsZ, m_fogFactor4 - fFogOfsZ, (1.0f / (m_fogFactor4 - m_fogFactor3)), 0.0f);
			m_dev->SetVertexShaderConstant( c_nVertexShader_Fog2, (float*)&vecConstant2, 1 );
#endif

			KCustomVector<K3DPrimitive*>::iterator it = m_prListBranch.begin();
			for ( ; it != m_prListBranch.end() ; ++it )
			{
				// 투명모드인가 아닌가
				if ((*it)->IsTransparent()!=renderTransparentOrOpaque) continue;

				{
					const K3DLight* pLight = GetLight((*it)->GetLightIndex());
					
					K3DVector litdir;
					if(pLight->type == K3DLight::LT_POINT)
					{
                        K3DVector *pos = (K3DVector*)&(*it)->GetTransform()->_41;
                        //litdir = GetLight(0)->position - *pos;
						litdir = pLight->position - *pos;
					}
					else if(pLight->type == K3DLight::LT_DIRECTIONAL)
					{
						//litdir = GetLight(0)->direction;
						litdir = pLight->direction * -1.0f;
					}
					else
					{
						assert(0 && "포인트, 디렉셔널 타입 외의 광원은 지원하지 않음.");
					}

					//K3DVector litdir = GetLight(1)->position - *pos;	// 임시코드
					Normalize(litdir);

					// setup shader constants for light
					const float afLighting[] =
					{
							litdir.x, litdir.y, litdir.z, 1.0f,				// [71] normalized light direction
							//1.0f, 0.0f, 0.0f, 1.0f,					// 임시 코드
							//GetLight(0)->ambient.r, GetLight(0)->ambient.g, GetLight(0)->ambient.b, GetLight(0)->ambient.a, // [72] light ambient color
							pLight->ambient.r, pLight->ambient.g, pLight->ambient.b, pLight->ambient.a, // [72] light ambient color
							//GetLight(0)->diffuse.r, GetLight(0)->diffuse.g, GetLight(0)->diffuse.b, GetLight(0)->diffuse.a	// [73] light diffuse color
							pLight->diffuse.r, pLight->diffuse.g, pLight->diffuse.b, pLight->diffuse.a	// [73] light diffuse color
					};

					m_dev->SetVertexShaderConstant( c_nVertexShader_Light, afLighting, 3 );
				}

				if(m_bLocalCoord)
				{
					pRootMat = (*it)->GetRootMat();
					K3DMatrixGetPosVector(vecTrans, *pRootMat);
					vecTrans -= vecCam;
					pRootMat->SetPosVector(vecTrans);

					(*it)->Render( this, m_dev );

					vecTrans += vecCam;
					pRootMat->SetPosVector(vecTrans);
				}
				else
				{
					(*it)->Render( this, m_dev );
				}
			}

			if( m_bLocalCoord )
			{
				RestoreBackUpViewCamera();
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
			}

			END_DPCOUNT();
		}
	}
}

void SViewPort::RenderFrond(bool renderTransparentOrOpaque)
{
	if( m_prListFrond.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_SPEED_TREE) )
		{
			m_dev->ResetPrevDeclarationTechnique();

			START_DPCOUNT("Frond");

			if (renderTransparentOrOpaque) {
				// Transparent polygon
				m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_TREE_ALPHABLEND );
			} else {
				// Opaque polygon
				m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_TREE_NONALPHABLEND );
			}


//			m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
			m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );

			//K3DMatrix TrBlendShaderMatrix;
			//K3DMatrixTranspose( &TrBlendShaderMatrix, &m_matBlendShader );
			//m_dev->SetVertexShaderConstant( c_nVertexShader_CompoundMatrix, &TrBlendShaderMatrix, 4 );

			// 이 중복 코드좀 없앴으면 하는 소망이있음 -_-
			K3DCamera camTemp;
			K3DVector vecCam;
			K3DVector vecTar;
			K3DMatrix* pRootMat;
			K3DVector vecTrans;
			K3DVector4 vec4;
			float fFogOfsZ = 0.0f;

			if( m_bLocalCoord )
			{
				BackUpViewCamera();
				camTemp = m_ViewCamera;
				vecCam = camTemp.GetCamPos();
				vecTar = camTemp.GetTargetPos();
				vecTar -= vecCam;
				camTemp.SetCamPos(0.0f, 0.0f, 0.0f);
				camTemp.SetTargetPos(vecTar.x, vecTar.y, vecTar.z);
				SetCamera(&camTemp);
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);

				K3DMatrix BlendShaderMatrix, TrBlendShaderMatrix;
				K3DMatrixMultiply(BlendShaderMatrix, m_matView, m_matProjection);
				K3DMatrixTranspose( TrBlendShaderMatrix, BlendShaderMatrix );
				m_dev->SetVertexShaderConstant( c_nVertexShader_CompoundMatrix, &TrBlendShaderMatrix, 4 );

				fFogOfsZ = vecCam.z;
			}

#ifdef WRAPPER_USE_FOG
			D3DXVECTOR4 vecConstant1(m_fogFactor1, m_fogFactor2, (1.0f / (m_fogFactor2 - m_fogFactor1)), 0.0f);
			m_dev->SetVertexShaderConstant( c_nVertexShader_Fog1, (float*)&vecConstant1, 1 );
			D3DXVECTOR4 vecConstant2(m_fogFactor3 - fFogOfsZ, m_fogFactor4 - fFogOfsZ, (1.0f / (m_fogFactor4 - m_fogFactor3)), 0.0f);
			m_dev->SetVertexShaderConstant( c_nVertexShader_Fog2, (float*)&vecConstant2, 1 );
#endif

			KCustomVector<K3DPrimitive*>::iterator it = m_prListFrond.begin();
			for ( ; it != m_prListFrond.end() ; ++it )
			{
				// 투명모드인가 아닌가
				if ((*it)->IsTransparent()!=renderTransparentOrOpaque) continue;

				if(m_bLocalCoord)
				{
					pRootMat = (*it)->GetRootMat();
					K3DMatrixGetPosVector(vecTrans, *pRootMat);
					vecTrans -= vecCam;
					pRootMat->SetPosVector(vecTrans);

					(*it)->Render( this, m_dev );

					vecTrans += vecCam;
					pRootMat->SetPosVector(vecTrans);
				}
				else
				{
					(*it)->Render( this, m_dev );
				}
			}

			if( m_bLocalCoord )
			{
				RestoreBackUpViewCamera();
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
			}

			END_DPCOUNT();
		}
	}
}

void SViewPort::RenderLeaf(bool renderTransparentOrOpaque)
{
	if( m_prListLeaf.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_SPEED_TREE) )
		{
			m_dev->ResetPrevDeclarationTechnique();

			//			m_dev->SetMipBias( 0.f );
			START_DPCOUNT("Leaf");

			if (renderTransparentOrOpaque) {
				// Transparent polygon
				m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_TREE_ALPHABLEND );
			} else {
				// Opaque polygon
				m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_TREE_NONALPHABLEND );
			}
//			m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
			//m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );

			((K3DRenderDeviceDX*)m_dev)->SetVertexShaderLeaf();

			//K3DMatrix TrBlendShaderMatrix;
			//K3DMatrixTranspose( &TrBlendShaderMatrix, &m_matBlendShader );
			//m_dev->SetVertexShaderConstant( c_nVertexShader_CompoundMatrix, &TrBlendShaderMatrix, 4 );

			K3DCamera camTemp;
			K3DVector vecCam;
			K3DVector vecTar;
			K3DMatrix* pRootMat;
			K3DVector vecTrans;
			K3DVector4 vec4;
			float fFogOfsZ = 0.0f;

			if( m_bLocalCoord )
			{
				BackUpViewCamera();
				camTemp = m_ViewCamera;
				vecCam = camTemp.GetCamPos();
				vecTar = camTemp.GetTargetPos();
				vecTar -= vecCam;
				camTemp.SetCamPos(0.0f, 0.0f, 0.0f);
				camTemp.SetTargetPos(vecTar.x, vecTar.y, vecTar.z);
				SetCamera(&camTemp);
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);

				K3DMatrix BlendShaderMatrix, TrBlendShaderMatrix;
				K3DMatrixMultiply(BlendShaderMatrix, m_matView, m_matProjection);
				K3DMatrixTranspose( TrBlendShaderMatrix, BlendShaderMatrix );
				m_dev->SetVertexShaderConstant( c_nVertexShader_CompoundMatrix, &TrBlendShaderMatrix, 4 );

				fFogOfsZ = vecCam.z;
			}

#ifdef WRAPPER_USE_FOG
			D3DXVECTOR4 vecConstant1(m_fogFactor1, m_fogFactor2, (1.0f / (m_fogFactor2 - m_fogFactor1)), 0.0f);
			m_dev->SetVertexShaderConstant( c_nVertexShader_Fog1, (float*)&vecConstant1, 1 );
			D3DXVECTOR4 vecConstant2(m_fogFactor3 - fFogOfsZ, m_fogFactor4 - fFogOfsZ, (1.0f / (m_fogFactor4 - m_fogFactor3)), 0.0f);
			m_dev->SetVertexShaderConstant( c_nVertexShader_Fog2, (float*)&vecConstant2, 1 );
#endif

			KCustomVector<K3DPrimitive*>::iterator it = m_prListLeaf.begin();
			for ( ; it != m_prListLeaf.end() ; ++it )
			{
				// 투명모드인가 아닌가
				if ((*it)->IsTransparent()!=renderTransparentOrOpaque) continue;

				{
					const K3DLight* pLight = GetLight((*it)->GetLightIndex());
					
					K3DVector litdir;
					if(pLight->type == K3DLight::LT_POINT)
					{
                        K3DVector *pos = (K3DVector*)&(*it)->GetTransform()->_41;
                        //litdir = GetLight(0)->position - *pos;
						litdir = pLight->position - *pos;
					}
					else if(pLight->type == K3DLight::LT_DIRECTIONAL)
					{
						//litdir = GetLight(0)->direction;
						litdir = pLight->direction * -1.0f;
					}
					else
					{
						assert(0 && "포인트, 디렉셔널 타입 외의 광원은 지원하지 않음.");
					}

					//K3DVector litdir = GetLight(1)->position - *pos;	// 임시코드
					Normalize(litdir);
					// setup shader constants for light
					const float afLighting[] =
					{
							litdir.x, litdir.y, litdir.z, 1.0f,				// [71] normalized light direction
							//1.0f, 0.0f, 0.0f, 1.0f,					// 임시 코드
							//GetLight(0)->ambient.r, GetLight(0)->ambient.g, GetLight(0)->ambient.b, GetLight(0)->ambient.a, // [72] light ambient color
							pLight->ambient.r, pLight->ambient.g, pLight->ambient.b, pLight->ambient.a, // [72] light ambient color
							//GetLight(0)->diffuse.r, GetLight(0)->diffuse.g, GetLight(0)->diffuse.b, GetLight(0)->diffuse.a	// [73] light diffuse color
							pLight->diffuse.r, pLight->diffuse.g, pLight->diffuse.b, pLight->diffuse.a	// [73] light diffuse color
					};
					m_dev->SetVertexShaderConstant( c_nVertexShader_Light, afLighting, 3 );
				}

				if(m_bLocalCoord)
				{
					pRootMat = (*it)->GetRootMat();
					K3DMatrixGetPosVector(vecTrans, *pRootMat);
					vecTrans -= vecCam;
					pRootMat->SetPosVector(vecTrans);

					(*it)->Render( this, m_dev );

					vecTrans += vecCam;
					pRootMat->SetPosVector(vecTrans);
				}
				else
				{
				(*it)->Render( this, m_dev );
			}
		}

			if( m_bLocalCoord )
			{
				RestoreBackUpViewCamera();
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
			}

			END_DPCOUNT();
		}
	}
}

// sonador #2.1.7.1	스피드 트리 퍼포먼스 증가
void SViewPort::RenderTreeBillboard()
{
#ifdef WRAPPER_BILLBOARD_MODE

	if( m_prListTreeBillboard.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_SPEED_TREE) )
		{
			m_dev->ResetPrevDeclarationTechnique();

			START_DPCOUNT("Tree Billboard");
			//if (renderTransparentOrOpaque) {
			//	// Transparent polygon
			//	m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_TREE_ALPHABLEND );
			//} else {
				// Opaque polygon
				m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_TREE_NONALPHABLEND );
			//}
			//m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
			//m_dev->SetRenderState( K3DRenderDevice::RS_MODULATE2X );
			//m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );

			((K3DRenderDeviceDX*)m_dev)->SetVertexShaderSpeedTreeBillboard();

			//K3DMatrix TrBlendShaderMatrix;
			//K3DMatrixTranspose( &TrBlendShaderMatrix, &m_matBlendShader );
			//m_dev->SetVertexShaderConstant( c_nVertexShader_CompoundMatrix, &TrBlendShaderMatrix, 4 );

			K3DCamera camTemp;
			K3DVector vecCam;
			K3DVector vecTar;
			K3DMatrix* pRootMat;
			K3DVector vecTrans;
			K3DVector4 vec4;
			float fFogOfsZ = 0.0f;

			if( m_bLocalCoord )
			{
				BackUpViewCamera();
				camTemp = m_ViewCamera;
				vecCam = camTemp.GetCamPos();
				vecTar = camTemp.GetTargetPos();
				vecTar -= vecCam;
				camTemp.SetCamPos(0.0f, 0.0f, 0.0f);
				camTemp.SetTargetPos(vecTar.x, vecTar.y, vecTar.z);
				SetCamera(&camTemp);
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);

				K3DMatrix BlendShaderMatrix, TrBlendShaderMatrix;
				K3DMatrixMultiply(BlendShaderMatrix, m_matView, m_matProjection);
				K3DMatrixTranspose( TrBlendShaderMatrix, BlendShaderMatrix );
				m_dev->SetVertexShaderConstant( c_nVertexShader_CompoundMatrix, &TrBlendShaderMatrix, 4 );

				fFogOfsZ = vecCam.z;
			}

#ifdef WRAPPER_USE_FOG
			D3DXVECTOR4 vecConstant1(m_fogFactor1, m_fogFactor2, (1.0f / (m_fogFactor2 - m_fogFactor1)), 0.0f);
			m_dev->SetVertexShaderConstant( c_nVertexShader_Fog1, (float*)&vecConstant1, 1 );
			D3DXVECTOR4 vecConstant2(m_fogFactor3 - fFogOfsZ, m_fogFactor4 - fFogOfsZ, (1.0f / (m_fogFactor4 - m_fogFactor3)), 0.0f);
			m_dev->SetVertexShaderConstant( c_nVertexShader_Fog2, (float*)&vecConstant2, 1 );
#endif

			KCustomVector<K3DPrimitive*>::iterator it = m_prListTreeBillboard.begin();
			for ( ; it != m_prListTreeBillboard.end() ; ++it )
			{
				// 투명모드인가 아닌가
				//if ((*it)->IsTransparent()!=renderTransparentOrOpaque) continue;

				{
					const K3DLight* pLight = GetLight((*it)->GetLightIndex());
					
					K3DVector litdir;
					if(pLight->type == K3DLight::LT_POINT)
					{
                        K3DVector *pos = (K3DVector*)&(*it)->GetTransform()->_41;
                        //litdir = GetLight(0)->position - *pos;
						litdir = pLight->position - *pos;
					}
					else if(pLight->type == K3DLight::LT_DIRECTIONAL)
					{
						//litdir = GetLight(0)->direction;
						litdir = pLight->direction * -1.0f;
					}
					else
					{
						assert(0 && "포인트, 디렉셔널 타입 외의 광원은 지원하지 않음.");
					}

					//K3DVector litdir = GetLight(1)->position - *pos;	// 임시코드
					Normalize(litdir);
					// setup shader constants for light
					const float afLighting[] =
					{
							litdir.x, litdir.y, litdir.z, 1.0f,				// [71] normalized light direction
							//1.0f, 0.0f, 0.0f, 1.0f,					// 임시 코드
							//GetLight(0)->ambient.r, GetLight(0)->ambient.g, GetLight(0)->ambient.b, GetLight(0)->ambient.a, // [72] light ambient color
							pLight->ambient.r, pLight->ambient.g, pLight->ambient.b, pLight->ambient.a, // [72] light ambient color
							//GetLight(0)->diffuse.r, GetLight(0)->diffuse.g, GetLight(0)->diffuse.b, GetLight(0)->diffuse.a	// [73] light diffuse color
							pLight->diffuse.r, pLight->diffuse.g, pLight->diffuse.b, pLight->diffuse.a	// [73] light diffuse color
					};
					m_dev->SetVertexShaderConstant( c_nVertexShader_Light, afLighting, 3 );
				}

				if(m_bLocalCoord)
				{
					pRootMat = (*it)->GetRootMat();
					K3DMatrixGetPosVector(vecTrans, *pRootMat);
					vecTrans -= vecCam;
					pRootMat->SetPosVector(vecTrans);

					(*it)->Render( this, m_dev );

					vecTrans += vecCam;
					pRootMat->SetPosVector(vecTrans);
				}
				else
				{
					(*it)->Render( this, m_dev );
				}
			}

			if( m_bLocalCoord )
			{
				RestoreBackUpViewCamera();
				m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
			}

			END_DPCOUNT();

			//m_dev->SetTransform(K3DRenderDevice::TS_VIEW, &m_matView);
			//m_dev->SetTransform(K3DRenderDevice::TS_PROJECTION, &m_matProjection);
		}
	}

#endif
}

void SViewPort::RenderSpeedGrass()
{
	if( m_prListSpeedGrass.size() > 0 )
	{
		if( m_nRenderFlag.IsOn( RENDER_SPEED_GRASS ) )
		{
			m_dev->ResetPrevDeclarationTechnique();
			
			START_DPCOUNT("Grass");
			m_dev->SetRenderState( K3DRenderDevice::RS_SPEED_GRASS );
			m_dev->SetDepthBufferWriteEnable( true );
			( ( K3DRenderDeviceDX* ) m_dev )->SetVertexShaderGrass();
			
			SetSpeedGrassShaderConstants();

			KCustomVector< K3DPrimitive* >::iterator it = m_prListSpeedGrass.begin();
			for ( ; it != m_prListSpeedGrass.end() ; it++ )
			{
				// set light infos
				const K3DLight* pLight = GetLight( ( *it )->GetLightIndex() );

				K3DVector litdir;
				if( pLight->type == K3DLight::LT_POINT )
				{
					K3DVector *pos = ( K3DVector* ) &( *it )->GetTransform()->_41;
					litdir = pLight->position - *pos;
				}
				else if(pLight->type == K3DLight::LT_DIRECTIONAL)
				{
					litdir = pLight->direction * -1.0f;
				}
				else
				{
					assert(0 && "포인트, 디렉셔널 타입 외의 광원은 지원하지 않음.");
				}

				Normalize(litdir);

				const float afLighting[] =
				{
					litdir.x, litdir.y, litdir.z, 1.0f,											// [21] normalized light direction
						pLight->ambient.r, pLight->ambient.g, pLight->ambient.b, pLight->ambient.a, // [22] light ambient color
						pLight->diffuse.r, pLight->diffuse.g, pLight->diffuse.b, pLight->diffuse.a	// [23] light diffuse color
				};

				m_dev->SetVertexShaderConstant( c_nShaderLightInfos, afLighting, 3 );

				( *it )->Render( this, m_dev );
			}
			END_DPCOUNT();
		}
	}
}

void SViewPort::RenderQuadPrimitive()
{
	if( m_prListQuad.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_QUAD) )
		{
			m_dev->ResetPrevDeclarationTechnique();

			m_dev->SetRenderState(K3DRenderDevice::RS_DEFAULT);
			m_dev->SetVertexShaderDefault();
			m_dev->EnableLightEffect(false);
			IDirect3DDevice9* pD3dDevice = ((K3DRenderDeviceDX*) m_dev)->GetD3DDevice();
			pD3dDevice->SetRenderState(D3DRS_COLORVERTEX, TRUE);
			pD3dDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
			m_dev->SetTransformIdentity(K3DRenderDevice::TS_WORLD);

			KCustomVector<K3DPrimitive*>::iterator it = m_prListQuad.begin();

			for (; it != m_prListQuad.end() ; ++it )
			{
				(*it)->Render( this, m_dev );
			}
		}
	}
}

void SViewPort::RenderLinePrimitive()
{
	if( m_prListLine.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_QUAD) )
		{
			m_dev->SetRenderState(K3DRenderDevice::RS_DEFAULT);
			m_dev->SetVertexShaderDefault();
			m_dev->EnableLightEffect(false);
			IDirect3DDevice9* pD3dDevice = ((K3DRenderDeviceDX*) m_dev)->GetD3DDevice();
			pD3dDevice->SetRenderState(D3DRS_COLORVERTEX, TRUE);
			pD3dDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
			m_dev->SetTransformIdentity(K3DRenderDevice::TS_WORLD);

			KCustomVector<K3DPrimitive*>::iterator it = m_prListLine.begin();

			for (; it != m_prListLine.end() ; ++it )
			{
				(*it)->Render( this, m_dev );
			}
		}
	}
}

void SViewPort::RenderPolyLinePrimitive()
{
	if(m_prListPolyLine.size() > 0)
	{
		if(m_nRenderFlag.IsOn(RENDER_POLYLINE))
		{
			m_dev->SetRenderState(K3DRenderDevice::RS_DEFAULT);
			m_dev->SetVertexShaderDefault();
			m_dev->EnableLightEffect(false);
			IDirect3DDevice9* pD3dDevice = ((K3DRenderDeviceDX*) m_dev)->GetD3DDevice();
			pD3dDevice->SetRenderState(D3DRS_COLORVERTEX, TRUE);
			pD3dDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
			m_dev->SetTransformIdentity(K3DRenderDevice::TS_WORLD);

			KCustomVector<K3DPrimitive*>::iterator it = m_prListPolyLine.begin();

			for (; it != m_prListPolyLine.end() ; ++it )
			{
				(*it)->Render(this, m_dev);
			}
		}
	}
}

void SViewPort::RenderBliiboardList()
{
}

void SViewPort::RenderAdditiveBliiboard()
{
}

void SViewPort::RenderLensflare()
{
	if ( m_prListLensFlare.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_LENSFLARE) )
		{

			START_DPCOUNT("Lens Flare");
			m_dev->SetRenderState( K3DRenderDevice::RS_LENSFLARE );
			m_dev->SetDepthBufferWriteEnable( false );
			m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_ALWAYS );

			KCustomVector<K3DPrimitive*>::iterator it = m_prListLensFlare.begin();
			for ( ; it != m_prListLensFlare.end() ; ++it )
			{
				(*it)->Render( this, m_dev );
			}
			END_DPCOUNT();
		}
	}
}

void SViewPort::RenderHighQualityWater()
{
}

void SViewPort::RenderSprite()
{
	if ( m_prSpriteList.size() > 0 || m_prAdditiveSpriteList.size() > 0 ||
		 m_prFrontSpriteList.size() > 0 || m_prFrontAdditiveSpriteList.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_SPRITE) )
		{

			START_DPCOUNT("Sprite");
			m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_ALWAYS );
			m_dev->SetDepthBufferWriteEnable( false );

			K3DMatrix backupWorldMat = *m_dev->GetTransform( K3DRenderDevice::TS_WORLD );

			m_dev->SetTransformIdentity( K3DRenderDevice::TS_WORLD );

			if ( m_prSpriteList.size() > 0 )
			{
				m_dev->SetRenderState( K3DRenderDevice::RS_SPRITE );
				//m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );
				drawSprite( &m_prSpriteList.front(), m_prSpriteList.size() );
			}
			if ( m_prAdditiveSpriteList.size() > 0 )
			{
				m_dev->SetRenderState( K3DRenderDevice::RS_ADDITIVE_PARTICLE );
				//m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );
				drawSprite( &m_prAdditiveSpriteList.front(), m_prAdditiveSpriteList.size() );
			}
			if ( m_prFrontSpriteList.size() > 0 )
			{
				m_dev->SetRenderState( K3DRenderDevice::RS_SPRITE );
				//m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );
				drawSprite( &m_prFrontSpriteList.front(), m_prFrontSpriteList.size() );
			}
			if ( m_prFrontAdditiveSpriteList.size() > 0 )
			{
				m_dev->SetRenderState( K3DRenderDevice::RS_ADDITIVE_PARTICLE );
				//m_dev->SetRenderState( K3DRenderDevice::RS_NO_MIPMAP );
				drawSprite( &m_prFrontAdditiveSpriteList.front(), m_prFrontAdditiveSpriteList.size() );
			}

			END_DPCOUNT();

			m_dev->SetTransform( K3DRenderDevice::TS_WORLD, &backupWorldMat );
		}
	}
}

void SViewPort::RenderWirePrimitive()
{
	if ( m_wprList.size() > 0 )
	{
		if( m_nRenderFlag.IsOn(RENDER_WPRLIST) )
		{

			m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
			m_dev->SetDepthBufferWriteEnable( true );
			m_dev->SetRenderState( K3DRenderDevice::RS_NOLIGHT_VTXCOLOR );

			for( std::list<KWireUtilPrimitive*>::iterator it = m_wprList.begin(); it != m_wprList.end(); it++ )
				(*it)->Render( this, m_dev );

		}
	}
}

void SViewPort::BeginRender()
{
	/// 2010.11.10 - prodongi
//#ifdef _DEV
//	extern bool g_bDebugMode;
//#endif

	{
		m_dev->SetViewport( m_viewport );

		if ( m_bClearDepthBuf || m_bClearColorBuf )
		{
			int option = 0;
			option |= m_bClearColorBuf ? K3DRenderDevice::FILL_COLOR :  0;
			option |= m_bClearDepthBuf ? K3DRenderDevice::FILL_DEPTH :  0;
			m_dev->SetFillColor( m_colFill );
			m_dev->Fill(option);
		}
		updateLight();

		//m_dev->SetMipBias( m_fMipBias );
		m_dev->SetSceneAmbientLight( m_colSceneAmbient );
		m_dev->SetTransform( K3DRenderDevice::TS_PROJECTION, &m_matProjection );
		m_dev->SetTransform( K3DRenderDevice::TS_VIEW, &m_matView );

//#ifndef NDEBUG
		
		/// 2010.11.10 - prodongi
//#ifdef _DEV
		if (g_UserInfo.isMonkeyTail())
		{
			extern bool g_bDebugMode;
			if( g_bDebugMode && GetKeyState( 20 ) )
				m_dev->SetFillMode(K3DRenderDevice::FM_WIREFRAME);
			else
				m_dev->SetFillMode(K3DRenderDevice::FM_SOLID);
		}
//#else
		else
		{
			m_dev->SetFillMode(K3DRenderDevice::FM_SOLID);
		}
//#endif

//#endif
	}

	m_dev->SetVertexShaderConstant(CONSTANT_CAMERAPOSITION, (const float*)&GetCameraPos(), 3);

	if ( m_fogMode != K3DRenderDevice::FOGM_NONE )
	{
		m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
	}

	if(m_pLightList.size() > 0)
	{
		//K3DVector lightdir = GetCameraTargetPos() - GetLight(0)->position;
		//lightdir = lightdir - 0.2f*K3DVector(lightdir.x, lightdir.y, 0);

		K3DVector lightdir = GetLight(0)->direction;
		Normalize(lightdir);
		m_dev->SetVertexShaderConstant(CONSTANT_LIGHTDIRECTION, (const float *)&lightdir, 3);
	}
}

void SViewPort::EndRender(bool bClearRegister)
{
	if(bClearRegister)
		ClearRegisteredList();
}

void SViewPort::Render( bool bClearRegister, bool bSetRenderTarget /*= true*/ )
{
	BeginRender();

	RenderSky();

	RenderCloud();

	//////////////////////////////////////////////////////////////////////////
	//지형
	// camera의 위치 설정

	RenderTerrain( false );

	RenderTerrainShadow(NULL, NULL);

	/*RenderBuilding(NULL, NULL);

	RenderAlphaBuilding(NULL, NULL);
	*/

/*	Moved to bottom, to enable transparent tree
	RenderBranch();

	RenderFrond();

	RenderLeaf();

	RenderTreeBillboard();
*/
	//RenderPathEffect();

	RenderQuadPrimitive();

	RenderLinePrimitive();

	RenderPolyLinePrimitive();

	/*RenderProp(NULL, NULL);

	RenderAlphaProp(NULL, NULL);
	*/

 	//m_dev->SetDepthBufferWriteEnable( true );
	//m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );

//	if ( m_dev )  // Setting Light attribute for VS
//		m_dev->SetVertexShaderGlobal( m_nLightIndex );

	/*RenderPrNoLightList();
	*/

	if ( m_fogMode != K3DRenderDevice::FOGM_NONE )
	{
		m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
	}

	//m_dev->SetDepthBufferCompareMode( K3DRenderDevice::DCM_LESSEQUAL );
	//m_dev->SetDepthBufferWriteEnable( true );
	
	/*RenderPrList( m_prMesh );

	RenderPrListSpecularList();

	RenderPrVSList();

	RenderPrVSListSpecularList();
	*/

	RenderPrList(m_prMesh, NULL, NULL);

	// fog off
	m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, 0, 0, 0, 0, 0 );

	/*RenderPrNoFogList();
	*/

	if ( m_fogMode != K3DRenderDevice::FOGM_NONE )
	{
		m_dev->SetFogMode( m_fogMode, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );
	}

	/*RenderPrAlphaList();

	RenderPrVSAlphaList();

	RenderPrVSAlphaSpecularList();
	*/


	// Render tree (opaque parts)
	// NOTE : THIS ROUTINES ARE NOT EXECUTED : See SGameViewPort.cpp for active code.
	RenderBranch(false);
	RenderFrond(false);
	RenderLeaf(false);
	RenderTreeBillboard();


	// Render transparent tree parts
	RenderBranch(true);
	RenderFrond(true);
	RenderLeaf(true);
		// Note : Billboard has no transparent rendering routine

	RenderPrAlphaList(m_prTransMesh, NULL, NULL);

	// fog off
	m_dev->SetFogMode( K3DRenderDevice::FOGM_NONE, m_fogColor, m_fogFactor1, m_fogFactor2, m_fogFactor3, m_fogFactor4 );

	//RenderPrAdditiveList(NULL, NULL);

	//RenderBliiboardList();

	/*RenderPrNoFogAlphaList();

	RenderAdditiveBuilding(NULL, NULL);

 	RenderAdditiveProp(NULL, NULL);
	*/

	//RenderAdditiveBliiboard();

	m_dev->SetCullMode( K3DRenderDevice::KCM_NONE );	// No culling
	RenderSpeedGrass();

	if( NULL != m_pChildViewportObj )
		m_pChildViewportObj->Render( bClearRegister );

	m_dev->SetCullMode(K3DRenderDevice::KCM_NONE);
	RenderLensflare();

	//////////////////////////////////////////////////////////////////////////
	/// 인터페이스
	RenderSprite();
	m_dev->SetCullMode(K3DRenderDevice::KCM_CCW);

	RenderWirePrimitive();

	EndRender(bClearRegister);
}

//void SViewPort::SetRenderBumpMapMode( bool bRender )
//{
//	m_bRenderBumpMap = bRender;
//}
//
//bool SViewPort::GetRenderBumpMapMode()
//{
//	return m_bRenderBumpMap;
//}

void SViewPort::SetSelfShadowAmbientFactor( float fFactor )
{
	m_fSelfShadowAmbientFactor = fFactor;
}

void SViewPort::SetSpeedGrassShaderConstants()
{
	K3DMatrix TrBlendShaderMatrix;
	K3DMatrixTranspose( TrBlendShaderMatrix, m_matBlendShader );
	m_dev->SetVertexShaderConstant( c_nShaderCompositeMatrix, &TrBlendShaderMatrix, 4 );

//#ifdef WRAPPER_USE_FOG
//	D3DXVECTOR4 vecConstant1(m_fogFactor1, m_fogFactor2, (1.0f / (m_fogFactor2 - m_fogFactor1)), 0.0f);
//	m_dev->SetVertexShaderConstant( c_nVertexShader_Fog1, (float*)&vecConstant1, 1 );
//	D3DXVECTOR4 vecConstant2(m_fogFactor3, m_fogFactor4, (1.0f / (m_fogFactor4 - m_fogFactor3)), 0.0f);
//	m_dev->SetVertexShaderConstant( c_nVertexShader_Fog2, (float*)&vecConstant2, 1 );
//#endif
	
	// pass in unitized billboarded grass quad
	const float* pUnitBB = CSpeedGrassRT::GetUnitBillboard( );
	const float c_fGrassWidth = 2.0f;
	for (int i = 0; i < 4; ++i)
	{
		float afVector[4] = { c_fGrassWidth * pUnitBB[i * 3 + 0],
			c_fGrassWidth * pUnitBB[i * 3 + 1],
			pUnitBB[i * 3 + 2],
			0.0f };
		m_dev->SetVertexShaderConstant(c_nShaderUnitGrassBillboard + i, afVector, 1);
	}

	// setup LOD information
	float afVector[4] = { 0.0f };
	CSpeedGrassRT::GetLodParams(afVector[0], afVector[1]);
	m_dev->SetVertexShaderConstant(c_nShaderLodParams, afVector, 1);

	// setup camera information
	const float* pCameraPos = CSpeedGrassRT::GetCameraPos();
	m_dev->SetVertexShaderConstant(c_nShaderCameraPos, pCameraPos, 1);

	// set global wind direction
	m_dev->SetVertexShaderConstant(c_nShaderWindDirection, CSpeedGrassRT::GetWindDirection(), 1);

	// set time values
	float afTimeValues[4] = { KSeqSpeedGrass::GetAccumTime() * c_fShaderTimeScale, c_fShaderWindPeriod, 0.0f, 0.0f };
	m_dev->SetVertexShaderConstant(c_nShaderTimeValues, afTimeValues, 1);
}