gapiapp.cpp

Windows mobile程序开发的GAPI示例程序,可用于游戏编程的参考

}



void GameXSetPixel(
	WORD nX, 
	WORD nY, 
	DWORD color
	)
{
	DWORD byteIndex; 

    
	byteIndex = (DWORD)(nY * g_gxdp.cbyPitch) + (nX * g_gxdp.cbxPitch);

    if (g_gxdp.ffFormat & kfDirectInverted)
	{
		color = ~color;
	}

    switch (g_gxdp.cBPP)
    {
    case 1:
		// Mask off the appropriate 1 bits, then or it in from the color.
		g_pMainBuffer[byteIndex] &= ~(0x80 >> ((nX & 0x07)));
		g_pMainBuffer[byteIndex] |= ((color & 0x01) << 8) >> ((nX & 0x07));    
    	break;
    
    case 2:
   		// Mask off the appropriate g_gxdp.cBPP (2) bits, then or it in from the color.
    	g_pMainBuffer[byteIndex] &= ~(0xC0 >> ((nX & 0x03) * g_gxdp.cBPP));
    	g_pMainBuffer[byteIndex] |= ((color & 0x03) << 6) >> ((nX & 0x03) * g_gxdp.cBPP);
    	break;
    
    case 4:
    	// If the nX is even the top g_gxdp.cBPP (4) bits need to be set.
        g_pMainBuffer[byteIndex] &= 0x0F << ((nX & 0x01) * g_gxdp.cBPP);
        g_pMainBuffer[byteIndex] |= (color & 0x0F) << ((!(nX & 0x01)) * g_gxdp.cBPP);
    	break;
        
    case 8:
    	g_pMainBuffer[byteIndex] = (BYTE)color & 0xFF;
    	break;

	case 16:
	   	*(WORD*)(&g_pMainBuffer[byteIndex]) = (WORD)color & 0xFFFF;
		break;
        
	case 32:
    	*(DWORD*)(&g_pMainBuffer[byteIndex]) = color;
		break;        
    }
	
}

//
// 0 clears the screen to black.
// any other value clears the screen to a random value.
//

BOOL ClearScreen()
{
	BYTE color = 0;
    if (g_gxdp.ffFormat & kfDirectInverted)
	{
		color = ~color;
	}
	for (WORD x=0; x<g_gxdp.cxWidth; x++)
        for (WORD y=0; y<g_gxdp.cyHeight; y++)
        {
            GameXSetPixel(x, y, color);
        }
	return FALSE;
}

