www.pudn.com > zfxcengine-0.1.0.zip > ceResourceManager.cpp

// $Id: ceResourceManager.cpp,v 1.13 2005/09/05 08:52:19 kimmi Exp $ 
///////////////////////////////////////////////////////////////// 
// 
//!   Module:     Core 
//!  \file:       ceResourceManager.cpp 
//!   Created:    18.09.2004 
//!   Author:     Kim Kulling aka kimmi 
// 
///////////////////////////////////////////////////////////////// 
#include "Core/ceResourceManager.h" 
#include "Core/ceExceptions.h" 
#include "Core/ceMemManager.h" 
#include "VFSystem/ceScratchSystem.h" 
#include "VFSystem/ceScratchFile.h" 
 
namespace ZFXCE { 
	///////////////////////////////////////////////////////////////// 
	ceResourceManager::ceResourceManager() 
	{ 
		PUSH_FUNCTION; 
 
		Init(0); 
	} 
	///////////////////////////////////////////////////////////////// 
	ceResourceManager::ceResourceManager(DWORD dwSize, ceVFSystem *pVFS) 
	{ 
		PUSH_FUNCTION; 
 
		Init(dwSize); 
		SetVFS(pVFS); 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::SetVFS(ceVFSystem *pVFS) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert(NULL != pVFS); 
		m_pVFS = pVFS; 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::Init(DWORD dwSize) 
	{ 
		PUSH_FUNCTION; 
 
		if (dwSize < 0) 
			m_dwMaxSize = 0; 
		else 
			m_dwMaxSize = dwSize; 
		 
		// Initialisiere Attribute 
		m_dwSize    = 0; 
		m_rhCurrent = 0; 
		m_uiMax     = 0; 
		m_pVFS      = NULL; 
		m_pCurrent  = NULL; 
		m_pLocked   = NULL; 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::Release() 
	{ 
		PUSH_FUNCTION; 
 
		ceResource *pRes = NULL; 
		// Release opened resources 
		if (0 != m_ResourceMap.size()) { 
			for (m_It = m_ResourceMap.begin(); m_It != m_ResourceMap.end(); 
					++m_It) { 
				pRes = (*m_It).second; 
			} 
			m_ResourceMap.clear(); 
		} 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::AddMemory(DWORD dwSize) 
	{ 
		PUSH_FUNCTION; 
 
		m_dwSize += dwSize; 
		if (m_dwSize > m_dwMaxSize) { 
			CE_EXCEPTION("Maximum memory of ressouremanager exceeded!", CELS_HARDERROR); 
			return; 
		} 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::DelMemory(DWORD dwSize) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert (dwSize < m_dwSize); 
		m_dwSize -= dwSize; 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::AddLoaderJob(ceResource *pResource) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert (NULL != pResource); 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::DelLoaderJob(ceResource *pResource) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert (NULL != pResource); 
	} 
	///////////////////////////////////////////////////////////////// 
	ceResourceManager::~ceResourceManager() 
	{ 
		PUSH_FUNCTION; 
 
		Release(); 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::Clear() 
	{ 
		PUSH_FUNCTION; 
 
		Release(); 
		Init(0); 
	} 
	///////////////////////////////////////////////////////////////// 
	RHANDLE ceResourceManager::AddResource(ceResource *pResource) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert(NULL != pResource);		 
		 
		// Get a handle 
		UINT uiID = 0; 
		if (!m_lFreeHandles.empty()) {  
			uiID = m_lFreeHandles.front(); 
			m_lFreeHandles.pop_front();	 
		} 
		else { 
			++m_uiMax; 
			uiID = m_uiMax; 
		} 
			 
		// Assign resourceid to resource 
		m_ResourceMap[uiID] = pResource; 
		m_pCurrent  = pResource; 
		m_rhCurrent = uiID; 
		DWORD dwSize = (DWORD) pResource->GetSize(); 
		m_dwSize += dwSize; 
		 
		return uiID; 
	} 
	///////////////////////////////////////////////////////////////// 
	ceResource *ceResourceManager::GetResource(RHANDLE Handle)  
	{ 
		PUSH_FUNCTION; 
 
		ceResource *pRes = NULL; 
		if (Handle == m_rhCurrent) { 
			ce_assert(NULL != m_pCurrent); 
			return m_pCurrent; 
		} 
			 
		// Search for resoure in map 
		m_It = m_ResourceMap.find(Handle); 
		if (m_It != m_ResourceMap.end())  
			CE_EXCEPTION("Cannot delete resource!", CELS_HARDERROR); 
		pRes = (*m_It).second; 
		 
		return pRes; 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::DelResource(RHANDLE Handle) 
	{ 
		PUSH_FUNCTION; 
 
		m_It = m_ResourceMap.find(Handle); 
		if (m_It != m_ResourceMap.end()) { 
			CE_EXCEPTION("Cannot delete ressource!", CELS_HARDERROR); 
		} 
		 
		m_ResourceMap.erase(m_It); 
	} 
	///////////////////////////////////////////////////////////////// 
	size_t ceResourceManager::GetNumResources() const 
	{ 
		PUSH_FUNCTION; 
 
		return m_ResourceMap.size(); 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::Lock(RHANDLE Handle) 
	{ 
		PUSH_FUNCTION; 
 
		ceResource *pRes = NULL; 
		pRes = GetResource(Handle); 
		ce_assert(NULL != pRes); 
		m_pLocked = pRes; 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::Lock(ceResource *pRes) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert(NULL != pRes); 
		m_pLocked = pRes; 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::Unlock(RHANDLE Handle) 
	{ 
		PUSH_FUNCTION; 
 
		ceResource *pRes = NULL; 
		m_It = m_ResourceMap.find(Handle); 
		if (m_It != m_ResourceMap.end()) 
			CE_EXCEPTION("Cannot delete resource!", CELS_HARDERROR); 
		 
		pRes = (*m_It).second; 
		m_pLocked = NULL; 
	} 
	///////////////////////////////////////////////////////////////// 
	void ceResourceManager::Unlock(ceResource *pRes) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert (NULL != pRes);		 
		m_pLocked = NULL; 
	} 
	///////////////////////////////////////////////////////////////// 
	DWORD ceResourceManager::GetSize() const 
	{ 
		PUSH_FUNCTION; 
 
		return m_dwSize; 
	} 
	//////////////////////////////////////////////////////////////////////////////// 
	UINT ceResourceManager::RegisterResType(const char *pResTypeName) 
	{ 
		PUSH_FUNCTION; 
		ce_assert (NULL != pResTypeName); 
		 
		// Enshure unique typeid 
		const UINT uiRes = FindResTypeByName(pResTypeName); 
		if (0 != uiRes) 
			return uiRes; 
 
		// Create a new typeid 
		char *pTemp = new char[strlen(pResTypeName)]; 
		ce_assert(NULL != pTemp); 
		m_vRegIDContainer.push_back(pTemp); 
		 
		// Register resource type in scratch system 
		if (NULL != m_pVFS) { 
			// unused : ceScratchSystem *pSystem = m_pVFS->GetScratchSystem(); 
//			pSystem-> 
		} 
 
		return (UINT) m_vRegIDContainer.size(); 
	} 
	//////////////////////////////////////////////////////////////////////////////// 
	bool ceResourceManager::UnregisterResType(const char *pResTypeName) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert (NULL != pResTypeName); 
		std::vector::iterator it; 
		UINT uiTypeID = FindResTypeByName(pResTypeName); 
		if (0 == uiTypeID) 
			return false; 
		m_vRegIDContainer[uiTypeID-1] = NULL; 
		 
		return true; 
	} 
	//////////////////////////////////////////////////////////////////////////////// 
	bool ceResourceManager::UnregisterResType(const UINT uiResTypeID) 
	{ 
		PUSH_FUNCTION; 
 
		// Enshure valid parameter 
		ce_assert(m_vRegIDContainer.size() >= uiResTypeID); 
		ce_assert(NULL != m_vRegIDContainer[uiResTypeID]); 
		 
		// Set assigned type id to NULL 
		if (NULL != m_vRegIDContainer[uiResTypeID-1]) { 
			m_vRegIDContainer[uiResTypeID-1] = NULL;	 
			return true; 
		} 
		return false; 
	} 
	//////////////////////////////////////////////////////////////////////////////// 
	UINT ceResourceManager::FindResTypeByName(const char *pResTypeName) 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert(NULL != pResTypeName); 
		std::vector::iterator it; 
		bool bFound= false; 
		UINT uiPos=0; 
		for (it = this->m_vRegIDContainer.begin(); it != this->m_vRegIDContainer.end(); it++) { 
			++uiPos; 
			if (0 == strncmp(*it, pResTypeName, strlen(pResTypeName))) { 
				bFound = true;			 
				break; 
			} 
		} 
		if (bFound) 
			return uiPos; 
 
		return 0; 
	} 
	//////////////////////////////////////////////////////////////////////////////// 
	bool ceResourceManager::Load(ceResource *pResource) 
	{ 
		ce_assert (NULL != pResource); 
		ceFile *pFile = pResource->GetFile(); 
		if (NULL == pFile) 
			return false; 
	 
		ceScratchSystem *pSystem = m_pVFS->GetScratchSystem(); 
		ceScratchFile *pScratch = pResource->GetScratchFile(); 
		size_t sSize = pScratch->GetFileSize(); 
		BYTE *pData = new BYTE[sSize]; 
		size_t sRead = pSystem->ReadScratchFile(pScratch , sSize, pData); 
		 
		// TODO Implement mesh serializer!!! 
		return (sRead == sSize); 
	} 
	//////////////////////////////////////////////////////////////////////////////// 
 
} // Namespace ZFXCE