Initial commit: ROW Client source code

Game client codebase including:
- CharacterActionControl: Character and creature management
- GlobalScript: Network, items, skills, quests, utilities
- RYLClient: Main client application with GUI and event handlers
- Engine: 3D rendering engine (RYLGL)
- MemoryManager: Custom memory allocation
- Library: Third-party dependencies (DirectX, boost, etc.)
- Tools: Development utilities

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Engine/Caldron/Src/Base/BaseCacheMgr.cpp

@@ -0,0 +1,60 @@
+/* *********************************************************************  
+
+* CBaseCacheMgr , CCacheObj 
+
+* <20><><EFBFBD><EFBFBD> : BaseCacheMgr.cpp 
+* <20><><EFBFBD><EFBFBD> : Caldron<6F><6E><EFBFBD><EFBFBD> <20><><EFBFBD>ο<EFBFBD><CEBF><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> CacheMgr<67><72><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> class
+* history : 
+	2004.01.16 wizardbug
+
+********************************************************************** */  
+
+#include "BaseCacheMgr.h"
+#include "SceneManager.h"
+#include "GMMemory.h"
+
+namespace Caldron {namespace Base {
+/*template < class T >
+T *CBaseCacheMgr<T>::LoadData(const char *strFileName)
+{
+	T *pNode = new T;
+	strcpy(pNode->m_strName,strFileName);
+	CSceneManager::m_pNewMeshObjectContainer->AddObj(Base::CResourceLoaderObj(strFileName,pNode));
+
+	unsigned long DataID = GetHashID(strFileName);
+	Base::CACHEITER itr  = m_CacheTable.find(DataID);
+	
+	if(itr == m_CacheTable.end())
+	{
+		
+		Base::CCacheObj *pObj = new Base::CCacheObj(pNode);
+	
+		m_CacheTable.insert(Base::CACHETABLEOBJ(DataID,pObj));
+		m_iCachesNum++;
+	}
+	else 
+	{// map <20>ȿ<EFBFBD> <20>Ȱ<EFBFBD><C8B0><EFBFBD> Hash Index <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+		
+		((*itr).second)->Add_Back(pNode);	
+	}
+
+	return pNode;
+
+}
+*/
+/*
+	template < class T >
+unsigned long CBaseCacheMgr<T>::GetHashID(const char *strFileName) 
+{
+	unsigned long ulHashId = 0;
+
+	int iLength = (int)strlen(strFileName);
+
+	for(int i=0;i < iLength; i++) {
+		ulHashId += (( i + 1) * strFileName[i]);
+	}	
+	return ulHashId;
+
+}
+*/
+}}

Engine/Caldron/Src/Base/BaseCacheMgr.h

