RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Restructure repository to include all source folders

Browse Source 
Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

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

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
tindevil
2025-11-29 20:17:20 +09:00
parent 5d3cd64a25
commit dd97ddec92
11602 changed files with 1446576 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
GameTools/CaldronBase/Base.vcproj Normal file
View File

@@ -0,0 +1,202 @@
<?xml version="1.0" encoding="ks_c_5601-1987"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="Base"
ProjectGUID="{C1552555-C254-4B21-8FE1-457F2494F4F7}"
SccProjectName="SAK"
SccAuxPath="SAK"
SccLocalPath="SAK"
SccProvider="SAK"
Keyword="Win32Proj">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="Debug"
IntermediateDirectory="Debug"
ConfigurationType="4"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
MinimalRebuild="TRUE"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="4"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile="$(OutDir)/Base.lib"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="Release"
IntermediateDirectory="Release"
ConfigurationType="4"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
RuntimeLibrary="4"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="TRUE"
DebugInformationFormat="3"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile="$(OutDir)/Base.lib"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="<22>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
<File
RelativePath=".\BaseCacheMgr.cpp">
</File>
<File
RelativePath=".\BaseObj.cpp">
</File>
<File
RelativePath=".\ByteDataObj.cpp">
</File>
<File
RelativePath=".\Caldron.cpp">
</File>
<File
RelativePath=".\D3D9GraphicLayer.cpp">
</File>
<File
RelativePath=".\DInput8Mgr.cpp">
</File>
<File
RelativePath=".\ExceptionMgr.cpp">
</File>
<File
RelativePath=".\LoadedObj.cpp">
</File>
<File
RelativePath=".\LogMgr.cpp">
</File>
<File
RelativePath=".\MemoryPool.cpp">
</File>
<File
RelativePath=".\ProfileMgr.cpp">
</File>
<File
RelativePath=".\ResourceLoader.cpp">
</File>
<File
RelativePath=".\Timer.cpp">
</File>
</Filter>
<Filter
Name="<22><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
<File
RelativePath=".\BaseCacheMgr.h">
</File>
<File
RelativePath=".\BaseObj.h">
</File>
<File
RelativePath=".\ByteDataObj.h">
</File>
<File
RelativePath="..\..\Include\Caldron.h">
</File>
<File
RelativePath=".\D3D9GraphicLayer.h">
</File>
<File
RelativePath=".\DInput8Mgr.h">
</File>
<File
RelativePath=".\ExceptionMgr.h">
</File>
<File
RelativePath=".\LoadedObj.h">
</File>
<File
RelativePath=".\LogMgr.h">
</File>
<File
RelativePath=".\MemoryPool.h">
</File>
<File
RelativePath=".\ProfileMgr.h">
</File>
<File
RelativePath=".\ResourceLoader.h">
</File>
<File
RelativePath=".\ThreadQueue.h">
</File>
<File
RelativePath=".\Timer.h">
</File>
</Filter>
<Filter
Name="<22><><EFBFBD>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD>"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
</Filter>
<File
RelativePath=".\ReadMe.txt">
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

10
GameTools/CaldronBase/Base.vcproj.vspscc Normal file
View File

@@ -0,0 +1,10 @@
""
{
"FILE_VERSION" = "9237"
"ENLISTMENT_CHOICE" = "NEVER"
"PROJECT_FILE_RELATIVE_PATH" = ""
"NUMBER_OF_EXCLUDED_FILES" = "0"
"ORIGINAL_PROJECT_FILE_PATH" = ""
"NUMBER_OF_NESTED_PROJECTS" = "0"
"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER"
}

29
GameTools/CaldronBase/BaseCacheMgr.cpp Normal file
View File

@@ -0,0 +1,29 @@
/* *********************************************************************
* 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"
namespace Caldron {namespace Base {
unsigned long CBaseCacheMgr::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;
}
}}

120
GameTools/CaldronBase/BaseCacheMgr.h Normal file
View File

@@ -0,0 +1,120 @@
#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 "./Caldron.h"
#include "./LoadedObj.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);
m_iDatasNum++;
}
void Add_Back(CLoadedObj *pObj)
{
m_lstDatas.push_back(pObj);
m_iDatasNum++;
}
~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;
class CBaseCacheMgr
{
protected:
unsigned long GetHashID(const char *strFileName);
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;
}
}
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_)

235
GameTools/CaldronBase/BaseObj.cpp Normal file
View File

@@ -0,0 +1,235 @@
/* *********************************************************************
* CBaseObj
* <20><><EFBFBD><EFBFBD> : BaseObj.cpp
* <20><><EFBFBD><EFBFBD> : Base Object Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
* history :
2003.10.31 (yundi) <20>ۼ<EFBFBD>
********************************************************************** */
#include "BaseObj.h"
namespace Caldron{ namespace Base{
int CBaseObj::ms_nTotalObjectCount = 0;
CBaseObj::CBaseObj( CBaseObj* pParentObj )
{
SetParent( NULL );
SetPrevSibling( NULL );
SetNextSibling( NULL );
SetFirstChild( NULL );
EstablishLinkageToParent( pParentObj );
++ms_nTotalObjectCount;
}
CBaseObj::~CBaseObj()
{
// <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE>ҵ<EFBFBD>.
if( NULL != GetFirstChild() )
{
CBaseObj* pObj = GetFirstChild()->GetLastSibling();
while( pObj )
{
CBaseObj* pDeleteObj = pObj;
pObj = pObj->GetPrevSibling();
SafeDelete( pDeleteObj );
}
}
Unlink();
--ms_nTotalObjectCount;
}
CBaseObj* CBaseObj::GetParent()
{
return m_rpParent;
}
CBaseObj* CBaseObj::GetFirstChild()
{
return m_rpFirstChild;
}
CBaseObj* CBaseObj::GetPrevSibling()
{
return m_rpPrevSibling;
}
CBaseObj* CBaseObj::GetNextSibling()
{
return m_rpNextSibling;
}
bool CBaseObj::LinkToParent( CBaseObj* pParentObj )
{
if( pParentObj == GetParent() )
{
return true;
}
CBaseObj* pObj = pParentObj;
while( NULL != pObj )
{
if( pObj == this )
{
// <20>ڽ<EFBFBD><DABD><EFBFBD> <20>ڽ<EFBFBD> <20><> <20>ϳ<EFBFBD><CFB3><EFBFBD> <20>θ<EFBFBD><CEB8><EFBFBD> link<6E>Ϸ<EFBFBD><CFB7><EFBFBD> <20>õ<EFBFBD><C3B5><EFBFBD> <20><><EFBFBD><EFBFBD>
return false;
}
pObj = pObj->GetParent();
}
if( !IsRoot() )
{
Unlink();
}
EstablishLinkageToParent( pParentObj );
return true;
}
CBaseObj* CBaseObj::GetLastSibling()
{
// <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>鿡<EFBFBD><E9BFA1> NULL <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3><EFBFBD><EFBFBD> <20><> <20><><EFBFBD>µ<EFBFBD> <20>̰<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>⿡ <20>δ°<CEB4> <20>ٶ<EFBFBD><D9B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>𸣰ڴ<F0B8A3B0>.
if( NULL == this )
{
return NULL;
}
CBaseObj* pObj = this;
while( NULL != pObj->GetNextSibling() )
{
pObj = pObj->GetNextSibling();
}
return pObj;
}
void CBaseObj::AddSiblingObj( CBaseObj* pObj )
{
CBaseObj* pLastSibling = GetLastSibling();
// establish mutual linkage
pLastSibling->SetNextSibling( pObj );
pObj->SetPrevSibling( pLastSibling );
}
void CBaseObj::Unlink()
{
// <20>θ<EFBFBD><CEB8><EFBFBD> sibling<6E><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD>κ<EFBFBD><CEBA><EFBFBD> <20>и<EFBFBD><D0B8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ΰ<EFBFBD> root <20><> <20><>
if( IsRoot() )
{
return;
}
if( GetParent()->GetFirstChild() == this )
{
GetParent()->SetFirstChild( GetNextSibling() );
}
if( GetPrevSibling() != NULL )
{
GetPrevSibling()->SetNextSibling( GetNextSibling() );
}
if( GetNextSibling() != NULL )
{
GetNextSibling()->SetPrevSibling( GetPrevSibling() );
}
SetParent( NULL );
SetPrevSibling( NULL );
SetNextSibling( NULL );
}
void CBaseObj::EstablishLinkageToParent( CBaseObj* pParent )
{
// this<69><73> parent<6E><74> sibling<6E><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9> <20><>ȿ<EFBFBD><C8BF> <20><><EFBFBD>¿<EFBFBD><C2BF><EFBFBD> parent<6E><74> child<6C>μ<EFBFBD>
// <20><>ȿ<EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> parent<6E><74> sibling<6E><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9> <20><><EFBFBD><EFBFBD>
if( NULL == pParent )
{
return;
}
SetParent( pParent );
CBaseObj* pParentFirstChild = pParent->GetFirstChild();
if( NULL == pParentFirstChild )
{
pParent->SetFirstChild( this );
}
else
{
pParentFirstChild->AddSiblingObj( this );
}
}
bool CBaseObj::IsRoot()
{
if( NULL == GetParent() &&
NULL == GetPrevSibling() &&
NULL == GetNextSibling() )
{
return true;
}
return false;
}
bool CBaseObj::IsLeaf()
{
if( NULL == GetFirstChild() )
{
return true;
}
return false;
}
bool CBaseObj::IsFirst()
{
if( NULL == GetPrevSibling() )
{
return true;
}
return false;
}
bool CBaseObj::IsLast()
{
if( NULL == GetNextSibling() )
{
return true;
}
return false;
}
}}

62
GameTools/CaldronBase/BaseObj.h Normal file
View File

@@ -0,0 +1,62 @@
/* *********************************************************************
* CBaseObj
* <20><><EFBFBD><EFBFBD> : BaseObj.h
* <20><><EFBFBD><EFBFBD> : Caldron<6F><6E><EFBFBD><EFBFBD> <20><><EFBFBD>ο<EFBFBD><CEBF><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> <20><><EFBFBD><EFBFBD> Object<63><74><EFBFBD><EFBFBD> Base Object Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
* history :
2003.10.31 (yundi) <20>ۼ<EFBFBD>
********************************************************************** */
#pragma once
#include "Caldron.h"
namespace Caldron
{
namespace Base
{
class CBaseObj
{
public:
CBaseObj( CBaseObj* pParentObj = NULL );
virtual ~CBaseObj();
bool LinkToParent( CBaseObj* pParentObj );
void Unlink();
bool IsRoot();
bool IsLeaf();
bool IsFirst();
bool IsLast();
CBaseObj* GetParent();
CBaseObj* GetFirstChild();
CBaseObj* GetPrevSibling();
CBaseObj* GetNextSibling();
private:
void SetParent( CBaseObj* pObj ) { m_rpParent = pObj; }
void SetFirstChild( CBaseObj* pObj ) { m_rpFirstChild = pObj; }
void SetPrevSibling( CBaseObj* pObj ) { m_rpPrevSibling = pObj; }
void SetNextSibling( CBaseObj* pObj ) { m_rpNextSibling = pObj; }
CBaseObj* GetLastSibling();
void AddSiblingObj( CBaseObj* pObj );
void EstablishLinkageToParent( CBaseObj* pParent );
static int _GetTotalObjectCount() { return ms_nTotalObjectCount; }
CBaseObj* m_rpParent;
CBaseObj* m_rpFirstChild;
CBaseObj* m_rpPrevSibling;
CBaseObj* m_rpNextSibling;
static int ms_nTotalObjectCount;
};
}
}

124
GameTools/CaldronBase/ByteDataObj.cpp Normal file
View File

@@ -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 "./LogMgr.h"
#include "ByteDataObj.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)
{
CLogMgr::_LogError("CByteDataObj::LoadByte() : %s file not exist\n",strFileName);
return false;
}
fseek(fp,0,SEEK_END);
m_lSize = ftell(fp);
if(m_lSize <= 0)
{
CLogMgr::_LogError("CByteDataObj::LoadByte() : %s file size Wrong\n",strFileName);
fclose(fp);
return false;
}
// Offset <20><><EFBFBD><EFBFBD>
if(m_lSize > lOffset)
m_lSize -= lOffset;
else
{
CLogMgr::_LogError("CByteDataObj::LoadByte() : %s File Offset<65><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ѱ踦 <20>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD>ϴ<EFBFBD>.\n",strFileName);
fclose(fp);
return false;
}
m_pBytes = new unsigned char[m_lSize];
if(m_pBytes == NULL)
{
CLogMgr::_LogError("CByteDataObj::LoadByte() : File Load Buffer's New Fail.\n");
fclose(fp);
return false;
}
fseek(fp,lOffset,SEEK_SET);
if(fread((unsigned char *)m_pBytes,sizeof(unsigned char),m_lSize,fp) != m_lSize)
{
CLogMgr::_LogError("CByteDataObj::LoadByte() : Load File Fail.\n");
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;
}
}}

55
GameTools/CaldronBase/ByteDataObj.h Normal file
View File

@@ -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_)

25
GameTools/CaldronBase/Caldron.cpp Normal file
View File

