pgesurface.cpp

使ppc屏幕变成黑白的程序

	int ix = 0, iy = 0;
	WORD wPos = 0;
	for (iy=pRect->top; iy<pRect->bottom; iy++)
	{
		isx = 0;
		for (ix=pRect->left; ix<pRect->right; ix++)
		{
			wPos = iy*m_SurfaceInfo.wWiedth + ix;
			if (m_pbtAlphaChanle[wPos] != 0)
				m_pbtAlphaChanle[wPos] = 
					pbtAlphaData[isy*iStep + isx];
			isx++;
		}
		isy++;
	}

	//pgeR(5, 重置Alpha通道标志) = 1;
}

void CPGESurface::RestoreAlphaChanle(RECT* pRect)
{
	// 大量的memcpy同样耗时！
	if (!m_bAlphaChanle) return;
	//if (pgeR(5, 重置Alpha通道标志) != 1) return;
	for (int iy=pRect->top; iy<pRect->bottom; iy++)
	{		
		memcpy(m_pbtAlphaChanle+iy*m_SurfaceInfo.wWiedth, 
			m_pbtAlphaChanleStatic+iy*m_SurfaceInfo.wWiedth, pRect->right);
	}
	//pgeR(5, 重置Alpha通道标志) = 0;

}

BYTE* CPGESurface::GetStaticAlphaChanle(WORD wKey)
{
	if (wKey == 0x7819 && m_bAlphaChanle)
	{
		return m_pbtAlphaChanleStatic;
	}
	return NULL;
}

PGE_RESULT CPGESurface::CreateAlphaWithMaskColor()
{
	if (m_btSurfaceBit < 16) return PGE_FAIL;
	if (m_bAlphaChanle != 0) return PGE_FAIL;
	m_bAlphaChanle = TRUE;
	m_pbtAlphaChanleStatic = new BYTE[m_dwDataSize];
	m_pbtAlphaChanle = new BYTE[m_dwDataSize];
	
	memset(m_pbtAlphaChanle, 0, m_dwDataSize);
	memset(m_pbtAlphaChanleStatic, 0, m_dwDataSize);

	for (int i=0; i<m_dwDataSize; i++)
	{
		if (m_pwMainData[i] != m_dwMaskColor)
		{
			m_pbtAlphaChanleStatic[i] = m_pbtAlphaChanle[i] = 32;
		}
	}

	return PGE_OK;
}

void CPGESurface::SetReplaceColor(WORD wColor)
{
	m_wRplaceColor = wColor;
}

WORD CPGESurface::GetReplaceColor()
{
	return m_wRplaceColor;
}

void CPGESurface::SetPiexl(int x, int y, WORD wColor)
{
	if (m_btSurfaceBit < 16) return;
	int iPos = y*m_SurfaceInfo.wWiedth+x;
	if (iPos < 0 || iPos > m_dwDataSize) return;
	//if(m_btSurfaceBit < 16)
	//{
	//	((BYTE*)m_pwMainData)[iPos] = wColor>>8;
	//	return;
	//}
	m_pwMainData[iPos] = wColor;
}

POINT ppt[500];
void CPGESurface::DrawLine(int x1, int y1, int x2, int y2, WORD wColor)
{
	register int t;
	int distance;
	int x=0,y=0,delta_x,delta_y,incx,incy;
	delta_x = x2-x1;
	delta_y = y2-y1;
	//根据x和y的变化量设置x和y的增长方式(每次加1还是减1或者是不变)
	if(delta_x>0) 
	{
		incx=1;
	}
	else if (delta_x==0) 
	{
		incx=0;
	}
	else 
	{
		delta_x=-delta_x; 
		incx=-1;
	}
	

	if (delta_y>0) 
	{
		incy=1;
	}
	else if (delta_y==0) 
	{	
		incy=0;
	}
	else 
	{
		delta_y=-delta_y; 
		incy=-1;
	}
	

	if(delta_x>delta_y)
	{
		distance=delta_x;
	}
	else
	{
		distance=delta_y;
	}

	//开始画线了	
	//一样的Bresenham算法
	//看看右边的图先

	//两个端点也要画
	for (t=0; t<distance+2; t++)
	{
		//画点
		ppt[t].x = x1;
		ppt[t].y = y1;
		SetPiexl(x1, y1, wColor);	 
		x+=delta_x;					   
		y+=delta_y;						
		if(x>distance)					 
		{								 
			x-=distance;				 
			x1+=incx;					
		}								
		if(y>distance)					
		{								
			y-=distance;				
			y1+=incy;					
		}								
	}
	int pp=0;
}													 

