port 2V2-c: chrmgr/chr modules + race registration chain

PythonCharacterManagerModule/PythonCharacterModule ported verbatim; the
2V0 chr/chrmgr stubs are gone and initchr/initchrmgr run in 40250 order.
The registration chain they need (RaceData/RaceDataFile/RaceManager/
RaceMotionData, GameType, AttributeData/AttributeInstance, TextFileLoader,
Util, Camera/CameraProcedure) is ported; CRaceManager is created in
PythonBoot. port.login_flow asserts race 0 has its wait motions and no
unhandled packet header; port.login_live 8/8 against 192.168.21.203.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

extension/src/port/EterLib/AttributeData.cpp

@@ -0,0 +1,200 @@
+#include "StdAfx.h"
+#include "../EterBase/Utils.h"
+#include "AttributeData.h"
+
+const char c_szAttributeDataFileHeader[] = "AttributeData";
+const int c_iAttributeDataFileHeaderLength = 13;
+
+/*DWORD CAttributeData::GetCollisionDataCount() const
+{
+	return m_CollisionDataVector.size();
+}
+
+BOOL CAttributeData::GetCollisionDataPointer(DWORD dwIndex, const TCollisionData ** c_ppCollisionData) const
+{
+	if (dwIndex >= GetCollisionDataCount())
+		return FALSE;
+
+	*c_ppCollisionData = &m_CollisionDataVector[dwIndex];
+
+	return TRUE;
+}
+*/
+
+const CStaticCollisionDataVector & CAttributeData::GetCollisionDataVector() const
+{
+	return m_StaticCollisionDataVector;
+}
+
+const THeightDataVector & CAttributeData::GetHeightDataVector() const
+{
+	return m_HeightDataVector;
+}
+
+DWORD CAttributeData::GetHeightDataCount() const
+{
+	return m_HeightDataVector.size();
+}
+
+BOOL CAttributeData::GetHeightDataPointer(DWORD dwIndex, const THeightData ** c_ppHeightData) const
+{
+	if (dwIndex >= GetHeightDataCount())
+		return FALSE;
+
+	*c_ppHeightData = &m_HeightDataVector[dwIndex];
+
+	return TRUE;
+}
+
+float CAttributeData::GetMaximizeRadius()
+{
+	return m_fMaximizeRadius;
+}
+
+size_t CAttributeData::AddCollisionData(const CStaticCollisionData& data)
+{
+	m_StaticCollisionDataVector.push_back(data);
+	return m_StaticCollisionDataVector.size();
+}
+
+bool CAttributeData::OnLoad(int /*iSize*/, const void * c_pvBuf)
+{
+	if (!c_pvBuf)
+	{
+		// NOTE: 파일이 존재하지 않으면 다른곳에서 그래픽 모델을 기반으로 충돌 데이터를 생성하니 리소스를 파괴하지 않고 유지시킴.
+		return true;
+	}
+
+	const BYTE * c_pbBuf = static_cast<const BYTE *> (c_pvBuf);
+
+	char szHeader[c_iAttributeDataFileHeaderLength+1];
+	memcpy(szHeader, c_pbBuf, c_iAttributeDataFileHeaderLength+1);
+	c_pbBuf += c_iAttributeDataFileHeaderLength+1;
+	if (strcmp(szHeader, c_szAttributeDataFileHeader))
+		return FALSE;
+
+	DWORD dwCollisionDataCount;
+	DWORD dwHeightDataCount;
+	memcpy(&dwCollisionDataCount, c_pbBuf, sizeof(DWORD));
+	c_pbBuf += sizeof(DWORD);
+	memcpy(&dwHeightDataCount, c_pbBuf, sizeof(DWORD));
+	c_pbBuf += sizeof(DWORD);
+
+	m_StaticCollisionDataVector.clear();
+	m_StaticCollisionDataVector.resize(dwCollisionDataCount);
+	m_HeightDataVector.clear();
+	m_HeightDataVector.resize(dwHeightDataCount);
+
+	for (DWORD i = 0; i < dwCollisionDataCount; ++i)
+	{
+		CStaticCollisionData & rCollisionData = m_StaticCollisionDataVector[i];
+		memcpy(&rCollisionData.dwType, c_pbBuf, sizeof(DWORD));
+		c_pbBuf += sizeof(DWORD);
+		memcpy(rCollisionData.szName, c_pbBuf, 32);
+		c_pbBuf += 32;
+		memcpy(&rCollisionData.v3Position, c_pbBuf, sizeof(D3DXVECTOR3));
+		c_pbBuf += sizeof(D3DXVECTOR3);
+
+		switch(rCollisionData.dwType)
+		{
+			case COLLISION_TYPE_PLANE:
+				memcpy(rCollisionData.fDimensions, c_pbBuf, 2*sizeof(float));
+				c_pbBuf += 2*sizeof(float);
+				break;
+			case COLLISION_TYPE_BOX:
+				memcpy(rCollisionData.fDimensions, c_pbBuf, 3*sizeof(float));
+				c_pbBuf += 3*sizeof(float);
+				break;
+			case COLLISION_TYPE_SPHERE:
+				memcpy(rCollisionData.fDimensions, c_pbBuf, sizeof(float));
+				c_pbBuf += sizeof(float);
+				break;
+			case COLLISION_TYPE_CYLINDER:
+				memcpy(rCollisionData.fDimensions, c_pbBuf, 2*sizeof(float));
+				c_pbBuf += 2*sizeof(float);
+				break;
+			case COLLISION_TYPE_AABB:
+				memcpy(rCollisionData.fDimensions, c_pbBuf, 3*sizeof(float));
+				c_pbBuf += 3*sizeof(float);
+				break;
+			case COLLISION_TYPE_OBB:
+				memcpy(rCollisionData.fDimensions, c_pbBuf, 3*sizeof(float));
+				c_pbBuf += 3*sizeof(float);
+				break;
+		}
+
+		memcpy(rCollisionData.quatRotation, c_pbBuf, sizeof(D3DXQUATERNION));
+		c_pbBuf += sizeof(D3DXQUATERNION);
+	}
+
+	for (DWORD j = 0; j < dwHeightDataCount; ++j)
+	{
+		THeightData & rHeightData = m_HeightDataVector[j];
+		memcpy(rHeightData.szName, c_pbBuf, 32);
+		c_pbBuf += 32;
+
+		DWORD dwPrimitiveCount;
+		memcpy(&dwPrimitiveCount, c_pbBuf, sizeof(DWORD));
+		c_pbBuf += sizeof(DWORD);
+
+		rHeightData.v3VertexVector.clear();
+		rHeightData.v3VertexVector.resize(dwPrimitiveCount);
+		memcpy(&rHeightData.v3VertexVector[0], c_pbBuf, dwPrimitiveCount*sizeof(D3DXVECTOR3));
+		c_pbBuf += dwPrimitiveCount*sizeof(D3DXVECTOR3);
+
+		// Getting Maximize Radius
+		for (DWORD k = 0; k < rHeightData.v3VertexVector.size(); ++k)
+		{
+			m_fMaximizeRadius = fMAX(m_fMaximizeRadius, fabs(rHeightData.v3VertexVector[k].x)+50.0f);
+			m_fMaximizeRadius = fMAX(m_fMaximizeRadius, fabs(rHeightData.v3VertexVector[k].y)+50.0f);
+			m_fMaximizeRadius = fMAX(m_fMaximizeRadius, fabs(rHeightData.v3VertexVector[k].z)+50.0f);
+		}
+		// Getting Maximize Radius
+	}
+
+	return true;
+}
+
+void CAttributeData::OnClear()
+{
+	m_StaticCollisionDataVector.clear();
+	m_HeightDataVector.clear();
+}
+
+bool CAttributeData::OnIsEmpty() const
+{
+	if (!m_StaticCollisionDataVector.empty())
+		return false;
+	if (!m_HeightDataVector.empty())
+		return false;
+
+	return true;
+}
+
+bool CAttributeData::OnIsType(TType type)
+{
+	if (CAttributeData::Type() == type)
+		return true;
+
+	return CResource::OnIsType(type);
+}
+
+CAttributeData::TType CAttributeData::Type()
+{
+	static TType s_type = StringToType("CAttributeData");
+	return s_type;
+}
+
+void CAttributeData::OnSelfDestruct()
+{
+	Clear();
+}
+
+CAttributeData::CAttributeData(const char * c_szFileName) : CResource(c_szFileName)
+{
+	m_fMaximizeRadius = 0.0f;
+}
+
+CAttributeData::~CAttributeData()
+{
+}

