pgesurface.cpp

使ppc屏幕变成黑白的程序

	DWORD dwScale;

#define PosRotScl	\
	y = (rDis.top + (iy-rSrc.top)) - (rDis.top + ((rSrc.bottom - rSrc.top)>>1));	\
	x = rDis.left - rSrc.left + ix - (rDis.left + ((rSrc.right - rSrc.left)>>1));	\
	dwScale = pSrcSurface->GetScaleOffset();	\
	iRot = pSrcSurface->GetRot();	\
	if (dwScale == 16384)	\
	{	\
		nx = ((x*farCos[iRot])>>10) + ((y*farSin[iRot])>>10)	\
			+(rDis.left+((rSrc.right - rSrc.left)>>1));	\
		ny = ((y*farCos[iRot])>>10) - ((x*farSin[iRot])>>10)	\
			+(rDis.top+((rSrc.bottom - rSrc.top)>>1));	\
	}	\
	else	\
	{	\
		nx = ((((x*farCos[iRot])>>10)*(long)dwScale)>>14) + ((y*farSin[iRot])>>10)	\
			+(rDis.left+((rSrc.right - rSrc.left)>>1));	\
		ny = ((((y*farCos[iRot])>>10)*(long)dwScale)>>14) - ((x*farSin[iRot])>>10)	\
			+(rDis.top+((rSrc.bottom - rSrc.top)>>1));	\
	}	\
	if (nx < 0) continue;	\
	nx = nx > m_SurfaceInfo.wWiedth ? m_SurfaceInfo.wWiedth : nx;	\
	ny = ny > m_SurfaceInfo.wHeigh ? m_SurfaceInfo.wHeigh : ny;	\
	dwDisPos = ny*m_SurfaceInfo.wWiedth+nx;	\
	if (dwDisPos >= m_dwDataSize) continue;	\

