#include "stdafx.h"
#include "KViewport.h"

#include "KRenderObjectMesh.h"
#include "KSeqForm.h"
#include "KSeqAvatar.h"
#include "KSeqAvatarEx.h"
#include "KSeqModel.h"
#include "TerrainDefine.h"
#include "TerrainProp.h"
#include "TerrainPropInfo.h"

#include <mmo/ArTime.h>
//#include "Util.h"

#include "KSeqSpeedTree.h"
#include "SSpeedTreeManager.h"
#include "SCobManager.h"

#include "KRenderObjectEtc.h"

#include <toolkit/XStringUtil.h>

#include <kfile/KFileManager.h>
#include <list>
/// 2010.11.10 - prodongi
#include "SItemDB.h"
#include "SGameLobbyDefine.h"

//#include "SDebug_Util.h"

namespace
{
	const char* c_szDefault = "default";
	const char* c_szDefaultLod01 = "default_lod01";

	const char* c_szCollisionCube = "ev_3dcol";
	const char* c_szAttributeCube = "ev_attr";

	const float c_fDummyCubeHalfLength = 1.f;

	template< typename T >
	T&	findname( T& a, T& b, const char* szName )
	{
		while( a != b )
		{
			if( strcmp( (*a)->GetName(), szName ) == 0 )
			{
				return a;
			}
			++a;
		}

		return b;
	}
};

float CTerrainProp::m_fLodMax = 1.0f;
float CTerrainProp::m_fLodDist = 1.0f;

bool  CTerrainProp::m_bHeightRender      = false;
bool  CTerrainProp::m_bSetSkipVisibility = false;
bool  CTerrainProp::m_bCameraCollisionRender = false;		// [sonador][COLLIDABLE_CAMERA]
float CTerrainProp::m_fCameraCollisionVisibility = 0.5f;	// [sonador][7.1.5]테스트용 클라이언트 제작 및 충돌 프랍 투명화 적용
float CTerrainProp::m_fGrassVisRange = 1.0f;
float CTerrainProp::m_fSpeedTreeVisRange = 1.0f;
float CTerrainProp::m_fPropSmallVisRange = 1.0f;
float CTerrainProp::m_fPropLargeVisRange = 1.0f;
float CTerrainProp::m_fBuildingSmallVisRange = 1.0f;
float CTerrainProp::m_fBuildingLargeVisRange = 1.0f;

volatile bool CTerrainProp::s_bStopThread = false;

static XCriticalSection					s_propLoadingLock;
static std::list< CTerrainProp* >		s_lstThreadLoadingProp;

namespace
{
	struct PropTri
	{
		X2D::Point<float> v[3];
		float			  z[3];	//높이
		K3DPlane plane;		//접선의 방정식 -_-
	};
	template< typename T > 
	inline bool COLLISION( const PropTri& lh,	const X2D::Point<T>& rh )	
	{ 
		X2D::CCW_RESULT ret = X2D::CheckClockWise(lh.v[0], lh.v[1], rh);
		return ret == X2D::CheckClockWise(lh.v[1], lh.v[2], rh) && ret == X2D::CheckClockWise(lh.v[2], lh.v[0], rh);
	}

	template< typename T > 
	inline bool COLLISION( const X2D::Rect<T>&  lh,	const PropTri& rh )	
	{ 
		// 하나라도 안에 있으면
		for(size_t i = 0; i < 3; ++i)
		{
			if(lh.IsCollision(rh.v[i]) )
				return	true;

			X2D::Line<float> line(rh.v[i%3], rh.v[(i+1)%3] );
		
			if(lh.IsCollision(line))
				return true;
		}
		X2D::Point<float> pt[4];
		pt[0].x = lh.GetLeft(); pt[0].y = lh.GetTop();
		pt[1].x = lh.GetLeft(); pt[1].y = lh.GetBottom();
		pt[2].x = lh.GetRight(); pt[2].y = lh.GetTop();
		pt[3].x = lh.GetRight(); pt[3].y = lh.GetBottom();

		for(size_t i = 0; i < 4; ++i)
		{
			if(COLLISION(rh, pt[i]) )
				return true;
		}

		return false;

	}

}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// STriangleIndex Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class STriangleIndex
{
public:
	STriangleIndex(float left, float top, float width, float height, size_t triSize, size_t numOfTesselX = 0, size_t numOfTesselY = 0)
	: m_Area(left,top,width,height)
	{
		m_NumOfTesselX = numOfTesselX;
		m_NumOfTesselY = numOfTesselY;
		
		if(m_NumOfTesselX == 0 && m_NumOfTesselY == 0)
		{
			m_NumOfTesselX = static_cast<size_t>( ::sqrtf(static_cast<float>(triSize) ) );
			m_NumOfTesselY = triSize / m_NumOfTesselX;
		}
		
		m_ppBlock = new triVector*[m_NumOfTesselY];		
		for(size_t i = 0; i < m_NumOfTesselY; ++i)
		{
			m_ppBlock[i] = new triVector[m_NumOfTesselX];				
		}

		m_WidthUnit = m_Area.GetWidth() / m_NumOfTesselX;
		m_HeightUnit = m_Area.GetHeight() / m_NumOfTesselY;
	}

	~STriangleIndex()
	{
		for(size_t i = 0; i < m_NumOfTesselY; ++i)		
		{
			SAFE_DELETE_ARRAY(m_ppBlock[i]);
		}

		SAFE_DELETE_ARRAY(m_ppBlock);
	}

	void AddTri(const PropTri& tri)
	{
		bool bColision = false;
		for(size_t y = 0; y < m_NumOfTesselY; ++y)
		{
			for(size_t x = 0; x < m_NumOfTesselX; ++x)
			{
				X2D::Rect<float> rect;
				rect.Set(m_Area.GetLeft() + m_WidthUnit * x, m_Area.GetTop() + m_HeightUnit * y, m_WidthUnit, m_HeightUnit);

				if( COLLISION(rect, tri) )
				{
					m_ppBlock[y][x].push_back(tri);
					bColision = true;
				}
			}
		}
		//if(false == bColision)
		//	_oprint("Cannot Add Tri : [0] (%.3f, %.3f), [1] (%.3f, %.3f), [2] (%.3f, %.3f)\n", tri.v[0].x,tri.v[0].y, 
		//		tri.v[1].x,tri.v[1].y, tri.v[2].x,tri.v[2].y);
	}
	void GetCollisionTriList(float x, float y, std::vector<PropTri*>* pTriVector)
	{
		float offsetX = x - m_Area.GetLeft();
		float offsetY = y - m_Area.GetTop();

		int blockX = static_cast<int>( offsetX / m_WidthUnit );
		int blockY = static_cast<int>( offsetY / m_HeightUnit );

		// 오버플로 방지
		if( blockY > m_NumOfTesselY-1 )
			blockY = m_NumOfTesselY-1;

		if( blockX > m_NumOfTesselX-1 )
			blockX = m_NumOfTesselX-1;

		triVector& tris = m_ppBlock[blockY][blockX];
		X2D::Point<float> pt(x,y);

		for(size_t i = 0; i < tris.size(); ++i)
		{
			if( COLLISION(tris[i], pt))
				pTriVector->push_back( &(tris[i]));
		}

		//if( 0 != HIBYTE(GetAsyncKeyState(VK_LMENU)) )
		//	_oprint("Count is %d, Find is %d\n", tris.size(), pTriVector->size() );

	}

private:
	size_t				m_NumOfTesselX, m_NumOfTesselY;
	X2D::Rect<float>	m_Area;
	float				m_WidthUnit;
	float				m_HeightUnit;

	
	typedef std::vector<PropTri> triVector;
	triVector**			m_ppBlock;
};



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CTerrainProp Implement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void CTerrainProp::removeFromLoadingList()
{
	THREAD_SYNCRONIZE( s_propLoadingLock );

	if( !m_bIsThreadPending ) return;

	std::list< CTerrainProp* >::iterator it;

	for( it = s_lstThreadLoadingProp.begin(); it != s_lstThreadLoadingProp.end(); ++it )
	{
		if( *it == this )
		{
			s_lstThreadLoadingProp.erase( it );
			return;
		}
	}
}

void CTerrainProp::addToLoadingList()
{
	THREAD_SYNCRONIZE( s_propLoadingLock );
	
	if( m_bIsRealLoad ) return;

#ifdef _DEBUG
	std::list< CTerrainProp* >::iterator it;
	for( it = s_lstThreadLoadingProp.begin(); it != s_lstThreadLoadingProp.end(); ++it )
	{
		if( *it == this )
		{
			assert( 0 );
			return;
		}
	}
#endif

	m_bIsThreadPending = true;

	s_lstThreadLoadingProp.push_back( this );
}

void CTerrainProp::PendLoading()
{
	if( m_bIsThreadPending ) return;
	addToLoadingList();
}

unsigned int __stdcall CTerrainProp::prop_loader( void* pArg )
{
	while( !s_bStopThread )
	{
		CTerrainProp *pProp = NULL;
		{
			s_propLoadingLock.Lock();
			if( s_lstThreadLoadingProp.empty() ) 
			{
				s_propLoadingLock.UnLock();
				Sleep( 100 );
				continue;
			}

			pProp = s_lstThreadLoadingProp.front();
			s_lstThreadLoadingProp.pop_front();

			pProp->StartThreadLoading();
			s_propLoadingLock.UnLock();
		}

		pProp->Load_Real( true );
	}

	s_bStopThread = false;

	return 0;
}