@@ -0,0 +1,25 @@
/* *********************************************************************
* 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;
const float FLOAT_PI = 3.14159265358979323846f;
const float FLOAT_2PI = 6.28318530717958647692f;
extern const float MIN_EPSILON = 1.0e-4f;
extern const float MAX_EPSILON = 1.0e+10f;
const int MAX_STRINGSIZE = 40;
// const int MAX_RELOADING = 3;
}

197
GameTools/CaldronBase/Caldron.h Normal file
View File

@@ -0,0 +1,197 @@
/* *********************************************************************
* Caldron Engine <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
* <20><><EFBFBD><EFBFBD> : Caldron.h
* <20><><EFBFBD><EFBFBD> : Caldron Engine <20><> <20>̿<EFBFBD><CCBF>ϴ°<CFB4><C2B0><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰԵǴ<D4B5> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
* <20>ۼ<EFBFBD><DBBC><EFBFBD>: 2003.10.23
* <20>ۼ<EFBFBD><DBBC><EFBFBD>: yundi ( 2003.10.23)
* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
********************************************************************** */
#pragma once
#pragma warning(disable:4786)
#pragma warning(disable:4251)
#pragma warning(disable:4503)
#include <algorithm>
//#include <d3d9.h>
#include <d3dx8.h>
#include <tchar.h>
#include <vector>
#include <queue>
#include <map>
#include <string>
#include <list>
#include <math.h>
#include <process.h>
#include <mmsystem.h>
#include <windows.h>
namespace Caldron
{
// epsilon <20><><EFBFBD><EFBFBD>
extern const float MIN_EPSILON;
extern const float MAX_EPSILON;
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
const float FLOAT_RAD = 0.0174532925f; // radian <20><>
extern const float FLOAT_PI; // pi
extern const float FLOAT_2PI;
extern const int MAX_STRINGSIZE;
const int MAX_RELOADING = 3; // Resource Loader <20><><EFBFBD><EFBFBD> Object <20>ε<EFBFBD> <20><><EFBFBD>н<EFBFBD> <20>ִ<EFBFBD> Reloading <20>õ<EFBFBD> Ƚ<><C8BD>
#define FLOAT_TO_INT(fValue) (*(int *)&(fValue))
#define IS_SIGNBIT(fValue) (FLOAT_TO_INT(fValue) & 0x80000000)
// template function <20><><EFBFBD><EFBFBD>
template<class _T>
inline void SafeDelete( _T ptr )
{
if( NULL != ptr )
{
delete (ptr);
ptr = NULL;
}
}
template<class _T>
inline void SafeDeleteA( _T ptr )
{
if( NULL != ptr )
{
delete[] (ptr);
ptr = NULL;
}
}
template<class _T>
inline void SafeRelease( _T ptr )
{
if( NULL != ptr )
{
ptr->Release();
ptr = NULL;
}
}
inline bool Succeeded( HRESULT hr )
{
return (hr >= 0);
}
inline bool Failed( HRESULT hr )
{
return (hr < 0);
}
inline bool IsZero(float fValue)
{
if((fValue > -(MIN_EPSILON)) && (fValue < MIN_EPSILON))
return true;
return false;
}
inline float Def2Rad( float fDeg )
{
return fDeg*FLOAT_PI/180;
}
// CProfileMgr <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
inline void ProfileGetTicks(_int64 * ticks)
{
__asm
{
push edx;
push ecx;
mov ecx,ticks;
_emit 0Fh
_emit 31h
mov [ecx],eax;
mov [ecx+4],edx;
pop ecx;
pop edx;
}
}
inline float ProfileGetTickRate(void)
{
static float _CPUFrequency = -1.0f;
if (_CPUFrequency == -1.0f) {
__int64 curr_rate = 0;
::QueryPerformanceFrequency ((LARGE_INTEGER *)&curr_rate);
_CPUFrequency = (float)curr_rate;
}
return _CPUFrequency;
}
//
/* *********************************************************************
* CBitset
* <20><><EFBFBD><EFBFBD> : Bitset.h
* <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> Bitset Class
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.10.24
* History : wizardbug ( 2003.10.24)
********************************************************************** */
class CBitset {
protected:
unsigned int *m_pBits; // Bit Set ptr
int m_iBitSize; // Bit Set Size
public:
CBitset() {
m_pBits = NULL;
m_iBitSize = 0;
}
~CBitset() {
if(m_pBits)
{
delete[] m_pBits;
m_pBits = NULL;
}
}
void ResizeBits(int iNewCount) {
m_iBitSize = iNewCount / 32 + 1; // Get Inteager Size
if(m_pBits) {
delete[] m_pBits;
m_pBits = NULL;
}
m_pBits = new unsigned int[m_iBitSize]; // Allocate Bits
ClearBits();
}
void ClearBits() { // Clear All Bits
memset(m_pBits,0,sizeof(unsigned int) * m_iBitSize);
}
void ClearOneBit(int index) {
m_pBits[ index >> 5 ] &= ~( 1 << ( index & 31 ) );
}
void SetBit(int index) { // Set Bit
m_pBits[ index >> 5 ] |= ( 1 << ( index & 31 ) );
}
bool GetBit(int index) { // Return Bit's Setting : return true or false
return (m_pBits[ index >> 5 ] & ( 1 << (index & 31 ) )) ? true : false;
}
};
/********************************************************************** */
}

92
GameTools/CaldronBase/CaldronBase.dsp Normal file
View File

@@ -0,0 +1,92 @@
# Microsoft Developer Studio Project File - Name="CaldronBase" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Static Library" 0x0104
CFG=CaldronBase - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "CaldronBase.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "CaldronBase.mak" CFG="CaldronBase - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "CaldronBase - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "CaldronBase - Win32 Debug" (based on "Win32 (x86) Static Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "CaldronBase - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD BASE RSC /l 0x412 /d "NDEBUG"
# ADD RSC /l 0x412 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo
!ELSEIF "$(CFG)" == "CaldronBase - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD BASE RSC /l 0x412 /d "_DEBUG"
# ADD RSC /l 0x412 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo
!ENDIF
# Begin Target
# Name "CaldronBase - Win32 Release"
# Name "CaldronBase - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# End Target
# End Project

16
GameTools/CaldronBase/CaldronBase.plg Normal file
View File

@@ -0,0 +1,16 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: CaldronBase - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
CaldronBase.lib - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

161
GameTools/CaldronBase/CaldronBase.vcproj Normal file
View File

@@ -0,0 +1,161 @@
<?xml version="1.0" encoding="ks_c_5601-1987"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="CaldronBase"
ProjectGUID="{D2E60DB8-59A3-4446-BAA7-53C4F661D8EF}"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="4"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Debug/CaldronBase.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile=".\Debug\CaldronBase.lib"
SuppressStartupBanner="TRUE"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1042"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="4"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\Release/CaldronBase.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLibrarianTool"
OutputFile=".\Release\CaldronBase.lib"
SuppressStartupBanner="TRUE"/>
<Tool
Name="VCMIDLTool"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1042"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath=".\BaseCacheMgr.cpp">
</File>
<File
RelativePath=".\BaseObj.cpp">
</File>
<File
RelativePath=".\ByteDataObj.cpp">
</File>
<File
RelativePath=".\Caldron.cpp">
</File>
<File
RelativePath=".\Timer.cpp">
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
<File
RelativePath=".\BaseCacheMgr.h">
</File>
<File
RelativePath=".\BaseObj.h">
</File>
<File
RelativePath=".\ByteDataObj.h">
</File>
<File
RelativePath=".\Caldron.h">
</File>
<File
RelativePath=".\ThreadQueue.h">
</File>
<File
RelativePath=".\Timer.h">
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

361
GameTools/CaldronBase/Console.cpp Normal file
View File

@@ -0,0 +1,361 @@
#include "./console.h"
#include "./DInput8Mgr.h"
#include "./D3D9GraphicLayer.h"
#include "../Scene/D3DXFont.h"
#include "../Scene/SceneStateMgr.h"
#include "../Scene/MainSceneMgr.h"
#include "../Scene/MaterialShaderMgr.h"
#include "../Scene/D3DXFont.h"
#include "./Timer.h"
#include "../Interface/CaldronMainInterface.h"
namespace Caldron {
namespace Scene {
void CConsoleMaterialShder::Apply()
{
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ALPHABLENDENABLE ,FALSE);
CSceneStateMgr::_SetD3DRenderState(D3DRS_TEXTUREFACTOR,0x00000000);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_COLOROP ,D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_COLORARG1 ,D3DTA_TFACTOR);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_COLOROP ,D3DTOP_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ALPHAOP ,D3DTOP_DISABLE );
}
}
namespace Base {
CConsole::CConsole(void) : m_iEnable(-1),m_fAniTime(0.5f),m_iUseLines(0),m_iWindowLines(20),m_iCurrentPos(0),m_iCursorX(0),m_iCursorY(0),
m_dwScreenWidth(0),m_dwScreenHeight(0),m_iMaterialShaderIndex(-1),m_iCurrentPage(1),m_fUnitUv(0.1f),m_fTargetUv(30.0f),m_fCurrentUv(0.0f),
m_fCurrentHeight(0.0f),m_fUnitAniHeight(0.0f),m_fTargetHeight(0.0f)
{
memset(m_strInputLine,0,sizeof(char) * 1024);
memset(m_pBuffer,0,sizeof(char *) * CONSOLE_MAXLINE);
m_iMaterialShaderIndex = -1;
m_dwConsoleDecl = D3DFVF_XYZRHW;// | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE1(2);
}
CConsole::~CConsole(void)
{
for(int i = 0; i < m_iUseLines; i++ )
{
SafeDeleteA(m_pBuffer[i]);
m_pBuffer[i] = NULL;
}
}
void CConsole::Init()
{
Scene::CConsoleMaterialShder *pShader = new Scene::CConsoleMaterialShder;
m_iMaterialShaderIndex = (Scene::CMainSceneMgr::_GetMaterialShaderMgr())->PushMaterialShader(pShader);
for(int i =0 ;i < 4;i++ )
{
m_pVertex[i].m_vecPos.w = 0.1f;
m_pVertex[i].m_vecPos.z = 0.1f;
}
}
void CConsole::Display()
{
if(m_iEnable != CONSOLEVIEW_HIDEANI)
{
CDInput8Mgr::Lock(CONSOLE_INPUTLOCK_KEY);
memset(m_strInputLine,0,sizeof(char) * 1024);
m_iEnable = CONSOLEVIEW_DISPLAYANI;
m_iWindowLines = 20;
m_iCurrentPos = 0;
m_iCursorX = 10;
m_iCursorY = (int)(m_fTargetHeight - 15);
}
}
void CConsole::Hide()
{
if(m_iEnable != CONSOLEVIEW_DISPLAYANI)
{
m_iEnable = CONSOLEVIEW_HIDEANI;
m_iWindowLines = 20;
m_iCurrentPos = 0;
}
}
void CConsole::ProcessKey()
{
if(m_iEnable == CONSOLEVIEW_DISPLAY)
{
if(CDInput8Mgr::PushOnceKey(DIK_GRAVE,CONSOLE_INPUTLOCK_KEY))
{
Scene::CMainSceneMgr::ChangeConsole();
}
if(CDInput8Mgr::PushOnceKey(DIK_RETURN ,CONSOLE_INPUTLOCK_KEY))
{
CommandExec();
m_iCurrentPos = 0;
memset(m_strInputLine,0,sizeof(char) * 1024);
}
// key <20>Է<EFBFBD>ó<EFBFBD><C3B3>
CDInput8Mgr::KeyStrok(m_strInputLine,m_iCurrentPos);
if(m_iCurrentPos >= 1024)
m_iCurrentPos = 1023;
if(m_iCurrentPos < 0)
m_iCurrentPos = 0;
}
}
void CConsole::Update(float fSkipFrame)
{
CD3D9GraphicLayer::_GetWindowSize(m_dwScreenWidth,m_dwScreenHeight);
m_fTargetHeight = (float)m_dwScreenHeight * 0.6f;
m_fUnitAniHeight = (float)m_fTargetHeight / m_fAniTime;
if(m_iEnable == CONSOLEVIEW_HIDE)
return ;
switch(m_iEnable)
{
case CONSOLEVIEW_HIDEANI:
if(m_fCurrentHeight > 0)
{
m_fCurrentHeight -= (float)m_fUnitAniHeight * fSkipFrame;
}
break;
case CONSOLEVIEW_DISPLAYANI:
if(m_fCurrentHeight < m_fTargetHeight)
{
m_fCurrentHeight += (float)m_fUnitAniHeight * fSkipFrame;
}
break;
case CONSOLEVIEW_DISPLAY:
break;
default:
break;
}
if(m_fCurrentHeight <= 0)
{
m_fCurrentHeight = 0;
m_iEnable = CONSOLEVIEW_HIDE;
CDInput8Mgr::Unlock();
}
else if(m_fCurrentHeight >= m_fTargetHeight)
{
m_fCurrentHeight = m_fTargetHeight;
m_iEnable = CONSOLEVIEW_DISPLAY;
}
m_fCurrentUv += m_fUnitUv * fSkipFrame;
if(m_fCurrentUv >= m_fTargetUv)
{
m_fUnitUv *= -1.0f;
}
else if(m_fCurrentUv <= 0.0f)
{
m_fUnitUv *= -1.0f;
}
ProcessKey();
}
void CConsole::Render(LPDIRECT3DDEVICE9 lpDevice)
{
if(m_iEnable == CONSOLEVIEW_HIDE)
return ;
Scene::CMainSceneMgr::_GetMaterialShaderMgr()->GetNodes(m_iMaterialShaderIndex)->Apply();
m_pVertex[3].m_vecPos.x = (float)m_dwScreenWidth;
m_pVertex[3].m_vecPos.y = m_fCurrentHeight;
m_pVertex[0].m_vecPos.x = 0.0f;
m_pVertex[0].m_vecPos.y = m_fCurrentHeight;
m_pVertex[1].m_vecPos.x = 0.0f;
m_pVertex[1].m_vecPos.y = 0.0f;
m_pVertex[2].m_vecPos.x = (float)m_dwScreenWidth;
m_pVertex[2].m_vecPos.y = 0.0f;
lpDevice->SetFVF(m_dwConsoleDecl);
lpDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN ,2,&m_pVertex,sizeof(CConsoleVertex));
if(m_iEnable == CONSOLEVIEW_DISPLAY)
{
RenderText(5,m_iCursorY,">");
if(m_iCurrentPos < 1023)
m_strInputLine[m_iCurrentPos] = '_';
RenderText((long)m_iCursorX,(long)m_iCursorY,m_strInputLine);
int iCount = (m_iUseLines > m_iWindowLines) ? m_iWindowLines : m_iUseLines;
for(int iLine = 0; iLine < iCount; iLine++)
{
RenderText((long)m_iCursorX,(long)iLine * 13 + 2,m_pBuffer[iLine]);
}
}
}
void CConsole::RenderText(long iX,long iY,const char *strText)
{
Scene::CMainSceneMgr::_GetFont()->PrintFont(iX,iY,strText);
}
void CConsole::AddText(const char *fmt,...)
{
static char str[1024];
int iLength;
va_list va;
va_start( va, fmt );
vsprintf( str, fmt, va );
va_end( va );
if(m_iUseLines == CONSOLE_MAXLINE)
SafeDeleteA(m_pBuffer[--m_iUseLines]);
memmove(&m_pBuffer[1],&m_pBuffer[0],sizeof(char *)*m_iUseLines);
iLength = (int)strlen(str) + 1;
m_pBuffer[0] = new char[iLength];
memcpy(m_pBuffer[0],str,iLength);
m_iUseLines++;
}
void CConsole::CommandExec()
{
m_strInputLine[m_iCurrentPos] = 0;
AddText(m_strInputLine);
if(strstr(m_strInputLine,"BYE")) // Console Close
Scene::CMainSceneMgr::ChangeConsole();
else if(strstr(m_strInputLine,"FOV")) // Fov
{
float fFov = 45.0f;
float fMinDistance = 0.1f;
float fMaxDistance = 10000.0f;
bool bRight = true;
char *tok = strtok(m_strInputLine," ");
if((tok = strtok(NULL," ")) != NULL)
{
fFov = (float)atof(tok);
if((tok = strtok(NULL," ")) != NULL)
{
fMinDistance = (float)atof(tok);
if((tok = strtok(NULL," ")) != NULL)
{
fMaxDistance = (float)atof(tok);
}
else
{
bRight = false;
}
}
else
{
bRight = false;
}
}
else
{
bRight = false;
}
if(bRight == true)
Scene::CSceneStateMgr::_SetD3DPerspectiveLHMatrix(Scene::D3DMATRIX_PROJECT,fFov,(float)m_dwScreenWidth / (float)m_dwScreenHeight,fMinDistance,fMaxDistance);
else
AddText("FOV arg wrong. ex> FOV 45.0 0.1 1000.0");
}
else if(strstr(m_strInputLine,"WIREFRAME VIEW")) // Fill Mode setting
Scene::CMainSceneMgr::_ChangeGlobalMode(Scene::GLOBAL_FILLMODE,D3DFILL_WIREFRAME);
else if(strstr(m_strInputLine,"SOLID VIEW"))
Scene::CMainSceneMgr::_ChangeGlobalMode(Scene::GLOBAL_FILLMODE,D3DFILL_SOLID);
else if(strstr(m_strInputLine,"FPS ON")) // Fps View
Scene::CMainSceneMgr::_ChangeGlobalMode(Scene::GLOBAL_FPSSTATE,1);
else if(strstr(m_strInputLine,"FPS OFF"))
Scene::CMainSceneMgr::_ChangeGlobalMode(Scene::GLOBAL_FPSSTATE,0);
else if(strstr(m_strInputLine,"CAMERA INFO ON")) // Camera Info
Scene::CMainSceneMgr::_ChangeGlobalMode(Scene::GLOBAL_CAMERAINFO,1);
else if(strstr(m_strInputLine,"CAMERA INFO OFF"))
Scene::CMainSceneMgr::_ChangeGlobalMode(Scene::GLOBAL_CAMERAINFO,0);
else if(strstr(m_strInputLine,"LOG CONSOLE")) // Log Device Setting
CLogMgr::_SetOutDevice(Caldron::LOG_CONSOLEOUT);
else if(strstr(m_strInputLine,"LOG FILE"))
CLogMgr::_SetOutDevice(Caldron::LOG_FILEOUT);
else if(strstr(m_strInputLine,"LOG MESSAGEBOX"))
CLogMgr::_SetOutDevice(Caldron::LOG_MESSAGEBOXOUT);
else if(strstr(m_strInputLine,"HELP")) // Help
HelpMessage();
else if(strstr(m_strInputLine,"FPS HOLD")) // Fps Hold
{
char *tok = strtok(m_strInputLine," ");
int iHold = 0;
if((tok = strtok(NULL," ")) != NULL)
{
if((tok = strtok(NULL," ")) != NULL)
{
iHold = atoi(tok);
Caldron::Base::CTimer::_GetInstance().SetFPS(iHold);
}
}
}
else if(strstr(m_strInputLine,"QUIT"))
{
Interface::CCaldronMsgObj *pNode = new Interface::CCaldronMsgObj(Interface::MESSAGE_APP_QUIT,0);
Interface::CCaldronMainInterface::PushCaldronMsg(pNode);
}
}
void CConsole::HelpMessage()
{
AddText(" BYE : Console Close");
AddText(" FOV FovValue MinValue MaxValue : Fov Setting ( ex > FOV 45.0 0.1 1000.0)");
AddText(" WIREFRAME VIEW : WireFrame View");
AddText(" SOLID VIEW : Solid View");
AddText(" FPS ON : FPS Draw");
AddText(" FPS OFF : FPS Not Draw");
AddText(" CAMERA INFO ON : Camera Info On");
AddText(" CAMERA INFO OFF : Camera Info Off");
AddText(" LOG CONSOLE : Log to Console");
AddText(" LOG FILE : Log to File");
AddText(" LOG MESSAGEBOX : Log to MessageBox");
AddText(" FPS HOLD holdFps : FPS HOLD ( ex > FPS HOLD 100 )");
AddText(" QUIT : APP Quit");
}
}}