void CPGESurface::DrawRect(int x1, int y1, int x2, int y2, WORD wColor)
{
	DrawLine(x1, y1, x2, y1, wColor);
	DrawLine(x1, y1, x1, y2, wColor);
	DrawLine(x2, y1, x2, y2, wColor);
	DrawLine(x1, y2, x2, y2, wColor);
}


/////////////////////////////////////////////////////////////
/////////////Surface Globe Function//////////////////////////
void CreateSurfaceFromFile(CPGESurface** pSurface, char* caFileName, 
								 CPGEDevice* pDevice, DWORD wMaskColor)
{
	int iSize = strlen(caFileName) - 1;

	char caTmp = caFileName[iSize - 2];
	if (caTmp < 97) caTmp = caTmp + 32;

	if (caTmp == 'p')
	{
		FILE* pf = PGEFileOpen(caFileName, "rb");
		if (pf == NULL) 
		{
			return;
		}
		PGEPicBaseHead PicHead;
		fread(&PicHead, sizeof(PGEPicBaseHead), 1, pf);
		
		if (PicHead.dwHeadFlag != *((DWORD*)"PGEP"))
		{
			return;
		}
		DWORD dwpgpX = PicHead.wWidth;
		DWORD dwpgpY = PicHead.wHeight;
		BOOL bAlpha = PicHead.bBitCount & 0x80;
		BYTE btCount = PicHead.bBitCount & 0x7f;
		BOOL bCompress = PicHead.bCompess;
		
		WORD* pPal = NULL;
		if (PicHead.wPalPiexlCount)
		{
			pPal = new WORD[PicHead.wPalPiexlCount];
			fseek(pf, PicHead.dwPalOffset, SEEK_SET);
			fread(pPal, PicHead.dwPalSize, 1, pf);
		}

		DWORD dwSize = dwpgpX * dwpgpY;

		BYTE* pBmpData = NULL;
		if(bCompress)
			pBmpData = new BYTE[PicHead.dwDeComSize];
		else
			pBmpData = new BYTE[PicHead.dwDataSize];


		fseek(pf, PicHead.dwDataOffset, SEEK_SET);

		BYTE* btCpBuf = NULL;
		if(bCompress)
		{
			btCpBuf = new BYTE[PicHead.dwDataSize];
			fread(btCpBuf, PicHead.dwDataSize, 1, pf);
			decompress(btCpBuf, PicHead.dwDataSize, pBmpData);
			SAFE_DELETE_ARY(btCpBuf);
		}
		else
		{
			fread(pBmpData, PicHead.dwDataSize, 1, pf);
		}


		if ((* pSurface) == NULL)
		{
			(*pSurface) = new CPGESurface(pDevice);
		}
	
		if (btCount == 8)
		{
			(*pSurface)->SetPal(pPal, PicHead.wPalPiexlCount);
		}
		(*pSurface)->CreateSurface(dwpgpY, dwpgpX, PGE_PGP_SURFACE, wMaskColor);

		BYTE* pAlphaBuf = NULL;
		if (bAlpha)	// 带Alpha通道
		{
			if (bCompress)
			{
				BYTE* pAlphaRdBuf = new BYTE[PicHead.dwAlphaSize];
				pAlphaBuf = new BYTE[PicHead.dwAlphaDeComSize];
				fseek(pf, SEEK_SET, PicHead.dwAlphaOffset);
				fread(pAlphaRdBuf, PicHead.dwAlphaSize, 1, pf);
				int a = decompress(pAlphaRdBuf, PicHead.dwAlphaSize, pAlphaBuf);
				SAFE_DELETE_ARY(pAlphaRdBuf);

			}
			else
			{
				pAlphaBuf = new BYTE[PicHead.dwAlphaSize];
				fseek(pf, SEEK_SET, PicHead.dwAlphaOffset);
				fread(pAlphaBuf, PicHead.dwAlphaSize, 1, pf);
			}
		}
		fclose(pf);

		(*pSurface)->SetPgpSurface((WORD*)pBmpData, pAlphaBuf);

	}
	else if (caTmp == 'b')
	{
		FILE* pf = PGEFileOpen(caFileName, "rb");
		if (pf == NULL) 
		{
			return;
		}
		BITMAPFILEHEADER bm;
		fread(&bm, 1, sizeof(BITMAPFILEHEADER), pf);
		if (bm.bfType!=*(WORD*)"BM")
		{		//AfxMessageBox("非位图文件");
			fclose(pf);
			return;
		}
		BITMAPINFOHEADER bmif;
		fread(&bmif, 1, sizeof(BITMAPINFOHEADER), pf);
		int bmx = bmif.biWidth;
		int bmy = bmif.biHeight>0?bmif.biHeight:(-bmif.biHeight);


		if (bmif.biBitCount < 8 || bmif.biCompression != 0) 
		{
			fclose(pf);
			return;
		}

		RGBQUAD *pRgb = NULL;
		if (bmif.biBitCount == 8) // 256色bmp
		{
			pRgb = (RGBQUAD*) new BYTE[bmif.biClrUsed * sizeof(RGBQUAD)];
			fread(pRgb, bmif.biClrUsed * sizeof(RGBQUAD), 1, pf);
		}

		BOOL bAlpha = FALSE;
		if (bmif.biBitCount == 32)	bAlpha = TRUE;// 带Alpha通道

		DWORD dwRealWidth = (((bmx*bmif.biBitCount)+31)>>5)<<2;
		int iBitSteps = bmif.biBitCount>>3;
		DWORD iSize = dwRealWidth*bmy*iBitSteps;

		BYTE* pBmpData = new BYTE[iSize];

		fseek(pf, bm.bfOffBits, SEEK_SET);
		fread(pBmpData, 1, iSize, pf);
		fclose(pf);

		if ((* pSurface) == NULL)
		{
			//ASSERT(pDevice);
			(*pSurface) = new CPGESurface(pDevice);
		}

		(*pSurface)->CreateSurface(bmy, bmx, PGE_NOMARL_SURFACE, wMaskColor);
		if (bAlpha)	// 带Alpha通道
		{
			(*pSurface)->EnableAlphaChanle();
		}

		WORD* pBuff = NULL;
		BYTE* pbtBuff = (*pSurface)->GetAlphaChanle();
		BYTE* pbtBuff1 = (*pSurface)->GetStaticAlphaChanle(0x7819);

		(*pSurface)->Lock((void**)&pBuff);

		int iy,ix;
		BYTE btPil;
		WORD caTmp[3];
		DWORD dwDataOff = 0;
		for(iy=0; iy<bmy; iy++)
		{
			for (ix=0; ix<bmx; ix++)
			{		
				if (pRgb == NULL)
				{			
					caTmp[0] = pBmpData[(iy*(dwRealWidth)+(ix*iBitSteps)) + 2];
					caTmp[1] = pBmpData[(iy*(dwRealWidth)+(ix*iBitSteps)) + 1];
					caTmp[2] = pBmpData[(iy*(dwRealWidth)+(ix*iBitSteps))];
				}
				else
				{
					btPil = pBmpData[(iy*(dwRealWidth)+(ix*iBitSteps))];
					if (bmif.biClrUsed != 0)
					{
						caTmp[0] = pRgb[btPil].rgbRed;
						caTmp[1] = pRgb[btPil].rgbGreen;
						caTmp[2] = pRgb[btPil].rgbBlue;
					}
					else
					{
						caTmp[0] = caTmp[1] = caTmp[2] = btPil;
					}

				}

				if (bmif.biHeight<0)		// 有时bmp图像的高会是负值，这时则不用颠倒 
				{
					dwDataOff = iy*bmx + ix;
				}
				else
				{
					dwDataOff = (bmy-iy-1)*bmx + ix;
				}

				if (bAlpha)
				{
					DWORD dbf=pBmpData[(iy*(dwRealWidth)+(ix*iBitSteps)) + 3];
					pbtBuff1[dwDataOff] = pbtBuff[dwDataOff] = ((float)dbf/255.f)*31;
				}

				pBuff[dwDataOff] = RGBto16bit565(caTmp[0], caTmp[1], caTmp[2]);

			}
		}
		SAFE_DELETE_ARY(pBmpData);
		SAFE_DELETE_ARY(pRgb);
		(*pSurface)->unLock();

	}
	
}