void CTerrainProp::BeginPropLoadingThread()
{
	unsigned dwThreadID;
	HANDLE hThread = reinterpret_cast< HANDLE >( _beginthreadex( NULL, 0, CTerrainProp::prop_loader, NULL, 0, &dwThreadID ) );
	CloseHandle( hThread );
}

void CTerrainProp::EndPropLoadingThread()
{
	_oprint( "**THREAD INFO : CTerrainProp::EndPropLoadingThread\n" );

	s_bStopThread = true;

	while( s_bStopThread ) Sleep( 1 );
}

CTerrainProp::CTerrainProp( const K3DVector& rPos, const K3DVector& rRotate, const K3DVector& rScale, float fZOffset, WORD wPropNum, const CTerrainPropInfo* pPropInfo, bool bLockHeight ,
						   int segmentIdx, int propIdx, bool bEnableLightmap, short texturegroupindex )
	: m_Pos( rPos )
	, m_Rotate( rRotate )
	, m_Scale( rScale )
	, m_fZOffset( fZOffset )
	, m_wPropNum( wPropNum )
	, m_pModel( NULL )
	, m_pBoundCube( NULL )
	, m_pOriginCorrection( NULL )
	, m_ptCurrentOriginCorrection( K3DVertex( 0.f, 0.f, 0.f ) )
	, m_fVisibility( 1.f )
	, m_nLodLevel( 0 )
	, m_bLodExist( false )
	//, m_bVisible(false)
	//, m_bDrawTestWire(true)
	, m_bDrawTestWire( false )		// [sonador][COLLIDABLE_CAMERA]
	//, m_bTestWireCreated(false)
	, m_bTestWireCreated( true )	// [sonador][COLLIDABLE_CAMERA]
	, m_bIsThreadPending( false )
	, m_bIsThreadLoading( false )
	, m_pIndexTri(NULL)
	, m_bLockHeight( bLockHeight )
	, m_segmentIdx(segmentIdx)
	, m_propIdx(propIdx)
	, m_bEnableLightmap(bEnableLightmap)
	, m_pCameraCollision( NULL )
	, m_nTextureGroupIndex( texturegroupindex )
{
	m_bIsClip     = false;
	m_bIsRealLoad = false;
	m_pModelHeight  = NULL;

	//test
	m_dwTime = 0;

	UpdateTransform();
	switch( pPropInfo->GetPropRenderType( m_wPropNum ) )
	{
	default:
	case CTerrainPropInfo::PROPRENDER_GENERAL:  m_nRenderType = KRenderObject::RENDEREFX_PROP; break;
	case CTerrainPropInfo::PROPRENDER_BUILDING: m_nRenderType = KRenderObject::RENDEREFX_BUILDING; break;
	}

	m_nShadowFlag = pPropInfo->GetShadowFlag( m_wPropNum );
	m_nRenderFlag = MAKELONG( m_nRenderType, m_nShadowFlag );

//#ifndef NDEBUG
	m_strFileName = pPropInfo->GetPropFileName( m_wPropNum ); //화일 이름, 디버그 용
//#endif

//	_oprint( "PROP_INFO : %d, %s\n", m_wPropNum, pPropInfo->GetPropFileName( m_wPropNum ) );

	if( true )
	{	
		LoadCOB( m_strFileName.c_str(), m_matTransform );

		//case CTerrainPropInfo::PROP_USE_NX3:
		//	{
		//		std::string strFileName = pPropInfo->GetPropFileName( m_wPropNum );
		//		m_pModel = CreateNAFModel( strFileName.c_str() );
		//		//건물일 경우 _lod%d 를 추가해서 읽는다. 현재 단계는 _lod01 까지 만들어져 있다.
		//		if( m_nRenderType == KRenderObject::RENDEREFX_BUILDING ||
		//			m_nRenderType == KRenderObject::RENDEREFX_BUILDING_HAS_STOOL )
		//		{
		//			XStringUtil::Replace( strFileName, ".", "_lod01." );
		//			if ( KFileManager::Instance().IsValidResource( strFileName.c_str() ) )
		//			{
		//				m_pModel->AddAnimation( c_szDefaultLod01, strFileName.c_str() );
		//				m_bLodExist = true;
		//			}
		//		}
		//	}
		//	break;

		//case CTerrainPropInfo::PROP_SPEEDTREE:
		//	{
		//		K3DMatrix mat;
		//		m_pModel = CreateSpeedTreeModel( pPropInfo->GetPropFileName( m_wPropNum ), m_matTransform );
		//	}
		//	break;
		////.cob 화일 읽는 곳
		//case CTerrainPropInfo::PROP_NPC:
		//	m_pModel = CreateNPCModel( pPropInfo->GetPropFileName( m_wPropNum ) );
		//	m_pModel->SetTransform( m_matTransform ); //KAvatarSeqEx 의 버그 때문에 넣은 것임. KAvatarSeqEx의 SetParentTransform 이 제대로 안됨.
		//	break;
	//	}
	}

	//if( NULL == m_pModel )
	//	m_pBoundCube = CreateDummyBoundCube();

	RefreshAllTransform();
//	CreateStools();
	SetVisibility( 1.f );
}

CTerrainProp::~CTerrainProp()
{
	Destroy();
}

void CTerrainProp::Destroy()
{
	// 운나쁘게 쓰레드 로딩 중이라면 로딩 끝날때까지 기다림
	while( m_bIsThreadLoading ) 
	{
		Sleep( 50 );
	}

	removeFromLoadingList();

	SAFE_DELETE( m_pBoundCube );
	SAFE_DELETE( m_pModel );
	SAFE_DELETE( m_pModelHeight );
	SAFE_DELETE( m_pIndexTri);
	SAFE_DELETE( m_pCameraCollision );

	iterator_texture_group_list itTextureGroup = m_vTextureGroupData.begin();
	while( itTextureGroup != m_vTextureGroupData.end() )
	{
		SAFE_DELETE( (*itTextureGroup) );
		itTextureGroup = m_vTextureGroupData.erase( itTextureGroup );
	}
	
}

bool CTerrainProp::IsSizeCull()
{
	if( m_pBoundCube )
	{
		const K3DVertex* pCube = m_pBoundCube->GetVertices();
		K3DVertex cubeValue = pCube[7]-pCube[0];
		//기본 플레이어 캐릭터의 크기는 20
		if( cubeValue.x > 200 || cubeValue.y > 200 || cubeValue.z > 200 )
			return false;
	}

	return true; 
}

void CTerrainProp::SetVisibility( float fVisible )
{
	if( m_bSetSkipVisibility ) return;

	if( fVisible < 0.f ) fVisible = 0.f;
	if( fVisible > 1.f ) fVisible = 1.f;

	m_fVisibility = fVisible;

	if( NULL != m_pModel )
	{
		m_pModel->SetVisibility( m_fVisibility );
//		m_pModel->SetLodLevel( m_fVisibility ); 
	}
}

// 스피드 트리만 쓰고 있음
void CTerrainProp::SetFloatLod(float fCameraDist, float fVisRange)
{
	bool bLongDist = false;
	fVisRange *= m_fLodDist;
	if ( fVisRange > 800.0f && m_fLodDist < 1.0f ) 
	{
		fVisRange = 800.0f;
		bLongDist = true;
	}

	float fLod = 1.0f - (fCameraDist / fVisRange);

	if( bLongDist )
		fLod *= 0.1f;

	if (fLod < 0.0f) fLod = 0.0f;

	//스피드 트리 버그 관련 수정
	// lod 레벨 0-1.0 사이로 고정
	//2009-12-23 : hunee
	//if (fLod > m_fLodMax) fLod = m_fLodMax;
	if (fLod > 1.0f) fLod = 1.0f;

	if(m_pModel)
	{
		m_pModel->SetLodLevel(fLod);
	}
}

//void CTerrainProp::SetVisible(float fCameraDist, float fVisRange)
//{
//	float fRatio = 0.0f;
//
//	switch(m_dwPropCategory)
//	{
//	case TYPE_GRASS:
//		fRatio = m_fGrassVisRange;
//		break;
//
//	case TYPE_SPEEDTREE:
//		fRatio = m_fSpeedTreeVisRange;
//		break;
//
//	case TYPE_PROPSMALL:
//		fRatio = m_fPropSmallVisRange;
//		break;
//
//	case TYPE_PROPLARGE:
//		fRatio = m_fPropLargeVisRange;
//		break;
//
//	case TYPE_NPC:
//		break;
//
//	case TYPE_BUILDINGSMALL:
//		fRatio = m_fBuildingSmallVisRange;
//		break;
//
//	case TYPE_BUILDINGLARGE:
//		fRatio = m_fBuildingLargeVisRange;
//		break;
//
//	default:
//		assert(0 && "잘못된 프랍 타입");
//		break;
//	}
//
//    if(fCameraDist < fVisRange * fRatio) m_bVisible = true;
//	else m_bVisible = false;
//}


void CTerrainProp::SetGrassVisRange(float fRange)
{
	m_fGrassVisRange = fRange;
}
void CTerrainProp::SetSpeedTreeVisRange(float fRange)
{
	m_fSpeedTreeVisRange = fRange;
}
void CTerrainProp::SetPropSmallVisRange(float fRange)
{
	m_fPropSmallVisRange = fRange;
}
void CTerrainProp::SetPropLargeVisRange(float fRange)
{
	m_fPropLargeVisRange = fRange;
}
//void CTerrainProp::SetNpcVisRange(float fRange)
//{
//	m_fNpcVisRange = fRange;
//}
void CTerrainProp::SetBuildingSmallVisRange(float fRange)
{
	m_fBuildingSmallVisRange = fRange;
}
void CTerrainProp::SetBuildingLargeVisRange(float fRange)
{
	m_fBuildingLargeVisRange = fRange;
}