#define RotSclFi \
	if (dwDisPos < m_dwDataSize-m_SurfaceInfo.wWiedth && dwDisPos > m_SurfaceInfo.wWiedth) \
	{ \
		*(pwDis + dwDisPos+1) = *(pwDis + dwDisPos); \
		*(pwDis + dwDisPos-1) = *(pwDis + dwDisPos); \
		*(pwDis + dwDisPos+m_SurfaceInfo.wWiedth) = *(pwDis + dwDisPos); \
		*(pwDis + dwDisPos+m_SurfaceInfo.wWiedth + 1) = *(pwDis + dwDisPos); \
		*(pwDis + dwDisPos+m_SurfaceInfo.wWiedth - 1) = *(pwDis + dwDisPos); \
		*(pwDis + dwDisPos-m_SurfaceInfo.wWiedth) = *(pwDis + dwDisPos); \
		*(pwDis + dwDisPos-m_SurfaceInfo.wWiedth + 1) = *(pwDis + dwDisPos); \
		*(pwDis + dwDisPos-m_SurfaceInfo.wWiedth - 1) = *(pwDis + dwDisPos); \
	} \
	

	if (wDrawFlag == PGE_BLT_ALPHA)	// 如果使用alpha
	{
		pSrcSurface->Lock((void**)&pwSrc);	// 锁定源表面

		BYTE* pbtSrcAlpha = pSrcSurface->GetAlphaChanle();
		BYTE btSrcAlphaVal = pSrcSurface->GetAlphaVal();
		if (bMask) dwSrcMask = pSrcSurface->GetMaskColor();

		DWORD dwSrcCol = rSrc.top * pSrcInfo->wWiedth;
		DWORD dwDisCol = rDis.top * m_SurfaceInfo.wWiedth;
		BYTE btAlphaVal;
		for(iy=rSrc.top; iy<rSrc.bottom; iy++)
		{
			if (iy-rSrc.top > wDisHeight) break;	// 如果超出目的矩形的下边缘，则裁剪掉
			idx = rDis.left;
			for(ix=rSrc.left; ix<rSrc.right; ix++)
			{
				if(ix-rSrc.left > wDisWide) break;	// 如果超出目的矩形的右边缘，则裁剪掉
				dwSrcPos = dwSrcCol + ix;	// 源地址偏移
				if(pwSrc[dwSrcPos] == dwSrcMask) continue; // 去掉遮罩颜色

				if (!bRotScl)
				{
					dwDisPos = dwDisCol + idx;	// 目的地址偏移
					if (pbtSrcAlpha == NULL)
					{
						MakeAlpha(pwSrc + dwSrcPos, 
							pwDis + dwDisPos, 
							btSrcAlphaVal);	
					}
					else
					{
						if (pbtSrcAlpha[dwSrcPos] == 31)
						{
							*(pwDis + dwDisPos) = *(pwSrc + dwSrcPos);
						}
						else if (pbtSrcAlpha[dwSrcPos] != 0)
						{
							MakeAlpha(pwSrc + dwSrcPos, 
								pwDis + dwDisPos, 
								pbtSrcAlpha[dwSrcPos]);	
						}
						//*(pwDis + dwDisPos)=*(pwSrc + dwSrcPos);
					}
				}
				else
				{
					PosRotScl;
					if (pbtSrcAlpha == NULL)
					{
						MakeAlpha(pwSrc + dwSrcPos, 
							pwDis + dwDisPos, 
							btSrcAlphaVal);	
					}
					else
					{
						if (pbtSrcAlpha[dwSrcPos] == 31)
						{
							if (bAndAlpha == PGE_BLT_ANDALPHA)
								MakeAlpha(pwSrc + dwSrcPos, 
								pwDis + dwDisPos, 
								m_pbtAlphaChanle[dwDisPos]);
							else
							*(pwDis + dwDisPos) = *(pwSrc + dwSrcPos);
						}
						else if (pbtSrcAlpha[dwSrcPos] != 0)
						{
							MakeAlpha(pwSrc + dwSrcPos, 
							pwDis + dwDisPos,
							pbtSrcAlpha[dwSrcPos]);
						}
						//*(pwDis + dwDisPos)=*(pwSrc + dwSrcPos);
					}
					RotSclFi;
				}

				idx++;
			}

		//	idy++;
			dwSrcCol += pSrcInfo->wWiedth; //行
			dwDisCol += m_SurfaceInfo.wWiedth;
		}
		pSrcSurface->unLock();
	}
	else if (wDrawFlag == PGE_BLT_NORMAL)
	{
		BYTE* pbtSrcAlpha = pSrcSurface->GetAlphaChanle();
		pSrcSurface->Lock((void**)&pwSrc);	// 锁定源表面

		if (!(bMask || bRotScl))
		{
			WORD wSize = wDisWide > (rSrc.right - rSrc.left) ? wSrcWide : wDisWide; 
			if (rDis.left + wDisWide > m_SurfaceInfo.wWiedth) wSize -= (rDis.left + wDisWide - m_SurfaceInfo.wWiedth);
			DWORD dwDisBuf = 0;
			DWORD dwSrcBuf = rSrc.top * pSrcInfo->wWiedth;
			for(iy=rSrc.top; iy<rSrc.bottom; iy++)
			{
				if (iy-rSrc.top > wDisHeight) break;	// 如果超出目的矩形的下边缘，则裁剪掉
				dwDisPos = dwDisBuf + rDis.left;
				dwSrcPos = dwSrcBuf + rSrc.left;
				memcpy(pwDis + dwDisPos, pwSrc + dwSrcPos, wSize<<1);
				
				if (bAndAlpha == PGE_CLT_COPYALPHA)
						memcpy(m_pbtAlphaChanle + dwDisPos, pbtSrcAlpha + dwSrcPos, wSize);

				dwDisBuf += m_SurfaceInfo.wWiedth;
				dwSrcBuf += pSrcInfo->wWiedth;
			}
		}
		else
		{
			dwSrcMask = pSrcSurface->GetMaskColor();
			for(iy=rSrc.top; iy<rSrc.bottom; iy++)
			{
				if (iy-rSrc.top > wDisHeight) break;	// 如果超出目的矩形的下边缘，则裁剪掉
				idx = rDis.left;
				for(ix=rSrc.left; ix<rSrc.right; ix++)
				{
					if(ix-rSrc.left > wDisWide) break;	// 如果超出目的矩形的右边缘，则裁剪掉
					dwSrcPos = iy * pSrcInfo->wWiedth + ix;	// 源地址偏移

					if (!bRotScl)
					{
						dwDisPos = idy * m_SurfaceInfo.wWiedth + idx;	// 目的地址偏移
						if (dwSrcMask != pwSrc[dwSrcPos])
						{
							*(pwDis + dwDisPos)=*(pwSrc + dwSrcPos);
						}
					}
					else
					{
						PosRotScl;
						if (dwSrcMask != pwSrc[dwSrcPos])
						{
							*(pwDis + dwDisPos)=*(pwSrc + dwSrcPos);
						}
						RotSclFi;
					}


					idx++;
				}
				idy++;
			}
			pSrcSurface->unLock();
		}
	}
	else if (wDrawFlag == PGE_BLT_ADD)
	{
		pSrcSurface->Lock((void**)&pwSrc);	// 锁定源表面

		if (bMask) dwSrcMask = pSrcSurface->GetMaskColor();

		for(iy=rSrc.top; iy<rSrc.bottom; iy++)
		{
			if (iy-rSrc.top > wDisHeight) break;	// 如果超出目的矩形的下边缘，则裁剪掉
			idx = rDis.left;
			for(ix=rSrc.left; ix<rSrc.right; ix++)
			{
				if(ix-rSrc.left > wDisWide) break;	// 如果超出目的矩形的右边缘，则裁剪掉
				dwSrcPos = iy * pSrcInfo->wWiedth + ix;	// 源地址偏移

				if (!bRotScl)
				{
					dwDisPos = idy * m_SurfaceInfo.wWiedth + idx;	// 目的地址偏移
					if (pwSrc[dwSrcPos] != dwSrcMask)
					{
						MakeADD(pwSrc + dwSrcPos, pwDis + dwDisPos);	
					}
				}
				else
				{
					PosRotScl;
					if (pwSrc[dwSrcPos] != dwSrcMask)
					{
						MakeADD(pwSrc + dwSrcPos, pwDis + dwDisPos);	
					}
					RotSclFi;
				}
				idx++;
			}
			idy++;
		}
		pSrcSurface->unLock();
	}
	else if (wDrawFlag == PGE_BLT_AND)
	{
		pSrcSurface->Lock((void**)&pwSrc);	// 锁定源表面

		if (bMask) dwSrcMask = pSrcSurface->GetMaskColor();

		for(iy=rSrc.top; iy<rSrc.bottom; iy++)
		{
			if (iy-rSrc.top > wDisHeight) break;	// 如果超出目的矩形的下边缘，则裁剪掉
			idx = rDis.left;
			for(ix=rSrc.left; ix<rSrc.right; ix++)
			{
				if(ix-rSrc.left > wDisWide) break;	// 如果超出目的矩形的右边缘，则裁剪掉
				dwSrcPos = iy * pSrcInfo->wWiedth + ix;	// 源地址偏移

				if (!bRotScl)
				{
					dwDisPos = idy * m_SurfaceInfo.wWiedth + idx;	// 目的地址偏移
					if (pwSrc[dwSrcPos] != dwSrcMask)
					{
						*(pwDis + dwDisPos) &= *(pwSrc + dwSrcPos);	
					}
				}
				else
				{
					PosRotScl;
					if (pwSrc[dwSrcPos] != dwSrcMask)
					{
						*(pwDis + dwDisPos) &= *(pwSrc + dwSrcPos);	
					}
					RotSclFi;
				}

				idx++;
			}
			idy++;
		}
		pSrcSurface->unLock();

	}
	else if (wDrawFlag == PGE_BLT_OR)
	{
		pSrcSurface->Lock((void**)&pwSrc);	// 锁定源表面

		if (bMask) dwSrcMask = pSrcSurface->GetMaskColor();

		for(iy=rSrc.top; iy<rSrc.bottom; iy++)
		{
			if (iy-rSrc.top > wDisHeight) break;	// 如果超出目的矩形的下边缘，则裁剪掉
			idx = rDis.left;
			for(ix=rSrc.left; ix<rSrc.right; ix++)
			{
				if(ix-rSrc.left > wDisWide) break;	// 如果超出目的矩形的右边缘，则裁剪掉
				dwSrcPos = iy * pSrcInfo->wWiedth + ix;	// 源地址偏移

				if (!bRotScl)
				{
					dwDisPos = idy * m_SurfaceInfo.wWiedth + idx;	// 目的地址偏移
					if (pwSrc[dwSrcPos] != dwSrcMask)
					{
						*(pwDis + dwDisPos) |= *(pwSrc + dwSrcPos);	
					}
				}
				else
				{
					PosRotScl;
					if (pwSrc[dwSrcPos] != dwSrcMask)
					{
						*(pwDis + dwDisPos) |= *(pwSrc + dwSrcPos);	
					}
					RotSclFi;
				}


				idx++;
			}
			idy++;
		}
		pSrcSurface->unLock();
	}
	
}