void DrawRect()
{
	WORD x,y;
    INT iScreenWidth = 0;
    INT iScreenHeight = 0;

	DWORD l_dwRed,l_dwGreen, l_dwBlue;

	if (g_gxdp.ffFormat & kfDirect565)
	{
		l_dwRed = COLOR_RED_565;
		l_dwGreen = COLOR_GREEN_565;
		l_dwBlue = COLOR_BLUE_565;
	}
	else if (g_gxdp.ffFormat & kfDirect555)
	{
		l_dwRed = COLOR_RED_555;
		l_dwGreen = COLOR_GREEN_555;
		l_dwBlue = COLOR_BLUE_555;
	}
	else if (g_gxdp.ffFormat & kfDirect444)
	{
		l_dwRed = COLOR_RED_444;
		l_dwGreen = COLOR_GREEN_444;
		l_dwBlue = COLOR_BLUE_444;
	}
	else if (g_gxdp.ffFormat & kfDirect888)
	{
		l_dwRed = COLOR_RED_888;
		l_dwGreen = COLOR_GREEN_888;
		l_dwBlue = COLOR_BLUE_888;
	}
	else if (g_gxdp.ffFormat & kfPalette)
	{
		l_dwRed = COLOR_RED_PALETTE;
		l_dwGreen = COLOR_GREEN_PALETTE;
		l_dwBlue = COLOR_BLUE_PALETTE;
	}
	else if (g_gxdp.cBPP == 4)
	{
		l_dwRed = COLOR_RED_4BPP;
		l_dwGreen = COLOR_GREEN_4BPP;
		l_dwBlue = COLOR_BLUE_4BPP;
	}
	else if (g_gxdp.cBPP == 2)
	{
		l_dwRed = COLOR_RED_2BPP;
		l_dwGreen = COLOR_GREEN_2BPP;
		l_dwBlue = COLOR_BLUE_2BPP;
	}
	else
	{
		DebugBreak();
	}
	

	iScreenWidth = GetSystemMetrics(SM_CXSCREEN);
	iScreenHeight = GetSystemMetrics(SM_CYSCREEN);
	
    if (g_bOrientation == PORTRAIT)
    {
        for(x=iScreenWidth/2-70; x<iScreenWidth/2-30;x++)
		{
            for(y=iScreenHeight/2 - 50; y<iScreenHeight/2 - 10; y++)
            {
                GameXSetPixel(x,y,l_dwRed);
            }
		}

        for(x=iScreenWidth/2-20; x<iScreenWidth/2+20;x++)
		{
            for(y=iScreenHeight/2 - 50; y<iScreenHeight/2 - 10; y++)
            {
                GameXSetPixel(x,y,l_dwGreen);
            }
		}

        for(x=iScreenWidth/2+30; x<iScreenWidth/2+70;x++)
		{
            for(y=iScreenHeight/2 - 50; y<iScreenHeight/2 - 10; y++)
            {
                GameXSetPixel(x,y,l_dwBlue);
            }
		}
    }
    else
    {
        for(x=iScreenWidth/2-20; x<iScreenWidth/2+20; x++)
		{
            for(y=iScreenHeight/2 - 10; y<iScreenHeight/2 + 30; y++)
            {
                GameXSetPixel(x,y,l_dwRed);
            }
		}

        for(x=iScreenWidth/2-20; x<iScreenWidth/2+20; x++)
		{
            for(y=iScreenHeight/2 - 60; y<iScreenHeight/2 - 20; y++)
            {
                GameXSetPixel(x,y,l_dwGreen);
            }
		}

        for(x=iScreenWidth/2-20; x<iScreenWidth/2+20; x++)
		{
            for(y=iScreenHeight/2 - 110; y<iScreenHeight/2 - 70; y++)
            {
                GameXSetPixel(x,y,l_dwBlue);
            }
		}
    }

	for(x=0; x<g_gxdp.cxWidth; x++)
	{
		GameXSetPixel(x,0,COLOR_WHITE);
		GameXSetPixel(x,(WORD)g_gxdp.cyHeight-1,COLOR_WHITE);
	}

	for(y=0; y<g_gxdp.cyHeight; y++)
	{
		GameXSetPixel(0,y,COLOR_WHITE);
		GameXSetPixel((WORD)g_gxdp.cxWidth-1, y,COLOR_WHITE);
	}
}