float CTerrainProp::GetVisRatio()
{
	float fRatio = 1.0f;

	switch(m_dwPropCategory)
	{
	case TYPE_GRASS:
		fRatio = m_fGrassVisRange;
		break;

	case TYPE_SPEEDTREE:
		fRatio = m_fSpeedTreeVisRange;
		break;

	case TYPE_PROPSMALL:
		fRatio = m_fPropSmallVisRange;
		break;

	case TYPE_PROPLARGE:
		fRatio = m_fPropLargeVisRange;
		break;

	case TYPE_NPC:
		break;

	case TYPE_BUILDINGSMALL:
		fRatio = m_fBuildingSmallVisRange;
		break;

	case TYPE_BUILDINGLARGE:
		fRatio = m_fBuildingLargeVisRange;
		break;

	default:
		//assert(0 && "잘못된 프랍 타입"); - 임시로 없앤다. 나중에 타입이 제대로 들어오면 다시 살릴 것. by blackfish
		break;
	}

	return fRatio;
}

void CTerrainProp::SetLodLevel( int nLevel )
{
	if( !m_pModel ) return;

	if( nLevel < 0 ) nLevel = 0;
	if( nLevel > 1 ) nLevel = 1;

	if( m_nLodLevel != nLevel )
	{
		m_nLodLevel = nLevel;

		if( m_nRenderType == KRenderObject::RENDEREFX_BUILDING ||
			m_nRenderType == KRenderObject::RENDEREFX_BUILDING_HAS_STOOL )
		{
			if( IsLodExist() )
			{
				//_oprint( "Building LOD Level : %d\n", m_nLodLevel );
				switch( m_nLodLevel )
				{
				default:
				case 0: m_pModel->PlayAnimation( GetSafeTickCount(), c_szDefault,      KSeqModel::SEQTYPE_LOOP ); break;
				case 1: m_pModel->PlayAnimation( GetSafeTickCount(), c_szDefaultLod01, KSeqModel::SEQTYPE_LOOP ); break;
				}
			}
		}
	}
}

int CTerrainProp::Process( DWORD dwTime )
{
	if( !m_bIsRealLoad ) return true;

	if( m_dwTime == dwTime ) return true;

	m_dwTime = dwTime;

	//if( NULL != m_pOriginCorrection )
	//{
	//	if( m_ptCurrentOriginCorrection != *m_pOriginCorrection )
	//	{
	//		m_ptCurrentOriginCorrection = *m_pOriginCorrection;
	//		UpdateCorrectedTransform();
	//	}
	//}
	return (NULL != m_pModel) ? m_pModel->Process( dwTime ) : KSeqForm::SEQINFO_NOP;
}

const K3DBoundRotCube* CTerrainProp::GetBoundCube() const
{ 
//	if( m_pModel ) return m_pModel->GetBoundCube();

	return m_pBoundCube; 
}

// { [sonador][COLLIDABLE_CAMERA]
bool CTerrainProp::CheckPolygonCollisionWithCollisionMesh
( const K3DVector& rayStart
, const K3DVector& rayEnd
, float& fNearestT
, K3DVector& vCollidedPoint
#ifdef _DEBUG
, K3DVector* pCollidedPolygon 
#endif
)
{
	if( m_CameraCollisionResource.empty( ) ) return 1.0f;
	if( ( (int)m_CameraCollisionResource.size( ) % 3 ) != 0 ) return 1.0f;

	K3DVector vCandidateCollidedPoint, vTempCollidedPoint, vRay;
	vRay = rayEnd - rayStart;
	
	bool bFound = false;
	float fT = 1.0f;

	std::vector< K3DVector >::iterator it = m_CameraCollisionResource.begin( ), itEnd = m_CameraCollisionResource.end( );
	for( ; it != itEnd; )
	{
		K3DVector& v1 = *it++;
		K3DVector& v2 = *it++;
		K3DVector& v3 = *it++;

		K3DVector tv1, tv2, tv3, tvNormal;
		K3DVectorTransform( tv1, v1, m_matTransform );
		K3DVectorTransform( tv2, v2, m_matTransform );
		K3DVectorTransform( tv3, v3, m_matTransform );
		K3DVectorCross( tvNormal, tv3 - tv1, tv2 - tv1 );

		if(!m_bTestWireCreated)
		{
			K3DVector vPolygonNormal( tvNormal.x, tvNormal.y, tvNormal.z ), vWeightCenter;
			vPolygonNormal.Normalize( 30 );
			vWeightCenter = ( tv1 + tv2 + tv3 ) / 3;
			m_prTestWire.AddLine( tv1, tv2, KColor(0,0,0,255) );
			m_prTestWire.AddLine( tv2, tv3, KColor(0,0,0,255) );
			m_prTestWire.AddLine( tv3, tv1, KColor(0,0,0,255) );
			m_prTestWire.AddLine( vWeightCenter, vWeightCenter + vPolygonNormal, KColor(0,0,255,255) );
		}

		if( K3DVectorDot( vRay, tvNormal ) < 0.f )	// 은면제거
		{
			fT = KPCCP::triangle_collide_edge_twosides( 
				tv1, tv2, tv3, rayStart, rayEnd, vTempCollidedPoint );
			if( fNearestT > fT )
			{
				bFound = true;
				fNearestT = fT;
				vCandidateCollidedPoint = vTempCollidedPoint;
#ifdef _DEBUG
				pCollidedPolygon[ 0 ] = tv1;
				pCollidedPolygon[ 1 ] = tv2;
				pCollidedPolygon[ 2 ] = tv3;
#endif
			}
		}
	}

	m_bTestWireCreated = true;

	if( bFound )
	{
		vCollidedPoint = vCandidateCollidedPoint;
	}

	return bFound;
}

// }
// { [sonador][7.1.7]충돌 처리 개선(Swept Shpere Collision Detection)
bool CTerrainProp::CheckPolygonEllipsoidCollisionWithCollisionMesh
( const K3DVector& rayStart
, const K3DVector& rayEnd
, const K3DMatrix& matCBM
, float& fNearestT
, K3DVector& vCollidedPoint
#ifdef _DEBUG
, K3DVector* pCollidedPolygon 
#endif
)	
{
	// 모든 파라메터는 ellipsoid vecter space 에 놓여있다고 가정된 구현 코드입니다!!!
	if( m_CameraCollisionResource.empty( ) ) return 1.0f;
	if( ( (int)m_CameraCollisionResource.size( ) % 3 ) != 0 ) return 1.0f;

	K3DVector vCandidateCollidedPoint, vRay;
	vRay = rayEnd - rayStart;

	bool bFound = false;
	float fT = 1.0f;

	std::vector< K3DVector >::iterator it = m_CameraCollisionResource.begin( ), itEnd = m_CameraCollisionResource.end( );
	for( ; it != itEnd; )
	{
		K3DMatrix matWorld;
		K3DMatrixMultiply( matWorld, m_matTransform, matCBM );
		
		K3DVector& v1 = *it++;
		K3DVector& v2 = *it++;
		K3DVector& v3 = *it++;

		K3DVector tv1, tv2, tv3, tvNormal;
		K3DVectorTransform( tv1, v1, matWorld );
		K3DVectorTransform( tv2, v2, matWorld );
		K3DVectorTransform( tv3, v3, matWorld );
		K3DVectorCross( tvNormal, tv3 - tv1, tv2 - tv1 );

		if(!m_bTestWireCreated)
		{
			K3DVector vPolygonNormal( tvNormal.x, tvNormal.y, tvNormal.z ), 
				vWeightCenter;
			vPolygonNormal.Normalize( 30 );
			vWeightCenter = ( tv1 + tv2 + tv3 ) / 3;
			m_prTestWire.AddLine( tv1, tv2, KColor(0,0,0,255) );
			m_prTestWire.AddLine( tv2, tv3, KColor(0,0,0,255) );
			m_prTestWire.AddLine( tv3, tv1, KColor(0,0,0,255) );
			m_prTestWire.AddLine( 
				vWeightCenter, vWeightCenter + vPolygonNormal, KColor(0,0,255,255) );
		}

		if( K3DVectorDot( vRay, tvNormal ) < 0.f )	// 은면제거
		{
			if( KPCCP::triangle_collide_swept_unit_sphere( tv1, tv2, tv3, rayStart, vRay, vCandidateCollidedPoint, fT ) && ( fNearestT > fT ) )
			{
				bFound = true;
				fNearestT = fT;
				vCollidedPoint = vCandidateCollidedPoint;
#ifdef _DEBUG
				pCollidedPolygon[ 0 ] = tv1;
				pCollidedPolygon[ 1 ] = tv2;
				pCollidedPolygon[ 2 ] = tv3;
#endif
			}
		}
	}
	m_bTestWireCreated = true;

	return bFound;
}
// }

