mapinfo.cpp

手机s60第三版动画编程相关

/*
 ============================================================================
 Name		: MapInfo.cpp
 Author	  : 
 Version	 : 1.0
 Copyright   : Your copyright notice
 Description : CMapInfo implementation
 ============================================================================
 */

#include "map/MapInfo.h"
#include "Common.h"

CMapInfo::CMapInfo(RFs& aFs, CSourceMapProvider& aSourceMapProvider) :
	iFs(aFs), iSourceMapProvider(aSourceMapProvider), iMapWidth(0), iMapHeight(0)
	{
	// No implementation required
	}

CMapInfo::~CMapInfo()
	{
	iUsedSourceMaps.Reset();
	iUsedSourceMaps.Close();

	iMapMatrix.ResetAndDestroy();
	iMapMatrix.Close();
	}

CMapInfo* CMapInfo::NewLC(RFs& aFs, CSourceMapProvider& aSourceMapProvider)
	{
	CMapInfo* self = new (ELeave)CMapInfo(aFs, aSourceMapProvider);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CMapInfo* CMapInfo::NewL(RFs& aFs, CSourceMapProvider& aSourceMapProvider)
	{
	CMapInfo* self = CMapInfo::NewLC(aFs, aSourceMapProvider);
	CleanupStack::Pop(); // self;
	return self;
	}

/**
 * 载入地图文件
 */
void CMapInfo::LoadMapL(const TInt aMapIndex)
	{
	// 构建要打开的文件名
	TFileName mapFile(KSourcePath);
	mapFile.AppendNum(aMapIndex);
	mapFile.Append(KMapExt);

	// 打开文件
	RFile file;
	CleanupClosePushL(file);
	User::LeaveIfError(file.Open(iFs, mapFile, EFileRead));

	CleanupStack::Pop(&file);

	// 读取内容
	TInt size;
	file.Size(size);
	HBufC8* fileContent = HBufC8::NewLC(size);
	TPtr8 ptr = fileContent->Des();

	User::LeaveIfError(file.Read(ptr));

	// 清空使用到的源图
	// 只清空数组不删除数据
	iUsedSourceMaps.Reset();

	// 开始解析
	TInt offset = 0;
	ParseMapSizeL(ptr, offset);
	ParseSourceMapL(ptr, offset);
	ParseMapPointItemsL(ptr, offset);

	CleanupStack::PopAndDestroy(fileContent);

	file.Close();

	}

/**
 * 解析地图大小
 */
void CMapInfo::ParseMapSizeL(const TDesC8& aDesC, TInt& aOffset)
	{
	TPckgBuf<TInt> pckgWidth;
	pckgWidth.Copy(aDesC.Mid(aOffset, sizeof(TInt)));
	iMapWidth = pckgWidth();

	aOffset += sizeof(TInt);

	TPckgBuf<TInt> pckgHeight;
	pckgHeight.Copy(aDesC.Mid(aOffset, sizeof(TInt)));
	iMapHeight = pckgHeight();

	aOffset += sizeof(TInt);
	}

/**
 * 解析需要使用到的源图
 */
void CMapInfo::ParseSourceMapL(const TDesC8& aDesC, TInt& aOffset)
	{
	TUint8 sourceMapsCount = aDesC[aOffset];
	aOffset += sizeof(TUint8);

	for (TUint8 n = 0; n < sourceMapsCount; n++)
		{
		// 获取源图索引
		TUint8 sourceMapIndex = aDesC[aOffset];

		// 获取源图信息
		const CSourceMapInfo& sourceMapInfo = iSourceMapProvider.GetMapInfoByIndex(sourceMapIndex);
		iUsedSourceMaps.AppendL(&sourceMapInfo);

		aOffset += sizeof(TUint8);
		}
	}

/**
 * 解析地图内容
 */
void CMapInfo::ParseMapPointItemsL(const TDesC8& aDesC, TInt& aOffset)
	{
	// 清空矩阵
	ClearMatrix();

	for (TInt n = 0; n < iMapHeight; n++)
		{
		for (TInt m = 0; m < iMapWidth; m++)
			{
			// 构建地图项
			CMapPointInfo* mapPointInfo = CMapPointInfo::NewLC();

			// 拆分地图项数据
			TPckgBuf<TUint64> pckgInfo;
			pckgInfo.Copy(aDesC.Mid(aOffset, sizeof(TUint64)));

			mapPointInfo->DeserializeFromValueL(pckgInfo());

			iMapMatrix.AppendL(mapPointInfo);

			CleanupStack::Pop(mapPointInfo);
			aOffset += sizeof(TUint64);
			}
		}
	}

/**
 * 绘制地图
 * @param aGc 设备上下文
 * @param aMapRect 地图矩阵
 * @param aMapOffsetX 地图左坐标偏移量
 * @param aMapOffsetY 地图顶坐标偏移量
 */
void CMapInfo::DrawMap(CBitmapContext& aGc, const TRect& aMapRect, const TInt aMapOffsetX, const TInt aMapOffsetY)
	{
	// 首先计算从哪一格开始画，结束到哪一格
	TInt leftIndex = -aMapOffsetX / KSourceMapItemWidth;
	TInt topIndex = -aMapOffsetY / KSourceMapItemHeight;
	
	if (leftIndex >= 0 && topIndex >= 0 )
		{
		TInt rightIndex = aMapRect.Width() / KSourceMapItemWidth + leftIndex + 1;
		TInt bottomIndex = aMapRect.Height() / KSourceMapItemHeight + topIndex + 1;

		if (rightIndex >= iMapWidth)
			{
			rightIndex = iMapWidth - 1;
			}
		
		if (bottomIndex >= iMapHeight)
			{
			bottomIndex = iMapHeight - 1;
			}
		
		// 设置绘制矩形
		aGc.SetClippingRect(aMapRect);

		TInt drawX = aMapRect.iTl.iX + aMapOffsetX;
		TInt drawY = aMapRect.iTl.iY + aMapOffsetY;

		for (int n = topIndex; n <= bottomIndex; n++)
			{
			for (int m = leftIndex; m <= rightIndex; m++)
				{
				// 获取矩阵信息项
				const CMapPointInfo& info = *iMapMatrix[n * iMapWidth + m];

				// 获取图层信息
				TInt layersCount = info.iLayerInfos.Count();
				for (int i = 0; i < layersCount; i++)
					{
					const TMapLayerInfo& layerInfo = info.iLayerInfos[i];

					// 地图索引大于0
					if (layerInfo.iSourceMapIndex > 0 && layerInfo.iMapItemIndex > 0)
						{
						// 获取对应的地图信息
						const CSourceMapInfo& srcMap = iSourceMapProvider.GetMapInfoByIndex(layerInfo.iSourceMapIndex - 1);

						TInt mapItemIndex = layerInfo.iMapItemIndex - 1;
						if (mapItemIndex < srcMap.GetMapItems().Count())
							{
							const TSourceMapItemInfo& srcMapItem = srcMap.GetMapItems()[mapItemIndex];
							const CFbsBitmap& mapImg = srcMap.GetMapImage();
							const CFbsBitmap& maskMapImg = srcMap.GetMaskMapImage();

							// 计算源图矩阵和绘制坐标
							TRect srcRect(srcMapItem.iStartX * KSourceMapItemWidth, srcMapItem.iStartY * KSourceMapItemHeight, (srcMapItem.iEndX + 1) * KSourceMapItemWidth, (srcMapItem.iEndY + 1)
									* KSourceMapItemHeight);
							
							TPoint destPoint(drawX + KSourceMapItemWidth - srcRect.Width(), drawY + KSourceMapItemWidth - srcRect.Height());

							aGc.BitBltMasked(destPoint, &mapImg, srcRect, &maskMapImg, EFalse);
							}
						}
					}

				drawX += KSourceMapItemWidth;
				}

			drawX = aMapRect.iTl.iX + aMapOffsetX;
			drawY += KSourceMapItemHeight;
			}

		aGc.CancelClippingRect();
		}
	}

/**
 * 清空矩阵
 */
void CMapInfo::ClearMatrix()
	{
	//	if (iMapWidth > 0 && iMapHeight > 0)
	//		{
	//		for (TInt n = 0; n < iMapHeight; n++)
	//			{
	//			delete []iMapMatrix[n];
	//			}
	//
	//		delete []iMapMatrix;
	//		}

	iMapMatrix.ResetAndDestroy();
	}

void CMapInfo::ConstructL()
	{

	}