resource.cpp

游戏框架

// ***************************************************************
//  Resource   version:  1.0
//  -------------------------------------------------------------
//	File Name:	Resource.cpp
//	Created:	2007/07/19
//	Modified:	2007/07/19   23:27
//	Author:		William.Liang
//  Msn:		[e-mail]
//  Email:		[e-mail], [e-mail]
//	Description:
//
//	Purpose:	
//  -------------------------------------------------------------
//  license:
//
//  The contents of this file are subject to the Mozilla Public
//  License Version 1.1 (the "License"); you may not use this file
//  except in compliance with the License. You may obtain a copy
//  of the License at http://www.mozilla.org/MPL/ Software dis-
//  tributed under the License is distributed on an "AS IS" 
//  basis, WITHOUT WARRANTY OF ANY KIND, either express or im-
//  plied. See the License for the specific language governing
//  rights and limitations under the License.
//
//  The Initial Developer of the Original Code is William.Liang .
//  Copyright (C) 2007 - All Rights Reserved.
// ***************************************************************
#include "StdAfx.h"
#include ".\Resource.h"

CResource::CResource(CResource* pResource){
	m_lpGDI		= pResource->GetGDI();
	m_hResource	= pResource->GetResourcePoint();
	m_szFileName= pResource->GetFileName();
	m_enType	= pResource->GetType();
	m_enFileType= pResource->GetFileType();
}

//************************************
// <p>Description: 构造函数</p>
// <p>Parameters:  </p>
// <p>    LPGDI lpGDI</p>
// <p>    _SIZE siSize</p>
//
// <p>Returns:   </p>
//************************************
CResource::CResource(LPGDI lpGDI, _SIZE siSize){
	m_lpGDI			= lpGDI;
	m_szFileName	= "";
	m_hResource		= m_lpGDI->Texture_Create((int)siSize.cx, (int)siSize.cy);

	m_enType		= Resource_Picture;
	m_enFileType	= Resource_UnKnown;
	m_wStatus		= 0;
}

//************************************
// <p>Description: 构造函数</p>
// <p>Parameters:  </p>
// <p>    _CString szFileName</p>
// <p>    LPGDI lpGDI</p>
//
// <p>Returns:   </p>
//************************************
CResource::CResource(_CString szFileName, LPGDI lpGDI, enResourceType ResourceType)
{
	m_lpGDI			= lpGDI;
	m_szFileName	= szFileName;

	m_wStatus		= 2;
	m_enType		= ResourceType;
	m_hResource		= NULL;

	// 除图像资源外，其它在第一次使用时才加载
	if(m_enType == Resource_Picture)
		ReLoad();
}

//************************************
// <p>Description: 析构函数</p>
//************************************
CResource::~CResource()
{
	Free();
}

//返回资源指针
LPRESOURCE CResource::GetResourcePoint(){
	return m_hResource;
}

//************************************
// <p>Description: 返回纹理</p>
// <p>Parameters:  </p>
//
// <p>Returns:   HTEXTURE __cdecl</p>
//************************************
HTEXTURE CResource::GetTexture(){
	if(GetType()==Resource_Picture)
		return (HTEXTURE)m_hResource;

	return NULL;
}

//返回效果
HEFFECT CResource::GetEffect(){
	if(GetType()==Resource_Effect)
		return (HEFFECT)m_hResource;

	return NULL;
}

//返回音乐
HMUSIC CResource::GetMusic(){
	if(GetType()==Resource_Music)
		return (HMUSIC)m_hResource;

	return NULL;
}

//返回流
HSTREAM CResource::GetStream(){
	if(GetType()==Resource_Stream)
		return (HSTREAM)m_hResource;

	return NULL;
}

//重新加载
BOOL CResource::ReLoad(){
	if(m_wStatus!=0){
		if(m_wStatus == 1)
			Free();

		switch(m_enType){
			case Resource_Picture:
				m_hResource = m_lpGDI->Texture_Load(m_szFileName);
				break;
			case Resource_Music:
				m_hResource = m_lpGDI->Music_Load(m_szFileName);
				break;
			case Resource_Stream:
				m_hResource = m_lpGDI->Stream_Load(m_szFileName);
				break;
			case Resource_Effect:
				m_hResource = m_lpGDI->Effect_Load(m_szFileName);
				break;
		}

		char* pError = m_lpGDI->System_GetErrorMessage();
		m_wStatus = m_hResource==NULL?0:1;

		return true;
	}

	return false;
}