float CTerrainProp::CheckPolygonCollision( const K3DVector& rNear, const K3DVector& rFar, K3DVector& rPickedPoint )
{
	if(!m_pModel) return false;

	_CID( GETMESH_VERTEXBUFFERS );
	_CID( GETMESH_INDEXBUFFERS );

	KMsgGET_MESHVERTEXBUFFERS msgGMVB;
	m_pModel->Perform(id_GETMESH_VERTEXBUFFERS, msgGMVB);

	KMsgGET_MESHINDEXBUFFERS msgGMIB;
	m_pModel->Perform(id_GETMESH_INDEXBUFFERS, msgGMIB);

	//float fDistance = 0.0f;
	//float fOriginalDistance = Magnitude(K3DVector(rFar - rNear));
	//float fSmallestDistance = fOriginalDistance;
	K3DVector rCandidatePickedPoint, rTempPickedPoint;

	int size = (int)msgGMVB.vVbStruct.size();
	if(size != msgGMIB.vIbStruct.size())
	{
		assert(0);
	}

	float fT = 1.0f;
	float fSmallestT = 1.0f;

	for(int k = 0; k < size; k++)
	{
		if(msgGMVB.vVbStruct[k]->nVBCount != msgGMIB.vIbStruct[k]->nIBCount) continue;

		for(int i = 0; i < msgGMVB.vVbStruct[k]->nVBCount; i++)
		{
			K3DVertexBufferDX* pVb = (K3DVertexBufferDX*) msgGMVB.vVbStruct[k]->pVBs[i];
			K3DIndexBufferDX* pIb = (K3DIndexBufferDX*) msgGMIB.vIbStruct[k]->pIBs[i];

			byte *pVtxData = NULL, *pIdxData = NULL;
			int nVtxCount = pVb->GetVertexCount();
			int nVtxStride = pVb->GetVertexStride();
			int nIdxCount = pIb->GetIndexCount();
			int nIdxFormat = pIb->GetFormat();
			
			int crap;

			//pVb->Lock((void**) &pVtxData, crap);
			//pIb->Lock((void**) &pIdxData, crap);
			//pVb->Lock((void**) &pVtxData, crap, D3DLOCK_READONLY);
			//pIb->Lock((void**) &pIdxData, crap, D3DLOCK_READONLY);
			pVb->Lock((void**) &pVtxData, crap, D3DLOCK_NOOVERWRITE);
			assert(pVtxData && "pVb->Lock((void**) &pVtxData, crap, D3DLOCK_NOOVERWRITE);");
			pIb->Lock((void**) &pIdxData, crap, D3DLOCK_NOOVERWRITE);
			assert(pIdxData && "pIb->Lock((void**) &pIdxData, crap, D3DLOCK_NOOVERWRITE);");

			unsigned short* pIdx16 = NULL;
			unsigned int* pIdx32 = NULL;
			
			K3DVertex v1, v2, v3;
			K3DPlane plane;
		
			for(int j = 0; j < nIdxCount / 3; j += 3)
			{
				if(nIdxFormat == D3DFMT_INDEX16)
				{
					pIdx16 = &((unsigned short*) pIdxData)[j];

					v1 = *((K3DVertex*) (pVtxData + ((*pIdx16) * nVtxStride)));
					++pIdx16;
					v2 = *((K3DVertex*) (pVtxData + ((*pIdx16) * nVtxStride)));
					++pIdx16;
					v3 = *((K3DVertex*) (pVtxData + ((*pIdx16) * nVtxStride)));
					++pIdx16;
				}
				else if(nIdxFormat == D3DFMT_INDEX32)
				{
					pIdx32 = &((unsigned int*) pIdxData)[j];

					v1 = *((K3DVertex*) (pVtxData + ((*pIdx32) * nVtxStride)));
					++pIdx32;
					v2 = *((K3DVertex*) (pVtxData + ((*pIdx32) * nVtxStride)));
					++pIdx32;
					v3 = *((K3DVertex*) (pVtxData + ((*pIdx32) * nVtxStride)));
					++pIdx32;
				}
				else
				{
					assert(0);
				}

				K3DVertex tv1, tv2, tv3;
				K3DMatrix matRes;
				K3DMatrixMultiply( matRes, msgGMVB.vVbStruct[k]->matLocal, m_matTransform );
				K3DVectorTransform(tv1, v1, matRes);
				K3DVectorTransform(tv2, v2, matRes);
				K3DVectorTransform(tv3, v3, matRes);

				//if(m_bDrawTestWire && !m_bTestWireCreated)
				if(!m_bTestWireCreated)
				{
					m_prTestWire.AddLine( tv1, tv2, KColor(0,0,0,255) );
					m_prTestWire.AddLine( tv2, tv3, KColor(0,0,0,255) );
					m_prTestWire.AddLine( tv3, tv1, KColor(0,0,0,255) );
				}

				//if( KPCCP::triangle_collide_edge( tv1, tv2, tv3, rNear, rFar ) )
				//{
				//	if( K3DPlaneFromPoints( &plane, &tv1, &tv2, &tv3 ) )
				//	{
				//		if( K3DPlaneIntersectLine( &rTempPickedPoint, &plane, &rNear, &rFar ) )
				//		{
				//			fT = Magnitude(rTempPickedPoint - rNear) / Magnitude(K3DVector(rFar - rNear));
				//			if(fSmallestT > fT)
				//			{
				//				fSmallestT = fT;
				//				rCandidatePickedPoint = rTempPickedPoint;
				//			}
				//		}
				//	}
				//}

				//if( KPCCP::triangle_collide_edge( tv1, tv3, tv2, rNear, rFar ) )
				//{
				//	if( K3DPlaneFromPoints( &plane, &tv1, &tv3, &tv2 ) )
				//	{
				//		if( K3DPlaneIntersectLine( &rTempPickedPoint, &plane, &rNear, &rFar ) )
				//		{
				//			fT = Magnitude(rTempPickedPoint - rNear) / Magnitude(K3DVector(rFar - rNear));
				//			if(fSmallestT > fT)
				//			{
				//				fSmallestT = fT;
				//				rCandidatePickedPoint = rTempPickedPoint;
				//			}
				//		}
				//	}
				//}

				fT = KPCCP::triangle_collide_edge_twosides( tv1, tv2, tv3, rNear, rFar, rTempPickedPoint );
				if( fSmallestT > fT )
				{
					fSmallestT = fT;
					rCandidatePickedPoint = rTempPickedPoint;
				}
			}

			pVb->Unlock();
			pIb->Unlock();
		}
	}

	m_bTestWireCreated = true;

	if(fSmallestT < 1.0f)
	{
		rPickedPoint = rCandidatePickedPoint;
		//return true;
	}

	//return false;

	return fSmallestT;
}

void CTerrainProp::ClipTest( const K3DVector* pFrustum)
{
	if( m_pBoundCube )
		m_bIsClip = !KPCCP::nonuniformcube_collide_nonuniformcube(pFrustum, m_pBoundCube->GetVertices());
}

bool CTerrainProp::GetIsClip()
{
	return m_bIsClip;
}

void CTerrainProp::Render( KViewportObject* pViewport )
{
	//if(!m_bVisible) return;

	if( !m_bIsRealLoad ) return;

	//if( GetKeyState( VK_SCROLL ) > 0 )
	//{
	//	for( TERRAINSTOOL_VECTOR::iterator itStool = m_StoolVector.begin(); itStool != m_StoolVector.end(); itStool++ )
	//		(*itStool).Render( pViewport );
	//}
	//else
	//{
	if( NULL != m_pModel )
	{
		if( m_fVisibility > 0.f )
		{
			m_pModel->Render( pViewport, m_nRenderFlag );

			/// 2010.11.10 - prodongi
//#ifdef _DEV
			if (g_UserInfo.isMonkeyTail())
			{
				// { 툴에서는 g_bDebugMode 는 무시해도 됨
				extern bool g_bDebugMode;
				if( g_bDebugMode && ( GetKeyState( VK_SCROLL ) & 0x0001 ) && ( GetKeyState( VK_SHIFT ) & 0x8000 ) )
				{
					if( m_pBoundCube ) m_pBoundCube->Render( pViewport );
				}
			}
//#endif
			// }
		}
	}

	if( m_bCameraCollisionRender )
	{
		if( m_pCameraCollision )
		{
			m_pCameraCollision->SetVisibility( m_fCameraCollisionVisibility );	//[sonador][7.1.5]테스트용 클라이언트 제작 및 충돌 프랍 투명화 적용
			m_pCameraCollision->Render( pViewport );
		}
	}

	//높이 화일	
	if( m_bHeightRender )
	{
		if( m_pModelHeight && m_fVisibility > 0.f )
		{
			if( m_pBoundCube ) m_pBoundCube->Render( pViewport );
			m_pModelHeight->Render( pViewport, m_nRenderFlag );

			pViewport->RegisterWire( &m_WirePrimitive );
		}
	}

	//
	if(m_bDrawTestWire)
	{
		pViewport->RegisterWire( &m_prTestWire );
	}
}

bool CTerrainProp::IsLoadCompleted() const
{
	if( m_pModel )
	{
		if( !m_pModel->IsLoadCompleted() ) 
			_oprint( "CTerrainProp::IsLoadCompleted() m_pModel->IsLoadCompleted() == false %d\n", m_wPropNum );
//			assert( false && "CTerrainProp::IsLoadCompleted() 리소스 파일을 찾을수 없기때문에 Render에서 제외됨 리소스 관리자에게 문의 하세요" );
	}
	else
	{
		_oprint( "CTerrainProp::IsLoadCompleted() m_pModel == NULL %d\n", m_wPropNum );
		//assert( false && "CTerrainProp::IsLoadCompleted() m_pModel == NULL 리소스 관리자에게 문의 하세요" );
	}

	return true;

	//nx3 파일 리소스가 존재 하지 않을시 로딩 화면에서 멈추는 현상이 발생될수 있음 - by metarrgear
/* 	if( m_pModel && m_pModel->IsLoadCompleted() == false )
	{
		m_pModel->TryPlayAnimation();
	}					

	return (NULL != m_pModel) ? m_pModel->IsLoadCompleted() : true;*/
}