extension/src/port/EterLib/AttributeInstance.cpp

@@ -0,0 +1,222 @@
+#include "StdAfx.h"
+#include "../EterBase/Utils.h"
+#include "AttributeInstance.h"
+#include "GrpMath.h"
+
+CDynamicPool<CAttributeInstance> CAttributeInstance::ms_kPool;
+
+const float c_fStepSize = 50.0f;
+
+bool CAttributeInstance::Picking(const D3DXVECTOR3 & v, const D3DXVECTOR3 & dir, float & out_x, float & out_y)
+{
+	if (IsEmpty())
+		return FALSE;
+	//fy *= -1.0f;
+
+	bool bPicked = false;
+	float nx = 0;
+	float ny = 0;
+
+	for (DWORD i = 0; i < m_v3HeightDataVector.size(); ++i)
+		for (DWORD j = 0; j < m_v3HeightDataVector[i].size(); j+=3)
+		{
+			const D3DXVECTOR3 & cv0 = m_v3HeightDataVector[i][j];
+			const D3DXVECTOR3 & cv2 = m_v3HeightDataVector[i][j+1];
+			const D3DXVECTOR3 & cv1 = m_v3HeightDataVector[i][j+2];
+
+			D3DXVECTOR3 n;
+			const auto vvv = (cv1 - cv0);
+			const auto vvv2 = (cv2 - cv0);
+			const auto vvv3 = (cv2 - cv1);
+			D3DXVec3Cross(&n,&vvv,&vvv2);
+			D3DXVECTOR3 x;
+			float t;
+			const auto _vv = (v - cv0);
+			t = - D3DXVec3Dot(&_vv,&n)/D3DXVec3Dot(&dir,&n);
+			
+			x = v+t*dir;
+			const auto vvv4 = (x - cv0);
+			const auto vvv5 = (x - cv1);
+			const auto vvv6 = (x - cv2);
+			D3DXVECTOR3 temp;
+			D3DXVec3Cross(&temp,&vvv,&vvv4);
+			if (D3DXVec3Dot(&temp,&n)<0) continue;
+			D3DXVec3Cross(&temp,&vvv3,&vvv5);
+			if (D3DXVec3Dot(&temp,&n)<0) continue;
+			const auto _vv_ = (cv0 - cv2);
+			D3DXVec3Cross(&temp,&_vv_,&vvv6);
+			if (D3DXVec3Dot(&temp,&n)<0) continue;
+
+			if (bPicked)
+			{
+				if ((v.x-x.x)*(v.x-x.x)+(v.y-x.y)*(v.y-x.y)<(v.x-nx)*(v.x-nx)+(v.y-ny)*(v.y-ny))
+				{
+					nx=x.x;
+					ny=x.y;
+				}
+			}
+			else
+			{
+				nx = x.x;
+				ny = x.y;
+			}
+			bPicked = true;
+	}	
+	if (bPicked)
+	{
+		out_x = nx;
+		out_y = ny;
+	} 
+	return bPicked;
+}
+
+BOOL CAttributeInstance::GetHeight(float fx, float fy, float * pfHeight)
+{	
+	if(IsEmpty())
+		return FALSE;
+
+	fy *= -1.0f;
+
+	if (!IsInHeight(fx, fy))
+		return FALSE;
+
+	BOOL bFlag = FALSE;
+
+	for (DWORD i = 0; i < m_v3HeightDataVector.size(); ++i)
+	for (DWORD j = 0; j < m_v3HeightDataVector[i].size(); j+=3)
+	{
+		const D3DXVECTOR3 & c_rv3Vertex0 = m_v3HeightDataVector[i][j];
+		const D3DXVECTOR3 & c_rv3Vertex1 = m_v3HeightDataVector[i][j+1];
+		const D3DXVECTOR3 & c_rv3Vertex2 = m_v3HeightDataVector[i][j+2];
+
+		if (
+			fx<c_rv3Vertex0.x && fx<c_rv3Vertex1.x && fx<c_rv3Vertex2.x ||
+			fx>c_rv3Vertex0.x && fx>c_rv3Vertex1.x && fx>c_rv3Vertex2.x ||
+			fy<c_rv3Vertex0.y && fy<c_rv3Vertex1.y && fy<c_rv3Vertex2.y ||
+			fy>c_rv3Vertex0.y && fy>c_rv3Vertex1.y && fy>c_rv3Vertex2.y
+			)
+			continue;
+
+		if (IsInTriangle2D(c_rv3Vertex0.x, c_rv3Vertex0.y,
+						   c_rv3Vertex1.x, c_rv3Vertex1.y,
+						   c_rv3Vertex2.x, c_rv3Vertex2.y, fx, fy))
+		{
+			D3DXVECTOR3 v3Line1 = c_rv3Vertex1 - c_rv3Vertex0;
+			D3DXVECTOR3 v3Line2 = c_rv3Vertex2 - c_rv3Vertex0;
+			D3DXVECTOR3 v3Cross;
+
+			D3DXVec3Cross(&v3Cross, &v3Line1, &v3Line2);
+			D3DXVec3Normalize(&v3Cross, &v3Cross);
+
+			if (0.0f != v3Cross.z)
+			{
+				float fd = (v3Cross.x*c_rv3Vertex0.x + v3Cross.y*c_rv3Vertex0.y + v3Cross.z*c_rv3Vertex0.z);
+				float fm = (v3Cross.x*fx + v3Cross.y*fy);
+				*pfHeight = fMAX((fd - fm) / v3Cross.z, *pfHeight);
+
+				bFlag = TRUE;
+			}
+		}
+	}
+
+	return bFlag;
+}
+
+CAttributeData * CAttributeInstance::GetObjectPointer() const
+{
+	return m_roAttributeData.GetPointer();
+}
+BOOL CAttributeInstance::IsInHeight(float fx, float fy)
+{
+	float fdx = m_matGlobal._41 - fx;
+	float fdy = m_matGlobal._42 - fy;
+	if (sqrtf(fdx*fdx + fdy*fdy) > m_fHeightRadius)
+		return FALSE;
+
+	return TRUE;
+}
+
+void CAttributeInstance::SetObjectPointer(CAttributeData * pAttributeData)
+{
+	Clear();
+	m_roAttributeData.SetPointer(pAttributeData);
+}
+
+void CAttributeInstance::RefreshObject(const D3DXMATRIX & c_rmatGlobal)
+{
+	assert(!m_roAttributeData.IsNull());
+
+	m_matGlobal = c_rmatGlobal;
+
+	// Height
+	m_fHeightRadius = m_roAttributeData->GetMaximizeRadius();
+
+	DWORD dwHeightDataCount = m_roAttributeData->GetHeightDataCount();
+	m_v3HeightDataVector.clear();
+	m_v3HeightDataVector.resize(dwHeightDataCount);
+	for (DWORD i = 0; i < dwHeightDataCount; ++i)
+	{
+		const THeightData * c_pHeightData;
+		if (!m_roAttributeData->GetHeightDataPointer(i, &c_pHeightData))
+			continue;
+
+		DWORD dwVertexCount = c_pHeightData->v3VertexVector.size();
+		m_v3HeightDataVector[i].clear();
+		m_v3HeightDataVector[i].resize(dwVertexCount);
+		for (DWORD j = 0; j < dwVertexCount; ++j)
+		{
+			D3DXVec3TransformCoord(&m_v3HeightDataVector[i][j], &c_pHeightData->v3VertexVector[j], &m_matGlobal);
+		}
+	}
+}
+
+const char * CAttributeInstance::GetDataFileName() const
+{
+	return m_roAttributeData->GetFileName();
+}
+
+void CAttributeInstance::CreateSystem(UINT uCapacity)
+{
+	ms_kPool.Create(uCapacity);
+}
+
+void CAttributeInstance::DestroySystem()
+{
+	ms_kPool.Destroy();
+}
+
+CAttributeInstance* CAttributeInstance::New()
+{
+	return ms_kPool.Alloc();
+}
+
+void CAttributeInstance::Delete(CAttributeInstance* pkInst)
+{
+	ms_kPool.Free(pkInst);
+}
+
+BOOL CAttributeInstance::IsEmpty() const
+{
+	if (!m_v3HeightDataVector.empty())
+		return FALSE;
+
+	return TRUE;
+}
+
+void CAttributeInstance::Clear()
+{
+	m_fHeightRadius = 0.0f;
+	m_fCollisionRadius = 0.0f;
+	D3DXMatrixIdentity(&m_matGlobal);
+
+	m_v3HeightDataVector.clear();
+
+	m_roAttributeData.SetPointer(NULL);
+}
+
+CAttributeInstance::CAttributeInstance()
+{
+}
+CAttributeInstance::~CAttributeInstance()
+{
+}