101
GameTools/CaldronBase/Console.h Normal file
View File

@@ -0,0 +1,101 @@
#pragma once
#include "Caldron.h"
#include "../Scene/MaterialShader.h"
namespace Caldron {
namespace Scene {
class CConsoleMaterialShder : public CMaterialShader
{
public:
CConsoleMaterialShder(){}
~CConsoleMaterialShder(){}
virtual void Apply();
};
}
namespace Base {
const int CONSOLE_MAXLINE = 512;
const int CONSOLE_LINE = 30;
const int CONSOLE_COL = 40;
const int CONSOLE_INPUTLOCK_KEY = 10;
enum CONSOLE_VIEWSTATE
{
CONSOLEVIEW_HIDE = 0,
CONSOLEVIEW_HIDEANI,
CONSOLEVIEW_DISPLAY,
CONSOLEVIEW_DISPLAYANI,
};
class CConsole
{
public:
class CConsoleVertex {
public:
D3DXVECTOR4 m_vecPos;
};
int m_iEnable;
float m_fAniTime;
char *m_pBuffer[CONSOLE_MAXLINE];
int m_iUseLines;
int m_iWindowLines;
char m_strInputLine[1024]; // <20>Է<EFBFBD> <20><><EFBFBD><EFBFBD>
int m_iCurrentPos;
int m_iCursorX,m_iCursorY;
DWORD m_dwScreenWidth,m_dwScreenHeight;
float m_fCurrentHeight;
float m_fUnitAniHeight;
float m_fTargetHeight;
float m_fUnitUv;
float m_fTargetUv;
float m_fCurrentUv;
int m_iCurrentPage;
int m_iMaterialShaderIndex;
CConsoleVertex m_pVertex[4];
DWORD m_dwConsoleDecl;
CConsole(void);
~CConsole(void);
void Init();
void Display(); // Console DisPlay
void Hide(); // Console Display Hide
void Render(LPDIRECT3DDEVICE9 lpDevice); // Console Render
void Update(float fSkipFrame);
void ProcessKey();
void RenderText(long iX,long iY,const char *strText);
void AddText(const char *str,...);
void CommandExec();
void HelpMessage();
};
}}

400
GameTools/CaldronBase/D3D9GraphicLayer.cpp Normal file
View File