void CTerrainProp::GetAttrbuteCubes( std::vector<K3DBoundRotCube>& rCubeVector ) const
{
	if( NULL != m_pModel )
	{
		// 속성 큐브를 구한다.
		_CID( REQ_EVBOX );
		KMsgREQ_EVBOX msg;
		if( NULL != m_pModel->Perform( id_REQ_EVBOX, msg ) )
		{
			const K3DMatrix& rPropMatrix = m_matTransform;

			int nBoxCount = msg.GetBoxCount();
			for( int n( 0 ); n < nBoxCount; ++n )
			{
				KEventBoxSeq* pEvBoxSeq = msg.GetBox( n );
				if( 0 == ::_stricmp( pEvBoxSeq->GetName(), c_szAttributeCube ) )
				{
					K3DBoundRotCube cube = pEvBoxSeq->GetCube();
					cube.AddTransform( rPropMatrix );

					rCubeVector.push_back( cube );
				}
			}
		}
	}
}

void CTerrainProp::Load_Real( bool bSlowLoad )
{
	if( m_bIsRealLoad ) return;

	//실제 보이는 프랍 로딩.
	//높이 화일 우선 로딩 대상.
	//Main 로딩 우선 순위 영향.
	//Lod  로딩 우선 순위 영향.

	struct _FlagRemover
	{
		_FlagRemover( volatile bool* volatile f ) : pFlag( f )	{}

		~_FlagRemover()	{ *pFlag = false; }

		volatile bool* volatile pFlag;
	};
	
	volatile _FlagRemover _remover01( &m_bIsThreadLoading );
	volatile _FlagRemover _remover02( &m_bIsThreadPending );

	if( m_strFileName.length() <= 0 )
	{	//프랍 이름 없는 것들
		m_bIsRealLoad = true;
		return;
	}

	std::vector<COBSET *>* coblist = COBManager::GetManager()->Load( m_strFileName.c_str() );
	if( coblist == NULL ) 
	{
		m_bIsRealLoad = true;
		return;
	}

	if( bSlowLoad ) Sleep( 10 );

	std::vector<COBSET *>::iterator it = coblist->begin();

	if( it != coblist->end() )
	{
		COBSET * pPropSet = (*it);

		//Prop 이 아니면 로딩 안 됨
		if( pPropSet->nClan != GCLAN_PROP_NX3   && 
			pPropSet->nClan != GCLAN_PROP_SPEED && 
			pPropSet->nClan != GCLAN_PROP_COB      )
		{
			m_bIsRealLoad = true;
			return;
		}

		if( pPropSet->m_AniList.empty() ) return;

		if( pPropSet->nClan == GCLAN_PROP_NX3   )
		{
			KSeqModel* pSeqNX3 = new KSeqModel;
			pSeqNX3->Initialize();

			NX3LoadPack loadpack;
			loadpack.Init();

			const char* nx3FileName = "";
			for( unsigned int i(0); pPropSet->m_AniList.size()>i; i++ )  //NX3
			{
				nx3FileName = pPropSet->m_AniList[i].c_str();
				pSeqNX3->AddAnimation( c_szDefault, nx3FileName, KNX3Manager::SEQTYPE_ALL, &loadpack );
				break;
			}

			if( bSlowLoad ) Sleep( 1 );

			for( unsigned int i(0); pPropSet->m_LodList.size()>i; i++ )  //Lod
			{
				pSeqNX3->AddAnimation( c_szDefaultLod01, pPropSet->m_LodList[i].strName.c_str(), KNX3Manager::SEQTYPE_ALL, &loadpack );
				m_bLodExist = true;
				break;
			}

			if( bSlowLoad ) Sleep( 1 );

			if( !pSeqNX3->PlayAnimation( GetSafeTickCount(), c_szDefault, KSeqModel::SEQTYPE_LOOP ) )
			{
				SAFE_DELETE( pSeqNX3 );
				SAFE_DELETE( m_pBoundCube );
				m_pBoundCube = CreateDummyBoundCube();
				m_bIsRealLoad = true;
				return;
			}

			if( bSlowLoad ) Sleep( 1 );

			m_pModel = pSeqNX3;
			m_nx3FileName = nx3FileName;
			
			// Lightmap Set
			THREAD_SYNCRONIZE(m_LightmapSetLock);
			_SetLightmap();
		}
		else if( pPropSet->nClan == GCLAN_PROP_SPEED )
		{
			for( unsigned int i(0); pPropSet->m_AniList.size()>i; i++ )  //Spt 화일
			{
				m_pModel = SpeedTreeManager::GetManager()->Load( pPropSet->m_AniList[i].c_str(), m_matTransform, m_matTransform._11 );
				if( bSlowLoad ) Sleep( 1 );
				break;
			}
		}
		else if( pPropSet->nClan == GCLAN_PROP_COB   )
		{
			KSeqAvatar* pSeqNAF = new KSeqAvatar;
			pSeqNAF->Initialize();

			for( unsigned int i(0); pPropSet->m_AniList.size()>i; i++ )  //Naf
			{
				pSeqNAF->AddAnimation( pPropSet->m_AniList[i].c_str(), TRUE );
				break; //한개만 추가
			}

			if( bSlowLoad ) Sleep( 1 );

			assert( pPropSet->m_MeshList.size() && "그래픽 리소스 에러 : Prop Mesh 가 없다." );
			for( unsigned int i(0); pPropSet->m_MeshList.size()>i; i++ )  //NX3
			{
				pSeqNAF->AddMesh( MPART_HAIR, pPropSet->m_MeshList[i].c_str() );
				break; //한개만 추가
			}

			if( bSlowLoad ) Sleep( 1 );

			pSeqNAF->PlayAnimation( GetSafeTickCount(), c_szDefault, KSeqModel::SEQTYPE_LOOP );

			if( bSlowLoad ) Sleep( 1 );

			m_pModel = pSeqNAF;
		}
		else
			assert( false && "pPropSet->nClan 알수없는 타입임" );

		// { [sonador][COLLIDABLE_CAMERA]
		if( pPropSet->m_strCameraCollisionFile.empty( ) || _stricmp( pPropSet->m_strCameraCollisionFile.c_str(), "empty" ) == 0 )
		{
			//cob에 cacol이 저장되있지 않다면 수동으로 ㅡ.,ㅡ
			pPropSet->m_strCameraCollisionFile = m_strFileName;
			size_t pos	= pPropSet->m_strCameraCollisionFile.find( "." );
			if(pos > 0 ) 
			{
				pPropSet->m_strCameraCollisionFile.erase( pos, 4 );
				pPropSet->m_strCameraCollisionFile += "_cacol.nx3";
			}
		}
		// }

		if( pPropSet->m_strCameraCollisionFile.length() > 0 && _stricmp( pPropSet->m_strCameraCollisionFile.c_str(), "empty" ) != 0 ) //카메라 충돌용 메쉬
		{
			SAFE_DELETE( m_pCameraCollision );
			KSeqModel* pSeqNX3 = new KSeqModel;
			pSeqNX3->Initialize();

			NX3LoadPack loadpack;
			loadpack.Init();
			pSeqNX3->AddAnimation( "default", pPropSet->m_strCameraCollisionFile.c_str(), KNX3Manager::SEQTYPE_ALL, &loadpack );
			if( bSlowLoad ) Sleep( 1 );
			pSeqNX3->PlayAnimation( GetSafeTickCount(), "default", KSeqModel::SEQTYPE_LOOP );
			if( bSlowLoad ) Sleep( 1 );
				
			m_pCameraCollision = pSeqNX3;
			// { [sonador][COLLIDABLE_CAMERA]
			KSeqObject* pSeqObj = m_pCameraCollision->GetCurrentAnimation();
			if( pSeqObj ) pSeqObj->realizeTime();
			// }
			CreateCameraCollisionSource( );
#ifndef _DEBUG	//디버그 버전도 아니고
#ifndef _DEV	//개발용 버전도 아니면
			SAFE_DELETE( m_pCameraCollision ); //배포용이므로 지우자
#endif
#endif
		}
		
		if( pPropSet->m_strHeightFile.length() > 0 && _stricmp( pPropSet->m_strHeightFile.c_str(), "empty" ) != 0 ) //높이 화일
		{
			KSeqModel* pSeqNX3 = new KSeqModel;
			pSeqNX3->Initialize();

			//TODO
			NX3LoadPack loadpack;
			loadpack.Init();
			loadpack.bLoad_PolyGon = true;

			pSeqNX3->AddAnimation( c_szDefault, pPropSet->m_strHeightFile.c_str(), KNX3Manager::SEQTYPE_ALL, &loadpack );

			if( bSlowLoad ) Sleep( 1 );

			pSeqNX3->PlayAnimation( GetSafeTickCount(), c_szDefault, KSeqModel::SEQTYPE_LOOP );

			if( bSlowLoad ) Sleep( 1 );

			_CID( GETMESH_TRI );
			KMsgGET_GETMESH_TRI msg;
			msg.mat            = m_matTransform;
			msg.pListTriangles = &m_listTrianglesHeight;
			
			pSeqNX3->Perform( id_GETMESH_TRI, msg );

#ifndef NDEBUG
			for(int i = 0; i < (int)m_listTrianglesHeight.size(); i += 3)
			{
				K3DVector &v1 = m_listTrianglesHeight[i+0];
				K3DVector &v2 = m_listTrianglesHeight[i+1];
				K3DVector &v3 = m_listTrianglesHeight[i+2];

				m_WirePrimitive.AddLine( v1, v2, KColor(255,255,0,255) );
				m_WirePrimitive.AddLine( v2, v3, KColor(0,255,255,255) );
				m_WirePrimitive.AddLine( v3, v1, KColor(255,0,255,255) );
			}
#endif
			CreateTriangleIndex();

#ifdef _DEBUG
			m_pModelHeight = pSeqNX3;
#else
			delete pSeqNX3;
#endif

			//높이 벡터 만들기
		}

		//텍스처 그룹 설정
		if( pPropSet->m_TextureGroupList[0].empty() == false )
		{
			iterator_texture_group_list itTextureGroupResult;

			iterator_texture_group_list itTextureGroup = pPropSet->m_TextureGroupList[0].begin();
			if( itTextureGroup != pPropSet->m_TextureGroupList[0].end() )
			{
				iterator_seq_list itSeqList = (*itTextureGroup)->vSeqList.begin();
				for( ; itSeqList != (*itTextureGroup)->vSeqList.end(); ++itSeqList )
				{
					for( int nTexGroupIndex = 0; nTexGroupIndex < TEXTURE_GROUP_INDEX_MAX; ++nTexGroupIndex )
					{
						int nTexUsingIndex = 0;
						std::vector< std::string >::iterator itStr = (*itSeqList)->vTextureIndex[nTexGroupIndex].begin();
						for( ; itStr != (*itSeqList)->vTextureIndex[nTexGroupIndex].end(); ++itStr, ++nTexUsingIndex )
						{
							itTextureGroupResult = findname( m_vTextureGroupData.begin(), m_vTextureGroupData.end(), (*itTextureGroup)->GetName() );
							if( itTextureGroupResult != m_vTextureGroupData.end() )
							{
								iterator_seq_list itSeqResult;
								itSeqResult = findname( (*itTextureGroupResult)->vSeqList.begin(), (*itTextureGroupResult)->vSeqList.end(), (*itSeqList)->GetName() );
								if( itSeqResult != (*itTextureGroupResult)->vSeqList.end() )
								{
									if( nTexUsingIndex < (int)(*itSeqResult)->vTextureIndex[nTexGroupIndex].size() )
										(*itSeqResult)->vTextureIndex[nTexGroupIndex][nTexUsingIndex] = (*itStr).c_str();
									else
									{
										(*itSeqResult)->vTextureIndex[nTexGroupIndex].resize( nTexUsingIndex + 1, "" );
										(*itSeqResult)->vTextureIndex[nTexGroupIndex][nTexUsingIndex] = (*itStr).c_str();
									}
								}
								else
								{
									TEXTURE_GROUP_LIST::Seq_list* seq = new TEXTURE_GROUP_LIST::Seq_list;
									seq->strSeqName = (*itSeqList)->strSeqName.c_str();
									seq->vTextureIndex[nTexGroupIndex].resize( nTexUsingIndex + 1, "" );
									seq->vTextureIndex[nTexGroupIndex][nTexUsingIndex] = (*itStr).c_str();
									(*itTextureGroupResult)->vSeqList.push_back( seq );
								}
							}
							else
							{								
								TEXTURE_GROUP_LIST* texture_data = new TEXTURE_GROUP_LIST;
								texture_data->strNx3Name	= (*itTextureGroup)->strNx3Name.c_str();

								TEXTURE_GROUP_LIST::Seq_list* pSeq = new TEXTURE_GROUP_LIST::Seq_list;
								pSeq->strSeqName = (*itSeqList)->strSeqName.c_str();
								pSeq->vTextureIndex[nTexGroupIndex].resize( nTexUsingIndex + 1, "" );
								pSeq->vTextureIndex[nTexGroupIndex][nTexUsingIndex] = (*itStr).c_str();
								texture_data->vSeqList.push_back( pSeq );
								m_vTextureGroupData.push_back( texture_data );
							}
						}
					}
				}
			}
			
			ChangeTexture( m_nTextureGroupIndex );
		}
	}	

//툴만
#ifndef _RAC
	if( m_pModel )
	{	//성능 관련된 정보 얻기
		_CID( GET_PERFORMANCEINFO );
		KMsgGET_PERFORMANCEINFO msg;
		m_pModel->Perform( id_GET_PERFORMANCEINFO, msg );
	}
#endif

	if( bSlowLoad ) Sleep( 1 );

	RefreshAllTransform();
	CreateStools();
	SetVisibility( 1.f );


	m_bIsRealLoad = true;
}