extension/src/port/EterLib/Camera.cpp

@@ -0,0 +1,633 @@
+// Camera.cpp: implementation of the CCamera class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "StdAfx.h"
+#include "../EterBase/Utils.h"
+#include "Camera.h"
+
+const float c_fDefaultResistance = 0.3f;
+
+CCameraManager aCameraManager;	// CCameraManager Instance
+
+void CCamera::SetCameraMaxDistance(float fMax)
+{
+	CAMERA_MAX_DISTANCE = fMax;
+}
+
+float CCamera::GetTargetHeight()
+{
+	return m_fTarget_;
+}
+
+void CCamera::SetTargetHeight(float fTarget)
+{
+	m_fTarget_=fTarget;	
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// CCamera
+//////////////////////////////////////////////////////////////////////////
+
+
+CCamera::CCamera() :
+m_fEyeGroundHeightRatio(0.3f),
+m_fTargetHeightLimitRatio(2.0f),
+m_fResistance(c_fDefaultResistance),
+m_isLock(false)
+{
+	m_fDistance						= 1.0f;
+	m_eCameraState					= CAMERA_STATE_NORMAL;
+	m_eCameraStatePrev				= CAMERA_STATE_NORMAL;
+	m_ulNumScreenBuilding			= 0;
+
+	m_fPitchSum = 0.0f;
+	m_fRollSum = 0.0f;
+
+	m_fTerrainCollisionRadius		= 50.0f;
+	m_fObjectCollisionRadius		= 50.0f;
+
+	m_bDrag							= false;
+
+	m_lMousePosX					= -1;
+	m_lMousePosY					= -1;
+
+	m_fTarget_						= CAMERA_TARGET_STANDARD;
+
+	m_v3AngularAcceleration			= D3DXVECTOR3(0.0f, 0.0f, 0.0f);
+	m_v3AngularVelocity				= D3DXVECTOR3(0.0f, 0.0f, 0.0f);
+
+	m_bProcessTerrainCollision		= true;
+
+    SetViewParams(D3DXVECTOR3(0.0f,0.0f,1.0f), D3DXVECTOR3(0.0f,0.0f,0.0f), D3DXVECTOR3(0.0f,1.0f,0.0f));
+}
+
+CCamera::~CCamera()
+{
+}
+
+void CCamera::Lock()
+{
+	m_isLock = true;
+}
+
+void CCamera::Unlock()
+{
+	m_isLock = false;
+}
+
+bool CCamera::IsLock()
+{
+	return m_isLock;
+}
+
+void CCamera::SetResistance(float fResistance)
+{
+	m_fResistance = c_fDefaultResistance * fResistance;
+}
+
+void CCamera::Wheel(int nLen)
+{
+	if (IsLock())
+		return;
+
+	m_v3AngularVelocity.y = (float)(nLen) * m_fResistance;
+}
+
+void CCamera::BeginDrag(int nMouseX, int nMouseY)
+{
+	if (IsLock())
+		return;
+
+	m_bDrag = true;
+	m_lMousePosX = nMouseX;
+	m_lMousePosY = nMouseY;
+	m_fPitchSum = 0.0f;
+	m_fRollSum = 0.0f;
+}
+
+bool CCamera::IsDraging()
+{
+	if (IsLock())
+		return false;
+
+	return m_bDrag;
+}
+
+bool CCamera::EndDrag()
+{
+	if (IsLock())
+		return false;
+
+	m_bDrag = false;
+
+	float fSum=sqrt(m_fPitchSum*m_fPitchSum+m_fRollSum*m_fRollSum);
+
+	m_fPitchSum = 0.0f;
+	m_fRollSum = 0.0f;
+	
+	if (fSum<1.0f)
+		return false;
+
+	return true;
+}
+
+bool CCamera::Drag(int nMouseX, int nMouseY, LPPOINT lpReturnPoint)
+{
+	if (IsLock())
+		return false;
+
+	if (!m_bDrag)
+	{
+		m_lMousePosX = nMouseX;
+		m_lMousePosY = nMouseY;
+		lpReturnPoint->x = m_lMousePosX;
+		lpReturnPoint->y = m_lMousePosY;
+		return false;
+	}
+	
+	long lMouseX = nMouseX;
+	long lMouseY = nMouseY;
+	
+	float fNewPitchVelocity = (float)(lMouseY - m_lMousePosY) * m_fResistance;
+	float fNewRotationVelocity = (float)(lMouseX - m_lMousePosX) * m_fResistance;
+
+	m_fPitchSum += fNewPitchVelocity;
+	m_fRollSum += fNewRotationVelocity;
+	
+	
+	if (CAMERA_STATE_CANTGOLEFT == GetCameraState())
+		fNewRotationVelocity = fMAX(0.0f, fNewRotationVelocity);
+	if (CAMERA_STATE_CANTGORIGHT == GetCameraState())
+		fNewRotationVelocity = fMIN(0.0f, fNewRotationVelocity);
+	if (CAMERA_STATE_CANTGODOWN == GetCameraState())
+		fNewPitchVelocity = fMAX(0.0f, fNewPitchVelocity);
+	
+	m_v3AngularVelocity.x = fNewRotationVelocity;
+	m_v3AngularVelocity.z = fNewPitchVelocity;
+
+	lpReturnPoint->x = m_lMousePosX;
+	lpReturnPoint->y = m_lMousePosY;
+	return true;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Update
+
+void CCamera::SetCameraState(eCameraState eNewCameraState)
+{
+	if (eNewCameraState == m_eCameraState)
+		return;
+
+	m_eCameraStatePrev = m_eCameraState;
+	m_eCameraState = eNewCameraState;
+
+/*
+	if ((CAMERA_STATE_NORMAL == m_eCameraStatePrev))
+	{
+		m_fDistanceBackup = m_fDistance;
+		m_fPitchBackup = m_fPitch;
+		m_fRollBackup = m_fRoll;
+	}
+	else if ((CAMERA_STATE_CANTGODOWN == m_eCameraStatePrev) && (CAMERA_STATE_CANTGODOWN == m_eCameraState) )
+	{
+		m_v3EyeBackup = m_v3Eye;
+	}
+*/
+}
+
+void CCamera::IncreaseNumSrcreenBuilding()
+{
+	++m_ulNumScreenBuilding;
+}
+
+void CCamera::ResetNumScreenBuilding()
+{
+	m_ulNumScreenBuilding = 0;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Property
+void CCamera::SetViewParams( const D3DXVECTOR3 &v3Eye, const D3DXVECTOR3& v3Target, const D3DXVECTOR3& v3Up)
+{
+	if (IsLock())
+		return;
+
+    // Set attributes for the view matrix
+    m_v3Eye = v3Eye;
+    m_v3Target = v3Target;
+    m_v3Up = v3Up;
+
+	SetViewMatrix();
+}
+
+void CCamera::SetEye(const D3DXVECTOR3 & v3Eye)
+{
+	if (IsLock())
+		return;
+
+    m_v3Eye = v3Eye;
+
+	SetViewMatrix();
+}
+
+void CCamera::SetTarget(const D3DXVECTOR3 & v3Target)
+{
+	if (IsLock())
+		return;
+
+    m_v3Target = v3Target;
+
+	SetViewMatrix();
+}
+
+void CCamera::SetUp(const D3DXVECTOR3 & v3Up)
+{
+	if (IsLock())
+		return;
+
+    m_v3Up = v3Up;
+
+	SetViewMatrix();
+}
+
+void CCamera::SetViewMatrix()
+{
+	m_v3View = m_v3Target - m_v3Eye;
+	D3DXVECTOR3 v3CenterRay = -m_v3View;
+ 	CalculateRoll();
+	m_fDistance = D3DXVec3Length(&m_v3View);
+	assert(m_fDistance >= 0);
+	D3DXVec3Normalize(&m_v3View , &m_v3View);
+
+    D3DXVec3Cross(&m_v3Cross, &m_v3Up, &m_v3View);
+	D3DXVec3Normalize(&m_v3Cross, &m_v3Cross);
+
+    D3DXVec3Cross(&m_v3Up, &m_v3View, &m_v3Cross);
+	D3DXVec3Normalize(&m_v3Up, &m_v3Up);
+	const auto vv = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
+	m_fPitch = D3DXVec3Dot(&m_v3Up, &vv);// / D3DXVec2Length(&v2ViewYZ);
+	if (m_fPitch >= 1)
+		m_fPitch = 1;
+	else if (m_fPitch <= -1)
+		m_fPitch = -1;
+	m_fPitch = acosf(m_fPitch);
+	m_fPitch *= (180.0f / D3DX_PI);
+	if ( 0 < m_v3View.z )
+		m_fPitch = -m_fPitch;
+
+	D3DXMatrixLookAtRH(&m_matView, &m_v3Eye, &m_v3Target, &m_v3Up);
+
+	float fDeterminantD3DMatView = D3DXMatrixfDeterminant(&m_matView);
+    D3DXMatrixInverse(&m_matInverseView, &fDeterminantD3DMatView, &m_matView);
+
+	m_matBillboard = m_matInverseView;
+    m_matBillboard._41 = 0.0f;
+    m_matBillboard._42 = 0.0f;
+    m_matBillboard._43 = 0.0f;
+
+	m_ViewRay.SetStartPoint(m_v3Target);
+	m_ViewRay.SetDirection(v3CenterRay, m_fDistance);
+
+	m_kCameraBottomToTerrainRay.SetStartPoint(m_v3Eye);
+	m_kCameraFrontToTerrainRay.SetStartPoint(m_v3Eye);
+	m_kCameraBackToTerrainRay.SetStartPoint(m_v3Eye);
+	m_kCameraLeftToTerrainRay.SetStartPoint(m_v3Eye);
+	m_kCameraRightToTerrainRay.SetStartPoint(m_v3Eye);
+	m_kTargetToCameraBottomRay.SetStartPoint(m_v3Target);
+
+	m_kCameraBottomToTerrainRay.SetDirection(-m_v3Up, 2.0f * m_fTerrainCollisionRadius);
+	m_kCameraFrontToTerrainRay.SetDirection(m_v3View, 4.0f * m_fTerrainCollisionRadius);
+	m_kCameraBackToTerrainRay.SetDirection(-m_v3View, m_fTerrainCollisionRadius);
+	m_kCameraLeftToTerrainRay.SetDirection(-m_v3Cross, 3.0f * m_fTerrainCollisionRadius);
+	m_kCameraRightToTerrainRay.SetDirection(m_v3Cross, 3.0f * m_fTerrainCollisionRadius);
+	const auto vv2 = (v3CenterRay - m_fTerrainCollisionRadius * m_v3Up);
+	m_kTargetToCameraBottomRay.SetDirection(v3CenterRay - m_fTerrainCollisionRadius * m_v3Up, D3DXVec3Length(&vv2));
+
+	m_kLeftObjectCollisionRay.SetStartPoint(m_v3Target);
+	m_kTopObjectCollisionRay.SetStartPoint(m_v3Target);
+	m_kRightObjectCollisionRay.SetStartPoint(m_v3Target);
+	m_kBottomObjectCollisionRay.SetStartPoint(m_v3Target);
+	const auto vv3 = (v3CenterRay + m_fObjectCollisionRadius * m_v3Cross);
+	const auto vv4 = (v3CenterRay - m_fObjectCollisionRadius * m_v3Cross);
+	const auto vv5 = (v3CenterRay + m_fObjectCollisionRadius * m_v3Up);
+	const auto vv6 = (v3CenterRay + m_fObjectCollisionRadius * m_v3Up);
+	m_kLeftObjectCollisionRay.SetDirection(v3CenterRay + m_fObjectCollisionRadius * m_v3Cross, D3DXVec3Length(&vv3));
+	m_kRightObjectCollisionRay.SetDirection(v3CenterRay - m_fObjectCollisionRadius * m_v3Cross, D3DXVec3Length(&vv4));
+	m_kTopObjectCollisionRay.SetDirection(v3CenterRay + m_fObjectCollisionRadius * m_v3Up, D3DXVec3Length(&vv5));
+	m_kBottomObjectCollisionRay.SetDirection(v3CenterRay - m_fObjectCollisionRadius * m_v3Up, D3DXVec3Length(&vv6));
+}
+
+void CCamera::Move(const D3DXVECTOR3 & v3Displacement)
+{
+	if (IsLock())
+		return;
+
+	m_v3Eye += v3Displacement;
+	m_v3Target += v3Displacement; 
+
+	SetViewMatrix();
+}
+
+void CCamera::Zoom(float fRatio)
+{
+	if (IsLock())
+		return;
+
+	if (fRatio == 1.0f)
+		return;
+
+	D3DXVECTOR3 v3Temp = m_v3Eye - m_v3Target;
+	v3Temp *= fRatio;
+	m_v3Eye = v3Temp + m_v3Target;
+
+	SetViewMatrix();
+}
+
+void CCamera::MoveAlongView(float fDistance) 
+{
+	if (IsLock())
+		return;
+
+	D3DXVECTOR3 v3Temp;
+	D3DXVec3Normalize(&v3Temp, &m_v3View);
+	
+	m_v3Eye += v3Temp * fDistance;
+	m_v3Target += v3Temp * fDistance;
+	
+	SetViewMatrix();
+}
+
+void CCamera::MoveAlongCross(float fDistance) 
+{
+	if (IsLock())
+		return;
+
+	D3DXVECTOR3 v3Temp;
+	D3DXVec3Normalize(&v3Temp, &m_v3Cross);
+
+	m_v3Eye += v3Temp * fDistance;
+	m_v3Target += v3Temp * fDistance;
+
+	SetViewMatrix();
+}
+
+void CCamera::MoveAlongUp(FLOAT fDistance) 
+{
+	if (IsLock())
+		return;
+
+	D3DXVECTOR3 v3Temp ;
+	D3DXVec3Normalize(&v3Temp, &m_v3Up);
+	m_v3Target += v3Temp * fDistance;
+	m_v3Eye += v3Temp * fDistance;
+	SetViewMatrix();
+}
+
+void CCamera::MoveLateral(float fDistance)
+{
+	if (IsLock())
+		return;
+
+	MoveAlongCross(fDistance);
+}
+
+void CCamera::MoveFront(float fDistance) 
+{	
+	if (IsLock())
+		return;
+
+	D3DXVECTOR3 v3Temp = D3DXVECTOR3(m_v3View.x, m_v3View.y, 0.0f);
+	D3DXVec3Normalize(&v3Temp, &v3Temp);
+
+	m_v3Eye += v3Temp * fDistance; 
+	m_v3Target += v3Temp * fDistance;
+	
+	SetViewMatrix();	
+}
+
+void CCamera::MoveVertical(float fDistance) 
+{
+	if (IsLock())
+		return;
+
+	m_v3Eye.z += fDistance;
+	m_v3Target.z += fDistance;
+
+	SetViewMatrix();
+}
+
+//void CCamera::RotateUpper(float fDegree)
+//{
+//	D3DXMATRIX matRot;
+//	D3DXMatrixRotationAxis(&matRot, &m_v3Cross, -D3DXToRadian(fDegree));
+//	D3DXVec3TransformCoord(&m_v3View, &m_v3View, &matRot) ;
+//    D3DXVec3Cross(&m_v3Up, &m_v3View, &m_v3Cross);
+//
+//	m_v3Target = m_v3Eye + m_v3View;
+//
+//	SetViewMatrix() ;
+//}
+
+void CCamera::RotateEyeAroundTarget(float fPitchDegree, float fRollDegree) 
+{
+	if (IsLock())
+		return;
+
+	D3DXMATRIX matRot, matRotPitch, matRotRoll;
+
+	// 머리위로 넘어가기 막기...
+	if (m_fPitch + fPitchDegree > 80.0f)
+	{
+		fPitchDegree = 80.0f - m_fPitch;
+	}
+	else if( m_fPitch + fPitchDegree < -80.0f)
+	{
+		fPitchDegree = -80.0f - m_fPitch;
+	}
+
+	D3DXMatrixRotationAxis(&matRotPitch, &m_v3Cross, D3DXToRadian(fPitchDegree));
+
+	D3DXMatrixRotationZ(&matRotRoll, -D3DXToRadian(fRollDegree));
+	matRot = matRotPitch * matRotRoll;
+
+	D3DXVECTOR3 v3Temp = m_v3Eye - m_v3Target;
+	D3DXVec3TransformCoord(&m_v3Eye, &v3Temp, &matRot);
+	m_v3Eye += m_v3Target;
+
+	SetUp(D3DXVECTOR3(0.0f, 0.0f, 1.0f));
+
+	m_fRoll += fRollDegree;
+
+	if (m_fRoll > 360.0f)
+		m_fRoll -= 360.0f;
+	else if (m_fRoll < -360.0f)
+		m_fRoll += 360.0f;
+}
+
+void CCamera::RotateEyeAroundPoint(const D3DXVECTOR3 & v3Point, float fPitchDegree, float fRollDegree)
+{
+//	if (IsLock())
+//		return;
+
+	D3DXMATRIX matRot, matRotPitch, matRotRoll;
+
+	D3DXMatrixRotationAxis(&matRotPitch, &m_v3Cross, D3DXToRadian(fPitchDegree));
+
+	D3DXMatrixRotationZ(&matRotRoll, -D3DXToRadian(fRollDegree));
+	matRot = matRotPitch * matRotRoll;
+	
+	D3DXVECTOR3 v3Temp = m_v3Eye - v3Point;
+	D3DXVec3TransformCoord(&m_v3Eye, &v3Temp, &matRot);
+	m_v3Eye += v3Point;
+	
+	const auto vv2 = (v3Temp + m_v3Up);
+	D3DXVec3TransformCoord(&m_v3Up, &vv2, &matRot);
+	m_v3Up -= (m_v3Eye - v3Point);
+	
+	v3Temp = m_v3Target - v3Point;
+	D3DXVec3TransformCoord(&m_v3Target, &v3Temp, &matRot);
+	m_v3Target += v3Point;
+
+	SetViewMatrix();
+}
+
+void CCamera::Pitch(const float fPitchDelta)
+{
+//	if (IsLock())
+//		return;
+
+	RotateEyeAroundTarget(fPitchDelta, 0.0f);
+}
+
+void CCamera::Roll(const float fRollDelta)
+{
+//	if (IsLock())
+//		return;
+
+	RotateEyeAroundTarget(0.0f, fRollDelta);
+}
+
+void CCamera::SetDistance(const float fdistance)
+{
+//	if (IsLock())
+//		return;
+
+	Zoom(fdistance/m_fDistance);
+}
+
+void CCamera::CalculateRoll()
+{
+	D3DXVECTOR2 v2ViewXY;
+	v2ViewXY.x = m_v3View.x;
+	v2ViewXY.y = m_v3View.y;
+ 	D3DXVec2Normalize(&v2ViewXY, &v2ViewXY);
+	const auto vv = D3DXVECTOR2(0.0f, 1.0f);
+	float fDot = D3DXVec2Dot(&v2ViewXY, &vv);
+	if (fDot >= 1)
+		fDot = 1;
+	else if (fDot <= -1)
+		fDot = -1;
+	fDot = acosf(fDot);
+	fDot *= (180.0f / D3DX_PI);
+	float fCross = D3DXVec2CCW (&v2ViewXY, &vv);
+	if ( 0 > fCross)
+	{
+		fDot = -fDot;
+	}
+
+	m_fRoll = fDot;
+
+}
+
+//////////////////////////////////////////////////////////////////////////
+// CCameraMananger
+//////////////////////////////////////////////////////////////////////////
+
+CCameraManager::CCameraManager() :
+m_pCurrentCamera(NULL),
+m_pPreviousCamera(NULL)
+{
+	AddCamera(DEFAULT_PERSPECTIVE_CAMERA);
+	AddCamera(DEFAULT_ORTHO_CAMERA);
+
+	SetCurrentCamera(DEFAULT_PERSPECTIVE_CAMERA);
+}
+
+CCameraManager::~CCameraManager()
+{
+	for (TCameraMap::iterator itor = m_CameraMap.begin(); itor != m_CameraMap.end(); ++itor)
+	{
+		delete (*itor).second;
+	}
+	m_CameraMap.clear();
+}
+
+CCamera * CCameraManager::GetCurrentCamera()
+{
+	if (!m_pCurrentCamera)
+		assert(false);
+	return m_pCurrentCamera;
+}
+
+void CCameraManager::SetCurrentCamera(unsigned char ucCameraNum)
+{
+	if (m_pCurrentCamera != m_CameraMap[ucCameraNum])
+		m_pPreviousCamera = m_pCurrentCamera;
+
+	m_pCurrentCamera = m_CameraMap[ucCameraNum];
+}
+
+void CCameraManager::ResetToPreviousCamera()
+{
+	if (!m_pPreviousCamera)
+		assert(false);
+	m_pCurrentCamera = m_pPreviousCamera;
+	m_pPreviousCamera = NULL;
+}
+
+bool CCameraManager::isCurrentCamera(unsigned char ucCameraNum)
+{
+	if (m_CameraMap[ucCameraNum] == m_pCurrentCamera)
+		return true;
+	return false;
+}
+
+// 잡스러운 함수들...
+bool CCameraManager::AddCamera(unsigned char ucCameraNum)
+{
+	if(m_CameraMap.end() != m_CameraMap.find(ucCameraNum))
+		return false;
+	m_CameraMap.insert(TCameraMap::value_type(ucCameraNum, new CCamera));
+	return true;
+}
+
+bool CCameraManager::RemoveCamera(unsigned char ucCameraNum)
+{
+	TCameraMap::iterator itor = m_CameraMap.find(ucCameraNum);
+	if(m_CameraMap.end() == itor)
+		return false;
+	m_CameraMap.erase(itor);
+	return true;
+}
+
+unsigned char CCameraManager::GetCurrentCameraNum()
+{
+	if (!m_pCurrentCamera)
+		return NO_CURRENT_CAMERA;
+	for (TCameraMap::iterator itor = m_CameraMap.begin(); itor != m_CameraMap.end(); ++itor)
+		if(m_pCurrentCamera == (*itor).second)
+			return (*itor).first;
+	return NO_CURRENT_CAMERA;
+}
+
+bool CCameraManager::isTerrainCollisionEnable()
+{
+	return m_pCurrentCamera->isTerrainCollisionEnable();
+}
+
+void CCameraManager::SetTerrainCollision(bool bEnable)
+{
+	m_pCurrentCamera->SetTerrainCollision(bEnable);
+}

extension/src/port/EterLib/TextFileLoader.cpp

@@ -0,0 +1,696 @@
+#include "StdAfx.h"
+#include "../EterBase/CRC32.h"
+#include <string>
+#include "../EterPack/EterPackManager.h"
+
+#include "Pool.h"
+#include "TextFileLoader.h"
+
+std::map<DWORD, CTextFileLoader*> CTextFileLoader::ms_kMap_dwNameKey_pkTextFileLoader;
+bool CTextFileLoader::ms_isCacheMode=false;
+
+CDynamicPool<CTextFileLoader::SGroupNode>	CTextFileLoader::SGroupNode::ms_kPool;
+
+CTokenVector* CTextFileLoader::SGroupNode::GetTokenVector(const std::string& c_rstGroupName)
+{
+	DWORD dwGroupNameKey=GenNameKey(c_rstGroupName.c_str(), c_rstGroupName.length());
+
+	std::map<DWORD, CTokenVector>::iterator f=m_kMap_dwKey_kVct_stToken.find(dwGroupNameKey);
+	if (m_kMap_dwKey_kVct_stToken.end()==f)
+		return NULL;
+
+	return &f->second;
+}
+
+bool CTextFileLoader::SGroupNode::IsExistTokenVector(const std::string& c_rstGroupName)
+{
+	DWORD dwGroupNameKey=GenNameKey(c_rstGroupName.c_str(), c_rstGroupName.length());
+
+	if (m_kMap_dwKey_kVct_stToken.end()==m_kMap_dwKey_kVct_stToken.find(dwGroupNameKey))
+		return false;
+
+	return true;
+}
+
+void CTextFileLoader::SGroupNode::InsertTokenVector(const std::string& c_rstGroupName, const CTokenVector& c_rkVct_stToken)
+{
+	DWORD dwGroupNameKey=GenNameKey(c_rstGroupName.c_str(), c_rstGroupName.length());
+
+	m_kMap_dwKey_kVct_stToken.insert(std::map<DWORD, CTokenVector>::value_type(dwGroupNameKey, c_rkVct_stToken));
+}
+
+DWORD CTextFileLoader::SGroupNode::GenNameKey(const char* c_szGroupName, UINT uGroupNameLen)
+{
+	return GetCRC32(c_szGroupName, uGroupNameLen);
+}
+
+const std::string& CTextFileLoader::SGroupNode::GetGroupName()
+{
+	return m_strGroupName;
+}
+
+bool CTextFileLoader::SGroupNode::IsGroupNameKey(DWORD dwGroupNameKey)
+{
+	if (dwGroupNameKey==m_dwGroupNameKey)
+		return true;
+
+	return false;
+}
+
+void CTextFileLoader::SGroupNode::SetGroupName(const std::string& c_rstGroupName)
+{
+	m_strGroupName=c_rstGroupName;
+	stl_lowers(m_strGroupName);
+
+	m_dwGroupNameKey=GenNameKey(m_strGroupName.c_str(), m_strGroupName.length());
+}
+
+
+CTextFileLoader::SGroupNode* CTextFileLoader::SGroupNode::New()
+{
+	return ms_kPool.Alloc();
+}
+
+void CTextFileLoader::SGroupNode::Delete(SGroupNode* pkNode)
+{
+	pkNode->m_kMap_dwKey_kVct_stToken.clear();
+	pkNode->ChildNodeVector.clear();
+	pkNode->m_strGroupName="";
+	pkNode->m_dwGroupNameKey=0;
+	ms_kPool.Free(pkNode);
+}
+
+
+
+void CTextFileLoader::SGroupNode::DestroySystem()
+{
+	ms_kPool.Destroy();
+}
+
+
+CTextFileLoader* CTextFileLoader::Cache(const char* c_szFileName)
+{
+	DWORD dwNameKey=GetCRC32(c_szFileName, strlen(c_szFileName));
+	std::map<DWORD, CTextFileLoader*>::iterator f=ms_kMap_dwNameKey_pkTextFileLoader.find(dwNameKey);
+	if (ms_kMap_dwNameKey_pkTextFileLoader.end()!=f)
+	{
+		if (!ms_isCacheMode)
+		{
+			delete f->second;
+
+			CTextFileLoader* pkNewTextFileLoader=new CTextFileLoader;
+			pkNewTextFileLoader->Load(c_szFileName);			
+			f->second=pkNewTextFileLoader;
+		}
+		f->second->SetTop();
+		return f->second;
+	}
+
+	CTextFileLoader* pkNewTextFileLoader=new CTextFileLoader;
+	pkNewTextFileLoader->Load(c_szFileName);
+
+	ms_kMap_dwNameKey_pkTextFileLoader.insert(std::map<DWORD, CTextFileLoader*>::value_type(dwNameKey, pkNewTextFileLoader));
+	return pkNewTextFileLoader;
+}
+
+void CTextFileLoader::SetCacheMode()
+{
+	ms_isCacheMode=true;
+}
+
+void CTextFileLoader::DestroySystem()
+{
+	{
+		std::map<DWORD, CTextFileLoader*>::iterator i;
+		for (i=ms_kMap_dwNameKey_pkTextFileLoader.begin(); i!=ms_kMap_dwNameKey_pkTextFileLoader.end(); ++i)
+			delete i->second;
+		ms_kMap_dwNameKey_pkTextFileLoader.clear();
+	}
+
+	SGroupNode::DestroySystem();
+}
+
+void CTextFileLoader::Destroy()
+{
+	__DestroyGroupNodeVector();
+}
+
+CTextFileLoader::CTextFileLoader()
+{
+	SetTop();
+
+	m_acBufData=NULL;
+	m_dwBufSize=0;
+	m_dwBufCapacity=0;
+
+	m_GlobalNode.m_strGroupName = "global";
+	m_GlobalNode.pParentNode = NULL;
+
+	m_kVct_pkNode.reserve(128);	
+}
+
+CTextFileLoader::~CTextFileLoader()
+{
+	Destroy();
+
+	if (m_acBufData)
+		delete [] m_acBufData;
+}
+
+void CTextFileLoader::__DestroyGroupNodeVector()
+{
+	std::vector<SGroupNode*>::iterator i;
+	for (i=m_kVct_pkNode.begin(); i!=m_kVct_pkNode.end(); ++i)
+		SGroupNode::Delete(*i);
+	m_kVct_pkNode.clear();
+}
+
+const char * CTextFileLoader::GetFileName()
+{
+	return m_strFileName.c_str();
+}
+
+bool CTextFileLoader::IsEmpty()
+{
+	return m_strFileName.empty();
+}
+
+bool CTextFileLoader::Load(const char * c_szFileName)
+{
+	m_strFileName = "";
+
+	const VOID* pvData;
+	CMappedFile kFile;
+	if (!CEterPackManager::Instance().Get(kFile, c_szFileName, &pvData))
+		return false;
+
+	if (m_dwBufCapacity<kFile.Size())
+	{
+		m_dwBufCapacity=kFile.Size();
+
+		if (m_acBufData)
+			delete [] m_acBufData;
+
+		m_acBufData=new char[m_dwBufCapacity];
+	}
+
+	m_dwBufSize=kFile.Size();
+	memcpy(m_acBufData, pvData, m_dwBufSize);
+
+	m_strFileName = c_szFileName;
+	m_dwcurLineIndex = 0;
+
+	m_textFileLoader.Bind(m_dwBufSize, m_acBufData);
+	return LoadGroup(&m_GlobalNode);
+}
+
+bool CTextFileLoader::LoadGroup(TGroupNode * pGroupNode)
+{
+	CTokenVector stTokenVector;
+	int nLocalGroupDepth = 0;
+	
+	for (; m_dwcurLineIndex < m_textFileLoader.GetLineCount(); ++m_dwcurLineIndex)
+	{
+		int iRet;
+
+		if ((iRet = m_textFileLoader.SplitLine2(m_dwcurLineIndex, &stTokenVector)) != 0)
+		{
+			if (iRet == -2)
+				TraceError("cannot find \" in %s:%lu", m_strFileName.c_str(), m_dwcurLineIndex);
+			continue;
+		}
+
+		stl_lowers(stTokenVector[0]);
+
+		if ('{' == stTokenVector[0][0])
+		{
+			nLocalGroupDepth++;
+			continue;
+		}
+
+		if ('}' == stTokenVector[0][0]) {
+			nLocalGroupDepth--;
+			break;
+		}
+
+		// Group
+		if (0 == stTokenVector[0].compare("group"))
+		{
+			if (2 != stTokenVector.size())
+			{
+				assert(!"There is no group name!");
+				continue;
+			}
+
+			TGroupNode * pNewNode = TGroupNode::New();
+			m_kVct_pkNode.push_back(pNewNode);
+
+			pNewNode->pParentNode = pGroupNode;
+			pNewNode->SetGroupName(stTokenVector[1]);			
+			pGroupNode->ChildNodeVector.push_back(pNewNode);
+
+			++m_dwcurLineIndex;
+
+			if( false == LoadGroup(pNewNode) )
+				return false;
+		}
+		// List
+		else if (0 == stTokenVector[0].compare("list"))
+		{
+			if (2 != stTokenVector.size())
+			{
+				assert(!"There is no list name!");
+				continue;
+			}
+
+			CTokenVector stSubTokenVector;
+
+			stl_lowers(stTokenVector[1]);
+			std::string key = stTokenVector[1];
+
+			stTokenVector.clear();
+
+			++m_dwcurLineIndex;
+			for (; m_dwcurLineIndex < m_textFileLoader.GetLineCount(); ++m_dwcurLineIndex)
+			{
+				if (!m_textFileLoader.SplitLine(m_dwcurLineIndex, &stSubTokenVector))
+					continue;
+
+				if ('{' == stSubTokenVector[0][0])
+					continue;
+				
+				if ('}' == stSubTokenVector[0][0])
+					break;
+
+				for (DWORD j = 0; j < stSubTokenVector.size(); ++j)
+				{
+					stTokenVector.push_back(stSubTokenVector[j]);
+				}
+			}
+
+			pGroupNode->InsertTokenVector(key, stTokenVector);
+			//pGroupNode->LocalTokenVectorMap.insert(std::make_pair(key, stTokenVector));
+		}
+		else
+		{
+			std::string key = stTokenVector[0];
+
+			if (1 == stTokenVector.size())
+			{
+				TraceError("CTextFileLoader::LoadGroup : must have a value (filename: %s line: %d key: %s)",
+							m_strFileName.c_str(),
+							m_dwcurLineIndex,
+							key.c_str());
+				break;
+			}
+
+			stTokenVector.erase(stTokenVector.begin());
+			pGroupNode->InsertTokenVector(key, stTokenVector);
+			//pGroupNode->LocalTokenVectorMap.insert(std::make_pair(key, stTokenVector));
+		}
+	}
+
+	return (nLocalGroupDepth == 0);
+}
+
+void CTextFileLoader::SetTop()
+{
+	m_pcurNode = &m_GlobalNode;
+}
+
+DWORD CTextFileLoader::GetChildNodeCount()
+{
+	if (!m_pcurNode)
+	{
+		assert(!"Node to access has not set!");
+		return 0;
+	}
+
+	return m_pcurNode->ChildNodeVector.size();
+}
+
+BOOL CTextFileLoader::SetChildNode(const char * c_szKey)
+{
+	if (!m_pcurNode)
+	{
+		assert(!"Node to access has not set!");
+		return FALSE;
+	}
+
+	DWORD dwKey=SGroupNode::GenNameKey(c_szKey, strlen(c_szKey));
+
+	for (DWORD i = 0; i < m_pcurNode->ChildNodeVector.size(); ++i)
+	{
+		TGroupNode * pGroupNode = m_pcurNode->ChildNodeVector[i];
+		if (pGroupNode->IsGroupNameKey(dwKey))
+		{
+			m_pcurNode = pGroupNode;
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+BOOL CTextFileLoader::SetChildNode(const std::string & c_rstrKeyHead, DWORD dwIndex)
+{
+	char szKey[32+1];
+	_snprintf(szKey, sizeof(szKey), "%s%02u", c_rstrKeyHead.c_str(), dwIndex);
+
+	return SetChildNode(szKey);
+}
+BOOL CTextFileLoader::SetChildNode(DWORD dwIndex)
+{
+	if (!m_pcurNode)
+	{
+		assert(!"Node to access has not set!");
+		return FALSE;
+	}
+
+	if (dwIndex >= m_pcurNode->ChildNodeVector.size())
+	{
+		assert(!"Node index to set is too large to access!");
+		return FALSE;
+	}
+
+	m_pcurNode = m_pcurNode->ChildNodeVector[dwIndex];
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::SetParentNode()
+{
+	if (!m_pcurNode)
+	{
+		assert(!"Node to access has not set!");
+		return FALSE;
+	}
+
+	if (NULL == m_pcurNode->pParentNode)
+	{
+		assert(!"Current group node is already top!");
+		return FALSE;
+	}
+
+	m_pcurNode = m_pcurNode->pParentNode;
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetCurrentNodeName(std::string * pstrName)
+{
+	if (!m_pcurNode)
+		return FALSE;
+	if (NULL == m_pcurNode->pParentNode)
+		return FALSE;
+
+	*pstrName = m_pcurNode->GetGroupName();
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::IsToken(const std::string & c_rstrKey)
+{
+	if (!m_pcurNode)
+	{
+		assert(!"Node to access has not set!");
+		return FALSE;
+	}
+
+	return m_pcurNode->IsExistTokenVector(c_rstrKey);
+	//return m_pcurNode->LocalTokenVectorMap.end() != m_pcurNode->LocalTokenVectorMap.find(c_rstrKey);
+}
+
+BOOL CTextFileLoader::GetTokenVector(const std::string & c_rstrKey, CTokenVector ** ppTokenVector)
+{
+	if (!m_pcurNode)
+	{
+		assert(!"Node to access has not set!");
+		return FALSE;
+	}
+
+	CTokenVector* pkRetTokenVector=m_pcurNode->GetTokenVector(c_rstrKey);
+	if (!pkRetTokenVector)
+		return FALSE;
+
+	*ppTokenVector = pkRetTokenVector;
+
+	//CTokenVectorMap::iterator itor = m_pcurNode->LocalTokenVectorMap.find(c_rstrKey);
+	//if (m_pcurNode->LocalTokenVectorMap.end() == itor)
+	//{
+		//Tracef(" CTextFileLoader::GetTokenVector - Failed to find the key %s [%s :: %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+	//	return FALSE;
+	//}
+
+	//*ppTokenVector = &itor->second;
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenBoolean(const std::string & c_rstrKey, BOOL * pData)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->empty())
+	{
+		//Tracef(" CTextFileLoader::GetTokenBoolean - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	*pData = BOOL(atoi(pTokenVector->at(0).c_str()));
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenByte(const std::string & c_rstrKey, BYTE * pData)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->empty())
+	{
+		//Tracef(" CTextFileLoader::GetTokenByte - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	*pData = BYTE(atoi(pTokenVector->at(0).c_str()));
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenWord(const std::string & c_rstrKey, WORD * pData)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->empty())
+	{
+		//Tracef(" CTextFileLoader::GetTokenWord - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	*pData = WORD(atoi(pTokenVector->at(0).c_str()));
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenInteger(const std::string & c_rstrKey, int * pData)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->empty())
+	{
+		//Tracef(" CTextFileLoader::GetTokenInteger - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	*pData = atoi(pTokenVector->at(0).c_str());
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenDoubleWord(const std::string & c_rstrKey, DWORD * pData)
+{
+	return GetTokenInteger(c_rstrKey, *(int **)(&pData));
+}
+
+BOOL CTextFileLoader::GetTokenFloat(const std::string & c_rstrKey, float * pData)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->empty())
+	{
+		//Tracef(" CTextFileLoader::GetTokenFloat - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	*pData = atof(pTokenVector->at(0).c_str());
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenVector2(const std::string & c_rstrKey, D3DXVECTOR2 * pVector2)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->size() != 2)
+	{
+		//Tracef(" CTextFileLoader::GetTokenVector2 - This key should have 2 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	pVector2->x = atof(pTokenVector->at(0).c_str());
+	pVector2->y = atof(pTokenVector->at(1).c_str());
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenVector3(const std::string & c_rstrKey, D3DXVECTOR3 * pVector3)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->size() != 3)
+	{
+		//Tracef(" CTextFileLoader::GetTokenVector3 - This key should have 3 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	pVector3->x = atof(pTokenVector->at(0).c_str());
+	pVector3->y = atof(pTokenVector->at(1).c_str());
+	pVector3->z = atof(pTokenVector->at(2).c_str());
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenVector4(const std::string & c_rstrKey, D3DXVECTOR4 * pVector4)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+	
+	if (pTokenVector->size() != 4)
+	{
+		//Tracef(" CTextFileLoader::GetTokenVector3 - This key should have 3 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+	
+	pVector4->x = atof(pTokenVector->at(0).c_str());
+	pVector4->y = atof(pTokenVector->at(1).c_str());
+	pVector4->z = atof(pTokenVector->at(2).c_str());
+	pVector4->w = atof(pTokenVector->at(3).c_str());
+	
+	return TRUE;
+}
+
+
+BOOL CTextFileLoader::GetTokenPosition(const std::string & c_rstrKey, D3DXVECTOR3 * pVector)
+{
+	return GetTokenVector3(c_rstrKey, pVector);
+}
+
+BOOL CTextFileLoader::GetTokenQuaternion(const std::string & c_rstrKey, D3DXQUATERNION * pQ)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+	
+	if (pTokenVector->size() != 4)
+	{
+		//Tracef(" CTextFileLoader::GetTokenVector3 - This key should have 3 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+	
+	pQ->x = atof(pTokenVector->at(0).c_str());
+	pQ->y = atof(pTokenVector->at(1).c_str());
+	pQ->z = atof(pTokenVector->at(2).c_str());
+	pQ->w = atof(pTokenVector->at(3).c_str());
+	
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenDirection(const std::string & c_rstrKey, D3DVECTOR * pVector)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->size() != 3)
+	{
+		//Tracef(" CTextFileLoader::GetTokenDirection - This key should have 3 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	pVector->x = atof(pTokenVector->at(0).c_str());
+	pVector->y = atof(pTokenVector->at(1).c_str());
+	pVector->z = atof(pTokenVector->at(2).c_str());
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenColor(const std::string & c_rstrKey, D3DXCOLOR * pColor)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->size() != 4)
+	{
+		//Tracef(" CTextFileLoader::GetTokenColor - This key should have 4 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	pColor->r = atof(pTokenVector->at(0).c_str());
+	pColor->g = atof(pTokenVector->at(1).c_str());
+	pColor->b = atof(pTokenVector->at(2).c_str());
+	pColor->a = atof(pTokenVector->at(3).c_str());
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenColor(const std::string & c_rstrKey, D3DCOLORVALUE * pColor)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->size() != 4)
+	{
+		//Tracef(" CTextFileLoader::GetTokenColor - This key should have 4 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	pColor->r = atof(pTokenVector->at(0).c_str());
+	pColor->g = atof(pTokenVector->at(1).c_str());
+	pColor->b = atof(pTokenVector->at(2).c_str());
+	pColor->a = atof(pTokenVector->at(3).c_str());
+
+	return TRUE;
+}
+
+BOOL CTextFileLoader::GetTokenString(const std::string & c_rstrKey, std::string * pString)
+{
+	CTokenVector * pTokenVector;
+	if (!GetTokenVector(c_rstrKey, &pTokenVector))
+		return FALSE;
+
+	if (pTokenVector->empty())
+	{
+		//Tracef(" CTextFileLoader::GetTokenString - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
+		return FALSE;
+	}
+
+	*pString = pTokenVector->at(0);
+
+	return TRUE;
+}

extension/src/port/EterLib/Util.cpp

@@ -0,0 +1,237 @@
+#include "StdAfx.h"
+#include "../EterPack/EterPackManager.h"
+
+#include "TextFileLoader.h"
+
+void PrintfTabs(FILE * File, int iTabCount, const char * c_szString, ...)
+{
+	va_list args;
+	va_start(args, c_szString);
+
+	static char szBuf[1024];
+	_vsnprintf(szBuf, sizeof(szBuf), c_szString, args);
+	va_end(args);
+
+	for (int i = 0; i < iTabCount; ++i)
+		fprintf(File, "    ");
+
+	fprintf(File, szBuf);
+}
+
+bool LoadTextData(const char * c_szFileName, CTokenMap & rstTokenMap)
+{
+	LPCVOID pMotionData;
+	CMappedFile File;
+
+	if (!CEterPackManager::Instance().Get(File, c_szFileName, &pMotionData))
+		return false;
+
+	CMemoryTextFileLoader textFileLoader;
+	CTokenVector stTokenVector;
+
+	textFileLoader.Bind(File.Size(), pMotionData);
+
+	for (DWORD i = 0; i < textFileLoader.GetLineCount(); ++i)
+	{
+		if (!textFileLoader.SplitLine(i, &stTokenVector))
+			continue;
+
+		if (2 != stTokenVector.size())
+			return false;
+
+		stl_lowers(stTokenVector[0]);
+		stl_lowers(stTokenVector[1]);
+
+		rstTokenMap[stTokenVector[0]] = stTokenVector[1];
+	}
+
+	return true;
+}
+
+bool LoadMultipleTextData(const char * c_szFileName, CTokenVectorMap & rstTokenVectorMap)
+{
+	LPCVOID pModelData;
+	CMappedFile File;
+
+	if (!CEterPackManager::Instance().Get(File, c_szFileName, &pModelData))
+		return false;
+
+	DWORD i;
+
+	CMemoryTextFileLoader textFileLoader;
+	CTokenVector stTokenVector;
+
+	textFileLoader.Bind(File.Size(), pModelData);
+
+	for (i = 0; i < textFileLoader.GetLineCount(); ++i)
+	{
+		if (!textFileLoader.SplitLine(i, &stTokenVector))
+			continue;
+
+		stl_lowers(stTokenVector[0]);
+
+		// Start or End
+		if (0 == stTokenVector[0].compare("start"))
+		{
+			CTokenVector stSubTokenVector;
+
+			stl_lowers(stTokenVector[1]);
+			std::string key = stTokenVector[1];
+			stTokenVector.clear();
+
+			for (i=i+1; i < textFileLoader.GetLineCount(); ++i)
+			{
+				if (!textFileLoader.SplitLine(i, &stSubTokenVector))
+					continue;
+
+				stl_lowers(stSubTokenVector[0]);
+
+				if (0 == stSubTokenVector[0].compare("end"))
+				{
+					break;
+				}
+
+				for (DWORD j = 0; j < stSubTokenVector.size(); ++j)
+				{
+					stTokenVector.push_back(stSubTokenVector[j]);
+				}
+			}
+
+			rstTokenVectorMap.insert(CTokenVectorMap::value_type(key, stTokenVector));
+		}
+		else
+		{
+			std::string key = stTokenVector[0];
+			stTokenVector.erase(stTokenVector.begin());
+			rstTokenVectorMap.insert(CTokenVectorMap::value_type(key, stTokenVector));
+		}
+	}
+
+	return true;
+}
+
+D3DXVECTOR3 TokenToVector(CTokenVector & rVector)
+{
+	if (3 != rVector.size())
+	{
+		assert(!"Size of token vector which will be converted to vector is not 3");
+		return D3DXVECTOR3(0.0f, 0.0f, 0.0f);
+	}
+
+	return D3DXVECTOR3(atof(rVector[0].c_str()),
+						atof(rVector[1].c_str()),
+						atof(rVector[2].c_str()));
+}
+
+D3DXCOLOR TokenToColor(CTokenVector & rVector)
+{
+	if (4 != rVector.size())
+	{
+		assert(!"Size of token vector which will be converted to color is not 4");
+		return D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
+	}
+
+	return D3DXCOLOR(atof(rVector[0].c_str()),
+						atof(rVector[1].c_str()),
+						atof(rVector[2].c_str()),
+						atof(rVector[3].c_str()));
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+// PORT: lines 142-296 of 40250 EterLib/Util.cpp (default code page and font face, with the Win32
+// EnumFontFamExProc callback) live in platform/EterLib/Util.cpp, which owns the font backend.
+
+
+int __base64_get( const int c )
+{
+	if( 'A' <= c && c <= 'Z' )
+		return c-'A';
+	if( 'a' <= c && c <= 'z' )
+		return c - 'a' + 26;
+	if( '0' <= c && c <= '9' )
+		return c - '0' + 52;
+	if( c == '+' )
+		return 62;
+	if( c == '/' )
+		return 63;
+	if( c == '=' )	// end of line
+		return -1;
+	return -2;	// non value;
+}
+
+void __strcat1(char * str,int i)
+{
+	char result[2];
+	result[0] = i;
+	result[1] = NULL;
+	strcat(str,result);
+}
+
+void base64_decode(const char * str,char * resultStr)
+{
+	int nCount=0, i=0, r, result;
+	int length = strlen(str);
+	char szDest[5]="";
+
+	strcpy(resultStr,"");
+	while(nCount < length)
+	{
+		i=0;
+		strcpy(szDest, "");
+		while(nCount<length && i<4)	// 4개의 바이트를 얻는다.
+		{			
+			r = str[nCount++];
+			result = __base64_get(r);
+			if(result!=-2)
+			{
+				if(result!=-1)
+					szDest[i++] = result;
+				else szDest[i++] = '@';	// It's end  (64번은 디코딩시 사용되지 않기 때문)
+			}
+		}
+
+		if(i==4)	// 4개의 소스를 모두 얻어냈다. 디코드 시작
+		{	
+			if( nCount+3 >= length )	// 데이터의 끝에 도달했다.
+			{
+				if( szDest[1] == '@' )
+				{
+					__strcat1(resultStr,(szDest[0]<<2));		
+					break;
+				}// exit while loop
+				else 
+					__strcat1(resultStr,(szDest[0]<<2 | szDest[1]>>4));	// 1 Byte
+				if( szDest[2] == '@' )
+				{
+					__strcat1(resultStr,(szDest[1]<<4));
+					break;
+				}
+				else 
+					__strcat1(resultStr,(szDest[1]<<4 | szDest[2]>>2));	// 2 Byte				
+				if( szDest[3] == '@' )
+				{
+					__strcat1(resultStr,(szDest[2]<<6));
+					break;
+				}
+				else 
+					__strcat1(resultStr,(szDest[2]<<6 | szDest[3]));	// 3 Byte				
+			}
+			else
+			{
+				__strcat1(resultStr,(szDest[0]<<2 | szDest[1]>>4));	// 1 Byte
+				__strcat1(resultStr,(szDest[1]<<4 | szDest[2]>>2));	// 2 Byte				
+				__strcat1(resultStr,(szDest[2]<<6 | szDest[3]));	// 3 Byte
+			}
+		}
+		
+	}// end of while
+
+	for (i = 0; i < strlen(resultStr); i++) 
+	{
+		char c = resultStr[i];
+		int xx = i + 5;
+		resultStr[i] = char(c ^ xx);
+	}	
+	// E
+}