//释放资源的内存占用
BOOL CResource::Free(){
	if(m_hResource){
		switch(m_enType){
			case Resource_Picture:
				m_lpGDI->Texture_Free(m_hResource);
				break;
			case Resource_Music:
				m_lpGDI->Music_Free(m_hResource);
				break;
			case Resource_Stream:
				m_lpGDI->Stream_Free(m_hResource);
				break;
			case Resource_Effect:
				m_lpGDI->Effect_Free(m_hResource);
				break;
		}
		
	}
	m_hResource	= NULL;

	return true;
}

//返回资源状态
WORD CResource::GetStatus(){
	return m_wStatus;
}

//************************************
// <p>Description: 返回纹理规格</p>
// <p>Parameters:  </p>
//
// <p>Returns:   _SIZE __cdecl</p>
//************************************
_SIZE CResource::GetSize(){
    _SIZE		Size;

	if(GetType()==Resource_Picture){
		Size.cx		= (float)m_lpGDI->Texture_GetWidth(m_hResource);
		Size.cy		= (float)m_lpGDI->Texture_GetHeight(m_hResource);
	}

	return Size;
}

//************************************
// <p>Description: 返回资源文件名</p>
// <p>Parameters:  </p>
//
// <p>Returns:   _CString __cdecl</p>
//************************************
_CString CResource::GetFileName()
{
	return m_szFileName;
}

//返回文件类型
enFileType CResource::GetFileType(){
	return m_enFileType;
}

//************************************
// <p>Description: 返回文件长度</p>
// <p>Parameters:  </p>
//
// <p>Returns:   DWORD __cdecl</p>
//************************************
DWORD CResource::GetFileLength()
{
	//读文件长度
	return 0;
}

//************************************
// <p>Description: 返回资源类型</p>
// <p>Parameters:  </p>
//
// <p>Returns:   enTextureType __cdecl</p>
//************************************
enResourceType CResource::GetType()
{
	return m_enType;
}
//************************************
// <p>Description: GetGDI	返回GDI指针</p>
// <p>Parameters:  </p>
//
// <p>Returns:   LPGDI</p>
//************************************
LPGDI CResource::GetGDI()
{
	return m_lpGDI;
}
//************************************
// <p>Description: 是否已知类型</p>
// <p>Parameters:  </p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool CResource::IsKnownFormat()
{
	return m_enType!=Resource_UnKnown && m_hResource;
}

//是否声音资源
bool CResource::IsSound(){
	return (m_enType==Resource_Music || m_enType==Resource_Stream || m_enType==Resource_Effect);
}

//是否图像资源
bool CResource::IsPicture(){
	return m_enType == Resource_Picture;
}