void CTerrainProp::LoadCOB( const char* szFileName, const K3DMatrix& rMatrix )
{
	//COB 데이타 만 읽어 들인다.
	//Cube 데이타 읽어 온다.

	if( m_strFileName.length() <= 0 )
	{	//프랍 이름 없는 것들
		m_pBoundCube = CreateDummyBoundCube();
		m_bIsRealLoad = true;
		return;
	}

	std::vector<COBSET *>* coblist = COBManager::GetManager()->Load( szFileName );
	if( coblist == NULL ) 
	{
		m_pBoundCube = CreateDummyBoundCube();
		return;
	}

	std::vector<COBSET *>::iterator it = coblist->begin();
	
	if( it != coblist->end() )
	{
		COBSET * pPropSet = (*it);

		//Prop 이 아니면 로딩 안 됨
		if( pPropSet->nClan != GCLAN_PROP_NX3   && 
			pPropSet->nClan != GCLAN_PROP_SPEED && 
			pPropSet->nClan != GCLAN_PROP_COB      )
		{
			m_pBoundCube = CreateDummyBoundCube();
			return;
		}

		K3DBoundRotCube* pCube = new K3DBoundRotCube( 
			pPropSet->fVisibleCube[0],			pPropSet->fVisibleCube[3],			
			pPropSet->fVisibleCube[1],			pPropSet->fVisibleCube[4],			
			pPropSet->fVisibleCube[2],			pPropSet->fVisibleCube[5] );

		pCube->SetWireColor( KColor( 255, 255, 0, 255 ) );

		m_pBoundCube       = pCube;
		m_nPropType        = pPropSet->nClan;
		m_dwPropRenderType = pPropSet->nRenderType;
		m_dwPropCategory   = pPropSet->nPropCategory;
		m_dwPropShadowType = pPropSet->nShadowType;
	}
}

KSeqForm* CTerrainProp::CreateNX3Model( const char* szNX3FileName, const char* szNAFFileName )
{
//	_oprint( "CreateNX3Model : %s %s\n", szNX3FileName, szNAFFileName );

	KSeqAvatar* pSeqNAF = new KSeqAvatar;
	pSeqNAF->Initialize();

	if( pSeqNAF->AddMesh( MPART_HAIR, szNX3FileName ) )
	{
		if( pSeqNAF->AddAnimation( szNAFFileName, TRUE ) )
		{
			pSeqNAF->PlayAnimation( GetSafeTickCount(), c_szDefault, KSeqModel::SEQTYPE_LOOP );
			return pSeqNAF;
		}
	}
	delete pSeqNAF;
	return NULL;
}

KSeqForm* CTerrainProp::CreateNAFModel( const char* szFileName )
{
//	_oprint( "CreateNAFModel : %s\n", szFileName );

	KSeqModel* pSeqNX3 = new KSeqModel;
	pSeqNX3->Initialize();

	NX3LoadPack loadpack;
	loadpack.Init();

	if( pSeqNX3->AddAnimation( c_szDefault, szFileName, KNX3Manager::SEQTYPE_ALL, &loadpack ) )
	{
		pSeqNX3->PlayAnimation( GetSafeTickCount(), c_szDefault, KSeqModel::SEQTYPE_LOOP );
		return pSeqNX3;
	}
	delete pSeqNX3;
	return NULL;
}

KSeqForm* CTerrainProp::CreateSpeedTreeModel( const char* szFileName, const K3DMatrix& rMatrix )
{
	//_oprint( "CreateSpeedTreeModel : %s\n", szFileName );

	return SpeedTreeManager::GetManager()->Load( szFileName, rMatrix, rMatrix._11 );
}

KSeqForm* CTerrainProp::CreateNPCModel( const char* szFileName )
{
//	_oprint( "CreateNPCModel : %s\n", szFileName );

	std::vector<COBSET*>* pCobList = COBManager::GetManager()->Load( szFileName );
	if( pCobList )
	{
		KSeqAvatarEx * pSeqAvatar = new KSeqAvatarEx;
		pSeqAvatar->Initialize();

		for( std::vector<COBSET*>::iterator it = pCobList->begin(); pCobList->end() != it; it++ )
		{	
			COBSET* pSet = (*it);
			if( NULL != pSet )
			{
				std::string strAniName;
				for( unsigned int j(0); pSet->m_AniList.size()  > j; j++ ) { pSeqAvatar->AddAnimation( pSet->nAniPart, pSet->m_AniList[j].c_str() ); CStringUtil::GetStrKey( pSet->m_AniList[j].c_str(), '_', strAniName ); }

				for( unsigned int j(0); pSet->m_HelmList.size() > j; j++ ) pSeqAvatar->AddMesh( pSet->nAniPart, MPART_HELM, pSet->m_HelmList[j].c_str() );
				for( unsigned int j(0); pSet->m_HairList.size() > j; j++ ) pSeqAvatar->AddMesh( pSet->nAniPart, MPART_HAIR, pSet->m_HairList[j].c_str() );
				for( unsigned int j(0); pSet->m_FaceList.size() > j; j++ ) pSeqAvatar->AddMesh( pSet->nAniPart, MPART_FACE, pSet->m_FaceList[j].c_str() );
				for( unsigned int j(0); pSet->m_BodyList.size() > j; j++ ) pSeqAvatar->AddMesh( pSet->nAniPart, MPART_BODY, pSet->m_BodyList[j].c_str() );
				for( unsigned int j(0); pSet->m_HandList.size() > j; j++ ) pSeqAvatar->AddMesh( pSet->nAniPart, MPART_HAND, pSet->m_HandList[j].c_str() );
				for( unsigned int j(0); pSet->m_FootList.size() > j; j++ ) pSeqAvatar->AddMesh( pSet->nAniPart, MPART_FOOT, pSet->m_FootList[j].c_str() );

				if( pSet->nAniPart == ANIPART_BIPED )
					pSeqAvatar->PlayAnimation( ANIPART_BIPED, GetSafeTickCount(), strAniName.c_str(), KSeqModel::SEQTYPE_LOOP );
			}
		}
		return pSeqAvatar;
	}
	return NULL;
}

