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>
2025-11-29 16:24:34 +09:00
commit e067522598
5135 changed files with 1745744 additions and 0 deletions
--- a/Engine/Caldron/Src/Scene/D3DBufferPools.cpp
+++ b/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;
+		}
+	}
+}
--- a/Engine/Caldron/Src/Scene/D3DBufferPools.h
+++ b/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];
+
+};
+
+
+}}
--- a/Engine/Caldron/Src/Scene/DrawElement.cpp
+++ b/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;
+	}
+
+
+
+
+}
+}
--- a/Engine/Caldron/Src/Scene/DrawElement.h
+++ b/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 );
+
+	};
+
+
+
+}
+}
--- a/Engine/Caldron/Src/Scene/Mesh.h
+++ b/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;
+	};
+
+
+}
+}
--- a/Engine/Caldron/Src/Scene/StateSet.cpp
+++ b/Engine/Caldron/Src/Scene/StateSet.cpp
@@ -0,0 +1,11 @@
+#include "StateSet.h"
+
+
+namespace Caldron
+{
+namespace Scene
+{
+
+
+}
+}
--- a/Engine/Caldron/Src/Scene/StateSet.h
+++ b/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>
+	};
+}
+}