//************************************
// <p>Description: 内存写入</p>
// <p>Parameters:  </p>
// <p>    CResource* pResource</p>
// <p>    _RECT rcSource</p>
// <p>    _RECT rcDestion</p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool CResource::Bitblt(CResource* pResource, _RECT* pSource, _RECT* pTarget, DWORD dwFlag){

	bool	bReFlag = true;				// 成功与否标志
	WORD	wProcessFlag = dwFlag&0x1F;	// 反转、平铺处理标志
	WORD	wReplaceW, wReplaceH;		// 平铺次数
	_SIZE	siSrcSize, siTarSize;
	_RECT	rcSource, rcTarget;
	DWORD	dwSourceWidth, dwTargetWidth;

	wReplaceW = wReplaceH = 1;
	// 计算源区域的大小及是否需反转、平铺
	siSrcSize = pResource->GetSize();
	dwSourceWidth = (DWORD)siSrcSize.cx;
	if(pSource==NULL){
		// 默认为源区域大小
		rcSource.left = rcSource.top = 0;
		rcSource.right = siSrcSize.cx;
		rcSource.bottom = siSrcSize.cy;
	}
	else{
		// 判断源区域是否没有包含有效区域
		if(pSource->left<0 && pSource->right<0 || pSource->top<0 && pSource->bottom<0
			|| pSource->left>siSrcSize.cx && pSource->right>siSrcSize.cx
			|| pSource->top>siSrcSize.cy && pSource->bottom>siSrcSize.cy)
			return false;

		// 判断是否水平反转
		if(pSource->right<pSource->left){
			Exchange(pSource->left, pSource->right);
			wProcessFlag |= 32;
		}
		// 判断是否水平反转
		if(pSource->bottom<pSource->top){
			Exchange(pSource->top, pSource->bottom);
			wProcessFlag |= 64;
		}

		// 修正边界
		if(pSource->left<0) pSource->left = 0;
		if(pSource->top<0) pSource->top = 0;
		if(pSource->right>siSrcSize.cx) pSource->right = siSrcSize.cx;
		if(pSource->bottom>siSrcSize.cy) pSource->bottom = siSrcSize.cy;

		// 记录源区域大小
		siSrcSize.cx = pSource->right - pSource->left;
		siSrcSize.cy = pSource->bottom - pSource->top;
		rcSource = *pSource;
	}

	// 计算目标区域的大小及是否需反转、平铺
	siTarSize = GetSize();
	dwTargetWidth = (DWORD)siTarSize.cx;
	if(pTarget==NULL){
		// 默认为目标区域大小
		rcTarget.left = rcTarget.top = 0;
		rcTarget.right = siTarSize.cx;
		rcTarget.bottom = siTarSize.cy;
	}
	else{
		// 判断源区域是否没有包含有效区域
		if(pTarget->left<0 && pTarget->right<0 || pTarget->top<0 && pTarget->bottom<0
			|| pTarget->left>siTarSize.cx && pTarget->right>siTarSize.cx
			|| pTarget->top>siTarSize.cy && pTarget->bottom>siTarSize.cy)
			return false;

		// 判断是否水平反转
		if(pTarget->right<pTarget->left){
			Exchange(pTarget->left, pTarget->right);
			wProcessFlag |= 32;
		}
		// 判断是否水平反转
		if(pTarget->bottom<pTarget->top){
			Exchange(pTarget->top, pTarget->bottom);
			wProcessFlag |= 64;
		}

		// 修正边界
		if(pTarget->left<0) pTarget->left = 0;
		if(pTarget->top<0) pTarget->top = 0;
		if(pTarget->right>siTarSize.cx) pTarget->right = siTarSize.cx;
		if(pTarget->bottom>siTarSize.cy) pTarget->bottom = siTarSize.cy;

		// 记录源区域大小
		siTarSize.cx = pTarget->right - pTarget->left;
		siTarSize.cy = pTarget->bottom - pTarget->top;
		rcTarget = *pTarget;
	}

	// 裁剪源区域大小<=目标区域大小
	if(siSrcSize.cx>siTarSize.cx || siSrcSize.cy>siTarSize.cy){
		if(siSrcSize.cx>siTarSize.cx){
			siSrcSize.cx = siTarSize.cx;
		}
		if(siSrcSize.cy>siTarSize.cy){
			siSrcSize.cy = siTarSize.cy;
		}
	}

	// 设置标志
	wProcessFlag &= dwFlag;
	if(wProcessFlag&RBB_TILE){
		// 计算平铺次数
		wReplaceW = (WORD)(siTarSize.cx)/(WORD)siSrcSize.cx;
		wReplaceH = (WORD)(siTarSize.cy)/(WORD)siSrcSize.cy;
	}
	else{
		wReplaceW = wReplaceH = 1;
	}

	DWORD*	pTarMemory = m_lpGDI->Texture_Lock(m_hResource, false, (int)rcTarget.left, (int)rcTarget.top, (int)siTarSize.cx, (int)siTarSize.cy);
	//DWORD*	pDesMemory = m_lpGDI->Texture_Lock(m_hResource, false);
	if(pTarMemory){
		DWORD*	pSrcMemory = m_lpGDI->Texture_Lock(pResource->GetTexture(), true, (int)rcSource.left, (int)rcSource.top, (int)siSrcSize.cx, (int)siSrcSize.cy);
		//DWORD*	pSrcMemory = m_lpGDI->Texture_Lock(pResource->GetTexture());
		if(pSrcMemory){
			// 重复行数
			DWORD	*pCurrentTar, *pCurrentSrc;

			//pCurrentTar = pTarMemory;
			
			// 平铺行
			for(WORD wRow=0;wRow<=wReplaceH;wRow++){
				// 平铺列
				for(WORD wCol=0;wCol<=wReplaceW;wCol++){
					// 设置目标区域
					pCurrentTar = pTarMemory+((DWORD)siSrcSize.cy*wRow*dwTargetWidth+((DWORD)siSrcSize.cx*wCol));
					// 重置源区域从左上角开始
					pCurrentSrc = pSrcMemory;

					// 写像素行
					DWORD dwWidth = wCol<wReplaceW?(DWORD)siSrcSize.cx:((DWORD)siTarSize.cx%((DWORD)siSrcSize.cx))==0 || (wProcessFlag&RBB_TILE) == 0?0:((DWORD)siTarSize.cx%((DWORD)siSrcSize.cx));
					DWORD dwHeight = wRow<wReplaceH?(DWORD)siSrcSize.cy:((DWORD)siTarSize.cy%((DWORD)siSrcSize.cy))==0 || (wProcessFlag&RBB_TILE) == 0?0:((DWORD)siTarSize.cy%((DWORD)siSrcSize.cy));
					if(dwWidth>0 && dwHeight>0){
						CopyMemoryRect(pCurrentTar, pCurrentSrc, dwWidth, dwHeight, dwTargetWidth, dwSourceWidth, wProcessFlag);
					}
					else
						break;
					//CopyMemoryRect(pCurrentTar, pCurrentSrc, (DWORD)siSrcSize.cx, (DWORD)siSrcSize.cy, dwTargetWidth, dwSourceWidth, wProcessFlag);
					//DWORD	dwResidual = ((DWORD)siTarSize.cx%((DWORD)siSrcSize.cx));
					//if(dwResidual>0){
					//	// 设置目标区域
					//	pCurrentTar = pTarMemory+((DWORD)siSrcSize.cy*wRow*dwTargetWidth+((DWORD)siSrcSize.cx*wCol))+(DWORD)siSrcSize.cx;
					//	// 重置源区域从左上角开始
					//	pCurrentSrc = pSrcMemory;

					//	// 补剩余的列
					//	CopyMemoryRect(pCurrentTar, pCurrentSrc, dwResidual, (DWORD)siSrcSize.cy, dwTargetWidth, dwSourceWidth, wProcessFlag);
					//}
					//for(DWORD dwPixalRow=0;dwPixalRow<(DWORD)siSrcSize.cy;dwPixalRow++){
					//	//pCurrentTar += dwPixalRow*(DWORD)siTarSize.cx;
					//	//pCurrentSrc += dwPixalRow*(size_t)siSrcSize.cx;
					//	// 写像素列
					//	for(DWORD dwPixalCol=0;dwPixalCol<(DWORD)siSrcSize.cx;dwPixalCol++){
					//		*pCurrentTar++ = *pCurrentSrc++;
					//	}
					//	// 重置下一行头部
					//	pCurrentTar += (dwTargetWidth-(DWORD)siSrcSize.cx);
					//	pCurrentSrc += (dwSourceWidth-(DWORD)siSrcSize.cx);
					//}
				}
			}

			//DWORD	dwOffset1, dwOffset2;
			//for(DWORD i=0;i<(DWORD)siSize.cy;i++){
			//	dwOffset1 = i*(size_t)siDstSize.cx;
			//	dwOffset2 = i*(size_t)siSrcSize.cx;
			//	CopyMemory(pDesMemory+dwOffset1, pSrcMemory+dwOffset2, sizeof(DWORD)*(size_t)siSize.cx);
			//}
			m_lpGDI->Texture_Unlock(pResource->GetTexture());
		}
		else
			bReFlag = false;

		m_lpGDI->Texture_Unlock(m_hResource);
	}
	else
		bReFlag = false;

	return bReFlag;
}