K3DBoundRotCube* CTerrainProp::CreateDummyBoundCube()
{
	K3DBoundRotCube* pCube = new K3DBoundRotCube(
		-c_fDummyCubeHalfLength,
		 c_fDummyCubeHalfLength,
		-c_fDummyCubeHalfLength,
		 c_fDummyCubeHalfLength,
		 0.f,
		 (c_fDummyCubeHalfLength * 2.f) );

	pCube->SetWireColor( KColor( 255, 0, 0, 255 ) );
	pCube->SetWireDrawMode( true );

	return pCube;
}

void CTerrainProp::UpdateTransform()
{
	K3DMatrixIdentity( m_matTransform          );
//	K3DMatrixIdentity( m_matCorrectedTransform );

	K3DMatrix matScale, matRotate, matWorld;
	K3DMatrixIdentity( matScale );
	K3DMatrixIdentity( matRotate );

	K3DMatrixScaling( matScale, m_Scale.x, m_Scale.y, m_Scale.z );
	K3DMatrixRotationYawPitchRoll( matRotate, m_Rotate.x, m_Rotate.y, m_Rotate.z );
	m_matTransform = matScale * matRotate;
	m_matTransform.SetPosVector( K3DVector( m_Pos.x, m_Pos.y, m_Pos.z + m_fZOffset ) );
}

void CTerrainProp::UpdateCorrectedTransform()
{
	//m_matCorrectedTransform = m_matTransform;

	//m_matCorrectedTransform._41 -= m_ptCurrentOriginCorrection.x;
	//m_matCorrectedTransform._42 -= m_ptCurrentOriginCorrection.y;
}

void CTerrainProp::RefreshAllTransform()
{
	UpdateTransform();
//	UpdateCorrectedTransform()

	if( NULL != m_pModel )
	{
		m_pModel->SetParentTransform( &m_matTransform );
	}

	if( NULL != m_pModelHeight )
	{
		m_pModelHeight->SetParentTransform( &m_matTransform );

#ifndef _RAC
		
		m_WirePrimitive.Clear();
		m_listTrianglesHeight.clear();

		_CID( GETMESH_TRI );
		KMsgGET_GETMESH_TRI msg;
		msg.mat            = m_matTransform;
		msg.pListTriangles = &m_listTrianglesHeight;
			
		m_pModelHeight->Perform( id_GETMESH_TRI, msg );
		for(int i = 0; i < (int)m_listTrianglesHeight.size(); i += 3)
		{
			K3DVector &v1 = m_listTrianglesHeight[i+0];
			K3DVector &v2 = m_listTrianglesHeight[i+1];
			K3DVector &v3 = m_listTrianglesHeight[i+2];

			m_WirePrimitive.AddLine( v1, v2, KColor(255,255,0,255) );
			m_WirePrimitive.AddLine( v2, v3, KColor(0,255,255,255) );
			m_WirePrimitive.AddLine( v3, v1, KColor(255,0,255,255) );
		}
#endif
	}

	if( m_pBoundCube ) m_pBoundCube->SetTransform( m_matTransform );

	if( m_pCameraCollision ) m_pCameraCollision->SetTransform( m_matTransform );
}

float CTerrainProp::GetPropHeightByTriangleIndex( float x, float y) const
{
	float fHeight = -999999999.f;

	if( !m_bIsRealLoad ) 
		return fHeight;

	std::vector<PropTri*> triList;
	m_pIndexTri->GetCollisionTriList(x,y,&triList);

	for(size_t i = 0; i < triList.size(); ++i)
	{
		const K3DPlane& plane = triList.at(i)->plane;
		// z = (-ax - by - d) / c;
		float fRet = ( -plane.a * x  -plane.b * y - plane.d ) / plane.c;
		if(fRet > fHeight)
		{
			fHeight = fRet;
		}

	}
	return fHeight;
}

void CTerrainProp::GetPropTriangle( float x, float y, K3DVector& v1, K3DVector& v2, K3DVector& v3 ) const
{
	float fHeight = -999999999.f;

	if( !m_bIsRealLoad ) return;

	std::vector<PropTri*> triList;
	m_pIndexTri->GetCollisionTriList(x,y,&triList);

	PropTri*	pTriList = NULL;
	for(size_t i = 0; i < triList.size(); ++i)
	{
		const K3DPlane& plane = triList.at(i)->plane;
		// z = (-ax - by - d) / c;
		float fRet = ( -plane.a * x  -plane.b * y - plane.d ) / plane.c;
		if(fRet > fHeight)
		{
			fHeight		= fRet;
			pTriList	= triList[i];
		}
	}

	if( pTriList )
	{
		v1 = K3DVector( pTriList->v[0].x, pTriList->v[0].y, pTriList->z[0] );
		v2 = K3DVector( pTriList->v[1].x, pTriList->v[1].y, pTriList->z[1] );
		v3 = K3DVector( pTriList->v[2].x, pTriList->v[2].y, pTriList->z[2] );
	}
}

float CTerrainProp::GetPropHeight( const K3DVector& rNear, const K3DVector& rFar, K3DVector& rPickedPoint ) const
{ 
	if( !m_bIsRealLoad ) 
		return false;

	float fStoolDistance = 1.f;

	for(int i = 0; i < (int)m_listTrianglesHeight.size(); i += 3)
	{
		const K3DVector &v1 = m_listTrianglesHeight[i+0];
		const K3DVector &v2 = m_listTrianglesHeight[i+1];
		const K3DVector &v3 = m_listTrianglesHeight[i+2];

		K3DVector inter;
		float fret = KPCCP::triangle_collide_edge_twosides( v1, v2, v3, rNear, rFar, inter );
		if( fret != 1.f )
		{
			//#ifndef NDEBUG
			//			m_WirePrimitive.AddLine( K3DVector(v1.x, v1.y, v1.z+10.f), K3DVector(v2.x, v2.y, v2.z+10.f), KColor(0,0,0,255) );
			//			m_WirePrimitive.AddLine( K3DVector(v2.x, v2.y, v2.z+10.f), K3DVector(v3.x, v3.y, v3.z+10.f), KColor(0,0,0,255) );
			//			m_WirePrimitive.AddLine( K3DVector(v3.x, v3.y, v3.z+10.f), K3DVector(v1.x, v1.y, v1.z+10.f), KColor(0,0,0,255) );
			//
			//			_oprint( "Prop Height 01 [%s]: %f %f %f\n", m_strFileName.c_str(), inter.x, inter.y, inter.z );
			//#endif
			if( fStoolDistance > fret )
			{
				fStoolDistance = fret;
				rPickedPoint = inter;
			}
		}
	}


	return fStoolDistance;




}


void CTerrainProp::CreateStools()
{
	//if( NULL != m_pModel )
	//{
	//	// 3d 충돌 큐브를 구한다.
	//	_CID( REQ_EVBOX );
	//	KMsgREQ_EVBOX msg;
	//	if( NULL != m_pModel->Perform( id_REQ_EVBOX, msg ) )
	//	{
	//		const K3DMatrix& rPropMatrix = m_matTransform;

	//		int nBoxCount = msg.GetBoxCount();
	//		for( int n( 0 ); n < nBoxCount; ++n )
	//		{
	//			KEventBoxSeq* pEvBoxSeq = msg.GetBox( n );
	//			if( 0 == ::_stricmp( pEvBoxSeq->GetName(), c_szCollisionCube ) )
	//			{
	//				K3DBoundRotCube cube = pEvBoxSeq->GetCube();
	//				cube.AddTransform( rPropMatrix );

	//				// stool 추가
	//				m_StoolVector.push_back( CTerrainStool( cube ) );
	//			}
	//		}
	//	}

	//	if( 0 < m_StoolVector.size() )
	//	{
	//		switch( m_nRenderType )
	//		{
	//		default:
	//		case KRenderObject::RENDEREFX_PROP:     m_nRenderType = KRenderObject::RENDEREFX_PROP_HAS_STOOL;     break;
	//		case KRenderObject::RENDEREFX_BUILDING: m_nRenderType = KRenderObject::RENDEREFX_BUILDING_HAS_STOOL; break;
	//		}
	//	}
	//}
}