_inline void MakeAlpha(WORD* wpSrc, WORD* wpDes, BYTE btAlpha)
{
	register DWORD d1;
	register DWORD wa = *wpSrc;
	register DWORD wb = *wpDes;
	register DWORD alpha = btAlpha;

	d1 = (((((((wa << 16) | wa) & 0x7e0f81f) - (((wb << 16) | wb) & 0x7e0f81f)) * alpha) >> 5) + (((wb << 16) | wb) & 0x7e0f81f)) & 0x7e0f81f;
	wa = (d1 & 0xffff0000)>>16;
	wb = d1 & 0xffff;
	*wpDes = wa | wb;
//	register BYTE bSrcR, bSrcG,bSrcB, bDisR, bDisG, bDisB;
//	bSrcR = (*wpSrc & 0xf800) >> 8;
//	bSrcG = (*wpSrc & 0x7e0) >> 3;
//	bSrcB = (*wpSrc & 0x1f) << 3; 
//	
//	bDisR = (*wpDes & 0xf800) >> 8;
//	bDisG = (*wpDes & 0x7e0) >> 3;
//	bDisB = (*wpDes & 0x1f) << 3; 
//
//#define apl(c1,c2) (c1*wAlpha+(255-wAlpha)*c2)>>8
//	*wpDes = RGBto16bit565(apl(bSrcR, bDisR), apl(bSrcG, bDisG), apl(bSrcB, bDisB));
}