void FillLocations(
	BOOL in_bOrientation 
	)
{
	int iScreenWidth = GetSystemMetrics(SM_CXSCREEN);
	int iScreenHeight = GetSystemMetrics(SM_CYSCREEN);
	
	if (in_bOrientation == PORTRAIT)
	{
		long l_wXMax = iScreenWidth;
		long l_wXMin = 0;

		long l_wYMax = iScreenHeight;
		long l_wYMin = 0;

		// UP
		if (g_gxkl.ptUp.x > l_wXMax)
		{
			l_wXMax = g_gxkl.ptUp.x;
		}

		if (g_gxkl.ptUp.x < l_wXMin)
		{
			l_wXMin = g_gxkl.ptUp.x;
		}

		if (g_gxkl.ptUp.y > l_wYMax)
		{
			l_wYMax = g_gxkl.ptUp.y;
		}

		if (g_gxkl.ptUp.y < l_wYMin)
		{
			l_wYMin = g_gxkl.ptUp.y;
		}

		// DOWN
		if (g_gxkl.ptDown.x > l_wXMax)
		{
			l_wXMax = g_gxkl.ptDown.x;
		}

		if (g_gxkl.ptDown.x < l_wXMin)
		{
			l_wXMin = g_gxkl.ptDown.x;
		}

		if (g_gxkl.ptDown.y > l_wYMax)
		{
			l_wYMax = g_gxkl.ptDown.y;
		}

		if (g_gxkl.ptDown.y < l_wYMin)
		{
			l_wYMin = g_gxkl.ptDown.y;
		}

		// Left
		if (g_gxkl.ptLeft.x > l_wXMax)
		{
			l_wXMax = g_gxkl.ptLeft.x;
		}

		if (g_gxkl.ptLeft.x < l_wXMin)
		{
			l_wXMin = g_gxkl.ptLeft.x;
		}

		if (g_gxkl.ptLeft.y > l_wYMax)
		{
			l_wYMax = g_gxkl.ptLeft.y;
		}

		if (g_gxkl.ptLeft.y < l_wYMin)
		{
			l_wYMin = g_gxkl.ptLeft.y;
		}

		// Right
		if (g_gxkl.ptRight.x > l_wXMax)
		{
			l_wXMax = g_gxkl.ptRight.x;
		}

		if (g_gxkl.ptRight.x < l_wXMin)
		{
			l_wXMin = g_gxkl.ptRight.x;
		}

		if (g_gxkl.ptRight.y > l_wYMax)
		{
			l_wYMax = g_gxkl.ptRight.y;
		}

		if (g_gxkl.ptRight.y < l_wYMin)
		{
			l_wYMin = g_gxkl.ptRight.y;
		}

		// A
		if (g_gxkl.ptA.x > l_wXMax)
		{
			l_wXMax = g_gxkl.ptA.x;
		}

		if (g_gxkl.ptA.x < l_wXMin)
		{
			l_wXMin = g_gxkl.ptA.x;
		}

		if (g_gxkl.ptA.y > l_wYMax)
		{
			l_wYMax = g_gxkl.ptA.y;
		}

		if (g_gxkl.ptA.y < l_wYMin)
		{
			l_wYMin = g_gxkl.ptA.y;
		}

		// B
		if (g_gxkl.ptB.x > l_wXMax)
		{
			l_wXMax = g_gxkl.ptB.x;
		}

		if (g_gxkl.ptB.x < l_wXMin)
		{
			l_wXMin = g_gxkl.ptB.x;
		}

		if (g_gxkl.ptB.y > l_wYMax)
		{
			l_wYMax = g_gxkl.ptB.y;
		}

		if (g_gxkl.ptB.y < l_wYMin)
		{
			l_wYMin = g_gxkl.ptB.y;
		}

		// C
		if (g_gxkl.ptC.x > l_wXMax)
		{
			l_wXMax = g_gxkl.ptC.x;
		}

		if (g_gxkl.ptC.x < l_wXMin)
		{
			l_wXMin = g_gxkl.ptC.x;
		}

		if (g_gxkl.ptC.y > l_wYMax)
		{
			l_wYMax = g_gxkl.ptC.y;
		}

		if (g_gxkl.ptC.y < l_wYMin)
		{
			l_wYMin = g_gxkl.ptC.y;
		}

		// Start
		if (g_gxkl.ptStart.x > l_wXMax)
		{
			l_wXMax = g_gxkl.ptStart.x;
		}

		if (g_gxkl.ptStart.x < l_wXMin)
		{
			l_wXMin = g_gxkl.ptStart.x;
		}

		if (g_gxkl.ptStart.y > l_wYMax)
		{
			l_wYMax = g_gxkl.ptStart.y;
		}

		if (g_gxkl.ptStart.y < l_wYMin)
		{
			l_wYMin = g_gxkl.ptStart.y;
		}

		// Now we have the MIN and MAX in both X and Y
		// Calculate the ratio

 		float l_fXRatio = (float)g_gxdp.cxWidth / (l_wXMax - l_wXMin +20);
		if (l_fXRatio > 1)
		{
			l_fXRatio = 1;
			l_wXMin = 0;
		}
		float l_fYRatio = (float)g_gxdp.cyHeight / (l_wYMax  - l_wYMin +20);

		g_wKeyLoc[UP][X][in_bOrientation] = (long)((float)(g_gxkl.ptUp.x - l_wXMin)* l_fXRatio)-5;
		g_wKeyLoc[UP][Y][in_bOrientation] = (long)((float)(g_gxkl.ptUp.y - l_wYMin) * l_fYRatio);

		g_wKeyLoc[DOWN][X][in_bOrientation] = (long)((float)(g_gxkl.ptDown.x  - l_wXMin) * l_fXRatio)-5;
		g_wKeyLoc[DOWN][Y][in_bOrientation] = (long)((float)(g_gxkl.ptDown.y  - l_wYMin) * l_fYRatio);

		g_wKeyLoc[LEFT][X][in_bOrientation] = (long)((float)(g_gxkl.ptLeft.x  - l_wXMin) * l_fXRatio)-5;
		g_wKeyLoc[LEFT][Y][in_bOrientation] = (long)((float)(g_gxkl.ptLeft.y  - l_wYMin) * l_fYRatio);

		g_wKeyLoc[RIGHT][X][in_bOrientation] = (long)((float)(g_gxkl.ptRight.x  - l_wXMin) * l_fXRatio)-5;
		g_wKeyLoc[RIGHT][Y][in_bOrientation] = (long)((float)(g_gxkl.ptRight.y  - l_wYMin) * l_fYRatio);

		g_wKeyLoc[A][X][in_bOrientation] = (long)((float)(g_gxkl.ptA.x  - l_wXMin) * l_fXRatio)-5;
		g_wKeyLoc[A][Y][in_bOrientation] = (long)((float)(g_gxkl.ptA.y  - l_wYMin) * l_fYRatio);

		g_wKeyLoc[B][X][in_bOrientation] = (long)((float)(g_gxkl.ptB.x  - l_wXMin) * l_fXRatio)-5;
		g_wKeyLoc[B][Y][in_bOrientation] = (long)((float)(g_gxkl.ptB.y  - l_wYMin) * l_fYRatio);

		g_wKeyLoc[C][X][in_bOrientation] = (long)((float)(g_gxkl.ptC.x  - l_wXMin) * l_fXRatio)-5;
		g_wKeyLoc[C][Y][in_bOrientation] = (long)((float)(g_gxkl.ptC.y  - l_wYMin) * l_fYRatio);

		g_wKeyLoc[START][X][in_bOrientation] = (long)((float)(g_gxkl.ptStart.x  - l_wXMin) * l_fXRatio)-5;
		g_wKeyLoc[START][Y][in_bOrientation] = (long)((float)(g_gxkl.ptStart.y  - l_wYMin) * l_fYRatio);


        // if the direction buttons are too close together on the screen, fix this
        if (g_wKeyLoc[UP][Y][in_bOrientation] > g_wKeyLoc[START][Y][in_bOrientation] - LETTER_HEIGHT - 2)
        {
            g_wKeyLoc[UP][Y][in_bOrientation] = g_wKeyLoc[START][Y][in_bOrientation] - LETTER_HEIGHT - 2;
        }
        if (g_wKeyLoc[DOWN][Y][in_bOrientation] < g_wKeyLoc[START][Y][in_bOrientation] + LETTER_HEIGHT + 2)
        {
            g_wKeyLoc[DOWN][Y][in_bOrientation] = g_wKeyLoc[START][Y][in_bOrientation] + LETTER_HEIGHT + 2;
        }
        if (g_wKeyLoc[LEFT][X][in_bOrientation] > g_wKeyLoc[START][X][in_bOrientation] - LETTER_HEIGHT - 2)
        {
            g_wKeyLoc[LEFT][X][in_bOrientation] = g_wKeyLoc[START][X][in_bOrientation] - LETTER_HEIGHT - 2;
        }
        if (g_wKeyLoc[RIGHT][X][in_bOrientation] < g_wKeyLoc[START][X][in_bOrientation] + LETTER_HEIGHT + 2)
        {
            g_wKeyLoc[RIGHT][X][in_bOrientation] = g_wKeyLoc[START][X][in_bOrientation] + LETTER_HEIGHT + 2;
        }
		
	}
	else // Invert the buttons location since GAPI is not reporting Landscape Position
	{
		g_wKeyLoc[UP][X][in_bOrientation] = g_wKeyLoc[LEFT][X][!in_bOrientation];
		g_wKeyLoc[UP][Y][in_bOrientation] = g_wKeyLoc[LEFT][Y][!in_bOrientation];

		g_wKeyLoc[DOWN][X][in_bOrientation] = g_wKeyLoc[RIGHT][X][!in_bOrientation];
		g_wKeyLoc[DOWN][Y][in_bOrientation] = g_wKeyLoc[RIGHT][Y][!in_bOrientation];

		g_wKeyLoc[LEFT][X][in_bOrientation] = g_wKeyLoc[DOWN][X][!in_bOrientation];
		g_wKeyLoc[LEFT][Y][in_bOrientation] = g_wKeyLoc[DOWN][Y][!in_bOrientation];

		g_wKeyLoc[RIGHT][X][in_bOrientation] = g_wKeyLoc[UP][X][!in_bOrientation];
		g_wKeyLoc[RIGHT][Y][in_bOrientation] = g_wKeyLoc[UP][Y][!in_bOrientation];

		g_wKeyLoc[A][X][in_bOrientation] = g_wKeyLoc[A][X][!in_bOrientation];
		g_wKeyLoc[A][Y][in_bOrientation] = g_wKeyLoc[A][Y][!in_bOrientation];

		g_wKeyLoc[B][X][in_bOrientation] = g_wKeyLoc[B][X][!in_bOrientation];
		g_wKeyLoc[B][Y][in_bOrientation] = g_wKeyLoc[B][Y][!in_bOrientation];

		g_wKeyLoc[C][X][in_bOrientation] = g_wKeyLoc[C][X][!in_bOrientation];
		g_wKeyLoc[C][Y][in_bOrientation] = g_wKeyLoc[C][Y][!in_bOrientation];

		g_wKeyLoc[START][X][in_bOrientation] = g_wKeyLoc[START][X][!in_bOrientation];
		g_wKeyLoc[START][Y][in_bOrientation] = g_wKeyLoc[START][Y][!in_bOrientation];

	}

}