bool CTerrainProp::CreateCameraCollisionSource( )
{
	if( !m_pCameraCollision ) return false;

	m_CameraCollisionResource.clear( );

	_CID( GETMESH_VERTEXBUFFERS );
	_CID( GETMESH_INDEXBUFFERS );

	KMsgGET_MESHVERTEXBUFFERS msgGMVB;
	m_pCameraCollision->Perform( id_GETMESH_VERTEXBUFFERS, msgGMVB );

	KMsgGET_MESHINDEXBUFFERS msgGMIB;
	m_pCameraCollision->Perform( id_GETMESH_INDEXBUFFERS, msgGMIB );

	if( msgGMVB.vVbStruct.size() != msgGMIB.vIbStruct.size() )
	{
		assert( 0 );
	}

	int nSize = msgGMVB.vVbStruct.size();

	// for each vertex buffer structs & index buffer structs

	for( int k = 0; k < nSize; ++k )
	{
		if( msgGMVB.vVbStruct[ k ]->nVBCount != msgGMIB.vIbStruct[ k ]->nIBCount ) continue;

		// for each vertex buffers & index buffers in this struct

		for( int j = 0; j < msgGMVB.vVbStruct[ k ]->nVBCount; ++j )
		{
			K3DVertexBuffer* pVB = (K3DVertexBufferDX*)msgGMVB.vVbStruct[ k ]->pVBs[ j ];
			K3DIndexBuffer* pIB	= (K3DIndexBufferDX*)msgGMIB.vIbStruct[ k ]->pIBs[ j ];

			byte *pVtxData = NULL, *pIdxData = NULL;

			int nVtxCount	= pVB->GetVertexCount();
			int nVtxStride	= pVB->GetVertexStride();
			int nIdxCount	= pIB->GetIndexCount();
			int nIdxFormat	= pIB->GetFormat();
			
			K3DVector v1, v2, v3;
			K3DPlane plane;
			unsigned short* pIdx16 = 0;
			unsigned int* pIdx32 = 0;

			// lock buffers

			int crap;

			pVB->Lock((void**) &pVtxData, crap, D3DLOCK_NOSYSLOCK);
			if( pVtxData == 0 )
				continue;
			assert(pVtxData && "pVb->Lock((void**) &pVtxData, crap, D3DLOCK_NOOVERWRITE);");
			pIB->Lock((void**) &pIdxData, crap, D3DLOCK_NOSYSLOCK);
			if( pIdxData == 0 )
				continue;
			assert(pIdxData && "pIb->Lock((void**) &pIdxData, crap, D3DLOCK_NOOVERWRITE);");

			for( int i = 0; i < nIdxCount; i += 3 )
			{
				if(nIdxFormat == D3DFMT_INDEX16)
				{
					pIdx16 = &( (unsigned short*)pIdxData )[ i ];

					v1 = *( (K3DVertex*)( pVtxData + ( (*pIdx16) * nVtxStride ) ) );
					++pIdx16;
					v2 = *( (K3DVertex*)( pVtxData + ( (*pIdx16) * nVtxStride ) ) );
					++pIdx16;
					v3 = *( (K3DVertex*)( pVtxData + ( (*pIdx16) * nVtxStride ) ) );
					++pIdx16;
				}
				else if(nIdxFormat == D3DFMT_INDEX32)
				{
					pIdx32 = &( (unsigned int*)pIdxData )[ i ];

					v1 = *( (K3DVertex*)( pVtxData + ( (*pIdx32) * nVtxStride ) ) );
					++pIdx32;
					v2 = *( (K3DVertex*)( pVtxData + ( (*pIdx32) * nVtxStride ) ) );
					++pIdx32;
					v3 = *( (K3DVertex*)( pVtxData + ( (*pIdx32) * nVtxStride ) ) );
					++pIdx32;
				}
				else
				{
					assert(0);
				}

				K3DVectorTransform( v1, v1, msgGMVB.vVbStruct[ k ]->matLocal );
				K3DVectorTransform( v2, v2, msgGMVB.vVbStruct[ k ]->matLocal );
				K3DVectorTransform( v3, v3, msgGMVB.vVbStruct[ k ]->matLocal );

				m_CameraCollisionResource.push_back( v1 );
				m_CameraCollisionResource.push_back( v2 );
				m_CameraCollisionResource.push_back( v3 );
			}

			// unlock buffers

			pVB->Unlock();
			pIB->Unlock();
		}
	}
	return true;
}

void CTerrainProp::CreateTriangleIndex()
{
	if( m_pIndexTri )
	{
		assert(0);
		return;
	}

	if(m_listTrianglesHeight.empty())
		return;

	// Min,Max 구하셈 -_-
	float left,top,right,bottom;
	left = top = m_listTrianglesHeight.front().x;
	right = bottom = m_listTrianglesHeight.front().y;
	
	for(size_t i = 1; i < m_listTrianglesHeight.size(); ++i)
	{
		const K3DVector &vtx = m_listTrianglesHeight.at(i);
		left = std::min(left, vtx.x);
		top = std::min(top, vtx.y);
	
		right = std::max(right, vtx.x);
		bottom = std::max(bottom, vtx.y);
	}

	m_PropArea = X2D::Rect<float>(left,top, right - left, bottom - top);
	m_pIndexTri = new STriangleIndex(left,top,right - left, bottom - top, m_listTrianglesHeight.size() / 3 );

	for(size_t i = 0; i < m_listTrianglesHeight.size(); i += 3)
	{
		const K3DVector &v1 = m_listTrianglesHeight[i+0];
		const K3DVector &v2 = m_listTrianglesHeight[i+1];
		const K3DVector &v3 = m_listTrianglesHeight[i+2];

		K3DVector vDiff1 = v2 - v1;
		K3DVector vDiff2 = v3 - v1;
		K3DVector vNormal = CrossProduct(vDiff1, vDiff2);
		Normalize(vNormal);

		PropTri tri;
		tri.plane.a = vNormal.x;
		tri.plane.b = vNormal.y;
		tri.plane.c = vNormal.z;
		// ax + by + cz + d = 0;
		tri.plane.d = -( K3DPlaneDotNormal(tri.plane, v1) );

		for(size_t k = 0; k < 3; ++k)
		{
			tri.v[k].x	= m_listTrianglesHeight[i+k].x;
			tri.v[k].y	= m_listTrianglesHeight[i+k].y;
			tri.z[k]	= m_listTrianglesHeight[i+k].z;
		}
		m_pIndexTri->AddTri(tri);
	}


}
void CTerrainProp::RefreshLightmap(bool bEnableLightmap)
{

	THREAD_SYNCRONIZE(m_LightmapSetLock);
	m_bEnableLightmap = bEnableLightmap;

	_SetLightmap();
}

void CTerrainProp::_SetLightmap()
{
	if(NULL != m_pModel && false == m_nx3FileName.empty() )
	{
		// Lightmap Set
		_CID( SET_LIGHT_MAP );
		KMsgSET_LIGHTMAP lightMapSet(m_bEnableLightmap ? m_nx3FileName.c_str() : "", m_segmentIdx, m_propIdx);
		m_pModel->Perform(id_SET_LIGHT_MAP, lightMapSet);
	}
}

CTerrainProp* CTerrainProp::GetTerrainProp()
{
	return this;
}

void CTerrainProp::ChangeTexture( short nTextureGroup )
{
	_CID( CHANGE_MESH_TEXTURE );
	KMsgCHANGE_MESH_TEXTURE msg;

	iterator_texture_group_list itTextureGroupResult = m_vTextureGroupData.begin();

	if( nTextureGroup > -1 && nTextureGroup < TEXTURE_GROUP_INDEX_MAX && 
		m_vTextureGroupData.empty() == false )
	{
		for( ; itTextureGroupResult != m_vTextureGroupData.end(); ++itTextureGroupResult )
		{
			std::vector< TEXTURE_GROUP_LIST::Seq_list* >::iterator itSeqList = (*itTextureGroupResult)->vSeqList.begin();
			for( ; itSeqList != (*itTextureGroupResult)->vSeqList.end(); ++itSeqList )
			{
				msg.szMeshName = (*itSeqList)->strSeqName.c_str();

				std::vector< std::string >::iterator iter = (*itSeqList)->vTextureIndex[nTextureGroup].begin();
				for( ; iter != (*itSeqList)->vTextureIndex[nTextureGroup].end(); ++iter )
				{
					msg.vTextureList.push_back( (*iter).c_str() );
				}

				if( m_pModel ) m_pModel->Perform( id_CHANGE_MESH_TEXTURE, msg );

				msg.vTextureList.clear();
			}						
		}
	}
	else
	{
		if( m_nTextureGroupIndex > -1 && m_nTextureGroupIndex < TEXTURE_GROUP_INDEX_MAX &&
			m_vTextureGroupData.empty() == false )
		{
			for( ; itTextureGroupResult != m_vTextureGroupData.end(); ++itTextureGroupResult )
			{
				std::vector< TEXTURE_GROUP_LIST::Seq_list* >::iterator itSeqList = (*itTextureGroupResult)->vSeqList.begin();
				for( ; itSeqList != (*itTextureGroupResult)->vSeqList.end(); ++itSeqList )
				{
					msg.szMeshName = (*itSeqList)->strSeqName.c_str();

					std::vector< std::string >::iterator iter = (*itSeqList)->vTextureIndex[m_nTextureGroupIndex].begin();
					for( ; iter != (*itSeqList)->vTextureIndex[m_nTextureGroupIndex].end(); ++iter )
					{
						msg.vTextureList.push_back( "" );
					}

					if( m_pModel ) m_pModel->Perform( id_CHANGE_MESH_TEXTURE, msg );

					msg.vTextureList.clear();
				}						
			}
		}
	}

	m_nTextureGroupIndex = nTextureGroup;
}