__inline void MakeADD(WORD* wpSrc, WORD* wpDes)
{
	register DWORD tdest = 0;
	register DWORD t;

	t = (*wpSrc & 0xf800) + (*wpDes & 0xf800);
	if(t > 0xf800) t = 0xf800;
		tdest |= t;

	t = (*wpSrc & 0x7e0) + (*wpDes & 0x7e0);
	if(t > 0x7e0) t = 0x7e0;
		tdest |= t;

	t = (*wpSrc & 0x1f) + (*wpDes & 0x1f);
	if(t > 0x1f) t = 0x1f;
		tdest |= t;


	*wpDes = (WORD)tdest;
}


PGE_RESULT CreateAlphaFromFile(CPGESurface* pSurface, 
							   char* caFileName)
{
	if (pSurface->GetSurfaceInfo()->wSurfaceTp == PGE_PGP_SURFACE) return PGE_FAIL;
	FILE* pf = PGEFileOpen(caFileName, "rb");
	if (pf == NULL) 
	{
		return PGE_FAIL;
	}
	BITMAPFILEHEADER bm;
	fread(&bm, 1, sizeof(BITMAPFILEHEADER), pf);
	if (bm.bfType!=*(WORD*)"BM")
	{		//AfxMessageBox("非位图文件");
		fclose(pf);
		return 0;
	}
	BITMAPINFOHEADER bmif;
	fread(&bmif, 1, sizeof(BITMAPINFOHEADER), pf);
	int bmx = bmif.biWidth;
	int bmy = bmif.biHeight;

	if (bmif.biBitCount != 8) 
	{
		fclose(pf);
		return PGE_FAIL;
	}

	RGBQUAD *pRgb = NULL;
	if (bmif.biBitCount == 8) // 256色bmp
	{
		pRgb = (RGBQUAD*) new BYTE[bmif.biClrUsed * sizeof(RGBQUAD)];
		fread(pRgb, bmif.biClrUsed * sizeof(RGBQUAD), 1, pf);
	}


	DWORD dwRealWidth = (((bmx*bmif.biBitCount)+31)>>5)<<2;
	int iBitSteps = bmif.biBitCount>>3;
	int iSize = dwRealWidth*bmy*iBitSteps;

	BYTE* pBmpData = new BYTE[iSize];

	fseek(pf, bm.bfOffBits, SEEK_SET);
	fread(pBmpData, 1, iSize, pf);
	fclose(pf);

	pSurface->EnableAlphaChanle();
	BYTE* pbtAlpha = pSurface->GetAlphaChanle();
	BYTE* pbtBuff1 = pSurface->GetStaticAlphaChanle(0x7819);

	int iy,ix;
	BYTE btPil;
	WORD caTmp[3];
	for(iy=0; iy<bmy; iy++)
	{
		for (ix=0; ix<bmx; ix++)
		{
			btPil = pBmpData[(iy*(dwRealWidth)+(ix*iBitSteps))];
			//if (bmif.biClrUsed != 0)
			//{
			//	caTmp[0] = pRgb[btPil].rgbRed;
			//	caTmp[1] = pRgb[btPil].rgbGreen;
			//	caTmp[2] = pRgb[btPil].rgbBlue;
			//}
			//else
			{
				caTmp[0] = caTmp[1] = caTmp[2] = btPil;
			}

			BYTE ba = RGBto16bit565(caTmp[0], caTmp[1], caTmp[2]);
			if (ba != 0)
			{
				int sa = 0;
			}
			pbtBuff1[(bmy-iy-1)*bmx + ix] = pbtAlpha[(bmy-iy-1)*bmx + ix] = ((float)(255-ba)/255.f)*32;
		}

	}

	SAFE_DELETE_ARY(pBmpData);
	SAFE_DELETE_ARY(pRgb);
	return 0;

}