@@ -0,0 +1,400 @@
// D3D9GraphicLayer.cpp: implementation of the CD3D9GraphicLayer class.
//
//////////////////////////////////////////////////////////////////////
#include "D3D9GraphicLayer.h"
/* *********************************************************************
* CD3D9GraphicLayer
* <20><><EFBFBD><EFBFBD> : D3D9GraphicLayer.h
* <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> D3D9 <20><><EFBFBD><EFBFBD><EFBFBD>̽<EFBFBD><CCBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> BaseGraphic Layer
<20><> app<70><70><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ÿ<EFBFBD> <20><> <20><><EFBFBD>̾ <20><><EFBFBD>ӹ޾<D3B9> D3d Layer<65><72> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.10.30
* history :
wizardbug ( 2003.10.30)
********************************************************************** */
LPDIRECT3DDEVICE9 Caldron::Base::CD3D9GraphicLayer::ms_pD3DDevice = NULL;
Caldron::Base::CD3D9GraphicLayer::CD3D9WindowInfo Caldron::Base::CD3D9GraphicLayer::m_WindowInfo;
Caldron::Base::CD3D9GraphicLayer::CD3D9ModeInfo Caldron::Base::CD3D9GraphicLayer::m_ModeInfo;
Caldron::Base::CD3D9GraphicLayer::CD3D9GraphicLayer()
{
m_pD3D9Obj = NULL;
m_hWnd = 0;
m_pExceptionMgr = new CExceptionMgr;
}
Caldron::Base::CD3D9GraphicLayer::~CD3D9GraphicLayer()
{
ReleaseAll();
}
void Caldron::Base::CD3D9GraphicLayer::ReleaseAll()
{
SafeRelease(m_pD3D9Obj);
SafeRelease(ms_pD3DDevice);
CLogMgr::_Close();
SafeDelete(m_pExceptionMgr);
}
HRESULT Caldron::Base::CD3D9GraphicLayer::InitD3DLayer(HINSTANCE hInstance,HWND hWnd,DWORD dwWidth, DWORD dwHeight,
bool bWindowed,D3DFORMAT ColorFormat,D3DFORMAT ZFormat,
DWORD dwVertexProcess,D3DMULTISAMPLE_TYPE Antial)
{
if((m_pD3D9Obj = Direct3DCreate9(D3D_SDK_VERSION)) == NULL)
{
CLogMgr::_LogError("CD3D9GraphicLayer::InitD3DLayer() : D3D9 Object Create Failed");
m_WindowInfo.m_bD3DRunning = false;
return E_FAIL;
}
m_ModeInfo.m_ColorFormat = ColorFormat;
m_ModeInfo.m_DepthStencilFormat = ZFormat;
m_ModeInfo.m_dwVertexProcessing = dwVertexProcess| D3DCREATE_MULTITHREADED;
m_ModeInfo.m_MultiSampling = Antial;
m_WindowInfo.m_hInstance = hInstance;
m_WindowInfo.m_dwWidth = dwWidth;
m_WindowInfo.m_dwHeight = dwHeight;
m_WindowInfo.m_bWindowed = bWindowed;
ZeroMemory(&m_PresentParameters,sizeof(m_PresentParameters));
m_PresentParameters.Windowed = m_WindowInfo.m_bWindowed;
m_PresentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
m_PresentParameters.EnableAutoDepthStencil = true;
m_PresentParameters.AutoDepthStencilFormat = m_ModeInfo.m_DepthStencilFormat;
m_hWnd = m_PresentParameters.hDeviceWindow = hWnd;
m_PresentParameters.BackBufferWidth = m_WindowInfo.m_dwWidth;
m_PresentParameters.BackBufferHeight = m_WindowInfo.m_dwHeight;
m_PresentParameters.BackBufferFormat = m_ModeInfo.m_ColorFormat;
m_PresentParameters.BackBufferCount = 1;
CheckD3DFormat(!(m_WindowInfo.m_bWindowed),m_ModeInfo.m_ColorFormat,&(m_PresentParameters.BackBufferFormat));
m_ModeInfo.m_ColorFormat = m_PresentParameters.BackBufferFormat;
m_PresentParameters.MultiSampleType = m_ModeInfo.m_MultiSampling;
m_PresentParameters.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
m_PresentParameters.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
if(ms_pD3DDevice != NULL)
{
SafeRelease(ms_pD3DDevice);
}
HRESULT hr;
if(Failed(hr = m_pD3D9Obj->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,m_hWnd,m_ModeInfo.m_dwVertexProcessing,
&m_PresentParameters,&ms_pD3DDevice)))
{
if(m_ModeInfo.m_dwVertexProcessing & D3DCREATE_HARDWARE_VERTEXPROCESSING)
{
m_ModeInfo.m_dwVertexProcessing &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING;
m_ModeInfo.m_dwVertexProcessing |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
if(Failed(m_pD3D9Obj->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,m_hWnd,m_ModeInfo.m_dwVertexProcessing,
&m_PresentParameters,&ms_pD3DDevice)))
{
CLogMgr::_LogError("CD3D9GraphicLayer::InitD3DLayer() : D3D9 Device Create Failed");
m_WindowInfo.m_bD3DRunning = false;
return E_FAIL;
}
}
if(m_ModeInfo.m_dwVertexProcessing & D3DCREATE_MULTITHREADED)
{
m_ModeInfo.m_dwVertexProcessing &= ~D3DCREATE_MULTITHREADED;
if(Failed(m_pD3D9Obj->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,m_hWnd,m_ModeInfo.m_dwVertexProcessing,
&m_PresentParameters,&ms_pD3DDevice)))
{
CLogMgr::_LogError("CD3D9GraphicLayer::InitD3DLayer() : D3D9 Device Create Failed");
m_WindowInfo.m_bD3DRunning = false;
return E_FAIL;
}
}
}
//D3DDISPLAYMODE pMode;
//ms_pD3DDevice->GetDisplayMode( 0,&pMode);
InitScene();
CheckDeviceCaps();
m_WindowInfo.m_bD3DRunning = true;
return S_OK;
}
// Lost <20>ÿ<EFBFBD> E_FAIL return
HRESULT Caldron::Base::CD3D9GraphicLayer::CheckDeviceLost()
{
if(!ms_pD3DDevice)
{
CLogMgr::_LogError("CD3D9GraphicLayer::ChecDeviceLost() : Device == NULL");
return E_FAIL;
}
switch(ms_pD3DDevice->TestCooperativeLevel())
{
case D3DERR_DEVICELOST:
CLogMgr::_LogError("CD3D9GraphicLayer::ChecDeviceLost() : Device Lost");
Sleep(100); // Device <20><> D3DERR_DEVICENOTRESET <20><><EFBFBD>°<EFBFBD> <20>ɶ<EFBFBD><C9B6><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ٸ<EFBFBD><D9B8><EFBFBD>.
m_WindowInfo.m_bD3DRunning = false;
return E_FAIL;
case D3DERR_DEVICENOTRESET:
{
if(Failed(ms_pD3DDevice->Reset(&m_PresentParameters)))
{
CLogMgr::_LogError("CD3D9GraphicLayer::ChecDeviceLost() : Reset Failed");
m_WindowInfo.m_bD3DRunning = false;
return E_FAIL;
}
InitScene();
m_WindowInfo.m_bD3DRunning = true;
return S_OK;
}
default:
m_WindowInfo.m_bD3DRunning = true;
return S_OK;
}
}
void Caldron::Base::CD3D9GraphicLayer::SaveSetting()
{
}
void Caldron::Base::CD3D9GraphicLayer::LoadSetting()
{
}
void Caldron::Base::CD3D9GraphicLayer::InitScene() // Scene Init
{
}
HRESULT Caldron::Base::CD3D9GraphicLayer::ChangePresentMode(UINT UIPresent)
{
m_PresentParameters.PresentationInterval = UIPresent;
//change device mode
if(ms_pD3DDevice == NULL)
{
CLogMgr::_LogError("CD3D9GraphicLayer::ChangeMode() : Device == NULL");
return E_FAIL;
}
if(FAILED(ms_pD3DDevice->Reset(&m_PresentParameters)))
{
// Mode Back.
m_PresentParameters.AutoDepthStencilFormat = m_ModeInfo.m_DepthStencilFormat;
m_PresentParameters.BackBufferWidth = m_WindowInfo.m_dwWidth;
m_PresentParameters.BackBufferHeight = m_WindowInfo.m_dwHeight;
m_PresentParameters.BackBufferFormat = m_ModeInfo.m_ColorFormat;
ms_pD3DDevice->Reset(&m_PresentParameters);
InitScene();
CLogMgr::_LogError("CD3D9GraphicLayer::ChangeMode() : Reset Failed");
return E_FAIL;
}
// Success Info Setting
InitScene();
return S_OK;
}
HRESULT Caldron::Base::CD3D9GraphicLayer::ChangeMode(DWORD dwWidth, DWORD dwHeight, D3DFORMAT Pixel, D3DFORMAT Zbuffer,UINT uiPresent)
{
//set new parameters
m_PresentParameters.AutoDepthStencilFormat = Zbuffer;
m_PresentParameters.BackBufferWidth = dwWidth;
m_PresentParameters.BackBufferHeight = dwHeight;
m_PresentParameters.BackBufferFormat = Pixel;
m_PresentParameters.PresentationInterval = uiPresent;
CheckD3DFormat(!m_WindowInfo.m_bWindowed,Pixel,&(m_PresentParameters.BackBufferFormat));
//change device mode
if(ms_pD3DDevice == NULL)
{
CLogMgr::_LogError("CD3D9GraphicLayer::ChangeMode() : Device == NULL");
return E_FAIL;
}
if(FAILED(ms_pD3DDevice->Reset(&m_PresentParameters)))
{
// Mode Back.
m_PresentParameters.AutoDepthStencilFormat = m_ModeInfo.m_DepthStencilFormat;
m_PresentParameters.BackBufferWidth = m_WindowInfo.m_dwWidth;
m_PresentParameters.BackBufferHeight = m_WindowInfo.m_dwHeight;
m_PresentParameters.BackBufferFormat = m_ModeInfo.m_ColorFormat;
CheckD3DFormat(!m_WindowInfo.m_bWindowed,Pixel,&(m_PresentParameters.BackBufferFormat));
ms_pD3DDevice->Reset(&m_PresentParameters);
InitScene();
CLogMgr::_LogError("CD3D9GraphicLayer::ChangeMode() : Reset Failed");
return E_FAIL;
}
// Success Info Setting
m_WindowInfo.m_dwWidth = dwWidth;
m_WindowInfo.m_dwHeight = dwHeight;
m_ModeInfo.m_ColorFormat = Pixel;
m_ModeInfo.m_DepthStencilFormat = Zbuffer;
InitScene();
return S_OK;
}
HRESULT Caldron::Base::CD3D9GraphicLayer::CheckDeviceCaps()
{
if(ms_pD3DDevice == NULL)
{
CLogMgr::_LogError("CD3D9GraphicLayer::CheckDeviceCaps() : Device == NULL");
return E_FAIL;
}
/////////////// Cap <20>˻<EFBFBD> <20><>ƾ <20><><EFBFBD><EFBFBD><EEB0A1> <20><>
/*
if(ms_pD3DDevice->m_D3dCaps->TextureCaps & D3DPTEXTURECAPS_ALPHAPALETTE )
return S_OK;
*/
return E_FAIL;
}
HRESULT Caldron::Base::CD3D9GraphicLayer::SetFullScreen(bool bWin)
{
m_PresentParameters.Windowed = !bWin;
//change device mode
if(ms_pD3DDevice == NULL)
{
CLogMgr::_LogError("CD3D9GraphicLayer::ChangeMode() : Device == NULL");
return E_FAIL;
}
CheckD3DFormat(!bWin,m_ModeInfo.m_ColorFormat,&(m_PresentParameters.BackBufferFormat));
if(FAILED(ms_pD3DDevice->Reset(&m_PresentParameters)))
{
// Mode Back.
m_PresentParameters.Windowed = m_WindowInfo.m_bWindowed;
CheckD3DFormat(!m_WindowInfo.m_bWindowed,m_ModeInfo.m_ColorFormat,&(m_PresentParameters.BackBufferFormat));
ms_pD3DDevice->Reset(&m_PresentParameters);
InitScene();
CLogMgr::_LogError("CD3D9GraphicLayer::ChangeMode() : Reset Failed");
return E_FAIL;
}
m_WindowInfo.m_bWindowed = !bWin;
InitScene();
return S_OK;
}
// <20><>üȭ<C3BC><C8AD> <20><><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD> Color Bit <20><><EFBFBD><EFBFBD> <20>ϴ<EFBFBD><CFB4><EFBFBD> Test
HRESULT Caldron::Base::CD3D9GraphicLayer::CheckD3DFormat(bool bFullScreen,D3DFORMAT iDepth,D3DFORMAT *pFormat)
{
if(bFullScreen){
switch(iDepth) {
case D3DFMT_R5G6B5:
case D3DFMT_X1R5G5B5:
(*pFormat)= Find16BitMode();
break;
case D3DFMT_A8R8G8B8:
case D3DFMT_X8R8G8B8:
(*pFormat)= Find32BitMode();
break;
default:
(*pFormat)=D3DFMT_UNKNOWN;
break;
}
}
else
{
//D3D will automatically use the Desktop's format
(*pFormat)=D3DFMT_UNKNOWN;
}
return S_OK;
}
D3DFORMAT Caldron::Base::CD3D9GraphicLayer::Find16BitMode()
{
const D3DFORMAT BufferFormats[]={D3DFMT_R5G6B5,D3DFMT_X1R5G5B5};
const int iFormatCount=sizeof(BufferFormats)/sizeof(D3DFORMAT);
HRESULT hr;
for(int count=0;count<iFormatCount;count++){
//CheckDeviceType() is used to verify that a Device can support a particular display mode.
hr=m_pD3D9Obj->CheckDeviceType(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
BufferFormats[count], //The is the primary (viewable) buffer format
BufferFormats[count], //This is the back (drawable) buffer format
FALSE);
if(Succeeded(hr)){
return BufferFormats[count];
}
}
CLogMgr::_LogError("CD3D9GraphicLayer::Find16BitMode() : 16Bit Mode Not Support");
return D3DFMT_UNKNOWN;
}
D3DFORMAT Caldron::Base::CD3D9GraphicLayer::Find32BitMode()
{
const D3DFORMAT BufferFormats[]={D3DFMT_A8R8G8B8,D3DFMT_X8R8G8B8};
const int iFormatCount=sizeof(BufferFormats)/sizeof(D3DFORMAT);
HRESULT hr;
for(int count=0;count<iFormatCount;count++){
//CheckDeviceType() is used to verify that a Device can support a particular display mode.
hr=m_pD3D9Obj->CheckDeviceType(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
BufferFormats[count], //The is the primary (viewable) buffer format
BufferFormats[count], //This is the back (drawable) buffer format
FALSE);
if(Succeeded(hr)){
return BufferFormats[count];
}
}
CLogMgr::_LogError("CD3D9GraphicLayer::Find16BitMode() : 16Bit Mode Not Support");
return D3DFMT_UNKNOWN;
}
void Caldron::Base::CD3D9GraphicLayer::Render()
{
if(Succeeded(CheckDeviceLost()))
{
RenderScene();
Update();
// Show the frame on the primary surface.
ms_pD3DDevice->Present( NULL, NULL, NULL, NULL );
}
}

150
GameTools/CaldronBase/D3D9GraphicLayer.h Normal file
View File

@@ -0,0 +1,150 @@
// D3D9GraphicLayer.h: interface for the CD3D9GraphicLayer class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_D3D9GRAPHICLAYER_H__1026F404_E2F8_4612_A94C_A84F641A0C9A__INCLUDED_)
#define AFX_D3D9GRAPHICLAYER_H__1026F404_E2F8_4612_A94C_A84F641A0C9A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "Caldron.h"
#include "./ExceptionMgr.h"
#include "./LogMgr.h"
/* *********************************************************************
* CD3D9GraphicLayer
* <20><><EFBFBD><EFBFBD> : D3D9GraphicLayer.h
* <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> D3D9 <20><><EFBFBD><EFBFBD><EFBFBD>̽<EFBFBD><CCBD><EFBFBD><EFBFBD><EFBFBD> ũ<><C5A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> BaseGraphic Layer
<20><> app<70><70><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ÿ<EFBFBD> <20><> <20><><EFBFBD>̾ <20><><EFBFBD>ӹ޾<D3B9> D3d Layer<65><72> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.10.30
* history :
wizardbug ( 2003.10.30)
********************************************************************** */
namespace Caldron {
namespace Base {
class CD3D9GraphicLayer
{
public:
class CD3D9WindowInfo
{
public:
bool m_bWindowed;
DWORD m_dwWidth;
DWORD m_dwHeight;
bool m_bD3DRunning;
HINSTANCE m_hInstance;
CD3D9WindowInfo()
{
m_bWindowed = true;
m_dwWidth = 800;
m_dwHeight = 600;
m_bD3DRunning = true;
m_hInstance = 0;
}
~CD3D9WindowInfo() {}
};
class CD3D9ModeInfo
{
public:
DWORD m_dwVertexProcessing;
D3DFORMAT m_ColorFormat;
D3DFORMAT m_DepthStencilFormat;
D3DMULTISAMPLE_TYPE m_MultiSampling;
CD3D9ModeInfo()
{
m_dwVertexProcessing = D3DCREATE_HARDWARE_VERTEXPROCESSING;
m_ColorFormat = D3DFMT_R5G6B5;
m_DepthStencilFormat = D3DFMT_D16;
m_MultiSampling = D3DMULTISAMPLE_NONE;
}
~CD3D9ModeInfo() {}
};
protected:
LPDIRECT3D9 m_pD3D9Obj;
static LPDIRECT3DDEVICE9 ms_pD3DDevice;
HWND m_hWnd;
D3DPRESENT_PARAMETERS m_PresentParameters;
D3DCAPS9 m_DeviceCaps;
CExceptionMgr *m_pExceptionMgr;
public:
static CD3D9WindowInfo m_WindowInfo;
static CD3D9ModeInfo m_ModeInfo;
static inline void _GetWindowSize(DWORD &dwWidth,DWORD &dwHeight)
{
dwWidth = m_WindowInfo.m_dwWidth;
dwHeight = m_WindowInfo.m_dwHeight;
}
//static inline CD3D9ModeInfo _GetModeInfo() { return m_ModeInfo;}
static inline LPDIRECT3DDEVICE9 _GetDevice() { return (ms_pD3DDevice != NULL) ? ms_pD3DDevice : NULL; }
inline HWND GetHwnd() { return m_hWnd;}
inline bool IsFullScreen() { return m_WindowInfo.m_bWindowed; }
inline bool IsD3DRunning() { return m_WindowInfo.m_bD3DRunning; }
// Change Fullscreen Mode
HRESULT SetFullScreen(bool bWin);
CD3D9GraphicLayer();
virtual ~CD3D9GraphicLayer();
// Device Create
HRESULT InitD3DLayer(HINSTANCE hInstance,
HWND hWnd,
DWORD dwWidth,
DWORD dwHeight,
bool bWindowed = true,
D3DFORMAT ColorFormat = D3DFMT_R5G6B5,
D3DFORMAT ZFormat = D3DFMT_D16,
DWORD dwVertexProcessing = D3DCREATE_HARDWARE_VERTEXPROCESSING,
D3DMULTISAMPLE_TYPE Antial = D3DMULTISAMPLE_NONE
);
void SaveSetting(); // Save D3D Create Info
void LoadSetting(); // Load D3D Create Info
// Device <20>ν<EFBFBD>Ʈ <20>Ǿ<EFBFBD><C7BE><EFBFBD> <20>׽<EFBFBD><D7BD><EFBFBD>
HRESULT CheckDeviceLost();
// Change Bit , width, height ..etc..
HRESULT ChangeMode(DWORD dwWidth, DWORD dwHeight, D3DFORMAT Pixel, D3DFORMAT Zbuffer,UINT UIPresent = D3DPRESENT_INTERVAL_IMMEDIATE);
HRESULT ChangePresentMode(UINT UIPresent = D3DPRESENT_INTERVAL_IMMEDIATE);
// <20><>ü <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Color Bit <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ°<C7B4> check
HRESULT CheckD3DFormat(bool bFullScreen,D3DFORMAT iDepth,D3DFORMAT *pFormat);
D3DFORMAT Find16BitMode();
D3DFORMAT Find32BitMode();
void ReleaseAll();
virtual HRESULT CheckDeviceCaps();
virtual void InitScene();
void Render();
// <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ尡 <20><><EFBFBD><20>κ<EFBFBD> Render Scene <20>κ<EFBFBD>
virtual void RenderScene(){};
virtual void Update(){};
virtual void Destroy(){};
};
};
};
#endif // !defined(AFX_D3D9GRAPHICLAYER_H__1026F404_E2F8_4612_A94C_A84F641A0C9A__INCLUDED_)