void CPGESurface::Flip()
{	
	// 有时间的话记得验证只更新变化后区域
	//if (m_SurfaceInfo.wSurfaceTp == PGE_MAIN_SURFACE)
	{				
		WORD*pBuff = m_pDevice->BeginDraw();
		memcpy(pBuff, m_pwMainData, (m_dwDataSize<<1));
		m_pDevice->EndDraw();			
	}

}

void CPGESurface::FlipH()
{
	
	//if (m_SurfaceInfo.wSurfaceTp == PGE_MAIN_SURFACE)
	{	
		WORD ix, iy;
		WORD*pBuff = m_pDevice->BeginDraw();
		DWORD dwDisOffset = 0;
		DWORD dwSrcOffset = 0;
		WORD* wpSrc = 0;
		for(ix=0; ix<m_SurfaceInfo.wHeigh; ix++)
		{
			dwDisOffset = 0;
			wpSrc = m_pwMainData+dwSrcOffset;
			for (iy=0; iy<m_SurfaceInfo.wWiedth; iy++)
			{
				*(pBuff + dwDisOffset + ix) = *(wpSrc+m_SurfaceInfo.wWiedth-1-iy);
				dwDisOffset += m_SurfaceInfo.wHeigh;
			}
			dwSrcOffset += m_SurfaceInfo.wWiedth;
		}
		m_pDevice->EndDraw();				
	}

}