void DrawButtons(BOOL in_bOrientation)
{
	for (BYTE l_bButton = 0; l_bButton<MAX_BUTTONS; l_bButton++)
	{
		DrawBitmap((DWORD*)g_dwBitmaps[l_bButton], LETTER_WIDTH,
			LETTER_HEIGHT, g_wKeyLoc[l_bButton][X][in_bOrientation],
			g_wKeyLoc[l_bButton][Y][in_bOrientation], !g_bKeyInverted[l_bButton]);
	}
}

void DrawBitmap(
	DWORD* in_dwBits, 
	WORD in_wWidth, 
	WORD in_wHeight, 
	long in_lx, 
	long in_ly, 
	BOOL in_bInverted
	)
{
	if (in_lx < 2) in_lx = 2;
	if (in_lx > (WORD)g_gxdp.cxWidth - 12) in_lx = g_gxdp.cxWidth - 12;
	if (in_ly < 2) in_ly = 2;
	if (in_ly > (WORD)g_gxdp.cyHeight - 12) in_ly = g_gxdp.cyHeight - 12;

	for(WORD l_wX = 0; l_wX<in_wWidth; l_wX++)
	{
		for(WORD l_wY = 0; l_wY<in_wHeight; l_wY++)
		{
			if (in_bInverted)
			{
				if (g_bOrientation == PORTRAIT)
				{
					GameXSetPixel(in_lx+l_wX, in_ly+l_wY, ~in_dwBits[l_wY*in_wWidth+l_wX]);
				}
				else
				{
					GameXSetPixel(in_lx+l_wY, in_ly + in_wWidth - l_wX, ~in_dwBits[l_wY*in_wWidth+l_wX]);
				}
			}
			else
			{
				if (g_bOrientation == PORTRAIT)
				{
					GameXSetPixel(in_lx+l_wX, in_ly+l_wY, in_dwBits[l_wY*in_wWidth+l_wX]);
				}
				else
				{
					GameXSetPixel(in_lx+l_wY, in_ly + in_wWidth - l_wX, in_dwBits[l_wY*in_wWidth+l_wX]);
				}
			}
		}
	}

}