444
GameTools/CaldronBase/DInput8Mgr.cpp Normal file
View File

@@ -0,0 +1,444 @@
// DInput9Mgr.cpp: implementation of the CDInput9Mgr class.
//
//////////////////////////////////////////////////////////////////////
#include "DInput8Mgr.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
int Caldron::Base::CDInput8Mgr::ms_iLockKey = -1;
DIMOUSESTATE Caldron::Base::CDInput8Mgr::m_MouseState;
int Caldron::Base::CDInput8Mgr::m_iMouseMove[MOUSE_AXISNUMS];
char Caldron::Base::CDInput8Mgr::m_strKeys[256];
char Caldron::Base::CDInput8Mgr::m_strBackKeys[256];
LPDIRECTINPUTDEVICE8 Caldron::Base::CDInput8Mgr::m_lpMouseDevice = NULL;
Caldron::Base::CDInput8Mgr::CDInput8Mgr()
{
m_lpKeyboardDevice = NULL;
m_lpMouseDevice = NULL;
m_lpDirectInput = NULL;
}
Caldron::Base::CDInput8Mgr::~CDInput8Mgr()
{
if(m_lpKeyboardDevice)
{
m_lpKeyboardDevice->Unacquire();
SafeRelease(m_lpKeyboardDevice);
}
if(m_lpMouseDevice)
{
m_lpMouseDevice->Unacquire();
SafeRelease(m_lpMouseDevice);
m_lpMouseDevice = NULL;
}
if(m_lpDirectInput)
{
SafeRelease(m_lpDirectInput);
}
}
HRESULT Caldron::Base::CDInput8Mgr::InitInputMgr(HINSTANCE hInstance,HWND hWnd,DWORD dwKeyboardLevel,DWORD dwMouseLevel)
{
HRESULT hr;
// direct input create
if(Failed(hr = DirectInput8Create(hInstance,DIRECTINPUT_VERSION,IID_IDirectInput8,(void **)&m_lpDirectInput,NULL)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : DInput8 Create Failed");
return hr;
}
//device create
if(Failed(hr = m_lpDirectInput->CreateDevice(GUID_SysMouse,&m_lpMouseDevice,NULL)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse Device Create Failed");
return hr;
}
if(Failed(hr = m_lpDirectInput->CreateDevice(GUID_SysKeyboard,&m_lpKeyboardDevice,NULL)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Keyboard Device Create Failed");
return hr;
}
//device information interface setting
if(Failed(hr = m_lpKeyboardDevice->SetDataFormat(&c_dfDIKeyboard)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Keyboard DataFormat Set Failed");
return hr;
}
if(Failed(hr = m_lpMouseDevice->SetDataFormat(&c_dfDIMouse)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse DataFormat Set Failed");
return hr;
}
//device cooperative setting (Ű <20><EFBFBD><EEB6BB> <20><><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF>.)
if(Failed(hr = m_lpKeyboardDevice->SetCooperativeLevel(hWnd,dwKeyboardLevel)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Keyboard CooperativeLevel Set Failed");
return hr;
}
if(Failed(hr = m_lpMouseDevice->SetCooperativeLevel(hWnd,dwMouseLevel)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse CooperativeLevel Set Failed");
return hr;
}
//device acquire
if(Failed(hr = m_lpKeyboardDevice->Acquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : KeyBoard Acquire Failed");
return hr;
}
if(Failed(hr = m_lpMouseDevice->Acquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse Acquire Failed");
return hr;
}
// information update
memset(m_strKeys,0,sizeof(char) * 256);
memset(m_strBackKeys,0,sizeof(char) * 256);
if(Failed(hr = m_lpKeyboardDevice->GetDeviceState(256,&m_strKeys)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Keyboard DeviceState Read Failed");
return hr;
}
if(Failed(hr = m_lpMouseDevice->GetDeviceState(sizeof(DIMOUSESTATE),&m_MouseState)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse DeviceState Read Failed");
return hr;
}
return S_OK;
}
HRESULT Caldron::Base::CDInput8Mgr::Acquire()
{
HRESULT hr;
if(Failed(hr = m_lpMouseDevice->Acquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse Acquire Failed");
return hr;
}
if(Failed(hr = m_lpKeyboardDevice->Acquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Keyboard Acquire Failed");
return hr;
}
return S_OK;
}
HRESULT Caldron::Base::CDInput8Mgr::Unacquire()
{
HRESULT hr;
if(Failed(hr = m_lpMouseDevice->Unacquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse Unacquire Failed");
return hr;
}
if(Failed(hr = m_lpKeyboardDevice->Unacquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Keyboard Unacquire Failed");
return hr;
}
return S_OK;
}
bool Caldron::Base::CDInput8Mgr ::PushButton(int index,int iKey)
{
if(ms_iLockKey != iKey)
return false;
HRESULT hr;
if(Failed(hr = m_lpMouseDevice->Acquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse Acquire Failed");
return false;
}
if(Failed(hr = m_lpMouseDevice->GetDeviceState(sizeof(DIMOUSESTATE),&m_MouseState)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse DeviceState Get Failed");
return false;
}
return (m_MouseState.rgbButtons[index] &0x80) ? true : false;
}
bool Caldron::Base::CDInput8Mgr::UpButton(int index,int iKey)
{
if(ms_iLockKey != iKey)
return false;
HRESULT hr;
if(Failed(hr = m_lpMouseDevice->Acquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse Acquire Failed");
return false;
}
if(Failed(hr = m_lpMouseDevice->GetDeviceState(sizeof(DIMOUSESTATE),&m_MouseState)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse DeviceState Get Failed");
return false;
}
return (m_MouseState.rgbButtons[index] &0x80) ? false : true;
}
bool Caldron::Base::CDInput8Mgr:: PushOnceKey(int index,int iKey)
{
if(ms_iLockKey != iKey)
return false;
bool bReturn = (m_strKeys[index] &0x80) ? true : false;
if(bReturn && (m_strBackKeys[index] != m_strKeys[index]))
return bReturn;
return false;
}
bool Caldron::Base::CDInput8Mgr::KeyStrok(char *strBuffer,int &iPos)
{
bool bPush = false;
for(int i = 0; i < 256; i++ )
{
bPush = (m_strKeys[i] &0x80) ? true : false;
if(bPush && (m_strBackKeys[i] != m_strKeys[i])) {
switch(i)
{
case 0x02:
strBuffer[iPos++] = '1';
break;
case 0x03:
strBuffer[iPos++] = '2';
break;
case 0x04:
strBuffer[iPos++] = '3';
break;
case 0x05:
strBuffer[iPos++] = '4';
break;
case 0x06:
strBuffer[iPos++] = '5';
break;
case 0x07:
strBuffer[iPos++] = '6';
break;
case 0x08:
strBuffer[iPos++] = '7';
break;
case 0x09:
strBuffer[iPos++] = '8';
break;
case 0x0A:
strBuffer[iPos++] = '9';
break;
case 0x0B:
strBuffer[iPos++] = '0';
break;
case 0x0C:
strBuffer[iPos++] = '-';
break;
case 0x0D:
strBuffer[iPos++] = '=';
break;
case 0x0E:
strBuffer[iPos--] = 0;
break;
case 0x0F:
strBuffer[iPos++] = '\t';
break;
case 0x10:
strBuffer[iPos++] = 'Q';
break;
case 0x11:
strBuffer[iPos++] = 'W';
break;
case 0x12:
strBuffer[iPos++] = 'E';
break;
case 0x13:
strBuffer[iPos++] = 'R';
break;
case 0x14:
strBuffer[iPos++] = 'T';
break;
case 0x15:
strBuffer[iPos++] = 'Y';
break;
case 0x16:
strBuffer[iPos++] = 'U';
break;
case 0x17:
strBuffer[iPos++] = 'I';
break;
case 0x18:
strBuffer[iPos++] = 'O';
break;
case 0x19:
strBuffer[iPos++] = 'P';
break;
case 0x1E:
strBuffer[iPos++] = 'A';
break;
case 0x1F:
strBuffer[iPos++] = 'S';
break;
case 0x20:
strBuffer[iPos++] = 'D';
break;
case 0x21:
strBuffer[iPos++] = 'F';
break;
case 0x22:
strBuffer[iPos++] = 'G';
break;
case 0x23:
strBuffer[iPos++] = 'H';
break;
case 0x24:
strBuffer[iPos++] = 'J';
break;
case 0x25:
strBuffer[iPos++] = 'K';
break;
case 0x26:
strBuffer[iPos++] = 'L';
break;
case 0x27:
strBuffer[iPos++] = ';';
break;
case 0x2B:
strBuffer[iPos++] = '\\';
break;
case 0x2C:
strBuffer[iPos++] = 'Z';
break;
case 0x2D:
strBuffer[iPos++] = 'X';
break;
case 0x2E:
strBuffer[iPos++] = 'C';
break;
case 0x2F:
strBuffer[iPos++] = 'V';
break;
case 0x30:
strBuffer[iPos++] = 'B';
break;
case 0x31:
strBuffer[iPos++] = 'N';
break;
case 0x32:
strBuffer[iPos++] = 'M';
break;
case 0x33:
strBuffer[iPos++] = ',';
break;
case 0x34:
strBuffer[iPos++] = '.';
break;
case 0x39:
strBuffer[iPos++] = ' ';
break;
default:
return false;
}
}
}
return bPush;
}
bool Caldron::Base::CDInput8Mgr::PushKey(int index,int iKey)
{
if(ms_iLockKey != iKey)
return false;
return (m_strKeys[index] &0x80) ? true : false;
}
bool Caldron::Base::CDInput8Mgr:: UpKey(int index,int iKey)
{
if(ms_iLockKey != iKey)
return false;
return (m_strKeys[index] &0x80) ? false : true;
}
HRESULT Caldron::Base::CDInput8Mgr::Update()
{
HRESULT hr;
// Key
// memset(m_strKeys,0,256);
if(Failed(hr = m_lpKeyboardDevice->Acquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : KeyBoard Acquire Failed");
return hr;
}
memcpy(m_strBackKeys,m_strKeys,sizeof(char) * 256);
if(Failed(hr = m_lpKeyboardDevice->GetDeviceState(256,&m_strKeys)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Keyboard DeviceState Get Failed");
return hr;
}
// Mouse
if(Failed(hr = m_lpMouseDevice->Acquire()))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse Acquire Failed");
return hr;
}
if(Failed(hr = m_lpMouseDevice->GetDeviceState(sizeof(DIMOUSESTATE),&m_MouseState)))
{
CLogMgr::_LogError("CDInput8Mgr::InitInputMgr() : Mouse DeviceState Get Failed");
return hr;
}
m_iMouseMove[MOUSE_XAXIS] = m_MouseState.lX;
m_iMouseMove[MOUSE_YAXIS] = m_MouseState.lY;
return S_OK;
}
void Caldron::Base::CDInput8Mgr::GetMouseMove(int &iX,int &iY,int iKey)
{
if(ms_iLockKey != iKey)
{
iX = 0;
iY = 0;
}
iX = m_iMouseMove[MOUSE_XAXIS];
iY = m_iMouseMove[MOUSE_YAXIS];
}

98
GameTools/CaldronBase/DInput8Mgr.h Normal file
View File

@@ -0,0 +1,98 @@
// DInput9Mgr.h: interface for the CDInput9Mgr class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_DINPUT9MGR_H__7F904814_C54A_42A0_A3F0_43B3EC33364B__INCLUDED_)
#define AFX_DINPUT9MGR_H__7F904814_C54A_42A0_A3F0_43B3EC33364B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <Dinput.h>
#include "Caldron.h"
#include "./LogMgr.h"
/* *********************************************************************
* CDInput9Mgr
* <20><><EFBFBD><EFBFBD> : DInput8Mgr.h
* <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> Direct Input9 <20><> <20>̿<EFBFBD><CCBF><EFBFBD> input Ű, mouse ó<><C3B3> class
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.10.31
* history :
wizardbug ( 2003.10.31)
********************************************************************** */
namespace Caldron
{
namespace Base
{
enum DINPUT8DEVICES
{
DINPUT8_KEYBOARD,
DINPUT8_MOUSE,
};
enum DINPUT8MOUSEBUTTON // Mouse Input
{
MOUSE_LBUTTON,
MOUSE_RBUTTON,
MOUSE_BUTTONNUMS,
};
enum DINPUT8MOUSEAXIS // Mouse Move Axis
{
MOUSE_XAXIS,
MOUSE_YAXIS,
MOUSE_AXISNUMS,
};
class CDInput8Mgr
{
protected:
LPDIRECTINPUT8 m_lpDirectInput;
LPDIRECTINPUTDEVICE8 m_lpKeyboardDevice;
static LPDIRECTINPUTDEVICE8 m_lpMouseDevice;
static DIMOUSESTATE m_MouseState;
static int m_iMouseMove[MOUSE_AXISNUMS];
static char m_strKeys[256];
static char m_strBackKeys[256];
static int ms_iLockKey;
public:
CDInput8Mgr();
~CDInput8Mgr();
HRESULT InitInputMgr(HINSTANCE ,HWND ,DWORD dwKeyboard = DISCL_FOREGROUND,DWORD dwMouse = DISCL_FOREGROUND);
HRESULT Acquire();
HRESULT Unacquire();
HRESULT Update();
static bool PushButton(int ,int iKey = -1);
static bool UpButton(int ,int iKey = -1);
static bool PushOnceKey(int ,int iKey = -1);
static bool PushKey(int ,int iKey = -1);
static bool UpKey(int ,int iKey = -1);
static bool KeyStrok(char *strBuffer,int &iPos);
static void GetMouseMove(int &iX,int &iY ,int iKey = -1);
static void Lock(const int &iKey) { ms_iLockKey = iKey;}
static void Unlock() { ms_iLockKey = -1;}
};
}
};
#endif // !defined(AFX_DINPUT9MGR_H__7F904814_C54A_42A0_A3F0_43B3EC33364B__INCLUDED_)

557
GameTools/CaldronBase/ExceptionMgr.cpp Normal file
View File

@@ -0,0 +1,557 @@
#include "./exceptionmgr.h"
#include "./LogMgr.h"
#pragma comment(linker, "/defaultlib:dbghelp.lib")
namespace Caldron { namespace Base {
LPTOP_LEVEL_EXCEPTION_FILTER CExceptionMgr::m_lpPrevFilter = NULL;
HANDLE CExceptionMgr::m_hProcess = NULL;
CExceptionMgr::CExceptionMgr(void)
{
m_lpPrevFilter = SetUnhandledExceptionFilter(Caldron::Base::CExceptionMgr::ExceptionFilter);
m_hProcess = GetCurrentProcess();
}
CExceptionMgr::~CExceptionMgr(void)
{
SetUnhandledExceptionFilter(m_lpPrevFilter);
}
LONG WINAPI CExceptionMgr::ExceptionFilter(PEXCEPTION_POINTERS pExceptionInfo )
{
WriteExceptionReport(pExceptionInfo);
if(m_lpPrevFilter)
return m_lpPrevFilter(pExceptionInfo);
else
return EXCEPTION_CONTINUE_SEARCH;
}
void CExceptionMgr::WriteExceptionReport(PEXCEPTION_POINTERS pExceptionInfo )
{
// Start out with a banner
CLogMgr::_LogNoHeader("========= Exception Report ============\n");
PEXCEPTION_RECORD pExceptionRecord = pExceptionInfo->ExceptionRecord;
// First print information about the type of fault
CLogMgr::_LogNoHeader("Exception Code : %08X %s\n",pExceptionRecord->ExceptionCode,GetExceptionString(pExceptionRecord->ExceptionCode) );
// Now print information about where the fault occured
TCHAR szFaultingModule[MAX_PATH];
DWORD section, offset;
GetLogicalAddress( pExceptionRecord->ExceptionAddress,
szFaultingModule,
sizeof( szFaultingModule ),
section, offset );
CLogMgr::_LogNoHeader("Fault address: %08X %02X:%08X %s\n",
pExceptionRecord->ExceptionAddress,
section, offset, szFaultingModule );
PCONTEXT pCtx = pExceptionInfo->ContextRecord;
// Show the registers
#ifdef _M_IX86 // X86 Only!
CLogMgr::_LogNoHeader("\nRegisters :\n");
CLogMgr::_LogNoHeader("EAX:%08X\nEBX:%08X\nECX:%08X\nEDX:%08X\nESI:%08X\nEDI:%08X\n",
pCtx->Eax, pCtx->Ebx, pCtx->Ecx, pCtx->Edx,
pCtx->Esi, pCtx->Edi );
CLogMgr::_LogNoHeader("CS:EIP:%04X:%08X\n", pCtx->SegCs, pCtx->Eip );
CLogMgr::_LogNoHeader("SS:ESP:%04X:%08X EBP:%08X\n",
pCtx->SegSs, pCtx->Esp, pCtx->Ebp );
CLogMgr::_LogNoHeader("DS:%04X ES:%04X FS:%04X GS:%04X\n",
pCtx->SegDs, pCtx->SegEs, pCtx->SegFs, pCtx->SegGs );
CLogMgr::_LogNoHeader("Flags:%08X\n",pCtx->EFlags );
#endif
SymSetOptions( SYMOPT_DEFERRED_LOADS );
// Initialize DbgHelp
if ( !SymInitialize( GetCurrentProcess(), 0, TRUE ) )
return;
CONTEXT trashableContext = *pCtx;
WriteCallStack( &trashableContext, false );
#ifdef _M_IX86 // X86 Only!
CLogMgr::_LogNoHeader("======================================\n");
CLogMgr::_LogNoHeader("Local Variable & Parameters\n");
trashableContext = *pCtx;
WriteCallStack( &trashableContext, true );
CLogMgr::_LogNoHeader("======================================\n");
CLogMgr::_LogNoHeader("Global Variable\n");
SymEnumSymbols( GetCurrentProcess(),
(DWORD64)GetModuleHandle(szFaultingModule),
0, EnumerateSymbolsCallback, 0 );
#endif // X86 Only!
SymCleanup( GetCurrentProcess() );
CLogMgr::_LogNoHeader("\n");
}
LPSTR CExceptionMgr::GetExceptionString(DWORD dwCode)
{
#define EXCEPTION( x ) case EXCEPTION_##x: return _T(#x);
switch ( dwCode )
{
EXCEPTION( ACCESS_VIOLATION )
EXCEPTION( DATATYPE_MISALIGNMENT )
EXCEPTION( BREAKPOINT )
EXCEPTION( SINGLE_STEP )
EXCEPTION( ARRAY_BOUNDS_EXCEEDED )
EXCEPTION( FLT_DENORMAL_OPERAND )
EXCEPTION( FLT_DIVIDE_BY_ZERO )
EXCEPTION( FLT_INEXACT_RESULT )
EXCEPTION( FLT_INVALID_OPERATION )
EXCEPTION( FLT_OVERFLOW )
EXCEPTION( FLT_STACK_CHECK )
EXCEPTION( FLT_UNDERFLOW )
EXCEPTION( INT_DIVIDE_BY_ZERO )
EXCEPTION( INT_OVERFLOW )
EXCEPTION( PRIV_INSTRUCTION )
EXCEPTION( IN_PAGE_ERROR )
EXCEPTION( ILLEGAL_INSTRUCTION )
EXCEPTION( NONCONTINUABLE_EXCEPTION )
EXCEPTION( STACK_OVERFLOW )
EXCEPTION( INVALID_DISPOSITION )
EXCEPTION( GUARD_PAGE )
EXCEPTION( INVALID_HANDLE )
}
// If not one of the "known" exceptions, try to get the string
// from NTDLL.DLL's message table.
static TCHAR szBuffer[512] = { 0 };
FormatMessage( FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_HMODULE,
GetModuleHandle( _T("NTDLL.DLL") ),
dwCode, 0, szBuffer, sizeof( szBuffer ), 0 );
return szBuffer;
}
//=============================================================================
// Given a linear address, locates the module, section, and offset containing
// that address.
//
// Note: the szModule paramater buffer is an output buffer of length specified
// by the len parameter (in characters!)
//=============================================================================
BOOL CExceptionMgr::GetLogicalAddress(PVOID addr, PTSTR szModule, DWORD len,DWORD& section, DWORD& offset)
{
MEMORY_BASIC_INFORMATION mbi;
if ( !VirtualQuery( addr, &mbi, sizeof(mbi) ) )
return FALSE;
DWORD hMod = (DWORD)mbi.AllocationBase;
if ( !GetModuleFileName( (HMODULE)hMod, szModule, len ) )
return FALSE;
// Point to the DOS header in memory
PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)hMod;
// From the DOS header, find the NT (PE) header
PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(hMod + pDosHdr->e_lfanew);
PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION( pNtHdr );
DWORD rva = (DWORD)addr - hMod; // RVA is offset from module load address
// Iterate through the section table, looking for the one that encompasses
// the linear address.
for ( unsigned i = 0;
i < pNtHdr->FileHeader.NumberOfSections;
i++, pSection++ )
{
DWORD sectionStart = pSection->VirtualAddress;
DWORD sectionEnd = sectionStart
+ max(pSection->SizeOfRawData, pSection->Misc.VirtualSize);
// Is the address in this section???
if ( (rva >= sectionStart) && (rva <= sectionEnd) )
{
// Yes, address is in the section. Calculate section and offset,
// and store in the "section" & "offset" params, which were
// passed by reference.
section = i+1;
offset = rva - sectionStart;
return TRUE;
}
}
return FALSE; // Should never get here!
}
void CExceptionMgr::WriteCallStack(PCONTEXT pContext,bool bWriteVariables )
{
CLogMgr::_LogNoHeader("==========Call Stack==========\n");
CLogMgr::_LogNoHeader("Address Frame Function SourceFile\n");
DWORD dwMachineType = 0;
// Could use SymSetOptions here to add the SYMOPT_DEFERRED_LOADS flag
STACKFRAME sf;
memset( &sf, 0, sizeof(sf) );
#ifdef _M_IX86
// Initialize the STACKFRAME structure for the first call. This is only
// necessary for Intel CPUs, and isn't mentioned in the documentation.
sf.AddrPC.Offset = pContext->Eip;
sf.AddrPC.Mode = AddrModeFlat;
sf.AddrStack.Offset = pContext->Esp;
sf.AddrStack.Mode = AddrModeFlat;
sf.AddrFrame.Offset = pContext->Ebp;
sf.AddrFrame.Mode = AddrModeFlat;
dwMachineType = IMAGE_FILE_MACHINE_I386;
#endif
while ( 1 )
{
// Get the next stack frame
if ( ! StackWalk( dwMachineType,
m_hProcess,
GetCurrentThread(),
&sf,
pContext,
0,
SymFunctionTableAccess,
SymGetModuleBase,
0 ) )
break;
if ( 0 == sf.AddrFrame.Offset ) // Basic sanity check to make sure
break; // the frame is OK. Bail if not.
CLogMgr::_LogNoHeader("%08X %08X ",sf.AddrPC.Offset, sf.AddrFrame.Offset );
// Get the name of the function for this stack frame entry
BYTE symbolBuffer[ sizeof(SYMBOL_INFO) + 1024 ];
PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)symbolBuffer;
pSymbol->SizeOfStruct = sizeof(symbolBuffer);
pSymbol->MaxNameLen = 1024;
DWORD64 symDisplacement = 0; // Displacement of the input address,
// relative to the start of the symbol
if ( SymFromAddr(m_hProcess,sf.AddrPC.Offset,&symDisplacement,pSymbol))
{
CLogMgr::_LogNoHeader("%hs+%I64X",pSymbol->Name, symDisplacement );
}
else // No symbol found. Print out the logical address instead.
{
TCHAR szModule[MAX_PATH] = _T("");
DWORD section = 0, offset = 0;
GetLogicalAddress( (PVOID)sf.AddrPC.Offset,
szModule, sizeof(szModule), section, offset );
CLogMgr::_LogNoHeader("%04X:%08X %s",section, offset, szModule );
}
// Get the source line for this stack frame entry
IMAGEHLP_LINE lineInfo = { sizeof(IMAGEHLP_LINE) };
DWORD dwLineDisplacement;
if ( SymGetLineFromAddr( m_hProcess, sf.AddrPC.Offset,
&dwLineDisplacement, &lineInfo ) )
{
CLogMgr::_LogNoHeader(" %s line %u",lineInfo.FileName,lineInfo.LineNumber);
}
CLogMgr::_LogNoHeader("\n");
// Write out the variables, if desired
if ( bWriteVariables )
{
// Use SymSetContext to get just the locals/params for this frame
IMAGEHLP_STACK_FRAME imagehlpStackFrame;
imagehlpStackFrame.InstructionOffset = sf.AddrPC.Offset;
SymSetContext( m_hProcess, &imagehlpStackFrame, 0 );
// Enumerate the locals/parameters
SymEnumSymbols( m_hProcess, 0, 0, EnumerateSymbolsCallback, &sf );
CLogMgr::_LogNoHeader("\n");
}
}
}
BOOL CALLBACK CExceptionMgr::EnumerateSymbolsCallback( PSYMBOL_INFO pSymInfo, ULONG SymbolSize,PVOID UserContext )
{
char szBuffer[2048];
__try
{
if ( FormatSymbolValue( pSymInfo, (STACKFRAME*)UserContext,
szBuffer, sizeof(szBuffer) ) )
CLogMgr::_LogNoHeader("\t%s\n",szBuffer);
}
__except( 1 )
{
CLogMgr::_LogNoHeader("punting on symbol %s\n",pSymInfo->Name);
}
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////
// Given a SYMBOL_INFO representing a particular variable, displays its
// contents. If it's a user defined type, display the members and their
// values.
//////////////////////////////////////////////////////////////////////////////
bool CExceptionMgr::FormatSymbolValue( PSYMBOL_INFO pSym, STACKFRAME *sf, char * pszBuffer, unsigned cbBuffer )
{
char * pszCurrBuffer = pszBuffer;
// Indicate if the variable is a local or parameter
if ( pSym->Flags & IMAGEHLP_SYMBOL_INFO_PARAMETER )
pszCurrBuffer += sprintf( pszCurrBuffer, "Parameter " );
else if ( pSym->Flags & IMAGEHLP_SYMBOL_INFO_LOCAL )
pszCurrBuffer += sprintf( pszCurrBuffer, "Local " );
// If it's a function, don't do anything.
if ( pSym->Tag == 5 ) // SymTagFunction from CVCONST.H from the DIA SDK
return false;
// Emit the variable name
pszCurrBuffer += sprintf( pszCurrBuffer, "\'%s\'", pSym->Name );
DWORD_PTR pVariable = 0; // Will point to the variable's data in memory
if ( pSym->Flags & IMAGEHLP_SYMBOL_INFO_REGRELATIVE )
{
// if ( pSym->Register == 8 ) // EBP is the value 8 (in DBGHELP 5.1)
{ // This may change!!!
pVariable = sf->AddrFrame.Offset;
pVariable += (DWORD_PTR)pSym->Address;
}
// else
// return false;
}
else if ( pSym->Flags & IMAGEHLP_SYMBOL_INFO_REGISTER )
{
return false; // Don't try to report register variable
}
else
{
pVariable = (DWORD_PTR)pSym->Address; // It must be a global variable
}
// Determine if the variable is a user defined type (UDT). IF so, bHandled
// will return true.
bool bHandled;
pszCurrBuffer = DumpTypeIndex(pszCurrBuffer,pSym->ModBase, pSym->TypeIndex,
0, pVariable, bHandled );
if ( !bHandled )
{
// The symbol wasn't a UDT, so do basic, stupid formatting of the
// variable. Based on the size, we're assuming it's a char, WORD, or
// DWORD.
BasicType basicType = GetBasicType( pSym->TypeIndex, pSym->ModBase );
pszCurrBuffer = FormatOutputValue(pszCurrBuffer, basicType, pSym->Size,
(PVOID)pVariable );
}
return true;
}
//////////////////////////////////////////////////////////////////////////////
// If it's a user defined type (UDT), recurse through its members until we're
// at fundamental types. When he hit fundamental types, return
// bHandled = false, so that FormatSymbolValue() will format them.
//////////////////////////////////////////////////////////////////////////////
char * CExceptionMgr::DumpTypeIndex(
char * pszCurrBuffer,
DWORD64 modBase,
DWORD dwTypeIndex,
unsigned nestingLevel,
DWORD_PTR offset,
bool & bHandled )
{
bHandled = false;
// Get the name of the symbol. This will either be a Type name (if a UDT),
// or the structure member name.
WCHAR * pwszTypeName;
if ( SymGetTypeInfo( m_hProcess, modBase, dwTypeIndex, TI_GET_SYMNAME,
&pwszTypeName ) )
{
pszCurrBuffer += sprintf( pszCurrBuffer, " %ls", pwszTypeName );
LocalFree( pwszTypeName );
}
// Determine how many children this type has.
DWORD dwChildrenCount = 0;
SymGetTypeInfo( m_hProcess, modBase, dwTypeIndex, TI_GET_CHILDRENCOUNT,
&dwChildrenCount );
if ( !dwChildrenCount ) // If no children, we're done
return pszCurrBuffer;
// Prepare to get an array of "TypeIds", representing each of the children.
// SymGetTypeInfo(TI_FINDCHILDREN) expects more memory than just a
// TI_FINDCHILDREN_PARAMS struct has. Use derivation to accomplish this.
struct FINDCHILDREN : TI_FINDCHILDREN_PARAMS
{
ULONG MoreChildIds[1024];
FINDCHILDREN(){Count = sizeof(MoreChildIds) / sizeof(MoreChildIds[0]);}
} children;
children.Count = dwChildrenCount;
children.Start= 0;
// Get the array of TypeIds, one for each child type
if ( !SymGetTypeInfo( m_hProcess, modBase, dwTypeIndex, TI_FINDCHILDREN,
&children ) )
{
return pszCurrBuffer;
}
// Append a line feed
pszCurrBuffer += sprintf( pszCurrBuffer, "\r\n" );
// Iterate through each of the children
for ( unsigned i = 0; i < dwChildrenCount; i++ )
{
// Add appropriate indentation level (since this routine is recursive)
for ( unsigned j = 0; j <= nestingLevel+1; j++ )
pszCurrBuffer += sprintf( pszCurrBuffer, "\t" );
// Recurse for each of the child types
bool bHandled2;
pszCurrBuffer = DumpTypeIndex( pszCurrBuffer, modBase,
children.ChildId[i], nestingLevel+1,
offset, bHandled2 );
// If the child wasn't a UDT, format it appropriately
if ( !bHandled2 )
{
// Get the offset of the child member, relative to its parent
DWORD dwMemberOffset;
SymGetTypeInfo( m_hProcess, modBase, children.ChildId[i],
TI_GET_OFFSET, &dwMemberOffset );
// Get the real "TypeId" of the child. We need this for the
// SymGetTypeInfo( TI_GET_TYPEID ) call below.
DWORD typeId;
SymGetTypeInfo( m_hProcess, modBase, children.ChildId[i],
TI_GET_TYPEID, &typeId );
// Get the size of the child member
ULONG64 length;
SymGetTypeInfo(m_hProcess, modBase, typeId, TI_GET_LENGTH,&length);
// Calculate the address of the member
DWORD_PTR dwFinalOffset = offset + dwMemberOffset;
BasicType basicType = GetBasicType(children.ChildId[i], modBase );
pszCurrBuffer = FormatOutputValue( pszCurrBuffer, basicType,
length, (PVOID)dwFinalOffset );
pszCurrBuffer += sprintf( pszCurrBuffer, "\r\n" );
}
}
bHandled = true;
return pszCurrBuffer;
}
char * CExceptionMgr::FormatOutputValue( char * pszCurrBuffer,
BasicType basicType,
DWORD64 length,
PVOID pAddress )
{
// Format appropriately (assuming it's a 1, 2, or 4 bytes (!!!)
if ( length == 1 )
pszCurrBuffer += sprintf( pszCurrBuffer, " = %X", *(PBYTE)pAddress );
else if ( length == 2 )
pszCurrBuffer += sprintf( pszCurrBuffer, " = %X", *(PWORD)pAddress );
else if ( length == 4 )
{
if ( basicType == btFloat )
{
pszCurrBuffer += sprintf(pszCurrBuffer," = %f", *(PFLOAT)pAddress);
}
else if ( basicType == btChar )
{
if ( !IsBadStringPtr( *(PSTR*)pAddress, 32) )
{
pszCurrBuffer += sprintf( pszCurrBuffer, " = \"%.31s\"",
*(PDWORD)pAddress );
}
else
pszCurrBuffer += sprintf( pszCurrBuffer, " = %X",
*(PDWORD)pAddress );
}
else
pszCurrBuffer += sprintf(pszCurrBuffer," = %X", *(PDWORD)pAddress);
}
else if ( length == 8 )
{
if ( basicType == btFloat )
{
pszCurrBuffer += sprintf( pszCurrBuffer, " = %lf",
*(double *)pAddress );
}
else
pszCurrBuffer += sprintf( pszCurrBuffer, " = %I64X",
*(DWORD64*)pAddress );
}
return pszCurrBuffer;
}
BasicType CExceptionMgr::GetBasicType( DWORD typeIndex, DWORD64 modBase )
{
BasicType basicType;
if ( SymGetTypeInfo( m_hProcess, modBase, typeIndex,
TI_GET_BASETYPE, &basicType ) )
{
return basicType;
}
// Get the real "TypeId" of the child. We need this for the
// SymGetTypeInfo( TI_GET_TYPEID ) call below.
DWORD typeId;
if (SymGetTypeInfo(m_hProcess,modBase, typeIndex, TI_GET_TYPEID, &typeId))
{
if ( SymGetTypeInfo( m_hProcess, modBase, typeId, TI_GET_BASETYPE,
&basicType ) )
{
return basicType;
}
}
return btNoType;
}
}}

92
GameTools/CaldronBase/ExceptionMgr.h Normal file
View File

@@ -0,0 +1,92 @@
#include "Caldron.h"
#include <dbghelp.h>
/* *********************************************************************
* CExceptionMgr
* <20><><EFBFBD><EFBFBD> : CException Mgr.h
* <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> Dbghelp<6C><70> LogMgr<67><72> <20>̿<EFBFBD><CCBF><EFBFBD> exception <20><><EFBFBD><EFBFBD> <20><>ƾ.
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2004.02.11
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : wizardbug ( 2004.02.11)
* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> :
* <20><><EFBFBD><EFBFBD> : Exception <20>ڵ鸵 <20><>ƾ<EFBFBD><C6BE> microsoft <20><><EFBFBD><EFBFBD> Į<><C4AE> ' under the hood' <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ƾ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
********************************************************************** */
#pragma once
namespace Caldron {
namespace Base {
// Stolen from Dbg Help Example
enum BasicType
{
btNoType = 0,
btVoid = 1,
btChar = 2,
btWChar = 3,
btInt = 6,
btUInt = 7,
btFloat = 8,
btBCD = 9,
btBool = 10,
btLong = 13,
btULong = 14,
btCurrency = 25,
btDate = 26,
btVariant = 27,
btComplex = 28,
btBit = 29,
btBSTR = 30,
btHresult = 31
};
class CExceptionMgr
{
public:
CExceptionMgr(void);
~CExceptionMgr(void);
// entry point where control comes on an unhandled exception
static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS pExceptionInfo );
static void WriteExceptionReport(PEXCEPTION_POINTERS pExceptionInfo );
static LPSTR GetExceptionString(DWORD dwCode);
static BOOL GetLogicalAddress(PVOID addr, PTSTR szModule, DWORD len,DWORD& section, DWORD& offset);
static void WriteCallStack(PCONTEXT pContext,bool bWriteVariables );
static BOOL CALLBACK EnumerateSymbolsCallback(PSYMBOL_INFO,ULONG, PVOID);
static bool FormatSymbolValue( PSYMBOL_INFO, STACKFRAME *, char * pszBuffer, unsigned cbBuffer );
static char * DumpTypeIndex( char *, DWORD64, DWORD, unsigned, DWORD_PTR, bool & );
static char * FormatOutputValue( char * pszCurrBuffer, BasicType basicType, DWORD64 length, PVOID pAddress );
static BasicType GetBasicType( DWORD typeIndex, DWORD64 modBase );
protected:
static LPTOP_LEVEL_EXCEPTION_FILTER m_lpPrevFilter;
static HANDLE m_hProcess;
};
/*
private:
// where report info is extracted and generated
static void GenerateExceptionReport( PEXCEPTION_POINTERS pExceptionInfo );
// Helper functions
static void WriteStackDetails( PCONTEXT pContext, bool bWriteVariables );
static int __cdecl _tprintf(const TCHAR * format, ...);
};
extern WheatyExceptionReport g_WheatyExceptionReport; // global instance of class
*/
}}

23
GameTools/CaldronBase/LoadedObj.cpp Normal file
View File

@@ -0,0 +1,23 @@
// LoadedObj.cpp: implementation of the CLoadedObj class.
//
//////////////////////////////////////////////////////////////////////
#pragma warning( disable : 4786 )
#include "./ByteDataObj.h"
#include "LoadedObj.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
namespace Caldron { namespace Base {
CLoadedObj::CLoadedObj()
{
m_bLoaded = false;
m_iReloadingCount = 0;
}
CLoadedObj::~CLoadedObj()
{
}
}}

48
GameTools/CaldronBase/LoadedObj.h Normal file
View File

@@ -0,0 +1,48 @@
// 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
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 CByteDataObj;
class CLoadedObj
{
public:
CLoadedObj();
virtual ~CLoadedObj();
virtual bool Load(CByteDataObj *) = 0;
virtual bool Unload() = 0;
bool m_bLoaded;
char m_strName[40];
int m_iReloadingCount; // ReLoading Ƚ<><C8BD>.
};
}
}
#endif // !defined(AFX_LOADEDOBJ_H__7BBE3A5F_6665_4F40_AA4D_82BACEBC32D3__INCLUDED_)

319
GameTools/CaldronBase/LogMgr.cpp Normal file
View File

@@ -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);
}

96
GameTools/CaldronBase/LogMgr.h Normal file
View File

@@ -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 "./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_)

11
GameTools/CaldronBase/MemoryPool.cpp Normal file
View File

@@ -0,0 +1,11 @@
#include ".\memorypool.h"
namespace Caldron { namespace Base {
CMemoryPool::CMemoryPool(void)
{
}
CMemoryPool::~CMemoryPool(void)
{
}
}}

14
GameTools/CaldronBase/MemoryPool.h Normal file
View File

@@ -0,0 +1,14 @@
#pragma once
#include "Caldron.h"
namespace Caldron {
namespace Base {
class CMemoryPool
{
public:
CMemoryPool(void);
~CMemoryPool(void);
};
}}

252
GameTools/CaldronBase/ProfileMgr.cpp Normal file
View File

@@ -0,0 +1,252 @@
/* *********************************************************************
* CProfileMgr
* <20><><EFBFBD><EFBFBD> : ProfileMgr.cpp
* <20><><EFBFBD><EFBFBD> :
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.11.05
* history :
wizardbug ( 2003.11.05) :: Gem3<6D><33> Profile System<65><6D> Caldron<6F><6E> <20>°<EFBFBD> <20><><EFBFBD><EFBFBD>
********************************************************************** */
#include "./ProfileMgr.h"
/***************************************************************************************************
**
** CProfileObj
**
***************************************************************************************************/
/***********************************************************************************************
* INPUT: *
* name - pointer to a static string which is the name of this profile node *
* parent - parent pointer *
* *
* WARNINGS: *
* The name is assumed to be a static pointer, only the pointer is stored and compared for *
* efficiency reasons. *
*=============================================================================================*/
Caldron::Base::CProfileObj::CProfileObj( const char * strName, CProfileObj * pParent ) :
m_strName( strName ),
m_iTotalCalls( 0 ),
m_fTotalTime( 0 ),
m_iStartTime( 0 ),
m_iRecursionCounter( 0 ),
m_pParent( pParent ),
m_pChild( NULL ),
m_pSibling( NULL )
{
Reset();
}
Caldron::Base::CProfileObj::~CProfileObj( void )
{
delete m_pChild;
delete m_pSibling;
}
/***********************************************************************************************
* INPUT: *
* name - static string pointer to the name of the node we are searching for *
* *
* WARNINGS: *
* All profile names are assumed to be static strings so this function uses pointer compares *
* to find the named node. *
*=============================================================================================*/
Caldron::Base::CProfileObj *Caldron::Base::CProfileObj::Get_Sub_Node( const char * strName )
{
// Try to find this sub node
CProfileObj * child = m_pChild;
while ( child ) {
if ( child->m_strName == strName ) {
return child;
}
child = child->m_pSibling;
}
// We didn't find it, so add it
CProfileObj * node = new CProfileObj( strName, this );
node->m_pSibling = m_pChild;
m_pChild = node;
return node;
}
void Caldron::Base::CProfileObj::Reset()
{
m_iTotalCalls = 0;
m_fTotalTime = 0.0f;
if ( m_pChild ) {
m_pChild->Reset();
}
if ( m_pSibling ) {
m_pSibling->Reset();
}
}
void Caldron::Base::CProfileObj::Call()
{
m_iTotalCalls++;
if (m_iRecursionCounter++ == 0) {
Caldron::ProfileGetTicks(&m_iStartTime);
}
}
bool Caldron::Base::CProfileObj::Return()
{
if ( --m_iRecursionCounter == 0 && m_iTotalCalls != 0 ) {
__int64 time;
Caldron::ProfileGetTicks(&time);
time -= m_iStartTime;
m_fTotalTime += (float)time / Caldron::ProfileGetTickRate();
}
return ( m_iRecursionCounter == 0 );
}
/***************************************************************************************************
**
** CProfileChecker
**
***************************************************************************************************/
Caldron::Base::CProfileChecker::CProfileChecker( CProfileObj * pStart )
{
m_pCurrentParent = pStart;
m_pCurrentChild = m_pCurrentParent->Get_Child();
}
void Caldron::Base::CProfileChecker::First(void)
{
m_pCurrentChild = m_pCurrentParent->Get_Child();
}
void Caldron::Base::CProfileChecker::Next(void)
{
m_pCurrentChild = m_pCurrentChild->Get_Sibling();
}
bool Caldron::Base::CProfileChecker::Is_Done(void)
{
return m_pCurrentChild == NULL;
}
void Caldron::Base::CProfileChecker::Enter_Child( int iIndex )
{
m_pCurrentChild = m_pCurrentParent->Get_Child();
while ( (m_pCurrentChild != NULL) && (iIndex != 0) ) {
iIndex--;
m_pCurrentChild = m_pCurrentChild->Get_Sibling();
}
if ( m_pCurrentChild != NULL ) {
m_pCurrentParent = m_pCurrentChild;
m_pCurrentChild = m_pCurrentParent->Get_Child();
}
}
void Caldron::Base::CProfileChecker::Enter_Parent( void )
{
if ( m_pCurrentParent->Get_Parent() != NULL ) {
m_pCurrentParent = m_pCurrentParent->Get_Parent();
}
m_pCurrentChild = m_pCurrentParent->Get_Child();
}
/***************************************************************************************************
**
** CProfileMgr
**
***************************************************************************************************/
Caldron::Base::CProfileObj Caldron::Base::CProfileMgr::m_Root( "Root", NULL );
Caldron::Base::CProfileObj *Caldron::Base::CProfileMgr::m_pCurrentNode = &CProfileMgr::m_Root;
int Caldron::Base::CProfileMgr::m_iFrameCounter = 0;
__int64 Caldron::Base::CProfileMgr::m_iResetTime = 0;
/***********************************************************************************************
* CProfileManager::Start_Profile -- Begin a named profile *
* *
* Steps one level deeper into the tree, if a child already exists with the specified name *
* then it accumulates the profiling; otherwise a new child node is added to the profile tree. *
* *
* INPUT: *
* name - name of this profiling record *
* *
* WARNINGS: *
* The string used is assumed to be a static string; pointer compares are used throughout *
* the profiling code for efficiency. *
*=============================================================================================*/
void Caldron::Base::CProfileMgr::StartProfile( const char * strName )
{
if (strName != m_pCurrentNode->Get_Name()) {
m_pCurrentNode = m_pCurrentNode->Get_Sub_Node( strName );
}
m_pCurrentNode->Call();
}
/***********************************************************************************************
* CProfileManager::Stop_Profile -- Stop timing and record the results. *
*=============================================================================================*/
void Caldron::Base::CProfileMgr::StopProfile( void )
{
// Return will indicate whether we should back up to our parent (we may
// be profiling a recursive function)
if (m_pCurrentNode->Return()) {
m_pCurrentNode = m_pCurrentNode->Get_Parent();
}
}
/***********************************************************************************************
* CProfileManager::Reset -- Reset the contents of the profiling system *
* *
* This resets everything except for the tree structure. All of the timing data is reset. *
*=============================================================================================*/
void Caldron::Base::CProfileMgr::Reset( void )
{
m_Root.Reset();
m_iFrameCounter = 0;
Caldron::ProfileGetTicks(&m_iResetTime);
}
/***********************************************************************************************
* CProfileManager::Increment_Frame_Counter -- Increment the frame counter *
*=============================================================================================*/
void Caldron::Base::CProfileMgr::Increment_Frame_Counter( void )
{
m_iFrameCounter++;
}
/***********************************************************************************************
* CProfileManager::Get_Time_Since_Reset -- returns the elapsed time since last reset *
*=============================================================================================*/
float Caldron::Base::CProfileMgr::Get_Time_Since_Reset( void )
{
__int64 time;
Caldron::ProfileGetTicks(&time);
time -= m_iResetTime;
return (float)time / Caldron::ProfileGetTickRate();
}

141
GameTools/CaldronBase/ProfileMgr.h Normal file
View File

@@ -0,0 +1,141 @@
/* *********************************************************************
* CProfileMgr
* <20><><EFBFBD><EFBFBD> : ProfileMgr.h
* <20><><EFBFBD><EFBFBD> :
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.11.05
* history :
wizardbug ( 2003.11.05) :: Gem3<6D><33> Profile System<65><6D> Caldron<6F><6E> <20>°<EFBFBD> <20><><EFBFBD><EFBFBD>
********************************************************************** */
/*
** A node in the Profile Hierarchy Tree
*/
#include "Caldron.h"
#include "./LogMgr.h"
namespace Caldron {
namespace Base {
class CProfileObj {
public:
CProfileObj( const char * strName, CProfileObj * pParent );
~CProfileObj( void );
CProfileObj *Get_Sub_Node( const char * strName );
CProfileObj *Get_Parent( void ) { return m_pParent; }
CProfileObj *Get_Sibling( void ) { return m_pSibling; }
CProfileObj *Get_Child( void ) { return m_pChild; }
void Reset( void );
void Call( void );
bool Return( void );
const char *Get_Name( void ) { return m_strName; }
int Get_Total_Calls( void ) { return m_iTotalCalls; }
float Get_Total_Time( void ) { return m_fTotalTime; }
protected:
const char * m_strName;
int m_iTotalCalls;
float m_fTotalTime;
__int64 m_iStartTime;
int m_iRecursionCounter;
CProfileObj * m_pParent;
CProfileObj * m_pChild;
CProfileObj * m_pSibling;
};
/*
** An iterator to navigate through the tree
*/
class CProfileChecker
{
public:
// Access all the children of the current parent
void First(void);
void Next(void);
bool Is_Done(void);
void Enter_Child( int iIndex ); // Make the given child the new parent
void Enter_Largest_Child( void ); // Make the largest child the new parent
void Enter_Parent( void ); // Make the current parent's parent the new parent
// Access the current child
const char * Get_Current_Name( void ) { return m_pCurrentChild->Get_Name(); }
int Get_Current_Total_Calls( void ) { return m_pCurrentChild->Get_Total_Calls(); }
float Get_Current_Total_Time( void ) { return m_pCurrentChild->Get_Total_Time(); }
// Access the current parent
const char * Get_Current_Parent_Name( void ) { return m_pCurrentParent->Get_Name(); }
int Get_Current_Parent_Total_Calls( void ) { return m_pCurrentParent->Get_Total_Calls(); }
float Get_Current_Parent_Total_Time( void ) { return m_pCurrentParent->Get_Total_Time(); }
CProfileObj * GetParentPtr() {return m_pCurrentParent;}
CProfileObj * GetChildPtr() { return m_pCurrentChild;}
protected:
CProfileObj * m_pCurrentParent;
CProfileObj * m_pCurrentChild;
CProfileChecker( CProfileObj * start );
friend class CProfileMgr;
};
/*
** The Manager for the Profile system
*/
class CProfileMgr {
public:
static void StartProfile( const char * strName );
static void StopProfile( void );
static void Reset( void );
static void Increment_Frame_Counter( void );
static int Get_Frame_Count_Since_Reset( void ) { return m_iFrameCounter; }
static float Get_Time_Since_Reset( void );
static CProfileChecker *GetChecker( void ) { return new CProfileChecker( &m_Root ); }
static void ReleaseChecker( CProfileChecker * iterator ) { SafeDelete(iterator); }
private:
static CProfileObj m_Root;
static CProfileObj *m_pCurrentNode;
static int m_iFrameCounter;
static __int64 m_iResetTime;
};
/*
** ProfileSampleClass is a simple way to profile a function's scope
** Use the PROFILE macro at the start of scope to time
*/
class CProfileSample {
public:
CProfileSample( const char * name )
{
CProfileMgr::StartProfile( name );
}
~CProfileSample( void )
{
CProfileMgr::StopProfile();
}
};
};
};
#ifdef _DEBUG
#define PROFILE( name ) Caldron::Base::CProfileSample __profile( name )
#else
#define PROFILE( name )
#endif

21
GameTools/CaldronBase/ReadMe.txt Normal file
View File

@@ -0,0 +1,21 @@
========================================================================
<20><><EFBFBD><EFBFBD> <20><><EFBFBD>̺귯<CCBA><EAB7AF> : Base <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
========================================================================
<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><> Base <20><><EFBFBD>̺귯<CCBA><EAB7AF> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʾҽ<CABE><D2BD>ϴ<EFBFBD>.
Base.vcproj
<20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>縦 <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> VC++ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>⺻ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.
<20>ش<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Visual C++<2B><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD>
<20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>÷<EFBFBD><C3B7><EFBFBD>, <20><><EFBFBD><EFBFBD> <20><>
<20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>ɿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.
/////////////////////////////////////////////////////////////////////////////
<EFBFBD><EFBFBD>Ÿ <20><><EFBFBD><EFBFBD>:
<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> "TODO:" <20>ּ<EFBFBD><D6BC><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ڰ<EFBFBD> <20>߰<EFBFBD><DFB0>ϰų<CFB0> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD> <20>ϴ<EFBFBD>
<EFBFBD>ҽ<EFBFBD> <20>ڵ<EFBFBD> <20>κ<EFBFBD><CEBA><EFBFBD> <20><>Ÿ<EFBFBD><C5B8><EFBFBD>ϴ<EFBFBD>.
/////////////////////////////////////////////////////////////////////////////

252
GameTools/CaldronBase/ResourceLoader.cpp Normal file
View File

@@ -0,0 +1,252 @@
#pragma warning( disable : 4786 )
#include "Caldron.h"
#include "./LoadedObj.h"
#include "ResourceLoader.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)
********************************************************************** */
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;
}
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();
}
}
}}

118
GameTools/CaldronBase/ResourceLoader.h Normal file
View File

@@ -0,0 +1,118 @@
// 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 "./ByteDataObj.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 = 1023;
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
{
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_)

108
GameTools/CaldronBase/ThreadQueue.h Normal file
View File

@@ -0,0 +1,108 @@
// 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 "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()
{
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~!");
}
LeaveCriticalSection(&m_CriticalSection);
return bResult;
}
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 true;
}
return false;
}
void Terminate()
{
SetEvent(m_Handle[CALDRONTHREAD_TERMINATE]);
}
void UnTerminate()
{
ResetEvent(m_Handle[CALDRONTHREAD_TERMINATE]);
}
protected:
HANDLE m_Handle[2];
CRITICAL_SECTION m_CriticalSection;
std::queue<T> m_Queue;
};
}
}
#endif // !defined(AFX_THREADQUEUE_H__D6165646_A901_43B4_BABC_5237337D0BFD__INCLUDED_)

58
GameTools/CaldronBase/Timer.cpp Normal file
View File

@@ -0,0 +1,58 @@
#include <windows.h>
#include <mmsystem.h>
#include "Timer.h"
Caldron::Base::CTimer& Caldron::Base::CTimer::_GetInstance()
{
static CTimer Instance;
return Instance;
}
Caldron::Base::CTimer::~CTimer()
{
}
void Caldron::Base::CTimer::Init( int keep )
{
if( !QueryPerformanceFrequency( &m_QPFTicksPerSec ) )
MessageBox( NULL, "Ÿ<EFBFBD≯ӽý<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>.", "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>", MB_OK );
QueryPerformanceCounter( &m_StartTime );
m_fFps = 0;
m_fElapsedTime = 0;
m_iKeepFrame = keep;
}
void Caldron::Base::CTimer::Update()
{
static LARGE_INTEGER CurTime;
static LARGE_INTEGER LastTime = m_StartTime;
QueryPerformanceCounter( &CurTime );
m_fElapsedTime = (float)(((double)CurTime.QuadPart - (double)LastTime.QuadPart) / (double)m_QPFTicksPerSec.QuadPart);
m_fFps = (float)((double)m_QPFTicksPerSec.QuadPart / ((double)CurTime.QuadPart - (double)LastTime.QuadPart));
m_fAppTime = (float)(((double)CurTime.QuadPart - (double)m_StartTime.QuadPart) / (double)m_QPFTicksPerSec.QuadPart);
if( m_iKeepFrame > 0 )
{
while( m_fFps > (float)m_iKeepFrame )
{
m_fFps = (float)((double)m_QPFTicksPerSec.QuadPart / ((double)CurTime.QuadPart - (double)LastTime.QuadPart));
QueryPerformanceCounter( &CurTime );
}
}
LastTime = CurTime;
}

45
GameTools/CaldronBase/Timer.h Normal file
View File

@@ -0,0 +1,45 @@
/**********************************************************************
* CTimer
* <20><><EFBFBD><EFBFBD> : Timer.h
* <20><><EFBFBD><EFBFBD> : Caldron Engine<6E><65> <20>ð<EFBFBD><C3B0><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20>ý<EFBFBD><C3BD><EFBFBD><EFBFBD>̴<EFBFBD>.
* <20>ۼ<EFBFBD><DBBC><EFBFBD> : 2003.10.24
* history :
kamzic072 ( 2003.10.24 )
***********************************************************************/
#if !defined(CALDRON__TIMER_H_)
#define CALDRON__TIMER_H_
namespace Caldron
{
namespace Base
{
class CTimer
{
private:
LARGE_INTEGER m_QPFTicksPerSec;
LARGE_INTEGER m_StartTime;
float m_fFps;
float m_fElapsedTime;
float m_fAppTime;
int m_iKeepFrame;
public:
virtual ~CTimer();
static CTimer& _GetInstance();
void Init( int keep = -1 );
float GetElapsedTime() { return m_fElapsedTime; };
float GetFPS() { return m_fFps; };
void SetFPS(int frame) { m_iKeepFrame = frame; };
void FreeFPS() { m_iKeepFrame = -1; };
float GetAppTime() { return m_fAppTime; };
void Update();
};
}
}
#endif // !defined(CALDRON__TIMER_H_)