PGESurfaceInfo* CPGESurface::GetSurfaceInfo()
{
	return &m_SurfaceInfo;
}


void CPGESurface::SetAlphaVal(BYTE btAlpha)
{
	m_btAlpha = btAlpha;
}

BYTE CPGESurface::GetAlphaVal()
{
	return m_btAlpha;
}

PGE_RESULT CPGESurface::SetSurfaceInfo(PGESurfaceInfo SurfaceInfo, CPGEBase* pPGEBase)
{
	if (pPGEBase == NULL) return PGE_FAIL;
	if (pPGEBase->m_dwClassID != PGE_DEVICE)
	{
		return PGE_FAIL;
	}
	m_SurfaceInfo = SurfaceInfo;
	return PGE_OK;
}

void CPGESurface::DrawText(char* pText, int x, int y, WORD wColor)
{
	if (m_btSurfaceBit < 16) return;
	BYTE* pwFontModel = NULL;
	register int iCharPos = 0, iMuBuf = 0;
	int ix = 0, iy = 0;
	DWORD wBuf, wBuf1;
	for(int i=0; i<strlen(pText); i++)
	{
		if ((BYTE)pText[i] > 0x80)
		{
			pwFontModel = m_pFont->GetText(pText+i);
			i += 1;
			iCharPos += 2;
		}
		else
		{	
			if ((BYTE)pText[i] == '\r' && (BYTE)pText[i+1] == '\n')
			{
				i += 1;
				y += m_btFontH;
				iCharPos = 0;
				continue;
			}
			pwFontModel = m_pFont->GetText(pText+i);
			iCharPos++;
			if ((BYTE)pText[i + 1] > 0x80) iCharPos++;
			
		}
		
		
		for(iy=0; iy<16; iy++)
		{
			for (ix=0; ix<16; ix++)
			{
				if (pwFontModel[(iy<<4)+ix] != 0)
				{
					wBuf = x+ix+iMuBuf;
					if (wBuf > m_SurfaceInfo.wWiedth) continue;
					wBuf1 = (iy+y)*m_SurfaceInfo.wWiedth+wBuf;
					if (wBuf1 >= m_dwDataSize) return;
					m_pwMainData[wBuf1] = wColor;
				}
			}
		}
		iMuBuf = iCharPos*m_btFontW;

	}	
	
}