@@ -0,0 +1,264 @@
+
+#if !defined(AFX_BASECACHEMGR_H__C53D076B_14CF_47B5_B21C_F7EF3477C7EA__INCLUDED_)
+#define AFX_BASECACHEMGR_H__C53D076B_14CF_47B5_B21C_F7EF3477C7EA__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#pragma warning( disable : 4786 )
+#include "../../include/Caldron.h"
+#include "./LoadedObj.h"
+#include "./ResourceLoader.h"
+
+
+namespace Caldron {
+	namespace Base {
+/* *********************************************************************  
+
+* CCacheObj
+
+* <20><><EFBFBD><EFBFBD> : BaseCacheMgr.h 
+* <20><><EFBFBD><EFBFBD> : Caldron<6F><6E><EFBFBD><EFBFBD> <20><><EFBFBD>ο<EFBFBD><CEBF><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> CacheMgr<67><72><EFBFBD><EFBFBD> data <20><> <20>ٷ<EFBFBD><D9B7><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+* history : 
+	2004.01.16 wizardbug
+
+********************************************************************** */  
+
+class CCacheObj {
+public:
+	std::vector<CLoadedObj *>	m_lstDatas;
+	int							m_iDatasNum;
+	CCacheObj() : m_iDatasNum(0)
+	{
+		m_lstDatas.clear();
+	}
+	CCacheObj(CLoadedObj *pObj)  : m_iDatasNum(0)
+	{
+		m_lstDatas.clear();
+		m_lstDatas.push_back(pObj);
+		pObj->m_iReferenceCount++;
+		m_iDatasNum++;
+	}
+	void Add_Back(CLoadedObj *pObj)
+	{
+		m_lstDatas.push_back(pObj);
+		pObj->m_iReferenceCount++;
+		m_iDatasNum++;
+	}
+	void Remove(int iNum)
+	{
+		if(m_iDatasNum <= iNum)
+			return;
+		if(m_lstDatas[iNum] && m_lstDatas[iNum]->m_bLoaded)
+		{
+			if(!(--m_lstDatas[iNum]->m_iReferenceCount))
+			{
+				SafeDelete(m_lstDatas[iNum]);
+				m_lstDatas.erase(m_lstDatas.begin() + iNum);
+				m_iDatasNum--;	
+			}
+		}
+		
+	}
+	void AddRef(int iNum)
+	{
+		if(m_iDatasNum <= iNum)
+			return;
+		if(m_lstDatas[iNum])
+		{
+			m_lstDatas[iNum]->m_iReferenceCount++;
+		}
+	}
+	~CCacheObj() {
+		if(m_iDatasNum > 0)
+		{
+			for(int i=0;i < m_iDatasNum; i++) 
+			{
+				if(m_lstDatas[i]) 
+				{
+					SafeDelete(m_lstDatas[i]);
+				}
+			}
+		}
+		m_iDatasNum =  0;
+		m_lstDatas.clear();
+	}
+
+		
+			
+};
+
+typedef std::map<unsigned long , CCacheObj *> CACHETABLE;
+typedef CACHETABLE::value_type CACHETABLEOBJ;
+typedef CACHETABLE::iterator CACHEITER;
+/* *********************************************************************  
+
+* CBaseCacheMgr
+
+* <20><><EFBFBD><EFBFBD> : BaseCacheMgr.h 
+* <20><><EFBFBD><EFBFBD> : Caldron<6F><6E><EFBFBD><EFBFBD> <20><><EFBFBD>ο<EFBFBD><CEBF><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> CacheMgr<67><72><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> class
+* history : 
+	2004.01.16 wizardbug
+
+********************************************************************** */  
+const int DEFAULT_MAXCACHENUM = 100;
+template <class T>
+class CBaseCacheMgr  
+{
+protected:
+	
+	unsigned long GetHashID(const char *strFileName)
+	{
+		unsigned long ulHashId = 0;
+
+		int iLength = (int)strlen(strFileName);
+
+		for(int i=0;i < iLength; i++) {
+			ulHashId += (( i + 1) * strFileName[i]);
+		}	
+		return ulHashId;
+
+
+	}
+
+	CACHETABLE m_CacheTable;
+	int	m_iCachesNum;
+
+
+public:
+	
+	CBaseCacheMgr(): m_iCachesNum(0)
+	{
+		m_CacheTable.clear();
+	}
+	virtual ~CBaseCacheMgr()
+	{
+		//if(m_iCachesNum > 0) 
+		//{
+			for(CACHEITER Itr = m_CacheTable.begin(); Itr != m_CacheTable.end();) 
+			{
+				if(Itr->second != NULL) 
+				{
+					SafeDelete(Itr->second);
+				}
+				
+				Itr++;
+			}
+			m_CacheTable.clear();
+			m_iCachesNum = 0;
+
+		//}
+
+		
+	}
+	void DeleteAllData()
+	{
+	//	if(m_iCachesNum > 0) 
+	//	{
+			for(CACHEITER Itr = m_CacheTable.begin(); Itr != m_CacheTable.end();) 
+			{
+				if(Itr->second != NULL) 
+				{
+					SafeDelete(Itr->second);
+				}
+				
+				Itr++;
+			}
+			m_CacheTable.clear();
+			m_iCachesNum = 0;
+
+	//	}
+
+	}
+	void DeleteData(const char *strFileName)
+	{
+
+		unsigned long DataID = GetHashID(strFileName);
+			
+		Base::CACHEITER itr  = m_CacheTable.find(DataID);
+		
+		if(itr != m_CacheTable.end()) 
+		{
+			if((*itr).second != NULL) 
+			{
+				for(int iNum = 0; iNum < (*itr).second->m_iDatasNum; iNum++)
+				{
+					if(!strcmp((*itr).second->m_lstDatas[iNum]->m_strName,strFileName))
+					{
+						((*itr).second)->Remove(iNum);				
+					}
+				}
+
+			}
+
+		}
+	}
+
+	T *GetData(const char *strFileName)
+	{
+		unsigned long DataID = GetHashID(strFileName);
+			
+		Base::CACHEITER itr  = m_CacheTable.find(DataID);
+		
+		if(itr == m_CacheTable.end()) 
+		{
+			return LoadData(strFileName);	
+		}
+		else	// Table <20>ȿ<EFBFBD> <20>̹<EFBFBD> texture <20><> <20>ε<EFBFBD><CEB5>Ǿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 
+		{
+			if((*itr).second != NULL) 
+			{
+				for(int iNum = 0; iNum < (*itr).second->m_iDatasNum; iNum++)
+				{
+					if(!strcmp((*itr).second->m_lstDatas[iNum]->m_strName,strFileName))
+					{
+						(*itr).second->AddRef(iNum);
+						return (T *)((*itr).second->m_lstDatas[iNum]);				
+					}
+				}
+				return LoadData(strFileName);	// Table <20><> obj<62><6A> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ϴ<EFBFBD> obj <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+			}
+
+		}
+		
+		return NULL;
+
+
+	}
+	T *LoadData(const char *strFileName)
+	{
+		T *pNode = new T;
+		strcpy(pNode->m_strName,strFileName);
+		CResourceLoader::AddObj(pNode);
+
+		unsigned long DataID = GetHashID(strFileName);
+		Base::CACHEITER itr  = m_CacheTable.find(DataID);
+		
+		if(itr == m_CacheTable.end())
+		{
+			
+			Base::CCacheObj *pObj = new Base::CCacheObj(pNode);
+			m_CacheTable.insert(Base::CACHETABLEOBJ(DataID,pObj));
+			m_iCachesNum++;
+		}
+		else 
+		{// map <20>ȿ<EFBFBD> <20>Ȱ<EFBFBD><C8B0><EFBFBD> Hash Index <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			
+			((*itr).second)->Add_Back(pNode);	
+		}
+
+		
+		return pNode;
+
+
+	}
+
+//	virtual void *GetData(const char *strFileName) = 0;
+//	virtual void *LoadData(const char *strFileName) = 0;
+	
+
+};
+	}
+}
+#endif // !defined(AFX_BASECACHEMGR_H__C53D076B_14CF_47B5_B21C_F7EF3477C7EA__INCLUDED_)

Engine/Caldron/Src/Base/ByteDataObj.cpp

@@ -0,0 +1,124 @@
+
+/* *********************************************************************  
+  
+  * CByteDataObj  
+  
+  * <20><><EFBFBD><EFBFBD> : ByteDataObj.h  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> CResourceMgr <20><><EFBFBD><EFBFBD> <20>о<EFBFBD><D0BE><EFBFBD><EFBFBD>̴<EFBFBD> <20><><EFBFBD>ҽ<EFBFBD><D2BD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ǵ<EFBFBD> <20>⺻ <20><><EFBFBD><EFBFBD>.
+           CLoadedObj<62><6A> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD> obj <20><><EFBFBD><EFBFBD> Load <20><>ƾ<EFBFBD><C6BE><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>ҽ<EFBFBD><D2BD><EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD> <20><><EFBFBD>·<EFBFBD> <20><>ȯ <20>ε<EFBFBD> <20>ȴ<EFBFBD>.
+
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+
+
+#include "ByteDataObj.h"
+#include <windows.h>
+#include <stdio.h>
+
+namespace Caldron {
+	namespace Base {
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CByteDataObj::CByteDataObj()
+{
+	m_pBytes = NULL;
+	m_lSize = 0;
+	m_lReadPos = 0;
+
+}
+
+CByteDataObj::~CByteDataObj()
+{
+	if(m_pBytes) 
+	{
+		delete[] m_pBytes;
+		m_pBytes = NULL;
+		m_lSize = 0;
+		m_lReadPos = 0;
+
+	}
+}
+unsigned char *CByteDataObj::GetReadPtr() 
+{
+	if((m_lReadPos >= m_lSize) || (m_pBytes == NULL)) 
+	{
+		return NULL;
+	}
+	
+	return &(m_pBytes[m_lReadPos]);
+
+}
+bool CByteDataObj::LoadByte(char *strFileName,long lOffset) 
+{
+	FILE *fp = fopen(strFileName,"rb");
+	long lFileSize = 0;
+
+	if(fp == NULL) 
+	{
+		return false;
+		
+	}
+	fseek(fp,0,SEEK_END);
+	m_lSize = ftell(fp);
+	if(m_lSize <= 0)
+	{
+	
+		fclose(fp);
+		return false;
+	}
+	// Offset <20><><EFBFBD><EFBFBD>
+	if(m_lSize > lOffset) 
+		m_lSize -= lOffset;
+	else 
+	{
+	
+		fclose(fp);
+		return false;
+	
+	}
+
+	m_pBytes = new unsigned char[m_lSize];
+	if(m_pBytes == NULL) 
+	{
+	
+		fclose(fp);
+		return false;
+	
+	}
+	fseek(fp,lOffset,SEEK_SET);
+	if(fread((unsigned char *)m_pBytes,sizeof(unsigned char),m_lSize,fp) != m_lSize)
+	{
+	
+		fclose(fp);
+		return false;
+	}
+	fclose(fp);			
+	return true;
+	
+}
+
+long CByteDataObj::Read(void *ptr,size_t UnitSize,int iNum)
+{
+	if(ptr == NULL)
+		return -1;
+	long lCurrentReaded = ((long)(UnitSize) * iNum) / UINT_SIZE;
+	if(m_lSize >= lCurrentReaded + m_lReadPos)
+	{
+		memcpy(ptr,&(m_pBytes[m_lReadPos]), (size_t)(UINT_SIZE * lCurrentReaded));
+		m_lReadPos += lCurrentReaded;
+	}
+	else 
+	{
+		return -1;
+
+	}
+	return m_lReadPos;
+	
+}
+}}

Engine/Caldron/Src/Base/ByteDataObj.h

@@ -0,0 +1,55 @@
+// ByteDataObj.h: interface for the CByteDataObj class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_BYTEDATAOBJ_H__A71C88C6_A81A_4696_9922_802A8B1C119A__INCLUDED_)
+#define AFX_BYTEDATAOBJ_H__A71C88C6_A81A_4696_9922_802A8B1C119A__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+
+
+namespace Caldron {
+	namespace Base {
+
+		const long  UINT_SIZE = (long)sizeof(unsigned char);
+
+/* *********************************************************************  
+  
+  * CByteDataObj  
+  
+  * <20><><EFBFBD><EFBFBD> : ByteDataObj.h  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> CResourceMgr <20><><EFBFBD><EFBFBD> <20>о<EFBFBD><D0BE><EFBFBD><EFBFBD>̴<EFBFBD> <20><><EFBFBD>ҽ<EFBFBD><D2BD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ǵ<EFBFBD> <20>⺻ <20><><EFBFBD><EFBFBD>.
+           CLoadedObj<62><6A> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD> obj <20><><EFBFBD><EFBFBD> Load <20><>ƾ<EFBFBD><C6BE><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>ҽ<EFBFBD><D2BD><EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD> <20><><EFBFBD>·<EFBFBD> <20><>ȯ <20>ε<EFBFBD> <20>ȴ<EFBFBD>.
+
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+
+
+class CByteDataObj  
+{
+public:
+	CByteDataObj();
+	virtual ~CByteDataObj();
+	
+	bool	LoadByte(char *strFileName,long lOffset = 0 );
+	long	GetByteSize() { return m_lSize; }
+	long	GetReadPos() { return m_lReadPos;}
+	void	SetReadPos(long lPos) { m_lReadPos = lPos;}
+	unsigned char *GetReadPtr();
+	long	Read(void *ptr,size_t UnitSize,int iNum);
+
+	unsigned char	*m_pBytes;
+	long		   	m_lSize;
+	long			m_lReadPos;
+
+};
+
+}}
+
+#endif // !defined(AFX_BYTEDATAOBJ_H__A71C88C6_A81A_4696_9922_802A8B1C119A__INCLUDED_)

Engine/Caldron/Src/Base/Caldron.cpp

@@ -0,0 +1,27 @@
+/* ********************************************************************* 
+#include "GMMemory.h"
+
+* Caldron Engine <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 
+
+* <20><><EFBFBD><EFBFBD> : Caldron.h
+* <20><><EFBFBD><EFBFBD> : Caldron namespace<63><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.10.23 
+* <20>ۼ<EFBFBD><DBBC><EFBFBD> : yundi ( 2003.10.23) 
+* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> :  
+
+********************************************************************** */ 
+
+namespace Caldron
+{
+	//const float FLOAT_RAD = 0.0174532925f;
+	extern const float FLOAT_PI2 = 1.57079632679f;
+	extern const float FLOAT_PI = 3.14159265358979323846f;
+	extern const float FLOAT_2PI = 6.28318530717958647692f;
+
+	extern const float MIN_EPSILON = 1.0e-4f;
+	extern const float MAX_EPSILON = 1.0e+10f;
+	extern const int	MAX_STRINGSIZE = 40;
+//	const int	MAX_RELOADING = 3;
+	
+
+}

Engine/Caldron/Src/Base/CaldronByteDataObj.cpp

@@ -0,0 +1,125 @@
+
+/* *********************************************************************  
+  
+  * CByteDataObj  
+  
+  * <20><><EFBFBD><EFBFBD> : ByteDataObj.h  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> CResourceMgr <20><><EFBFBD><EFBFBD> <20>о<EFBFBD><D0BE><EFBFBD><EFBFBD>̴<EFBFBD> <20><><EFBFBD>ҽ<EFBFBD><D2BD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ǵ<EFBFBD> <20>⺻ <20><><EFBFBD><EFBFBD>.
+           CLoadedObj<62><6A> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD> obj <20><><EFBFBD><EFBFBD> Load <20><>ƾ<EFBFBD><C6BE><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>ҽ<EFBFBD><D2BD><EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD> <20><><EFBFBD>·<EFBFBD> <20><>ȯ <20>ε<EFBFBD> <20>ȴ<EFBFBD>.
+
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+
+
+#include "CaldronByteDataObj.h"
+#include <windows.h>
+#include <stdio.h>
+#include "GMMemory.h"
+
+namespace Caldron {
+	namespace Base {
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CCaldronByteDataObj::CCaldronByteDataObj()
+{
+	m_pBytes = NULL;
+	m_lSize = 0;
+	m_lReadPos = 0;
+
+}
+
+CCaldronByteDataObj::~CCaldronByteDataObj()
+{
+	if(m_pBytes) 
+	{
+		delete[] m_pBytes;
+		m_pBytes = NULL;
+		m_lSize = 0;
+		m_lReadPos = 0;
+
+	}
+}
+unsigned char *CCaldronByteDataObj::GetReadPtr() 
+{
+	if((m_lReadPos >= m_lSize) || (m_pBytes == NULL)) 
+	{
+		return NULL;
+	}
+	
+	return &(m_pBytes[m_lReadPos]);
+
+}
+bool CCaldronByteDataObj::LoadByte(char *strFileName,long lOffset) 
+{
+	FILE *fp = fopen(strFileName,"rb");
+	long lFileSize = 0;
+
+	if(fp == NULL) 
+	{
+		return false;
+		
+	}
+	fseek(fp,0,SEEK_END);
+	m_lSize = ftell(fp);
+	if(m_lSize <= 0)
+	{
+	
+		fclose(fp);
+		return false;
+	}
+	// Offset <20><><EFBFBD><EFBFBD>
+	if(m_lSize > lOffset) 
+		m_lSize -= lOffset;
+	else 
+	{
+	
+		fclose(fp);
+		return false;
+	
+	}
+
+	m_pBytes = new unsigned char[m_lSize];
+	if(m_pBytes == NULL) 
+	{
+	
+		fclose(fp);
+		return false;
+	
+	}
+	fseek(fp,lOffset,SEEK_SET);
+	if(fread((unsigned char *)m_pBytes,sizeof(unsigned char),m_lSize,fp) != m_lSize)
+	{
+	
+		fclose(fp);
+		return false;
+	}
+	fclose(fp);			
+	return true;
+	
+}
+
+long CCaldronByteDataObj::Read(void *ptr,size_t UnitSize,int iNum)
+{
+	if(ptr == NULL)
+		return -1;
+	long lCurrentReaded = ((long)(UnitSize) * iNum) / UINT_SIZE;
+	if(m_lSize >= lCurrentReaded + m_lReadPos)
+	{
+		memcpy(ptr,&(m_pBytes[m_lReadPos]), (size_t)(UINT_SIZE * lCurrentReaded));
+		m_lReadPos += lCurrentReaded;
+	}
+	else 
+	{
+		return -1;
+
+	}
+	return m_lReadPos;
+	
+}
+}}

Engine/Caldron/Src/Base/CaldronByteDataObj.h

@@ -0,0 +1,55 @@
+// ByteDataObj.h: interface for the CByteDataObj class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_BYTEDATAOBJ_H__A71C88C6_A81A_4696_9922_802A8B1C119A__INCLUDED_)
+#define AFX_BYTEDATAOBJ_H__A71C88C6_A81A_4696_9922_802A8B1C119A__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+
+
+namespace Caldron {
+	namespace Base {
+
+		const long  UINT_SIZE = (long)sizeof(unsigned char);
+
+/* *********************************************************************  
+  
+  * CByteDataObj  
+  
+  * <20><><EFBFBD><EFBFBD> : ByteDataObj.h  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> CResourceMgr <20><><EFBFBD><EFBFBD> <20>о<EFBFBD><D0BE><EFBFBD><EFBFBD>̴<EFBFBD> <20><><EFBFBD>ҽ<EFBFBD><D2BD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ǵ<EFBFBD> <20>⺻ <20><><EFBFBD><EFBFBD>.
+           CLoadedObj<62><6A> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD> obj <20><><EFBFBD><EFBFBD> Load <20><>ƾ<EFBFBD><C6BE><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>ҽ<EFBFBD><D2BD><EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD> <20><><EFBFBD>·<EFBFBD> <20><>ȯ <20>ε<EFBFBD> <20>ȴ<EFBFBD>.
+
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+
+
+class CCaldronByteDataObj  
+{
+public:
+	CCaldronByteDataObj();
+	virtual ~CCaldronByteDataObj();
+	
+	bool	LoadByte(char *strFileName,long lOffset = 0 );
+	long	GetByteSize() { return m_lSize; }
+	long	GetReadPos() { return m_lReadPos;}
+	void	SetReadPos(long lPos) { m_lReadPos = lPos;}
+	unsigned char *GetReadPtr();
+	long	Read(void *ptr,size_t UnitSize,int iNum);
+
+	unsigned char	*m_pBytes;
+	long		   	m_lSize;
+	long			m_lReadPos;
+
+};
+
+}}
+
+#endif // !defined(AFX_BYTEDATAOBJ_H__A71C88C6_A81A_4696_9922_802A8B1C119A__INCLUDED_)

Engine/Caldron/Src/Base/LoadedObj.cpp

@@ -0,0 +1,25 @@
+// LoadedObj.cpp: implementation of the CLoadedObj class.
+//
+//////////////////////////////////////////////////////////////////////
+#pragma warning( disable : 4786 )
+#include <include/Caldron.h>
+#include "./CaldronByteDataObj.h"
+#include "LoadedObj.h"
+#include "GMMemory.h"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+namespace Caldron { namespace Base {
+CLoadedObj::CLoadedObj(const char *strFileName) : m_bLoaded(false),m_iReloadingCount(0),m_pByteDataObj(0)
+{
+	strcpy(m_strName,strFileName);
+}
+CLoadedObj::~CLoadedObj()
+{
+	SafeDelete(m_pByteDataObj);
+	m_pByteDataObj = 0;
+}
+
+
+}}

Engine/Caldron/Src/Base/LoadedObj.h

@@ -0,0 +1,54 @@
+// LoadedObj.h: interface for the CLoadedObj class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_LOADEDOBJ_H__7BBE3A5F_6665_4F40_AA4D_82BACEBC32D3__INCLUDED_)
+#define AFX_LOADEDOBJ_H__7BBE3A5F_6665_4F40_AA4D_82BACEBC32D3__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+
+#include "./CaldronByteDataObj.h"
+
+
+namespace Caldron {
+	namespace Base {
+
+/* *********************************************************************  
+  
+  * CLoadedObj  
+  
+  * <20><><EFBFBD><EFBFBD> : LoadedObj.h  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> CResourceMgr <20><> <20>̿<EFBFBD><CCBF><EFBFBD> <20>ε<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ҽ<EFBFBD> obj <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> class 
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+
+class CLoadedObj  
+{
+public:
+	CLoadedObj() : m_bLoaded(false),m_iReloadingCount(0),m_pByteDataObj(0),m_bFirst(0),m_iReferenceCount(0)
+	{}
+	CLoadedObj(const char *strFileName);
+	virtual ~CLoadedObj();
+	virtual bool Load(CCaldronByteDataObj *) = 0;
+	virtual bool PostLoad() = 0;
+	//virtual bool Unload() = 0;
+	bool		m_bLoaded;
+	bool		m_bFirst;
+	char		m_strName[256];
+	int			m_iReloadingCount;		// ReLoading Ƚ<><C8BD>.
+	unsigned int m_iReferenceCount;
+	CCaldronByteDataObj *m_pByteDataObj;
+
+
+};
+
+
+	}
+}
+#endif // !defined(AFX_LOADEDOBJ_H__7BBE3A5F_6665_4F40_AA4D_82BACEBC32D3__INCLUDED_)

Engine/Caldron/Src/Base/LogMgr.cpp

@@ -0,0 +1,319 @@
+/* *********************************************************************
+
+  * CLogMgr
+  * <20><><EFBFBD><EFBFBD> : LogMgr.cpp
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> <20>޼<EFBFBD><DEBC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ó<><C3B3><EFBFBD>ϴ<EFBFBD> Log System
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.10.23
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : wizardbug ( 2003.10.23)
+  * <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> : 
+
+********************************************************************** */
+
+#include "./LogMgr.h"
+#include "./Console.h"
+#include "../Scene/MainSceneMgr.h"
+
+
+//////////////////////////////////////////////////////////////////////
+// static <20>Լ<EFBFBD>, <20><><EFBFBD><EFBFBD> 
+//////////////////////////////////////////////////////////////////////
+
+Caldron::Base::CLogMgr *Caldron::Base::CLogMgr::ms_pInstance = NULL;
+
+/*
+Caldron::Base::CLogMgr *Caldron::Base::CLogMgr::_GetInstance();
+void Caldron::Base::CLogMgr::_LogMessage(const char *,...);
+void Caldron::Base::CLogMgr::_LogError(const char *,...);
+void Caldron::Base::CLogMgr::_SetOutDevice(Caldron::LOG_OUTDEVICES iDevice);
+void Caldron::Base::CLogMgr::_SetOutMessageFlag(Caldron::LOG_MESSAGES iMessage,bool bFlag);
+void Caldron::Base::CLogMgr::_Close();
+*/
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+
+Caldron::Base::CLogMgr::CLogMgr() : m_pLogFile(0), m_iOutDevice(Caldron::LOG_FILEOUT),m_bBufferEmpty(true)
+{
+
+	
+	m_pBitFlag = new CBitset;
+	
+	if(m_pBitFlag != NULL) 
+	{
+
+		m_pBitFlag->ResizeBits(Caldron::LOG_MESSAGES_NUM);
+		m_pBitFlag->ClearBits();
+	
+		for(int i = 0; i < Caldron::LOG_MESSAGES_NUM; i++ ) 
+		{
+			m_pBitFlag->SetBit(i);
+		}
+	}
+
+	memset((char *)m_pLogBuffer,sizeof(char),2560);
+	memset((char *)m_pLogFileName,sizeof(char),256);
+	
+
+}
+void Caldron::Base::CLogMgr::ValueRelease() 
+{
+
+	if(m_pLogFile != NULL)
+	{
+		fclose(m_pLogFile);
+		m_pLogFile = NULL;
+	}
+	Caldron::SafeDelete(m_pBitFlag);
+	m_pBitFlag = NULL;
+
+}
+Caldron::Base::CLogMgr::~CLogMgr() 
+{
+}
+
+void Caldron::Base::CLogMgr::_Close()
+{
+	if(ms_pInstance != NULL)
+	{
+		ms_pInstance->ValueRelease();	
+		Caldron::SafeDelete(ms_pInstance);
+		ms_pInstance = NULL;
+	}
+
+}
+
+
+Caldron::Base::CLogMgr *Caldron::Base::CLogMgr::_GetInstance() 
+{
+	if(ms_pInstance == NULL)
+	{
+		ms_pInstance = new Caldron::Base::CLogMgr;
+		ms_pInstance->WriteFirstRunLog();
+
+	}
+
+	return ms_pInstance;
+
+}
+
+void Caldron::Base::CLogMgr::_SetOutDevice(Caldron::LOG_OUTDEVICES iDevice) 
+{
+	if(ms_pInstance == NULL)
+	{
+		_GetInstance();	// CLogMgr <20><><EFBFBD><EFBFBD>
+	}
+	
+	switch(iDevice) 
+	{
+
+		case LOG_FILEOUT:
+		case LOG_CONSOLEOUT:				// Console
+		case LOG_MESSAGEBOXOUT:				// Window Message Box
+			ms_pInstance->m_iOutDevice = iDevice;
+			break;
+		default:
+			_LogError("CLogMgr::SetOutDevice() | <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> Device<63><65> <20><><EFBFBD><EFBFBD><EFBFBD>ϼ̽<CFBC><CCBD>ϴ<EFBFBD>.");	
+			break;
+
+
+	}
+
+}
+void Caldron::Base::CLogMgr::_SetOutMessageFlag(Caldron::LOG_MESSAGES iMessage,bool bFlag) 
+{
+	if(ms_pInstance == NULL)
+	{
+		_GetInstance();	// CLogMgr <20><><EFBFBD><EFBFBD>
+	}
+	if(ms_pInstance->m_pBitFlag != NULL) {
+		if(bFlag == true) 
+		{
+			ms_pInstance->m_pBitFlag->SetBit(iMessage);
+			ms_pInstance->_LogMessage("======= %s Bit On =======",LOG_LABEL[iMessage]);
+		}
+		else
+		{
+			ms_pInstance->_LogMessage("======= %s Bit Off =======",LOG_LABEL[iMessage]);
+			ms_pInstance->m_pBitFlag->ClearOneBit(iMessage);
+			
+		}
+	}
+}
+void Caldron::Base::CLogMgr::_LogMessage(const char *pFormat,...) 
+{
+	if(ms_pInstance == NULL)
+	{
+		_GetInstance();	// CLogMgr <20><><EFBFBD><EFBFBD>
+	}
+	if((ms_pInstance->m_pBitFlag != NULL)  && (!ms_pInstance->m_pBitFlag->GetBit(Caldron::LOG_MESSAGE)))
+		return;
+
+/*
+	// Checking <20><>ƾ<EFBFBD><C6BE><EFBFBD><EFBFBD>
+	char *pCheckptr = (char *)pFormat;   
+	int iFCount = 0;	// % Count
+
+    while((*pCheckptr) != '\0') 
+    { 
+		 if((*pCheckptr) == '%') 
+			iFCount++; 
+         pCheckptr++;
+
+    }          
+
+	int iExist = 0;                                         
+	int iVaCount = 0; 
+    va_list ap; 
+      
+    va_start( ap, pFormat ); 
+    while( iExist != -1 ) 
+    { 
+		iVaCount++; 
+		iExist = va_arg( ap, char); 
+    } 
+    va_end( ap ); 
+    if( iFCount != iVaCount ) 
+		return;     
+    // Checking <20><>ƾ<EFBFBD><C6BE><EFBFBD><EFBFBD> 
+*/
+	va_list ap;
+	va_start(ap, pFormat);
+	vsprintf(ms_pInstance->m_pLogBuffer, pFormat, ap);
+	va_end(ap);
+	ms_pInstance->m_bBufferEmpty = false;
+	
+	switch(ms_pInstance->m_iOutDevice) 
+	{
+		case LOG_FILEOUT:
+			ms_pInstance->WriteBufferToFile(LOG_MESSAGE);
+			break;
+		case LOG_CONSOLEOUT:				// Console
+			ms_pInstance->WriteBufferToConsole(LOG_MESSAGE);
+			break;
+		case LOG_MESSAGEBOXOUT:				// Window Message Box
+			ms_pInstance->WriteBufferToMessageBox(LOG_MESSAGE);
+			break;		
+	}
+}
+void Caldron::Base::CLogMgr::_LogError(const char *pFormat,...) 
+{
+	if(ms_pInstance == NULL)
+	{
+		_GetInstance();	// CLogMgr <20><><EFBFBD><EFBFBD>
+	}
+	
+	if((ms_pInstance->m_pBitFlag != NULL)  && (!ms_pInstance->m_pBitFlag->GetBit(Caldron::LOG_ERROR)))
+		return;
+
+
+	va_list ap;
+
+	va_start(ap, pFormat);
+	vsprintf(ms_pInstance->m_pLogBuffer, pFormat, ap);
+	va_end(ap);
+	ms_pInstance->m_bBufferEmpty = false;
+	
+	switch(ms_pInstance->m_iOutDevice) 
+	{
+		case LOG_FILEOUT:
+			ms_pInstance->WriteBufferToFile(LOG_ERROR);
+			break;
+		case LOG_CONSOLEOUT:				// Console
+			ms_pInstance->WriteBufferToConsole(LOG_ERROR);
+			break;
+		case LOG_MESSAGEBOXOUT:				// Window Message Box
+			ms_pInstance->WriteBufferToMessageBox(LOG_ERROR);
+			break;		
+	}
+}
+void Caldron::Base::CLogMgr::_LogNoHeader(const char *pFormat,...)
+{
+	if(ms_pInstance == NULL)
+	{
+		_GetInstance();	// CLogMgr <20><><EFBFBD><EFBFBD>
+	}
+	
+	if((ms_pInstance->m_pBitFlag != NULL)  && (!ms_pInstance->m_pBitFlag->GetBit(Caldron::LOG_NOHEADER)))
+		return;
+
+
+	va_list ap;
+
+	va_start(ap, pFormat);
+	vsprintf(ms_pInstance->m_pLogBuffer, pFormat, ap);
+	va_end(ap);
+	ms_pInstance->m_bBufferEmpty = false;
+	
+	switch(ms_pInstance->m_iOutDevice) 
+	{
+		case LOG_FILEOUT:
+			ms_pInstance->WriteBufferToFile(LOG_NOHEADER);
+			break;
+		case LOG_CONSOLEOUT:				// Console
+			ms_pInstance->WriteBufferToConsole(LOG_NOHEADER);
+			break;
+		case LOG_MESSAGEBOXOUT:				// Window Message Box
+			ms_pInstance->WriteBufferToMessageBox(LOG_NOHEADER);
+			break;		
+	}
+}
+void Caldron::Base::CLogMgr::WriteFirstRunLog() 
+{
+	time_t	t = time(NULL);
+	char *pDate = asctime(localtime(&t));
+
+	if(m_pLogFile == NULL)
+	{
+		m_pLogFile = fopen(Caldron::Base::LOG_FILENAME,"at+");
+	}
+	if(m_pLogFile != NULL) 
+	{
+		fprintf(m_pLogFile,"\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+		fprintf(m_pLogFile,"!!!!!!! Below Logs, Application Last Run !!!!!!! %s",pDate);
+		fprintf(m_pLogFile,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
+		fclose(m_pLogFile);
+	}
+
+	m_pLogFile = NULL;
+
+}
+void Caldron::Base::CLogMgr::WriteBufferToFile(Caldron::LOG_MESSAGES iMessage) 
+{
+	time_t	t = time(NULL);
+	char *pDate = asctime(localtime(&t));
+
+	if(m_pLogFile == NULL)
+	{
+		m_pLogFile = fopen(Caldron::Base::LOG_FILENAME,"at+");
+	}
+	if(m_pLogFile != NULL) 
+	{
+		if(iMessage == LOG_NOHEADER) 
+		{
+			fprintf(m_pLogFile,"%s",m_pLogBuffer);
+		}
+		else 
+			fprintf(m_pLogFile,"%s %s | %s",LOG_LABEL[iMessage],m_pLogBuffer,pDate);
+		fclose(m_pLogFile);
+	}
+
+	m_pLogFile = NULL;
+
+}
+void Caldron::Base::CLogMgr::WriteBufferToConsole(Caldron::LOG_MESSAGES iMessage)
+{
+	if(iMessage == LOG_NOHEADER) 
+	{
+		Caldron::Scene::CMainSceneMgr::_GetConsole()->AddText("%s",m_pLogBuffer);
+	}
+	else 
+		Caldron::Scene::CMainSceneMgr::_GetConsole()->AddText("%s %s",LOG_LABEL[iMessage],m_pLogBuffer);
+	
+}
+void Caldron::Base::CLogMgr::WriteBufferToMessageBox(Caldron::LOG_MESSAGES iMessage)
+{
+
+	MessageBox(NULL,m_pLogBuffer,LOG_LABEL[iMessage],MB_OK);
+
+}

Engine/Caldron/Src/Base/LogMgr.h

@@ -0,0 +1,96 @@
+// WBLogSystem.h: interface for the WBLogSystem class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_WBLOGSYSTEM_H__3836C71D_3ABD_4A3D_99E8_385123E4F17C__INCLUDED_)
+#define AFX_WBLOGSYSTEM_H__3836C71D_3ABD_4A3D_99E8_385123E4F17C__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+/* *********************************************************************
+
+  * CLogMgr
+  * <20><><EFBFBD><EFBFBD> : LogMgr.h
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> <20>޼<EFBFBD><DEBC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ó<><C3B3><EFBFBD>ϴ<EFBFBD> Log System
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.10.23
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : wizardbug ( 2003.10.23)
+  * <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> : 
+
+********************************************************************** */
+#include <time.h>
+#include "../../include/Caldron.h"
+
+
+//#define __LOG_WRITE__	// __LOG_WRITE__ <20><> define <20><><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD><D6BE><EFBFBD> Log <20><> <20><><EFBFBD>µȴ<C2B5>.
+
+namespace Caldron 
+{
+		// <20>ܺη<DCBA> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> Enum.
+	enum LOG_MESSAGES 
+	{
+		LOG_MESSAGE,				// <20>Ϲ<EFBFBD> Log Message
+		LOG_ERROR,					// Error Log Message
+		LOG_NOHEADER,				// Header <20><><EFBFBD><EFBFBD> <20>޼<EFBFBD><DEBC><EFBFBD>.
+		LOG_MESSAGES_NUM,		
+	};
+
+	enum LOG_OUTDEVICES 
+	{ 
+		LOG_FILEOUT,					// Log File
+		LOG_CONSOLEOUT,				// Console 
+		LOG_MESSAGEBOXOUT,				// Window Message Box
+		LOG_OUTDEVICES_NUM,			
+	};
+
+	namespace Base 
+	{
+
+		const char * const LOG_LABEL[3] = { 
+										" LOG[ MESSAGE ] | ",
+										" LOG[ ERROR ] | ",
+										""
+
+									};
+		const char LOG_FILENAME[] = "Caldron.log";
+
+		class CLogMgr  
+		{
+		private:
+			static CLogMgr				*ms_pInstance;
+			FILE						*m_pLogFile;
+			Caldron::LOG_OUTDEVICES		m_iOutDevice;
+			
+			char						m_pLogBuffer[2560];	// Log Buffer
+			char						m_pLogFileName[256];
+
+			bool						m_bBufferEmpty;
+			CBitset						*m_pBitFlag;
+
+
+		protected:
+			CLogMgr();
+
+			void						WriteBufferToFile(Caldron::LOG_MESSAGES);
+			void						WriteBufferToConsole(Caldron::LOG_MESSAGES);
+			void						WriteBufferToMessageBox(Caldron::LOG_MESSAGES);
+			void						WriteFirstRunLog();	
+		public:
+			~CLogMgr();
+			void						ValueRelease();
+
+			static void					_SetOutDevice(Caldron::LOG_OUTDEVICES iDevice);
+			static CLogMgr *			_GetInstance();
+			static void					_LogMessage(const char *,...);
+			static void					_LogError(const char *,...);
+			static void					_LogNoHeader(const char *,...);
+
+			static void					_SetOutMessageFlag(Caldron::LOG_MESSAGES iMessage,bool bFlag);
+			static void					_Close();
+			
+
+		};
+	};
+};
+#endif // !defined(AFX_WBLOGSYSTEM_H__3836C71D_3ABD_4A3D_99E8_385123E4F17C__INCLUDED_)

Engine/Caldron/Src/Base/ResourceLoader.cpp

@@ -0,0 +1,425 @@
+#pragma warning( disable : 4786 )
+
+#include "../../include/Caldron.h"
+#include "./LoadedObj.h"
+
+#include "ResourceLoader.h"
+#include "GMMemory.h"
+
+namespace Caldron {namespace Base {
+/* *********************************************************************  
+  
+  * CResourceLoaderObj  
+  
+  * <20><><EFBFBD><EFBFBD> : ResourceLoader.cpp  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> CResourceLoader <20><><EFBFBD><EFBFBD> Load Queue<75><65> <20><><EFBFBD> resource <20><><EFBFBD><EFBFBD> 
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+/*
+CResourceLoaderObj::CResourceLoaderObj() 
+{
+	m_pObj = NULL;
+	m_State = RLOBJSTATE_READY;
+}
+CResourceLoaderObj::CResourceLoaderObj(const char *strFileName,CLoadedObj *pObj) 
+{
+	strcpy(m_strFileName,strFileName);
+	m_pObj = pObj;
+	m_pObj->m_bLoaded = false;
+	m_State = RLOBJSTATE_READY;
+}
+CResourceLoaderObj::~CResourceLoaderObj() 
+{
+
+}
+*/
+/* *********************************************************************  
+  
+  * CResourceLoader  
+  
+  * <20><><EFBFBD><EFBFBD> : ResourceLoader.cpp  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> ResourceLoader, 
+           thread<61><64> <20>и<EFBFBD><D0B8>Ͽ<EFBFBD> <20>޸<EFBFBD> <20><>ƾ <20><> <20>ε<EFBFBD><CEB5><EFBFBD>ƾ<EFBFBD><C6BE> <20>и<EFBFBD> <20>Ͽ<EFBFBD><CFBF><EFBFBD>.
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+CThreadQueue<CLoadedObj *> CResourceLoader::m_ReadyQueue(g_iMaxLoaderQueue);
+
+DWORD WINAPI LoaderThreadProc(LPVOID lpParam) 
+{
+	CResourceLoader *pLoader = (CResourceLoader *)(lpParam);
+	pLoader->LoaderFunc();
+	
+	return 0;
+
+}
+DWORD WINAPI ProcessThreadProc(LPVOID lpParam) 
+{
+	CResourceLoader *pLoader = (CResourceLoader *)(lpParam);
+	pLoader->ProcessFunc();
+	return 0;
+
+}
+
+void CResourceLoader::StartLoader()
+{
+	if(!m_LoaderHandle)
+	{
+		if((m_LoaderHandle = CreateThread(NULL,0,LoaderThreadProc,(LPVOID)this,0,&m_LoaderThreadID)) == NULL) {
+			//CLogMgr::_LogError("CResourceLoader::Loading() : Create Loader Thread Failed");
+			
+		}
+	}
+	if(!m_ProcessHandle)
+	{
+		if((m_ProcessHandle = CreateThread(NULL,0,ProcessThreadProc,(LPVOID)this,0,&m_ProcessThreadID)) == NULL) {
+			//CLogMgr::_LogError("CResourceLoader::Loading() : Create Process Thread Failed");
+		}
+
+	}
+	
+}
+void CResourceLoader::LoaderFunc()
+{	
+	CLoadedObj *pObj = NULL;
+	while( m_ReadyQueue.RemoveFront(pObj))
+	{
+		if(pObj)
+		{
+			if(pObj->m_pByteDataObj)
+				delete pObj->m_pByteDataObj;
+			
+			pObj->m_pByteDataObj = new CCaldronByteDataObj;
+
+			if(!(pObj->m_pByteDataObj->LoadByte(pObj->m_strName))) 
+			{
+				pObj->m_bLoaded = false;
+			}
+			else 
+			{
+				m_Queue.PushBack(pObj);
+			}
+
+		}
+	}
+
+}
+void CResourceLoader::ProcessFunc()
+{
+
+	CLoadedObj *pObj = NULL;
+	while( m_Queue.RemoveFront(pObj))
+	{
+		if(pObj)
+		{
+			if(!pObj->Load(pObj->m_pByteDataObj))		
+			{	// <20>ε<EFBFBD> <20><><EFBFBD>нÿ<D0BD> <20>ٽ<EFBFBD> queue<75><65> <20>־ ReLoading <20>õ<EFBFBD> <20>Ѵ<EFBFBD>.												
+				if(pObj->m_iReloadingCount < Caldron::MAX_RELOADING) {
+					pObj->m_bLoaded = false;
+					m_Queue.PushBack(pObj);
+					//CLogMgr::_LogError("CResourceLoader::ProcessFunc: Load fail, Reloading.");
+					pObj->m_iReloadingCount++;	
+				}
+				else
+				{
+					pObj->m_bLoaded = false;
+				}
+			}
+			else 
+			{
+				m_ResultQueue.PushBack(pObj);
+			}
+
+		}
+		else
+		{
+			//CLogMgr::_LogError("CResourceLoader::ProcessFunc: Obj Ptr is NULL");
+		}
+	}
+
+}
+void CResourceLoader::ProcessAllData()
+{
+	while(1)
+	{
+		Sleep(2000);
+		if(!m_ReadyQueue.GetQueueSize() && 
+			!m_Queue.GetQueueSize())
+		{
+			
+			break;
+		}
+	}
+	if(m_ResultQueue.GetQueueSize())
+	{
+		int iProcess = m_ResultQueue.GetQueueSize(); 
+		CLoadedObj *pObj = NULL;
+
+		while(iProcess)
+		{
+			if(m_ResultQueue.RemoveFront(pObj))
+			{
+				pObj->PostLoad();
+				SafeDelete(pObj->m_pByteDataObj);
+				pObj->m_pByteDataObj = NULL;
+			}
+			else
+			{
+				break;
+			}
+			iProcess--;
+
+		}
+	}
+}
+
+void CResourceLoader::Process()
+{
+	if(m_ResultQueue.GetQueueSize())
+	{
+		int iProcess = (m_ResultQueue.GetQueueSize() > g_iMaxProcessNums) ? g_iMaxProcessNums : m_ResultQueue.GetQueueSize(); 
+		CLoadedObj *pObj = NULL;
+
+		while(iProcess)
+		{
+			if(m_ResultQueue.RemoveFront(pObj))
+			{
+				pObj->PostLoad();
+				SafeDelete(pObj->m_pByteDataObj);
+				pObj->m_pByteDataObj = NULL;
+			}
+			else
+			{
+				break;
+			}
+			iProcess--;
+
+		}
+	}
+}
+void CResourceLoader::Clear()
+{
+	ProcessAllData();
+	m_ReadyQueue.ClearQueue();
+	m_Queue.ClearQueue();
+	m_ResultQueue.ClearQueue();
+
+}
+/*
+class CResourceLoader
+{
+public:
+	CResourceLoader();
+	virtual ~CResourceLoader();
+	void StartLoader();
+	int AddObj(CResourceLoaderObj *);
+protected:
+	void LoaderFunc();
+	void ProcessFunc();
+	DWORD m_dwWait;
+	
+	CThreadQueue<CResourceLoaderObj *>m_lstObj;
+	CThreadQueue<CResourceLoaderObj *>m_Queue;
+	
+	CCriticalSectionQueue<CLoadedObj *>m_ResultQueue;
+
+	unsigned long					m_LoaderThreadID;
+	unsigned long					m_ProcessThreadID;
+
+	HANDLE							m_LoaderHandle;
+	HANDLE							m_ProcessHandle;
+
+
+};
+
+CResourceLoader::CResourceLoader() : m_Queue(g_iMaxLoaderQueue)
+{
+	m_bLoading = false;
+
+	m_dwWait = 0;
+	m_lstObj.clear();
+	m_lstReady.clear();
+	InitializeCriticalSection(&m_ObjCriticalSection);
+	m_LoaderThreadID = m_ProcessThreadID = 0;
+	m_EndEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	m_LoaderHandle = 0;
+	m_ProcessHandle = 0;
+
+
+}
+
+CResourceLoader::~CResourceLoader()
+{
+	DeleteCriticalSection(&m_ObjCriticalSection);
+	CloseHandle(m_EndEvent);
+	CloseHandle(m_LoaderHandle);
+	CloseHandle(m_ProcessHandle);
+	
+}
+void CResourceLoader::Loading() 
+{
+	m_bLoading = true;
+	// Event <20>ʱ<EFBFBD>ȭ
+	ResetEvent(m_EndEvent);
+	if((m_LoaderHandle = CreateThread(NULL,0,LoaderThreadProc,(LPVOID)this,0,&m_LoaderThreadID)) == NULL) {
+		CLogMgr::_LogError("CResourceLoader::Loading() : Create Loader Thread Failed");
+		
+	}
+	if((m_ProcessHandle = CreateThread(NULL,0,ProcessThreadProc,(LPVOID)this,0,&m_ProcessThreadID)) == NULL) {
+		CLogMgr::_LogError("CResourceLoader::Loading() : Create Process Thread Failed");
+	}
+}
+
+DWORD CResourceLoader::WaitFinished() 
+{
+	return WaitForMultipleObjects(1, &m_EndEvent, FALSE, m_dwWait);
+}
+int CResourceLoader::FinishPercent() {
+	return 0;
+}
+void CResourceLoader::LoaderFunc()
+{
+	for(int iIndex = 0; iIndex < GetObjNum(); iIndex++) 
+	{
+		CResourceLoaderObj *pObj = &m_lstObj[iIndex];
+		if(!(pObj->m_ByteData.LoadByte(pObj->m_strFileName))) 
+		{
+			pObj->m_State = RLOBJSTATE_FAILED;
+			if(pObj->m_pObj)
+				pObj->m_pObj->m_bLoaded = false;
+		}
+		else 
+		{
+			pObj->m_State = RLOBJSTATE_LOADING;
+			m_Queue.PushBack(pObj);
+		}
+	}
+	m_Queue.Terminate();
+}
+void CResourceLoader::ProcessFunc()
+{
+	CResourceLoaderObj *pObj = NULL;
+	while( m_Queue.RemoveFront(pObj))
+	{
+		if((pObj) && (pObj->m_pObj))
+		{
+			if(!pObj->m_pObj->Load(&(pObj->m_ByteData)))		
+			{	// <20>ε<EFBFBD> <20><><EFBFBD>нÿ<D0BD> <20>ٽ<EFBFBD> queue<75><65> <20>־ ReLoading <20>õ<EFBFBD> <20>Ѵ<EFBFBD>.												
+				if(pObj->m_pObj->m_iReloadingCount < Caldron::MAX_RELOADING) {
+					pObj->m_State = RLOBJSTATE_LOADING;
+					pObj->m_pObj->m_bLoaded = false;
+					m_Queue.PushBack(pObj);
+					CLogMgr::_LogError("CResourceLoader::ProcessFunc: Load fail, Reloading.");
+					pObj->m_pObj->m_iReloadingCount++;	
+				}
+				else 
+				{
+					pObj->m_State = RLOBJSTATE_FAILED;
+					pObj->m_pObj->m_bLoaded = true;
+
+				}
+			}
+			else 
+			{
+				pObj->m_State = RLOBJSTATE_LOADED;
+				pObj->m_pObj->m_bLoaded = true;
+			}
+		}
+		else 
+		{
+			CLogMgr::_LogError("CResourceLoader::ProcessFunc: Obj Ptr is NULL");
+		}
+	}
+	SetEvent(m_EndEvent);
+}
+int CResourceLoader::AddObj(CResourceLoaderObj &Obj)
+{
+	if(!m_bLoading) {
+		EnterCriticalSection(&m_ObjCriticalSection);
+		m_lstObj.push_back(Obj);
+		LeaveCriticalSection(&m_ObjCriticalSection);
+		return (int)(m_lstObj.size());
+	}
+	else {
+		m_lstReady.push_back(Obj);
+		return -2;
+	}
+}
+CResourceLoaderObj CResourceLoader::GetObj(int iIndex) 
+{
+	EnterCriticalSection(&m_ObjCriticalSection);
+	CResourceLoaderObj Obj = m_lstObj[iIndex];
+	LeaveCriticalSection(&m_ObjCriticalSection);
+
+	return Obj;
+}
+void CResourceLoader::SetObj(int iIndex,CResourceLoaderObj &Obj)
+{
+	EnterCriticalSection(&m_ObjCriticalSection);
+	m_lstObj[iIndex] = Obj;
+	LeaveCriticalSection(&m_ObjCriticalSection);
+
+}
+int CResourceLoader::GetObjNum()
+{
+	EnterCriticalSection(&m_ObjCriticalSection);
+	int iNum = (int)m_lstObj.size();
+	LeaveCriticalSection(&m_ObjCriticalSection);
+	
+	return iNum;
+}
+void CResourceLoader::ClearAllObj()
+{
+	EnterCriticalSection(&m_ObjCriticalSection);
+	m_lstObj.clear();
+	LeaveCriticalSection(&m_ObjCriticalSection);
+
+}
+CResourceLoaderObjState CResourceLoader::GetObjState(int iIndex)
+{
+	return m_lstObj[iIndex].m_State;
+}
+bool CResourceLoader::Finished()
+{
+	if(WaitFinished() != (WAIT_OBJECT_0))
+		return false;
+	CloseHandle(m_LoaderHandle);
+	CloseHandle(m_ProcessHandle);
+	m_LoaderHandle = m_ProcessHandle = 0;
+
+	return true;
+
+}
+void CResourceLoader::Process() {
+	if((m_bLoading == true) && WaitFinished() == (WAIT_OBJECT_0))
+	{
+		m_bLoading = false;
+		ClearAllObj();
+		CloseHandle(m_LoaderHandle);
+		CloseHandle(m_ProcessHandle);
+		m_LoaderHandle = m_ProcessHandle = 0;
+	}
+	else 
+	{
+		if((m_lstObj.size() > 0 )&& (m_bLoading == false))
+			Loading();
+		return;
+	}
+	if(m_lstReady.size() > 0 && !m_bLoading)
+	{
+		
+		// Ready ť<><C5A5> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>͵<EFBFBD><CDB5><EFBFBD> <20>ε<EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>ѱ<EFBFBD><D1B1><EFBFBD>	
+		m_lstObj.reserve(m_lstReady.size());
+		std::copy(m_lstReady.begin(),m_lstReady.end(),std::back_inserter(m_lstObj));
+
+		m_lstReady.clear();
+		Loading();
+	}
+
+}*/
+}}

Engine/Caldron/Src/Base/ResourceLoader.h

@@ -0,0 +1,163 @@
+// ResourceLoader.h: interface for the CResourceLoader class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_RESOURCELOADER_H__16578E31_424F_4D74_9304_44BEC2BE6F95__INCLUDED_)
+#define AFX_RESOURCELOADER_H__16578E31_424F_4D74_9304_44BEC2BE6F95__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+
+#include "./LoadedObj.h"
+#include "./CaldronByteDataObj.h"
+#include "./ThreadQueue.h"
+
+
+
+namespace Caldron {
+	namespace Base {
+/* *********************************************************************  
+  
+  * CResourceLoaderObj  
+  
+  * <20><><EFBFBD><EFBFBD> : ResourceLoader.h  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> CResourceLoader <20><><EFBFBD><EFBFBD> Load Queue<75><65> <20><><EFBFBD> resource <20><><EFBFBD><EFBFBD> 
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+
+enum CResourceLoaderObjState {
+	RLOBJSTATE_READY = 0,
+	RLOBJSTATE_LOADING,
+	RLOBJSTATE_LOADED,
+	RLOBJSTATE_FAILED,
+
+};
+const int g_iMaxLoaderQueue = 100000;
+const int g_iMaxResultQueue = 200000;
+const int g_iMaxProcessNums = 10;
+
+/*
+class CResourceLoaderObj {
+public:
+
+	CResourceLoaderObj();
+	CResourceLoaderObj(const char *strFileName,CLoadedObj *pObj);
+
+	virtual ~CResourceLoaderObj();
+	
+	CResourceLoaderObjState m_State;
+//	CByteDataObj			m_ByteData;
+	char					m_strFileName[40];
+	CLoadedObj				*m_pObj;
+
+};
+*/
+/* *********************************************************************  
+  
+  * CResourceLoader  
+  
+  * <20><><EFBFBD><EFBFBD> : ResourceLoader.h  
+  * <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> ResourceLoader 
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.06  
+  * history : 
+      wizardbug ( 2004.01.06)  
+  
+********************************************************************** */  
+
+class CResourceLoader
+{
+protected:
+	
+	static CThreadQueue<CLoadedObj *>m_ReadyQueue;
+	CThreadQueue<CLoadedObj *>m_Queue;
+	
+	CCriticalSectionQueue<CLoadedObj *>m_ResultQueue;
+
+	unsigned long					m_LoaderThreadID;
+	unsigned long					m_ProcessThreadID;
+
+	HANDLE							m_LoaderHandle;
+	HANDLE							m_ProcessHandle;
+
+public:
+	CResourceLoader() :/*m_ReadyQueue(g_iMaxLoaderQueue),*/m_Queue(g_iMaxLoaderQueue),m_ResultQueue(g_iMaxResultQueue),
+						m_LoaderThreadID(0),m_ProcessThreadID(0),
+						m_LoaderHandle(0),m_ProcessHandle(0)
+						{}
+	virtual ~CResourceLoader()
+	{
+		Clear();
+		CloseHandle(m_LoaderHandle);
+		CloseHandle(m_ProcessHandle);
+
+	}
+	void StartLoader();
+	static void AddObj(CLoadedObj *pAddObj)
+	{
+		m_ReadyQueue.PushBack(pAddObj);
+	}
+	void LoaderFunc();
+	void ProcessFunc();
+	void Process();
+	void ProcessAllData();
+
+	void Clear();
+
+
+};
+/*
+class CResourceLoader  
+{
+public:
+	CResourceLoader();
+	virtual ~CResourceLoader();
+	int	 FinishPercent();
+	// <20><><EFBFBD><EFBFBD> queue<75>ȿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> obj <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ƾ
+	void Loading();
+		
+	void ClearAllObj();
+	int AddObj(CResourceLoaderObj &);
+	void SetObj(int iIndex,CResourceLoaderObj &);
+
+	int	 GetObjNum();
+	CResourceLoaderObj GetObj(int iIndex);
+	// <20><><EFBFBD><EFBFBD> <20>ε<EFBFBD><CEB5><EFBFBD><EFBFBD><EFBFBD>	
+	CResourceLoaderObjState GetObjState(int iIndex);
+	
+	DWORD WaitFinished();
+	// <20><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>忡<EFBFBD><E5BFA1> ȣ<><C8A3>
+	void ProcessFunc();
+	// <20>δ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>忡<EFBFBD><E5BFA1> ȣ<><C8A3>
+	void LoaderFunc();
+	bool Finished();
+	void Process();
+
+protected:
+	// Loading Thread ȣ<><C8A3><EFBFBD><EFBFBD> <20><><EFBFBD>ٸ<EFBFBD><D9B8><EFBFBD> <20>ð<EFBFBD>
+	// 0 : <20><><EFBFBD>ٷ<EFBFBD> return, INFINIT : Loading <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ٸ<EFBFBD>. (default : 0)
+	DWORD							m_dwWait;		
+	std::vector<CResourceLoaderObj> m_lstObj;
+	std::vector<CResourceLoaderObj> m_lstReady;
+
+	CThreadQueue<CResourceLoaderObj *>m_Queue;
+	
+	CRITICAL_SECTION				m_ObjCriticalSection;
+	
+	unsigned long					m_LoaderThreadID;
+	unsigned long					m_ProcessThreadID;
+
+	HANDLE							m_EndEvent;
+	HANDLE							m_LoaderHandle;
+	HANDLE							m_ProcessHandle;
+
+	bool							m_bLoading;
+};
+*/
+}}
+
+#endif // !defined(AFX_RESOURCELOADER_H__16578E31_424F_4D74_9304_44BEC2BE6F95__INCLUDED_)

Engine/Caldron/Src/Base/ThreadQueue.h

@@ -0,0 +1,181 @@
+// ThreadQueue.h: interface for the CThreadQueue class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_THREADQUEUE_H__D6165646_A901_43B4_BABC_5237337D0BFD__INCLUDED_)
+#define AFX_THREADQUEUE_H__D6165646_A901_43B4_BABC_5237337D0BFD__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+#include "../../include/Caldron.h"
+//#include "./LogMgr.h"
+
+/* *********************************************************************  
+  
+  * CThreadQueue  
+  
+  * <20><><EFBFBD><EFBFBD> : ThreadQueue.cpp  
+  * <20><><EFBFBD><EFBFBD> :  
+  * <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.01.09  
+  * history : 
+      wizardbug ( 2004.01.09)  
+  
+********************************************************************** */  
+
+namespace Caldron {
+	namespace Base {
+
+enum CALDRONTHREADEVENT_ID { 
+	CALDRONTHREAD_SEMAPHORE = 0,
+	CALDRONTHREAD_TERMINATE, 
+};
+template<class T>
+class CThreadQueue  
+{
+public:
+	CThreadQueue(int iMaxQueueSize) 
+	{
+		InitializeCriticalSection(&m_CriticalSection);
+		m_Handle[CALDRONTHREAD_SEMAPHORE] = CreateSemaphore(NULL,0,iMaxQueueSize,NULL);
+		m_Handle[CALDRONTHREAD_TERMINATE] = CreateEvent(NULL,TRUE,FALSE,NULL);
+		
+	}
+	virtual ~CThreadQueue() 
+	{
+		ClearQueue();	
+		DeleteCriticalSection(&m_CriticalSection);
+		CloseHandle(m_Handle[CALDRONTHREAD_SEMAPHORE]);
+		CloseHandle(m_Handle[CALDRONTHREAD_TERMINATE]);	
+	}
+	bool PushBack(T Obj) 
+	{
+		EnterCriticalSection(&m_CriticalSection);
+		m_Queue.push(Obj);
+		
+		// semaphore count <20><><EFBFBD><EFBFBD>
+		bool bResult = (ReleaseSemaphore(m_Handle[CALDRONTHREAD_SEMAPHORE],1,NULL) != 0);
+		if(!bResult) 
+		{
+			m_Queue.pop();		// pop()<29><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٷ<EFBFBD><D9B7><EFBFBD><EFBFBD><EFBFBD> remove <20><>Ų<EFBFBD><C5B2>.
+			//CLogMgr::_LogError("CThreadQueue::PushBack() : Queue is Full~!");
+			MessageBox(NULL,"Queue Full","ThreadQueue",MB_OK);	
+		}
+		
+		LeaveCriticalSection(&m_CriticalSection);
+		return bResult;
+	}
+	void ClearQueue()
+	{
+		EnterCriticalSection(&m_CriticalSection);
+		while(m_Queue.size())
+		{
+			m_Queue.pop();
+
+		}
+		LeaveCriticalSection(&m_CriticalSection);
+
+	}
+
+	bool RemoveFront(T &Obj) 
+	{
+		bool bResult = false;
+		// Semarphore <20><> <20><><EFBFBD><EFBFBD> <20><>ŭ Return <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EEB0A3>
+		CALDRONTHREADEVENT_ID ReturnID = (CALDRONTHREADEVENT_ID)WaitForMultipleObjects(2,m_Handle,FALSE,INFINITE);
+		
+		if(ReturnID == CALDRONTHREAD_SEMAPHORE) 
+		{
+			bResult = true;
+			EnterCriticalSection(&m_CriticalSection);
+			if(m_Queue.size()) 
+			{
+				Obj = m_Queue.front();
+				m_Queue.pop();			// pop()<29><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٷ<EFBFBD><D9B7><EFBFBD><EFBFBD><EFBFBD> remove <20><>Ų<EFBFBD><C5B2>.
+			}
+			else 
+			{
+				//CLogMgr::_LogError("CThreadQueue::RemoveFront() : Queue is Empty~!");
+				bResult = false;
+			}
+			LeaveCriticalSection(&m_CriticalSection);
+			return bResult;
+		}
+		return bResult;
+	}
+	void Terminate() 
+	{
+		SetEvent(m_Handle[CALDRONTHREAD_TERMINATE]);
+	}
+	void UnTerminate() 
+	{
+		ResetEvent(m_Handle[CALDRONTHREAD_TERMINATE]);
+	}
+	int GetQueueSize() 
+	{ 
+		return (int)m_Queue.size();
+	}
+protected:	
+
+	HANDLE m_Handle[2];
+	CRITICAL_SECTION m_CriticalSection;
+	std::queue<T> m_Queue;
+
+};
+template<class T>
+class CCriticalSectionQueue
+{
+public:
+	CCriticalSectionQueue(int iMaxQueueSize) 
+	{
+		InitializeCriticalSection(&m_CriticalSection);
+	
+	}
+	virtual ~CCriticalSectionQueue() 
+	{	
+		ClearQueue();
+		DeleteCriticalSection(&m_CriticalSection);
+	}
+	void ClearQueue()
+	{
+		EnterCriticalSection(&m_CriticalSection);
+		while(m_Queue.size())
+		{
+			m_Queue.pop();
+
+		}
+		LeaveCriticalSection(&m_CriticalSection);
+
+	}
+	void PushBack(T Obj) 
+	{
+		EnterCriticalSection(&m_CriticalSection);
+		m_Queue.push(Obj);
+		LeaveCriticalSection(&m_CriticalSection);
+	}
+	bool RemoveFront(T &Obj) 
+	{
+		bool bReturn = false;
+		EnterCriticalSection(&m_CriticalSection);
+		if(m_Queue.size()) 
+		{
+			Obj = m_Queue.front();
+			m_Queue.pop();			// pop()<29><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٷ<EFBFBD><D9B7><EFBFBD><EFBFBD><EFBFBD> remove <20><>Ų<EFBFBD><C5B2>.
+			bReturn = true;
+		}
+		LeaveCriticalSection(&m_CriticalSection);
+		return bReturn;
+
+	}
+	int GetQueueSize() 
+	{ 
+		return (int)m_Queue.size();
+	}
+protected:
+	CRITICAL_SECTION m_CriticalSection;
+	std::queue<T> m_Queue;
+
+};
+
+	}
+}
+#endif // !defined(AFX_THREADQUEUE_H__D6165646_A901_43B4_BABC_5237337D0BFD__INCLUDED_)

Engine/Caldron/Src/Scene/D3DBufferPools.cpp

@@ -0,0 +1,613 @@
+#include "./d3dbufferpools.h"
+#include "SceneManager.h"
+#include "GMMemory.h"
+
+using namespace Caldron::Scene;
+
+void CD3DBufferObj::CreateBuffer(int iType,unsigned int uiSize,DWORD dwDecl,LPDIRECT3DRESOURCE8 lpBuffer)
+{
+	m_iBufferObjType = iType;
+	m_uiBufferSize = uiSize;
+	m_dwValue = dwDecl;
+
+	m_pBuffers = lpBuffer;
+
+}
+void CD3DBufferObj::NullBuffer()
+{
+	SafeRelease(m_pBuffers);
+	m_pBuffers = NULL;
+	m_iBufferObjType = 0;
+	m_uiBufferSize = 0;
+	m_dwValue = 0;
+
+
+}
+CD3DBufferPools::CD3DBufferPools(void)
+{
+	for(int i = 0; i < D3DBUFFER_SIZENUM - 1; i++ )
+	{
+		m_DVertexBufferNums[i] = 0;
+		m_DIndexBufferNums[i] = 0;
+	}
+
+	m_DCustomVertexBufferPools.clear();
+	m_DCustomIndexBufferPools.clear();
+	m_DIndexBufferNums[D3DBUFFER_SIZENUM - 1] = 0;
+	m_DVertexBufferNums[D3DBUFFER_SIZENUM - 1] = 0;
+	
+	for(int i = 0; i < D3DBUFFER_SIZENUM - 1; i++ )
+	{
+		m_SVertexBufferNums[i] = 0;
+		m_SIndexBufferNums[i] = 0;
+	}
+
+	m_SCustomVertexBufferPools.clear();
+	m_SCustomIndexBufferPools.clear();
+	m_SIndexBufferNums[D3DBUFFER_SIZENUM - 1] = 0;
+	m_SVertexBufferNums[D3DBUFFER_SIZENUM - 1] = 0;
+}	
+
+CD3DBufferPools::~CD3DBufferPools(void)
+{
+	// Dynamic Buffer Clear
+	for(int i = 0; i < D3DBUFFER_SIZENUM - 1; i++ )
+	{
+		while(!m_DVertexBufferPools[i].empty())
+		{
+			CD3DBufferObj *pObj = m_DVertexBufferPools[i].front();
+			m_DVertexBufferPools[i].pop();
+			if(pObj)
+			{
+				pObj->NullBuffer();
+				SafeDelete(pObj);
+
+			}
+		}
+		while(!m_DIndexBufferPools[i].empty())
+		{
+			CD3DBufferObj *pObj = m_DIndexBufferPools[i].front();
+			m_DIndexBufferPools[i].pop();
+			if(pObj)
+			{
+				pObj->NullBuffer();
+				SafeDelete(pObj);
+
+			}
+		}
+	
+		m_DVertexBufferNums[i] = 0;
+		m_DIndexBufferNums[i] = 0;
+	}
+
+	for(int i = 0; i < (int)m_DVertexBufferNums[D3DBUFFER_SIZENUM - 1]; i++ )
+	{	
+		if(m_DCustomVertexBufferPools[i])
+		{
+			m_DCustomVertexBufferPools[i]->NullBuffer();
+			SafeDelete(m_DCustomVertexBufferPools[i]);
+			m_DCustomVertexBufferPools[i] = NULL;
+		}
+	}
+	m_DCustomVertexBufferPools.clear();
+
+	for(int i = 0; i < (int)m_DIndexBufferNums[D3DBUFFER_SIZENUM - 1]; i++ )
+	{	
+		if(m_DCustomIndexBufferPools[i])
+		{
+			m_DCustomIndexBufferPools[i]->NullBuffer();
+			SafeDelete(m_DCustomIndexBufferPools[i]);
+			m_DCustomIndexBufferPools[i] = NULL;
+		}
+	}
+	m_DCustomIndexBufferPools.clear();
+	
+	// Static Buffer Clear
+	for(int i = 0; i < D3DBUFFER_SIZENUM - 1; i++ )
+	{
+		while(!m_SVertexBufferPools[i].empty())
+		{
+			CD3DBufferObj *pObj = m_SVertexBufferPools[i].front();
+			m_SVertexBufferPools[i].pop();
+			if(pObj)
+			{
+				pObj->NullBuffer();
+				SafeDelete(pObj);
+
+			}
+		}
+		while(!m_SIndexBufferPools[i].empty())
+		{
+			CD3DBufferObj *pObj = m_SIndexBufferPools[i].front();
+			m_SIndexBufferPools[i].pop();
+			if(pObj)
+			{
+				pObj->NullBuffer();
+				SafeDelete(pObj);
+
+			}
+		}
+
+	
+		m_SVertexBufferNums[i] = 0;
+		m_SIndexBufferNums[i] = 0;
+	}
+
+	for(int i = 0; i < (int)m_SVertexBufferNums[D3DBUFFER_SIZENUM - 1]; i++ )
+	{	
+		if(m_SCustomVertexBufferPools[i])
+		{
+			m_SCustomVertexBufferPools[i]->NullBuffer();
+			SafeDelete(m_SCustomVertexBufferPools[i]);
+			m_SCustomVertexBufferPools[i] = NULL;
+		}
+	}
+	m_SCustomVertexBufferPools.clear();
+
+	for(int i = 0; i < (int)m_SIndexBufferNums[D3DBUFFER_SIZENUM - 1]; i++ )
+	{	
+		if(m_SCustomIndexBufferPools[i])
+		{
+			m_SCustomIndexBufferPools[i]->NullBuffer();
+			SafeDelete(m_SCustomIndexBufferPools[i]);
+			m_SCustomIndexBufferPools[i] = NULL;
+		}
+	}
+	m_SCustomIndexBufferPools.clear();
+
+
+}
+LPDIRECT3DVERTEXBUFFER8 CD3DBufferPools::GetVertexBuffer(unsigned int uiSize,DWORD dwDecl,bool bDynamic)
+{
+	LPDIRECT3DVERTEXBUFFER8 pReturn = NULL;
+	int i,j;
+	if(bDynamic)
+	{
+		for(i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+		{
+			if(uiSize <= ArrBufferSize[i])
+			{
+				if(m_DVertexBufferNums[i])
+				{
+					CD3DBufferObj *pObj = m_DVertexBufferPools[i].front();
+					m_DVertexBufferPools[i].pop();
+					m_DVertexBufferNums[i]--;
+					if(pObj)
+					{
+						pReturn = (LPDIRECT3DVERTEXBUFFER8) pObj->m_pBuffers;
+						SafeDelete(pObj);
+						return pReturn;
+					}
+					return NULL;
+				}
+				return (pReturn = (LPDIRECT3DVERTEXBUFFER8)CreateBuffer(bDynamic,Scene::D3DBUFFEROBJ_VERTEX,i,dwDecl));	
+
+			}
+		}
+		// Custom Size
+		if(m_DVertexBufferNums[D3DBUFFER_SIZENUM - 1])
+		{
+			for(j = 0; j < (int)m_DVertexBufferNums[D3DBUFFER_SIZENUM - 1]; j++ )
+			{
+
+				if((m_DCustomVertexBufferPools[j]->m_uiBufferSize) >= uiSize) 
+				{
+					pReturn = ((LPDIRECT3DVERTEXBUFFER8)m_DCustomVertexBufferPools[j]->m_pBuffers);	
+					SafeDelete(m_DCustomVertexBufferPools[j]);
+					m_DCustomVertexBufferPools.erase(m_DCustomVertexBufferPools.begin() + j);
+					m_DVertexBufferNums[D3DBUFFER_SIZENUM - 1]--;
+
+					return pReturn;
+				}
+
+			}
+		}
+	}
+	else	//static 
+	{
+		for(i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+		{
+			if(uiSize <= ArrBufferSize[i])
+			{
+				if(m_SVertexBufferNums[i])
+				{
+					CD3DBufferObj *pObj = m_SVertexBufferPools[i].front();
+					m_SVertexBufferPools[i].pop();
+					m_SVertexBufferNums[i]--;
+					if(pObj)
+					{
+						pReturn = (LPDIRECT3DVERTEXBUFFER8) pObj->m_pBuffers;
+						SafeDelete(pObj);
+						return pReturn;
+					}
+					return NULL;
+				}
+				return (pReturn = (LPDIRECT3DVERTEXBUFFER8)CreateBuffer(bDynamic,Scene::D3DBUFFEROBJ_VERTEX,i,dwDecl));	
+
+			}
+		}
+		// Custom Size
+		if(m_SVertexBufferNums[D3DBUFFER_SIZENUM - 1])
+		{
+			for(j = 0; j < (int)m_SVertexBufferNums[D3DBUFFER_SIZENUM - 1]; j++ )
+			{
+
+				if((m_SCustomVertexBufferPools[j]->m_uiBufferSize) >= uiSize) 
+				{
+					pReturn = ((LPDIRECT3DVERTEXBUFFER8)m_SCustomVertexBufferPools[j]->m_pBuffers);	
+					SafeDelete(m_SCustomVertexBufferPools[j]);
+					m_SCustomVertexBufferPools.erase(m_SCustomVertexBufferPools.begin() + j);
+					m_SVertexBufferNums[D3DBUFFER_SIZENUM - 1]--;
+
+					return pReturn;
+				}
+
+			}
+		}
+	}
+	return (pReturn = (LPDIRECT3DVERTEXBUFFER8)CreateBuffer(bDynamic,Scene::D3DBUFFEROBJ_VERTEX,-1,dwDecl,uiSize));	
+
+}
+
+LPDIRECT3DINDEXBUFFER8	CD3DBufferPools::GetIndexBuffer(unsigned int uiSize,DWORD dwFormat,bool bDynamic)
+{
+	LPDIRECT3DINDEXBUFFER8 pReturn = NULL;
+	int i,j;
+	if(bDynamic)
+	{
+		for(i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+		{
+			if(uiSize <= ArrBufferSize[i])
+			{
+				if(m_DIndexBufferNums[i])
+				{
+					CD3DBufferObj *pObj = m_DIndexBufferPools[i].front();
+					m_DIndexBufferPools[i].pop();
+					m_DIndexBufferNums[i]--;
+					if(pObj)
+					{
+						pReturn = (LPDIRECT3DINDEXBUFFER8) pObj->m_pBuffers;
+						SafeDelete(pObj);
+						return pReturn;
+					}
+					return NULL;
+				}
+				return (pReturn = (LPDIRECT3DINDEXBUFFER8)CreateBuffer(bDynamic,Scene::D3DBUFFEROBJ_INDEX,i,dwFormat));	
+				
+			}
+		}
+		// Custom Size
+		if(m_DIndexBufferNums[D3DBUFFER_SIZENUM - 1])
+		{
+			for(j = 0; j < (int)m_DIndexBufferNums[D3DBUFFER_SIZENUM - 1]; j++ )
+			{
+
+				if((m_DCustomIndexBufferPools[j]->m_uiBufferSize) >= uiSize) 
+				{
+					pReturn = ((LPDIRECT3DINDEXBUFFER8)m_DCustomIndexBufferPools[j]->m_pBuffers);	
+					SafeDelete(m_DCustomIndexBufferPools[j]);
+					m_DCustomIndexBufferPools.erase(m_DCustomIndexBufferPools.begin() + j);
+					m_DIndexBufferNums[D3DBUFFER_SIZENUM - 1]--;
+					return pReturn;
+				}
+
+			}
+		}
+	}
+	else		//Static Buffer
+	{
+		for(i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+		{
+			if(uiSize <= ArrBufferSize[i])
+			{
+				if(m_SIndexBufferNums[i])
+				{
+					CD3DBufferObj *pObj = m_SIndexBufferPools[i].front();
+					m_SIndexBufferPools[i].pop();
+					m_SIndexBufferNums[i]--;
+					if(pObj)
+					{
+						pReturn = (LPDIRECT3DINDEXBUFFER8) pObj->m_pBuffers;
+						SafeDelete(pObj);
+						return pReturn;
+					}
+					return NULL;
+				}
+				return (pReturn = (LPDIRECT3DINDEXBUFFER8)CreateBuffer(bDynamic,Scene::D3DBUFFEROBJ_INDEX,i,dwFormat));	
+				
+			}
+		}
+		// Custom Size
+		if(m_SIndexBufferNums[D3DBUFFER_SIZENUM - 1])
+		{
+			for(j = 0; j < (int)m_SIndexBufferNums[D3DBUFFER_SIZENUM - 1]; j++ )
+			{
+
+				if((m_SCustomIndexBufferPools[j]->m_uiBufferSize) >= uiSize) 
+				{
+					pReturn = ((LPDIRECT3DINDEXBUFFER8)m_SCustomIndexBufferPools[j]->m_pBuffers);	
+					SafeDelete(m_SCustomIndexBufferPools[j]);
+					m_SCustomIndexBufferPools.erase(m_SCustomIndexBufferPools.begin() + j);
+					m_SIndexBufferNums[D3DBUFFER_SIZENUM - 1]--;
+					return pReturn;
+				}
+
+			}
+		}
+
+
+	}
+	return (pReturn = (LPDIRECT3DINDEXBUFFER8)CreateBuffer(bDynamic,Scene::D3DBUFFEROBJ_INDEX,-1,dwFormat,uiSize));	
+
+}
+void CD3DBufferPools::UnRef(unsigned int iType,LPDIRECT3DRESOURCE8 lpBuffer)
+{
+	// ppuchuu 2004/11/15
+	if( NULL == lpBuffer )
+	{
+		return;
+	}
+
+	// edith 2008.12.12 <20><><EFBFBD><EFBFBD>Ǯ<EFBFBD><C7AE> <20>ִ밳<D6B4><EBB0B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+	unsigned int iMaxPoolCount = 100;
+	bool bDynamic = false;
+
+
+	if(iType == Scene::D3DBUFFEROBJ_VERTEX)
+	{
+		D3DVERTEXBUFFER_DESC VertexBufferDesc;
+		((LPDIRECT3DVERTEXBUFFER8)lpBuffer)->GetDesc(&VertexBufferDesc);
+		
+		if(VertexBufferDesc.Usage & D3DUSAGE_DYNAMIC)
+			bDynamic = true;
+
+		if(bDynamic)
+		{
+			// <20>ִ밳<D6B4><EBB0B3> <20><><EFBFBD><EFBFBD>.
+			for(int i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+			{
+				if(VertexBufferDesc.Size <= ArrBufferSize[i])
+				{
+					if(m_DVertexBufferNums[i] >= iMaxPoolCount)
+					{
+						SafeRelease(lpBuffer);
+						return;
+					}
+					break;
+				}
+			}
+		}
+		else
+		{
+			// <20>ִ밳<D6B4><EBB0B3> <20><><EFBFBD><EFBFBD>
+			for(int i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+			{
+				if(VertexBufferDesc.Size <= ArrBufferSize[i])
+				{
+					if(m_SVertexBufferNums[i] >= iMaxPoolCount)
+					{
+						SafeRelease(lpBuffer);
+						return;
+					}
+					break;
+				}
+			}
+		}
+
+		CD3DBufferObj *pObj = new CD3DBufferObj;
+		pObj->CreateBuffer(iType,VertexBufferDesc.Size,VertexBufferDesc.FVF,lpBuffer);
+
+		if(bDynamic)
+		{
+			for(int i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+			{
+				if(pObj->m_uiBufferSize <= ArrBufferSize[i])
+				{
+					m_DVertexBufferPools[i].push(pObj);
+					m_DVertexBufferNums[i]++;
+					return;
+				}
+			}
+			m_DCustomVertexBufferPools.push_back(pObj);
+			m_DVertexBufferNums[D3DBUFFER_SIZENUM - 1]++;
+		}
+		else	// Static Buffer
+		{
+			for(int i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+			{
+				if(pObj->m_uiBufferSize <= ArrBufferSize[i])
+				{
+					m_SVertexBufferPools[i].push(pObj);
+					m_SVertexBufferNums[i]++;
+					return;
+				}
+			}
+			m_SCustomVertexBufferPools.push_back(pObj);
+			m_SVertexBufferNums[D3DBUFFER_SIZENUM - 1]++;
+		}
+	}
+	else if(iType == Scene::D3DBUFFEROBJ_INDEX)
+	{
+		D3DINDEXBUFFER_DESC IndexBufferDesc;
+		((LPDIRECT3DINDEXBUFFER8)lpBuffer)->GetDesc(&IndexBufferDesc);
+		
+		if(IndexBufferDesc.Usage & D3DUSAGE_DYNAMIC)
+			bDynamic = true;
+		
+		if(bDynamic)
+		{
+			// <20>ִ밳<D6B4><EBB0B3> <20><><EFBFBD><EFBFBD>.
+			for(int i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+			{
+				if(IndexBufferDesc.Size <= ArrBufferSize[i])
+				{
+					if(m_DIndexBufferNums[i] >= iMaxPoolCount)
+					{
+						SafeRelease(lpBuffer);
+						return;
+					}
+					break;
+				}
+			}
+		}
+		else
+		{
+			// <20>ִ밳<D6B4><EBB0B3> <20><><EFBFBD><EFBFBD>
+			for(int i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+			{
+				if(IndexBufferDesc.Size <= ArrBufferSize[i])
+				{
+					if(m_SIndexBufferNums[i] >= iMaxPoolCount)
+					{
+						SafeRelease(lpBuffer);
+						return;
+					}
+					break;
+				}
+			}
+		}
+
+		CD3DBufferObj *pObj = new CD3DBufferObj;
+		pObj->CreateBuffer(iType,IndexBufferDesc.Size,IndexBufferDesc.Format,lpBuffer);
+
+		if(bDynamic)
+		{
+			for(int i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+			{
+				if(pObj->m_uiBufferSize <= ArrBufferSize[i])
+				{
+					m_DIndexBufferPools[i].push(pObj);
+					m_DIndexBufferNums[i]++;
+					return;
+				}
+			}
+			m_DCustomIndexBufferPools.push_back(pObj);
+			m_DIndexBufferNums[D3DBUFFER_SIZENUM - 1]++;
+		}
+		else	// Static 
+		{
+
+			for(int i = 0;i < D3DBUFFER_SIZENUM - 1; i++)
+			{
+				if(pObj->m_uiBufferSize <= ArrBufferSize[i])
+				{
+					m_SIndexBufferPools[i].push(pObj);
+					m_SIndexBufferNums[i]++;
+					return;
+				}
+			}
+			m_SCustomIndexBufferPools.push_back(pObj);
+			m_SIndexBufferNums[D3DBUFFER_SIZENUM - 1]++;
+		}
+	}
+	
+}
+LPDIRECT3DRESOURCE8 CD3DBufferPools::CreateBuffer(bool bDynamic,unsigned int iType,int iSizeType,DWORD dwValue,unsigned int uiCustomSize)
+{
+	unsigned int uiSize = 0;
+
+	if(iSizeType >= 0)
+		uiSize = ArrBufferSize[iSizeType];
+	else
+		uiSize = uiCustomSize;
+
+	if(iType == Scene::D3DBUFFEROBJ_VERTEX)
+	{
+		LPDIRECT3DVERTEXBUFFER8 lpVertex;
+	
+		if(!bDynamic)
+		{
+			
+//			if(Caldron::Failed(CSceneManager::GetDevice()->CreateVertexBuffer(uiSize,D3DUSAGE_WRITEONLY,dwValue,D3DPOOL_DEFAULT,&lpVertex)))
+			if(Caldron::Failed(CSceneManager::GetDevice()->CreateVertexBuffer(uiSize,D3DUSAGE_WRITEONLY,0,D3DPOOL_MANAGED,&lpVertex)))
+			{
+				MessageBox(NULL,"Buffer Create Faile(1)","Error",MB_OK);
+			}
+		}
+		else
+		{
+			if(Caldron::Failed(CSceneManager::GetDevice()->CreateVertexBuffer(uiSize,D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC,0,D3DPOOL_DEFAULT,&lpVertex)))
+			{
+				MessageBox(NULL,"Buffer Create Faile(2)","Error",MB_OK);
+			}
+		}
+	
+		return lpVertex;
+
+	}
+	else if(iType == Scene::D3DBUFFEROBJ_INDEX)
+	{
+		LPDIRECT3DINDEXBUFFER8 lpIndex;
+		if(!bDynamic)
+		{
+			if(Caldron::Failed(CSceneManager::GetDevice()->CreateIndexBuffer(uiSize,D3DUSAGE_WRITEONLY,(D3DFORMAT)dwValue,D3DPOOL_MANAGED,&lpIndex)))
+//			if(Caldron::Failed(CSceneManager::GetDevice()->CreateIndexBuffer(uiSize,D3DUSAGE_WRITEONLY,(D3DFORMAT)dwValue,D3DPOOL_DEFAULT,&lpIndex)))
+			{
+				MessageBox(NULL,"Buffer Create Faile(3)","Error",MB_OK);
+			}
+		}
+		else
+		{
+
+			if(Caldron::Failed(CSceneManager::GetDevice()->CreateIndexBuffer(uiSize,D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC,(D3DFORMAT)dwValue,D3DPOOL_DEFAULT ,&lpIndex)))
+			{
+				MessageBox(NULL,"Buffer Create Faile(4)","Error",MB_OK);
+			}
+		}
+	
+	
+	
+
+		return lpIndex;
+
+	}
+
+	return NULL;	
+
+}
+void CD3DBufferPools::InitBuffer()
+{
+	int i,j;
+
+	for( i = 0; i <  8; i++ )
+	{
+		LPDIRECT3DVERTEXBUFFER8 lpVertexBuffer[80];
+		LPDIRECT3DINDEXBUFFER8 lpIndexBuffer[80];
+
+		for( j = 0;j < 80; j++ )
+		{
+			if(j < 15)
+			{
+				lpVertexBuffer[j] = GetVertexBuffer(ArrBufferSize[i] - 10,0,false);	
+				lpIndexBuffer[j] = GetIndexBuffer(ArrBufferSize[i] - 10,D3DFMT_INDEX16,false);	
+			}
+			else
+			{
+				lpVertexBuffer[j] = GetVertexBuffer(ArrBufferSize[i] - 10,0,true);	
+				lpIndexBuffer[j] = GetIndexBuffer(ArrBufferSize[i] - 10,D3DFMT_INDEX16,true);
+			}
+		}
+		for(j = 0;j < 80; j++ )
+		{
+			UnRef(D3DBUFFEROBJ_VERTEX,lpVertexBuffer[j]);
+			UnRef(D3DBUFFEROBJ_INDEX,lpIndexBuffer[j]);
+			lpVertexBuffer[j] = NULL;
+			lpIndexBuffer[j] = NULL;
+		}
+	}
+
+	for(i = 0; i < 5; i++ )
+	{
+		LPDIRECT3DVERTEXBUFFER8 lpCustomBuffer[5];
+		lpCustomBuffer[0] = GetVertexBuffer(150000,0,true);
+		lpCustomBuffer[1] = GetVertexBuffer(100000,0,true);
+		lpCustomBuffer[2] = GetVertexBuffer(50000,0,true);
+		lpCustomBuffer[3] = GetVertexBuffer(50000,0,true);
+		lpCustomBuffer[4] = GetVertexBuffer(150000,0,true);
+		for(j = 0; j < 5; j++ )
+		{
+			UnRef(D3DBUFFEROBJ_VERTEX,lpCustomBuffer[j]);
+			lpCustomBuffer[j] = NULL;
+		}
+	}
+}

Engine/Caldron/Src/Scene/D3DBufferPools.h

@@ -0,0 +1,90 @@
+#pragma once
+#include "../../include/Caldron.h"
+
+namespace Caldron {
+	namespace Scene {
+enum D3DBUFFFEROBJ_TYPE 
+{
+	D3DBUFFEROBJ_VERTEX = 0,
+	D3DBUFFEROBJ_INDEX,
+	D3DBUFFEROBJ_TYPENUM,
+
+};
+enum D3DBUFFER_SIZE
+{
+	D3DBUFFER_SIZE1 = 0, // 100
+	D3DBUFFER_SIZE2 = 1, // 250
+	D3DBUFFER_SIZE3 = 2, // 500
+	D3DBUFFER_SIZE4 = 3, // 1000
+	D3DBUFFER_SIZE5 = 4, // 3000
+	D3DBUFFER_SIZE6 = 5, // 7000
+	D3DBUFFER_SIZE7 = 6, // 10000
+	D3DBUFFER_SIZE8 = 7, // 20000
+	D3DBUFFER_SIZE9 = 8, // Custom Buffer
+	D3DBUFFER_SIZENUM = 9,
+
+};
+// edith 2010.01.29 D3D <20><><EFBFBD><EFBFBD> ũ<><C5A9> <20><><EFBFBD><EFBFBD>
+const unsigned int ArrBufferSize[8] = {
+	100,
+	250,
+	500,
+	1000,
+	3000,
+	7000,
+	10000,
+	20000
+};
+class CD3DBufferObj
+{
+public:	
+	int					m_iBufferObjType;
+	LPDIRECT3DRESOURCE8 m_pBuffers;
+	unsigned int		m_uiBufferSize;
+	DWORD				m_dwValue;
+
+
+	CD3DBufferObj() : m_pBuffers(NULL),m_uiBufferSize(0),m_dwValue(0){}
+	~CD3DBufferObj()
+	{
+		//SafeRelease(m_pBuffers);
+		m_pBuffers = NULL;
+	}
+	void NullBuffer();
+	void CreateBuffer(int iType,unsigned int uiSize,DWORD dwDecl,LPDIRECT3DRESOURCE8 lpBuffer);
+
+};
+
+class CD3DBufferPools
+{
+public:
+	CD3DBufferPools(void);
+	~CD3DBufferPools(void);
+	void InitBuffer();
+
+	LPDIRECT3DVERTEXBUFFER8 GetVertexBuffer(unsigned int uiSize,DWORD dwDecl,bool bDynamic = false);
+	LPDIRECT3DINDEXBUFFER8	GetIndexBuffer(unsigned int uiSize,DWORD dwFormat,bool bDynamic = false);
+	void UnRef(unsigned int iType,LPDIRECT3DRESOURCE8 lpBuffer);
+
+	LPDIRECT3DRESOURCE8 CreateBuffer(bool bDynamic,unsigned int iType,int iSizeType,DWORD dwValue,unsigned int uiCustomSize = 0);
+	// Dynamic Buffer
+	std::queue<CD3DBufferObj *>		m_DVertexBufferPools[D3DBUFFER_SIZENUM -1];
+	std::vector<CD3DBufferObj *>	m_DCustomVertexBufferPools;
+	unsigned int					m_DVertexBufferNums[D3DBUFFER_SIZENUM];
+
+	std::queue<CD3DBufferObj *>		m_DIndexBufferPools[D3DBUFFER_SIZENUM -1];
+	std::vector<CD3DBufferObj *>	m_DCustomIndexBufferPools;
+	unsigned int					m_DIndexBufferNums[D3DBUFFER_SIZENUM];
+	// Static Buffer
+	std::queue<CD3DBufferObj *>		m_SVertexBufferPools[D3DBUFFER_SIZENUM -1];
+	std::vector<CD3DBufferObj *>	m_SCustomVertexBufferPools;
+	unsigned int					m_SVertexBufferNums[D3DBUFFER_SIZENUM];
+
+	std::queue<CD3DBufferObj *>		m_SIndexBufferPools[D3DBUFFER_SIZENUM -1];
+	std::vector<CD3DBufferObj *>	m_SCustomIndexBufferPools;
+	unsigned int					m_SIndexBufferNums[D3DBUFFER_SIZENUM];
+
+};
+
+
+}}

Engine/Caldron/Src/Scene/DrawElement.cpp

@@ -0,0 +1,408 @@
+#include "DrawElement.h"
+#include <algorithm>
+
+
+namespace Caldron
+{
+namespace Scene
+{
+	IDirect3DDevice8* CDrawElementMgr::ms_pDevice;
+
+	std::vector< DRAW_ELEMENT > CDrawElementMgr::ms_avecDynamicDrawElement[MAX_DRAW_ELEMENT_LAYER];
+//	std::vector< DRAW_ELEMENT > CDrawElementMgr::ms_avecStaticDrawElement[MAX_DRAW_ELEMENT_LAYER];
+
+	int CDrawElementMgr::ms_nDynamicVertexBufferCount;
+	DWORD CDrawElementMgr::ms_dwDynamicVertexBufferSize;
+
+	int CDrawElementMgr::ms_nDynamicIndexBufferCount;
+	DWORD CDrawElementMgr::ms_dwDynamicIndexBufferSize;
+
+//	int CDrawElementMgr::ms_nStaticVertexBufferCount;
+//	DWORD CDrawElementMgr::ms_dwStaticVertexBufferSize;
+
+//	int CDrawElementMgr::ms_nStaticIndexBufferCount;
+//	DWORD CDrawElementMgr::ms_dwStaticIndexBufferSize;
+
+//	IDirect3DVertexBuffer8** CDrawElementMgr::ms_apDynamicVertexBuffer;
+//	IDirect3DIndexBuffer8** CDrawElementMgr::ms_apDynaicIndexBuffer;
+	IDirect3DVertexBuffer8* CDrawElementMgr::ms_pDynamicVertexBuffer;
+	IDirect3DIndexBuffer8* CDrawElementMgr::ms_pDynamicIndexBuffer;
+
+	std::map< CBaseMesh*, UINT > CDrawElementMgr::ms_mapVBAllocationInfo;
+	std::map< CBaseMesh*, UINT > CDrawElementMgr::ms_mapIBAllocationInfo;
+	int CDrawElementMgr::ms_nVBUsedInByte;
+	int CDrawElementMgr::ms_nIBUsedInByte;
+
+
+//	IDirect3DVertexBuffer8** CDrawElementMgr::ms_apStaticVertexBuffer;
+//	IDirect3DIndexBuffer8** CDrawElementMgr::ms_apStaticIndexBuffer;
+
+	DRAW_ELEMENT CDrawElementMgr::ms_LastTimeDE;
+
+
+	bool CDrawElementMgr::_Init( IDirect3DDevice8* pDevice, DRAW_ELEMENT_MGR_INIT_PARAM* pInitParam )
+	{
+		ms_pDevice = pDevice;
+
+		HRESULT hr;
+
+		// dynamic VB <20>Ҵ<EFBFBD>
+		hr = pDevice->CreateVertexBuffer( pInitParam->dwDynamicVertexBufferSize, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,
+			0, D3DPOOL_DEFAULT, &ms_pDynamicVertexBuffer );
+		if( FAILED(hr) )
+		{
+			return false;
+		}
+
+		// dynamic IB <20>Ҵ<EFBFBD>
+		hr = pDevice->CreateIndexBuffer( pInitParam->dwDynamicIndexBufferSize, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,
+			D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ms_pDynamicIndexBuffer );
+		if( FAILED(hr) )
+		{
+			return false;
+		}
+
+		// static VB <20>Ҵ<EFBFBD>
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+		// static IB <20>Ҵ<EFBFBD>
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+
+		ms_nDynamicVertexBufferCount = 1;//pInitParam->nDynamicVertexBufferCount;
+		ms_dwDynamicVertexBufferSize = pInitParam->dwDynamicVertexBufferSize;
+
+		ms_nDynamicIndexBufferCount = 1;//pInitParam->nDynamicIndexBufferCount;
+		ms_dwDynamicIndexBufferSize = pInitParam->dwDynamicIndexBufferSize;
+
+
+//		ms_nStaticVertexBufferCount = pInitParam->nStaticVertexBufferCount;
+//		ms_dwStaticVertexBufferSize = pInitParam->dwStaticVertexBufferSize;
+
+//		ms_nStaticIndexBufferCount = pInitParam->nStaticIndexBufferCount;
+//		ms_dwStaticIndexBufferSize = pInitParam->dwStaticIndexBufferSize;
+
+
+		ms_LastTimeDE.pMesh = NULL;
+		ms_LastTimeDE.pTM = NULL;
+		ms_LastTimeDE.pTextureTM = NULL;
+		ms_LastTimeDE.textureSlot.apTexture[0] = NULL;
+		ms_LastTimeDE.textureSlot.nUsed = 1;
+		ms_LastTimeDE.hVertexShader = NULL;
+		ms_LastTimeDE.hPixelShader = NULL;
+		ms_LastTimeDE.pStateSet = NULL;
+
+
+		return true;
+	}
+
+
+	bool CDrawElementMgr::_RegisterDrawElement( int nLayer, DRAW_ELEMENT& rDE )
+	{
+		if( nLayer >= MAX_DRAW_ELEMENT_LAYER )
+		{
+			return false;
+		}
+
+		if( false == rDE.ValidityCheck() )
+		{
+			return false;
+		}
+
+		// D/E <20><> <20><><EFBFBD>ҵ鿡 <20><><EFBFBD><EFBFBD> lock <20><> <20>ʿ<EFBFBD><CABF>ҵ<EFBFBD>.. <20>׷<EFBFBD><D7B7><EFBFBD> <20>̷<EFBFBD><CCB7><EFBFBD> <20>Ϸ<EFBFBD><CFB7><EFBFBD> <20><> <20><><EFBFBD>ҵ<EFBFBD> <20><><EFBFBD><EFBFBD> lockable <20><> <20><>ü<EFBFBD><C3BC> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+		rDE.pMesh->Lock();
+
+		ms_avecDynamicDrawElement[nLayer].push_back( rDE );
+
+		return true;
+	}
+
+
+//	bool CDrawElementMgr::_RegisterStaticDrawElement( int nLayer, DRAW_ELEMENT& rDE )
+//	{
+//		//
+//		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> dynamic <20>϶<EFBFBD><CFB6><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ٲ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>
+//		//
+//
+//		if( nLayer >= MAX_DRAW_ELEMENT_LAYER )
+//		{
+//			return false;
+//		}
+//
+//		if( false ==rDE.ValidityCheck() )
+//		{
+//			return false;
+//		}
+//
+//		// D/E <20><> <20><><EFBFBD>ҵ鿡 <20><><EFBFBD><EFBFBD> lock <20><> <20>ʿ<EFBFBD><CABF>ҵ<EFBFBD>.. <20>׷<EFBFBD><D7B7><EFBFBD> <20>̷<EFBFBD><CCB7><EFBFBD> <20>Ϸ<EFBFBD><CFB7><EFBFBD> <20><> <20><><EFBFBD>ҵ<EFBFBD> <20><><EFBFBD><EFBFBD> lockable <20><> <20><>ü<EFBFBD><C3BC> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+//
+//		ms_avecDynamicDrawElement[nLayer].push_back( rDE );
+//
+//		return true;
+//	}
+
+	void CDrawElementMgr::_Process()
+	{
+		VIB_PACKET packet;
+
+		// sort
+		_Sort();
+
+		// optimize
+		_Optimize();
+
+
+
+		for( int i = 0; i < MAX_DRAW_ELEMENT_LAYER; ++i )
+		{
+			// per-layer setting ( ex) Render Target Change )
+			// render target, view matrix, projection matrix <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+
+
+
+			std::vector< DRAW_ELEMENT > & rvecDE = ms_avecDynamicDrawElement[i];	// shortcut to i-th layer of D/E vector
+
+			for( int j = 0; j < rvecDE.size(); ++j )
+			{
+				DRAW_ELEMENT &rCurrentDrawElement = rvecDE[j];
+
+				// mesh data uploading (to VB/IB )
+				_UploadMesh( rCurrentDrawElement, packet );
+
+				// draw primitive(include state setting)
+				_Render( rCurrentDrawElement, packet );
+
+				// unlock D/E related components
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> CMesh <20><> Lock/Unlock <20><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD><EFBFBD>
+				rCurrentDrawElement.pMesh->Unlock();
+			}
+
+			// flush D/E list 'cause this is DYNAMIC D/E list
+            rvecDE.clear();
+		}
+
+		ms_pDevice->SetStreamSource( 0, NULL, 0 );
+		ms_pDevice->SetIndices( NULL, 0 );
+	}
+
+	void CDrawElementMgr::_Close()
+	{
+		// VB/IB <20><><EFBFBD><EFBFBD>
+		SafeRelease( ms_pDynamicVertexBuffer );
+		SafeRelease( ms_pDynamicIndexBuffer );
+	}
+
+	// D/E sort comparison processor
+	bool DE_Ascend( DRAW_ELEMENT rDE1, DRAW_ELEMENT rDE2 )
+	{
+		if( rDE1.textureSlot.apTexture[0] > rDE2.textureSlot.apTexture[0] ) return false;
+		if( rDE1.pTM > rDE2.pTM ) return false;
+		if( rDE1.hVertexShader > rDE2.hVertexShader ) return false;
+		if( rDE1.hPixelShader > rDE2.hPixelShader ) return false;
+		if( rDE1.pStateSet > rDE2.pStateSet ) return false;
+		if( rDE1.pMesh > rDE2.pMesh ) return false;
+
+		return true;
+	}
+
+	void CDrawElementMgr::_Sort()
+	{
+		for( int i = 0; i < MAX_DRAW_ELEMENT_LAYER; ++i )
+		{
+			std::stable_sort( ms_avecDynamicDrawElement[i].begin(), ms_avecDynamicDrawElement[i].end(), DE_Ascend );
+		}
+
+	}
+
+
+	void CDrawElementMgr::_Optimize()
+	{
+		// nothing now..
+	}
+
+
+	void CDrawElementMgr::_UploadMesh( DRAW_ELEMENT &rDE, VIB_PACKET &rPacket )
+	{
+		std::map< CBaseMesh*, UINT >::iterator it;
+		BYTE* pByteDataInBuffer = NULL;
+		UINT uSizeInByte;	// <20>Ҵ<EFBFBD><D2B4><EFBFBD> mesh data <20><> byte <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+		UINT uAllocOffset;	// buffer <20><><EFBFBD><EFBFBD> upload <20><> <20><>ġ
+		UINT uRemain;	// buffer <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20><><EFBFBD><EFBFBD>
+		HRESULT hr;
+
+		// VB <20><><EFBFBD><EFBFBD> <20>̹<EFBFBD> upload <20>Ǿ<EFBFBD><C7BE>ִ<EFBFBD> mesh <20>ΰ<EFBFBD>?
+		it = ms_mapVBAllocationInfo.find( rDE.pMesh );
+		if( it != ms_mapVBAllocationInfo.end() )
+		{
+			// <20>׷<EFBFBD><D7B7>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> VIB packet <20><> <20><><EFBFBD><EFBFBD>
+			rPacket.uPositionInVB = it->second;
+		}
+		else
+		{
+			// <20>ƴϸ<C6B4> <20>Ҵ<EFBFBD> <20><><EFBFBD><EFBFBD>
+			
+			//////////////////////////////////////////////////////////////////////////
+			//
+			// DrawPrimitive <20>迭<EFBFBD><E8BFAD> offset <20><><EFBFBD><EFBFBD> <20>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD>͵<EFBFBD><CDB5><EFBFBD> vertex <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>̹Ƿ<CCB9>
+			// mesh vertex data<74><61> upload <20><> <20><><EFBFBD><EFBFBD> <20><> <20><>ġ<EFBFBD><C4A1> vertex size<7A><65> <20>°<EFBFBD> align
+			// <20><> <20>ش<EFBFBD>.
+			//
+
+			uSizeInByte = rDE.pMesh->GetVertexCount() * rDE.pMesh->GetVertexSize();
+
+			UINT uUsedAlignFixed = (ms_nVBUsedInByte % rDE.pMesh->GetVertexSize() ) ? 
+										( ( ms_nVBUsedInByte/rDE.pMesh->GetVertexSize() ) + 1 ) * rDE.pMesh->GetVertexSize() :
+										ms_nVBUsedInByte; // vertex size <20><><EFBFBD>迡 <20><><EFBFBD><EFBFBD> <20>ø<EFBFBD>
+			uRemain = ms_dwDynamicVertexBufferSize - uUsedAlignFixed;
+
+			// Lock VB
+			if( uRemain < uSizeInByte )
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ҷ<EFBFBD> -> discard all & reset alloc info
+				uAllocOffset = 0;
+				hr = ms_pDynamicVertexBuffer->Lock( uAllocOffset, uSizeInByte, &pByteDataInBuffer, D3DLOCK_DISCARD );
+				if( FAILED(hr) )
+				{
+					return;	// Lock <20><><EFBFBD>н<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>..-_-
+				}
+
+				// VB flush, <20>Ҵ<EFBFBD><D2B4><EFBFBD><EFBFBD><EFBFBD> clear
+				ms_mapVBAllocationInfo.clear();
+				ms_nVBUsedInByte = 0;
+			}
+			else
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ҷ<EFBFBD> -> <20><> Lock
+				uAllocOffset = uUsedAlignFixed;
+				hr = ms_pDynamicVertexBuffer->Lock( uAllocOffset, uSizeInByte, &pByteDataInBuffer, D3DLOCK_NOOVERWRITE );
+				if( FAILED(hr) )
+				{
+					return;	// Lock <20><><EFBFBD>н<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>..-_-
+				}
+			}
+			
+			// upload, <20>Ҵ<EFBFBD><D2B4><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			rDE.pMesh->UploadVertexData( pByteDataInBuffer );
+			ms_pDynamicVertexBuffer->Unlock();
+
+            ms_mapVBAllocationInfo[rDE.pMesh] = uAllocOffset;
+			ms_nVBUsedInByte = uUsedAlignFixed + uSizeInByte;
+		}
+
+		// indexed mesh <20><> <20>ƴϸ<C6B4> -> <20><><EFBFBD><EFBFBD>
+		if( !( rDE.pMesh->IsIndexed() ) )
+		{
+			return;
+		}
+
+		// IB <20><><EFBFBD><EFBFBD> VB <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ݺ<EFBFBD>
+		
+		// IB <20><><EFBFBD><EFBFBD> <20>̹<EFBFBD> upload <20>Ǿ<EFBFBD><C7BE>ִ<EFBFBD> mesh <20>ΰ<EFBFBD>?
+		it = ms_mapIBAllocationInfo.find( rDE.pMesh );
+		if( it != ms_mapIBAllocationInfo.end() )
+		{
+			// <20>׷<EFBFBD><D7B7>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> VIB packet <20><> <20><><EFBFBD><EFBFBD>
+			rPacket.uPositionInIB = it->second;
+		}
+		else
+		{
+			// <20>ƴϸ<C6B4> <20>Ҵ<EFBFBD> <20><><EFBFBD><EFBFBD>
+
+			uSizeInByte = rDE.pMesh->GetIndexCount() * sizeof(WORD);
+			uRemain = ms_dwDynamicIndexBufferSize - ms_nIBUsedInByte;
+
+			// Lock IB
+			if( uRemain < uSizeInByte )
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ҷ<EFBFBD> -> discard all & reset alloc info
+				uAllocOffset = 0;
+				hr = ms_pDynamicIndexBuffer->Lock( uAllocOffset, uSizeInByte, &pByteDataInBuffer, D3DLOCK_DISCARD );
+				if( FAILED(hr) )
+				{
+					return;	// Lock <20><><EFBFBD>н<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>..-_-
+				}
+
+				// IB flush, <20>Ҵ<EFBFBD><D2B4><EFBFBD><EFBFBD><EFBFBD> clear
+				ms_mapIBAllocationInfo.clear();
+				ms_nIBUsedInByte = 0;
+			}
+			else
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ҷ<EFBFBD> -> <20><> Lock
+				uAllocOffset = ms_nIBUsedInByte;
+				hr = ms_pDynamicIndexBuffer->Lock( uAllocOffset, uSizeInByte, &pByteDataInBuffer, D3DLOCK_NOOVERWRITE );
+				if( FAILED(hr) )
+				{
+					return;	// Lock <20><><EFBFBD>н<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>..-_-
+				}
+			}
+
+			// upload, <20>Ҵ<EFBFBD><D2B4><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			rDE.pMesh->UploadIndexData( pByteDataInBuffer );
+			ms_pDynamicIndexBuffer->Unlock();
+
+			ms_mapIBAllocationInfo[rDE.pMesh] = uAllocOffset;
+			ms_nIBUsedInByte += uSizeInByte;
+		}
+	}
+
+
+	void CDrawElementMgr::_Render( DRAW_ELEMENT &rDE, VIB_PACKET &rPacket )
+	{
+// <20>ӽ<EFBFBD><D3BD>ڵ<EFBFBD>
+ms_pDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
+ms_pDevice->LightEnable( 0, TRUE );
+
+
+		// ms_LastTimeDE <20><> rDE <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD> <20><> <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD>
+
+		// rPacket <20><> VB/IB <20><> last time <20><> <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD> stream source <20><> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD>..<2E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> VB/IB <20><> <20>ϳ<EFBFBD><CFB3><EFBFBD><EFBFBD>̹Ƿ<CCB9> <20><><EFBFBD><EFBFBD>
+		// ...<2E>Ϸ<EFBFBD><CFB7><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, SSS<53><53> stride <20><> <20>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD>ͷ<EFBFBD> <20><><EFBFBD><EFBFBD>Ƿ<EFBFBD> <20>Ź<EFBFBD> <20><><EFBFBD>ִ°<D6B4><C2B0><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>-_-;
+		ms_pDevice->SetStreamSource( 0, ms_pDynamicVertexBuffer, rDE.pMesh->GetVertexSize() );
+
+		ms_pDevice->SetTransform( D3DTS_WORLD, rDE.pTM );
+
+		if( NULL == rDE.hVertexShader )
+		{
+			DWORD dwFVF = rDE.pMesh->GetFVF();
+			ms_pDevice->SetVertexShader( dwFVF );
+		}
+		else
+		{
+			ms_pDevice->SetVertexShader( rDE.hVertexShader );
+		}
+		ms_pDevice->SetPixelShader( rDE.hPixelShader );
+
+		if( NULL == rDE.textureSlot.apTexture[0] )
+		{
+			ms_pDevice->SetTexture( 0, NULL );			
+		}
+		else
+		{
+			ms_pDevice->SetTexture( 0, rDE.textureSlot.apTexture[0]->GetTexture() );
+		}
+
+
+		if( rDE.pMesh->IsIndexed() )
+		{
+			ms_pDevice->SetIndices( ms_pDynamicIndexBuffer, rPacket.uPositionInVB / rDE.pMesh->GetVertexSize() );
+
+			ms_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, rDE.pMesh->GetVertexCount(),
+				rPacket.uPositionInIB / sizeof(WORD), rDE.pMesh->GetIndexCount() / 3 );
+		}
+		else
+		{
+			ms_pDevice->DrawPrimitive(  D3DPT_TRIANGLELIST, rPacket.uPositionInVB / rDE.pMesh->GetVertexSize(),
+				rDE.pMesh->GetVertexCount()/3 );
+		}
+
+		// last time <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
+		ms_LastTimeDE = rDE;
+	}
+
+
+
+
+}
+}

Engine/Caldron/Src/Scene/DrawElement.h

@@ -0,0 +1,186 @@
+#pragma once
+
+#pragma warning( disable : 4786 )
+#include "../../include/Caldron.h"
+
+#include "Mesh.h"
+//#include "Texture.h"
+#include "NTexture.h"
+#include "StateSet.h"
+
+#include <vector>
+
+
+//////////////////////////////////////////////////////////////////////////
+//
+// 1<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> dynamic buffer <20><>, VB/IB <20><> 1<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>θ<EFBFBD> <20><><EFBFBD><EFBFBD>
+//
+
+namespace Caldron
+{
+namespace Scene
+{
+	const int MAX_DRAW_ELEMENT_LAYER = 5;
+	const int MAX_TEXTURE_SLOT = 8;
+
+	struct TEXTURE_SLOT
+	{
+		//CTexture* apTexture[MAX_TEXTURE_SLOT];
+		CROSSM::CNTexture* apTexture[MAX_TEXTURE_SLOT];
+        int nUsed;
+
+
+		TEXTURE_SLOT()
+		{
+			apTexture[0] = NULL;
+			nUsed = 1;
+		}
+/*
+		TEXTURE_SLOT( int n, CTexture pt0, CTexture pt1 = NULL, CTexture pt2 = NULL, CTexture pt3 = NULL )
+		{
+			apTexture[0] = pt0;
+			apTexture[1] = pt1;
+			apTexture[2] = pt2;
+			apTexture[3] = pt3;
+
+			nUsed = n;
+		}
+*/
+	};
+
+
+	struct DRAW_ELEMENT
+	{
+		CBaseMesh* pMesh;
+        D3DMATRIX* pTM;
+		D3DMATRIX* pTextureTM;
+		TEXTURE_SLOT textureSlot;
+		DWORD hVertexShader;
+		DWORD hPixelShader;
+		CStateSet* pStateSet;
+
+
+
+		// VB/IB <20><> upload <20><> <20><>ġ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ͺκ<CDBA> <20>ʿ<EFBFBD>
+		DRAW_ELEMENT() {}
+
+
+		DRAW_ELEMENT( CBaseMesh* _pMesh, D3DMATRIX* _pTM, D3DMATRIX* _pTextureTM, TEXTURE_SLOT* _pTextureSlot, DWORD _hVertexShader, DWORD _hPixelShader, CStateSet* _pStateSet )
+		{
+			pMesh = _pMesh;
+			pTM = _pTM;
+			pTextureTM = _pTextureTM;
+			textureSlot = *_pTextureSlot;
+			hVertexShader = _hVertexShader;
+			hPixelShader = _hPixelShader  ;
+			pStateSet = _pStateSet;
+		}
+
+		bool ValidityCheck()
+		{
+			if( NULL == pMesh ) return false;
+			//if( NULL == pTextureSlot ) return false;
+			// VS, PS <20><><EFBFBD><EFBFBD> null <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+            if( NULL == pStateSet ) return false;
+
+			return true;
+		}
+	};
+
+
+	struct DRAW_ELEMENT_MGR_INIT_PARAM
+	{
+		int nDynamicVertexBufferCount;
+		DWORD dwDynamicVertexBufferSize;
+
+		int nDynamicIndexBufferCount;
+		DWORD dwDynamicIndexBufferSize;
+
+		int nStaticVertexBufferCount;
+		DWORD dwStaticVertexBufferSize;
+
+		int nStaticIndexBufferCount;
+		DWORD dwStaticIndexBufferSize;
+	};
+
+	struct VIB_PACKET
+	{
+		//IDirect3DVertexBuffer8* pVB;
+		//IDirect3DIndexBuffer8* pIB;
+		UINT uPositionInVB;
+		UINT uPositionInIB;
+
+		VIB_PACKET()
+		{
+			uPositionInVB = 0;
+			uPositionInIB = 0;
+		}
+	};
+
+
+	class CDrawElementMgr
+	{
+	public:
+		// <20>ʱ<EFBFBD>ȭ( InitDevice <20><> <20>ʱ<EFBFBD>ȭ)
+		static bool _Init( IDirect3DDevice8* pDevice, DRAW_ELEMENT_MGR_INIT_PARAM* pInitParam );
+
+		// Draw Element <20><><EFBFBD><EFBFBD>
+		static bool _RegisterDrawElement( int nLayer, DRAW_ELEMENT& rDE );
+
+		// Static Draw Element <20><><EFBFBD><EFBFBD>
+//		static bool _RegisterStaticDrawElement( int nLayer, DRAW_ELEMENT& rDE );
+
+		// register <20><> D/E <20><><EFBFBD><EFBFBD> sort <20>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD>ȭ<EFBFBD><C8AD> <20><> DrawPrimitive ȣ<><C8A3>
+		static void _Process();
+
+		// <20><><EFBFBD><EFBFBD>( _Init <20><> pair )
+		static void _Close();
+
+	private:
+		static IDirect3DDevice8* ms_pDevice;
+
+		static std::vector< DRAW_ELEMENT > ms_avecDynamicDrawElement[MAX_DRAW_ELEMENT_LAYER];
+//		static std::vector< DRAW_ELEMENT > ms_avecStaticDrawElement[MAX_DRAW_ELEMENT_LAYER];
+
+		static int ms_nDynamicVertexBufferCount;
+		static DWORD ms_dwDynamicVertexBufferSize;
+
+		static int ms_nDynamicIndexBufferCount;
+		static DWORD ms_dwDynamicIndexBufferSize;
+
+
+//		static int ms_nStaticVertexBufferCount;
+//		static DWORD ms_dwStaticVertexBufferSize;
+
+//		static int ms_nStaticIndexBufferCount;
+//		static DWORD ms_dwStaticIndexBufferSize;
+
+//		static IDirect3DVertexBuffer8** ms_apDynamicVertexBuffer;
+//		static IDirect3DIndexBuffer8** ms_apDynaicIndexBuffer;
+		static IDirect3DVertexBuffer8* ms_pDynamicVertexBuffer;
+		static IDirect3DIndexBuffer8* ms_pDynamicIndexBuffer;
+
+//		static IDirect3DVertexBuffer8** ms_apStaticVertexBuffer;
+//		static IDirect3DIndexBuffer8** ms_apStaticIndexBuffer;
+
+
+		static std::map< CBaseMesh*, UINT > ms_mapVBAllocationInfo;
+		static std::map< CBaseMesh*, UINT > ms_mapIBAllocationInfo;
+		static int ms_nVBUsedInByte;
+		static int ms_nIBUsedInByte;
+
+		static DRAW_ELEMENT ms_LastTimeDE;
+
+
+		// Process <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE>
+		static void _Sort();
+		static void _Optimize();
+		static void _UploadMesh( DRAW_ELEMENT &rDE, VIB_PACKET &rPacket );
+		static void _Render( DRAW_ELEMENT &rDE, VIB_PACKET &rPacket );
+
+	};
+
+
+
+}
+}

Engine/Caldron/Src/Scene/Mesh.h

@@ -0,0 +1,192 @@
+#pragma once
+
+#pragma warning( disable : 4786 )
+#include "../../include/Caldron.h"
+
+
+namespace Caldron
+{
+namespace Scene
+{
+
+	class CBaseMesh
+	{
+	public:
+		CBaseMesh()
+		{
+			m_nLockCount = 0;
+		}
+		
+		virtual ~CBaseMesh()
+		{
+			// m_nLockCount <20><> 0<><30> <20>ƴ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>޽<EFBFBD><DEBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD>.
+		}
+
+		void Lock()
+		{
+			// thread safe code <20>ʿ<EFBFBD><CABF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?
+			++m_nLockCount;
+		}
+		
+		void Unlock()
+		{
+			// thread safe code <20>ʿ<EFBFBD><CABF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?
+			if( m_nLockCount > 0 )
+			{
+				// <20><><EFBFBD><EFBFBD> lock count <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>޽<EFBFBD><DEBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ҽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+				--m_nLockCount;
+			}
+		}
+
+		bool IsLocked()
+		{
+			return (m_nLockCount>0);
+		}
+
+		// VB <20><> vertex <20><><EFBFBD><EFBFBD> upload <20><> <20><><EFBFBD><EFBFBD>
+		virtual void UploadVertexData( void* p ) = 0;
+		// IB <20><> index <20><><EFBFBD><EFBFBD> upload <20><> <20><><EFBFBD><EFBFBD>
+		virtual void UploadIndexData( void* p ) = 0;
+
+		// 
+		virtual int GetVertexCount() = 0;
+		virtual int GetIndexCount() = 0;
+
+
+		virtual int GetVertexSize() = 0;
+		virtual DWORD GetFVF() = 0;
+
+
+		bool IsIndexed()
+		{
+			return m_bIndexed;
+		}
+
+
+	protected:
+		int m_nLockCount;
+		bool m_bIndexed;
+	};
+
+
+	template <class _T>
+	class CMesh : public CBaseMesh
+	{
+	public:
+		CMesh()
+		{
+		}
+
+		~CMesh()
+		{
+		}
+
+		// VB <20><> vertex <20><><EFBFBD><EFBFBD> upload <20><> <20><><EFBFBD><EFBFBD>
+		void UploadVertexData( void* p )
+		{
+			if( 0 == m_vecVertexData.size() )
+			{
+				return;
+			}
+
+			MoveMemory( p, &(m_vecVertexData[0]), sizeof(_T) * m_vecVertexData.size() );
+		}
+
+		// IB <20><> index <20><><EFBFBD><EFBFBD> upload <20><> <20><><EFBFBD><EFBFBD>
+		void UploadIndexData( void* p )
+		{
+			if( 0 == m_vecIndexData.size() )
+			{
+				return;
+			}
+
+			MoveMemory( p, &(m_vecIndexData[0]), sizeof(_T) * m_vecIndexData.size() );
+		}
+
+
+		//
+		int GetVertexCount()
+		{
+			return m_vecVertexData.size();
+		}
+		//
+		int GetIndexCount()
+		{
+			return m_vecIndexData.size();
+		}
+
+
+		int GetVertexSize()
+		{
+			return sizeof( _T );
+		}
+
+		DWORD GetFVF()
+		{
+			return _T::GetFVF();
+		}
+
+
+
+		// vertex <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD>Ȯ<EFBFBD><C8AE>)
+		void SetVertexCount( int n )
+		{
+			m_vecVertexData.resize( n );
+		}
+
+		// <20>ش<EFBFBD> index <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD> Ȯ<><C8AE>)
+		void SetIndexCount( int n )
+		{
+			m_vecIndexData.resize( n );
+
+			if( 0 == n )
+			{
+				m_bIndexed = false;
+			}
+			else
+			{
+				m_bIndexed = true;
+			}
+		}
+
+
+		//
+		_T* GetVertexWritePtr()
+		{
+			if( IsLocked() )
+			{
+				return NULL;
+			}
+
+			if( 0 == m_vecVertexData.size() )
+			{
+				return NULL;
+			}
+
+			return &(m_vecVertexData[0]);
+		}
+
+		WORD* GetIndexWritePtr()
+		{
+			if( IsLocked() )
+			{
+				return NULL;
+			}
+
+			if( 0 == m_vecIndexData.size() )
+			{
+				return NULL;
+			}
+
+			return &(m_vecIndexData[0]);
+		}
+
+
+	private:
+		std::vector< _T > m_vecVertexData;
+		std::vector< WORD > m_vecIndexData;
+	};
+
+
+}
+}

Engine/Caldron/Src/Scene/StateSet.cpp

@@ -0,0 +1,11 @@
+#include "StateSet.h"
+
+
+namespace Caldron
+{
+namespace Scene
+{
+
+
+}
+}

Engine/Caldron/Src/Scene/StateSet.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#pragma warning( disable : 4786 )
+#include "../../include/Caldron.h"
+
+#include "Mesh.h"
+#include "Texture.h"
+
+
+namespace Caldron
+{
+namespace Scene
+{
+	class CStateSet
+	{
+	public:
+
+
+	};
+
+	class CStateSetMgr
+	{
+	public:
+		// <20>ʱ<EFBFBD>ȭ( InitDevice <20><> <20>ʱ<EFBFBD>ȭ)
+		static bool _Init( IDirect3DDevice8* pDevice );
+
+		// StateSet Manager <20>ܺο<DCBA><CEBF><EFBFBD> d3d device <20><> <20><><EFBFBD><EFBFBD> <20>õ<EFBFBD><C3B5><EFBFBD> state change <20><><EFBFBD><EFBFBD> <20>˻<EFBFBD><CBBB><EFBFBD> device <20><> StateSet Mgr <20><> state<74><65> <20><><EFBFBD><EFBFBD>ȭ
+		static void _GetCurrentDeviceState();
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> StateSet <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> D3D Device <20><> <20><><EFBFBD><EFBFBD>
+		static void _ApplyStateSet( CStateSet* pStateSet );
+
+	private:
+		// <20><> state <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	};
+}
+}