void ChangeDisplayMode(
	BOOL in_bLandscape
	)
{
    INT iScreenWidth = GetSystemMetrics(SM_CXSCREEN);
	INT iScreenHeight = GetSystemMetrics(SM_CYSCREEN);

	if (in_bLandscape)
	{
		if (FALSE == g_bFullScreen)
		{
			GXSetViewport(iScreenHeight/2 - 115, 150, 0, 0);

			RECT sRegion;
			sRegion.left = 0;
			sRegion.right = iScreenWidth;
			sRegion.top = iScreenHeight/2 - 55;
			sRegion.bottom = iScreenHeight/2 - 5;
			InvalidateRect(hWnd, &sRegion, TRUE);
		}
		g_gxkl = GXGetDefaultKeys(GX_LANDSCAPEKEYS);
	}
	else
	{
		if (FALSE == g_bFullScreen)
		{
		    GXSetViewport(iScreenHeight/2-55, 50, 0, 0);

			RECT sRegion;
			sRegion.left = 0;
			sRegion.right = iScreenWidth;
			sRegion.top = iScreenHeight/2 - 115;
			sRegion.bottom = iScreenHeight/2 + 35;
			InvalidateRect(hWnd, &sRegion, TRUE);
		}
		g_gxkl = GXGetDefaultKeys(GX_NORMALKEYS);
	}
	g_bOrientation = in_bLandscape;
}