PGE_RESULT CPGESurface::CreateFont(void* pData, WORD iUseType)
{
	if (iUseType == PGE_FONT_USEMAIN)
	{
		if (m_SurfaceInfo.wSurfaceTp == PGE_MAIN_SURFACE) return PGE_FAIL;
		CPGESurface* pSurf = (CPGESurface*)m_pDevice->GetMainSurface();
		m_pFont = pSurf->GetFont(this);
	}
	else if (iUseType == PGE_FONT_USESURFACE)
	{
		CPGESurface* pSurf = (CPGESurface*)pData;
		m_pFont = pSurf->GetFont(this);	
	}
	else if (iUseType == PGE_FONT_USEFILE)
	{
		char* caFileName = (char*)pData;
		m_pFont = new CPGEFont();
		m_pFont->CreateFont(caFileName);
	}
	if (m_pFont) 
	{
		m_btFontH = m_pFont->GetFontInfo()->btFontSize;
		m_btFontW = m_btFontH / 1.85f;
		return PGE_OK;
	}
	else
	{
		return PGE_FAIL;
	}
}

void CPGESurface::SetPal(WORD* pwPal, int iPalPiexlCount)
{
	m_btSurfaceBit = 8;
//	if (!m_pwPal)
//		m_pwPal = new WORD[iPalPiexlCount];
//	memcpy(m_pwPal, pwPal, iPalPiexlCount*2);
	m_pwPal = pwPal;
}

CPGEFont* CPGESurface::GetFont(CPGEBase* pPGEBase)
{
	if (NULL == pPGEBase) return NULL;
	if (pPGEBase->m_dwClassID != PGE_SURFACE) return NULL;
	return m_pFont;
}
BYTE* CPGESurface::GetAlphaChanle()
{
	if (m_bAlphaChanle) return m_pbtAlphaChanle;
	return NULL;
}

PGE_RESULT CPGESurface::EnableAlphaChanle()
{
	m_bAlphaChanle = TRUE;
	if (PGE_PGP_SURFACE == m_SurfaceInfo.wSurfaceTp)
	{
		if (!m_pbtAlphaChanleStatic)
		{
			m_pbtAlphaChanleStatic = new BYTE[m_dwDataSize];
			if (m_pbtAlphaChanle)
				memcpy(m_pbtAlphaChanleStatic, m_pbtAlphaChanle, m_dwDataSize);

		}
		return PGE_OK;
	}

	if (!m_pbtAlphaChanle) 
	{
		m_pbtAlphaChanle = new BYTE[m_dwDataSize];
	}

	if (!m_pbtAlphaChanleStatic)
	{
		m_pbtAlphaChanleStatic = new BYTE[m_dwDataSize];
	}
	return PGE_OK;
}

void CPGESurface::SetPgpSurface(WORD* pwPicData, BYTE* pbtAlpha)
{
	if (PGE_PGP_SURFACE != m_SurfaceInfo.wSurfaceTp) return;
	m_pwMainData = pwPicData;
	if (pbtAlpha)
	{
		m_bAlphaChanle = 1;
		m_pbtAlphaChanle = pbtAlpha;
		if (m_pbtAlphaChanleStatic)	// 如果PGP面想使用静态alpha通道，必须EnableAlphaChanle
			memcpy(m_pbtAlphaChanleStatic, pbtAlpha, m_dwDataSize);
	}
}
void CPGESurface::SetAlphaChanle(RECT* pRect, BYTE* pbtAlphaData)
{
	if (!m_bAlphaChanle) return;
	if (!pbtAlphaData) return;
	int isx = 0;
	int isy = 0;
	int iStep = pRect->right - pRect->left;