able/vmware-svga
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
vmware-svga/examples/pong/main.c

715 lines
17 KiB
C
Raw Blame History

/*
* PongOS v2.0
*
* Micah Dowty <micah@vmware.com>
*
* Copyright (C) 2008-2009 VMware, Inc. Licensed under the MIT
* License, please see the README.txt. All rights reserved.
*/
#include "svga.h"
#include "intr.h"
#include "io.h"
#include "timer.h"
#include "keyboard.h"
#include "vmbackdoor.h"
#include "math.h"
#define PONG_DOT_SIZE 8
#define PONG_DIGIT_PIXEL_SIZE 10
#define PONG_BG_COLOR 0x000000
#define PONG_SPRITE_COLOR 0xFFFFFF
#define PONG_PLAYFIELD_COLOR 0xAAAAAA
#define PONG_FRAME_RATE 60
#define MODE_WIDTH 800
#define MODE_HEIGHT 600
#define MAX_DIRTY_RECTS 128
#define MAX_SPRITES 8
typedef struct {
float x, y;
} Vector2;
typedef struct {
int x, y, w, h;
} Rect;
typedef struct {
Rect r;
uint32 color;
} FillRect;
static struct {
uint32 *buffer;
Rect dirtyRects[MAX_DIRTY_RECTS];
uint32 numDirtyRects;
} back;
static struct {
FillRect paddles[2];
FillRect ball;
uint8 scores[2];
float ballSpeed;
float paddleVelocities[2];
float paddlePos[2];
Vector2 ballVelocity;
Vector2 ballPos;
Bool playfieldDirty;
} pong;
/*
*-----------------------------------------------------------------------------
*
* Random32 --
*
* "Random" number generator. To save code space, we actually just use
* the low bits of the TSC. This of course isn't actually random, but
* it's good enough for Pong.
*
*-----------------------------------------------------------------------------
*/
static uint32
Random32(void)
{
uint64 t;
__asm__ __volatile__("rdtsc" : "=A" (t));
return (uint32)t;
}
/*
*-----------------------------------------------------------------------------
*
* RectTestIntersection --
*
* Returns TRUE iff two Rects intersect with each other.
*
*-----------------------------------------------------------------------------
*/
static Bool
RectTestIntersection(Rect *a, // IN
Rect *b) // IN
{
return !(a->x + a->w < b->x ||
a->x > b->x + b->w ||
a->y + a->h < b->y ||
a->y > b->y + b->h);
}
/*
*-----------------------------------------------------------------------------
*
* BackFill --
*
* Perform a color fill on the backbuffer.
*
*-----------------------------------------------------------------------------
*/
static void
BackFill(FillRect fr) // IN
{
int i, j;
for (i = 0; i < fr.r.h; i++) {
uint32 *line = &back.buffer[(fr.r.y + i) * MODE_WIDTH + fr.r.x];
for (j = 0; j < fr.r.w; j++) {
line[j] = fr.color;
}
}
}
/*
*-----------------------------------------------------------------------------
*
* BackMarkDirty --
*
* Mark a region of the backbuffer as dirty. We'll copy it to the
* front buffer and ask the host to update it on the next
* BackUpdate().
*
*-----------------------------------------------------------------------------
*/
static void
BackMarkDirty(Rect rect) // IN
{
back.dirtyRects[back.numDirtyRects++] = rect;
}
/*
*-----------------------------------------------------------------------------
*
* BackUpdate --
*
* Copy all dirty regions of the backbuffer to the frontbuffer, and
* send updates to the SVGA device. Clears the dirtyRects list.
*
* For flow control, this also waits for the host to process the
* batch of updates we just queued into the FIFO.
*
*-----------------------------------------------------------------------------
*/
static void
BackUpdate() // IN
{
int rectNum;
for (rectNum = 0; rectNum < back.numDirtyRects; rectNum++) {
Rect rect = back.dirtyRects[rectNum];
uint32 i, j;
for (i = 0; i < rect.h; i++) {
uint32 offset = (rect.y + i) * MODE_WIDTH + rect.x;
uint32 *src = &back.buffer[offset];
uint32 *dest = &((uint32*) gSVGA.fbMem)[offset];
for (j = 0; j < rect.w; j++) {
dest[j] = src[j];
}
}
SVGA_Update(rect.x, rect.y, rect.w, rect.h);
}
back.numDirtyRects = 0;
SVGA_SyncToFence(SVGA_InsertFence());
}
/*
*-----------------------------------------------------------------------------
*
* PongDrawString --
*
* Draw a string of digits, using our silly blocky font. The
* string's origin is the top-middle.
*
*-----------------------------------------------------------------------------
*/
static void
PongDrawString(uint32 x, // IN
uint32 y, // IN
const char *str, // IN
uint32 strLen) // IN
{
const int charW = 4;
const int charH = 5;
static const uint8 font[] = {
0xF1, // **** ...*
0x91, // *..* ...*
0x91, // *..* ...*
0x91, // *..* ...*
0xF1, // **** ...*
0xFF, // **** ****
0x11, // ...* ...*
0xFF, // **** ****
0x81, // *... ...*
0xFF, // **** ****
0x9F, // *..* ****
0x98, // *..* *...
0xFF, // **** ****
0x11, // ...* ...*
0x1F, // ...* ****
0xFF, // **** ****
0x81, // *... ...*
0xF1, // **** ...*
0x91, // *..* ...*
0xF1, // **** ...*
0xFF, // **** ****
0x99, // *..* *..*
0xFF, // **** ****
0x91, // *..* ...*
0xF1, // **** ...*
};
x -= (PONG_DIGIT_PIXEL_SIZE * (strLen * (charW + 1) - 1)) / 2;
while (*str) {
int digit = *str - '0';
if (digit >= 0 && digit <= 9) {
int i, j;
for (j = 0; j < charH; j++) {
for (i = 0; i < charW; i++) {
if ((font[digit / 2 * 5 + j] << i) & (digit & 1 ? 0x08 : 0x80)) {
FillRect pixel = {
{x + i * PONG_DIGIT_PIXEL_SIZE,
y + j * PONG_DIGIT_PIXEL_SIZE,
PONG_DIGIT_PIXEL_SIZE,
PONG_DIGIT_PIXEL_SIZE},
PONG_PLAYFIELD_COLOR,
};
BackFill(pixel);
}
}
}
}
x += PONG_DIGIT_PIXEL_SIZE * (charW + 1);
str++;
}
}
/*
*-----------------------------------------------------------------------------
*
* DecDigit --
*
* Utility for extracting a decimal digit.
*
*-----------------------------------------------------------------------------
*/
static char
DecDigit(int i, int div, Bool blank)
{
if (blank && i < div) {
return ' ';
}
return (i / div) % 10 + '0';
}
/*
*-----------------------------------------------------------------------------
*
* PongDrawPlayfield --
*
* Redraw the playfield for Pong.
*
*-----------------------------------------------------------------------------
*/
static void
PongDrawPlayfield()
{
int i;
/*
* Clear the screen
*/
FillRect background = {
{0, 0, MODE_WIDTH, MODE_HEIGHT},
PONG_BG_COLOR,
};
BackFill(background);
/*
* Draw the dotted dividing line
*/
for (i = PONG_DOT_SIZE;
i <= MODE_HEIGHT - PONG_DOT_SIZE * 2;
i += PONG_DOT_SIZE * 2) {
FillRect dot = {
{(MODE_WIDTH - PONG_DOT_SIZE) / 2, i,
PONG_DOT_SIZE, PONG_DOT_SIZE},
PONG_PLAYFIELD_COLOR,
};
BackFill(dot);
}
/*
* Draw the score counters.
*
* sprintf() is big, so we'll format this the old-fashioned way.
* Right-justify the left score, and left-justify the right score.
*/
{
char scoreStr[7] = " ";
char *p = scoreStr;
*(p++) = DecDigit(pong.scores[0], 100, TRUE);
*(p++) = DecDigit(pong.scores[0], 10, TRUE);
*(p++) = DecDigit(pong.scores[0], 1, FALSE);
p++;
if (pong.scores[1] >= 100) {
*(p++) = DecDigit(pong.scores[1], 100, TRUE);
}
if (pong.scores[1] >= 10) {
*(p++) = DecDigit(pong.scores[1], 10, TRUE);
}
*(p++) = DecDigit(pong.scores[1], 1, FALSE);
PongDrawString(MODE_WIDTH/2, PONG_DIGIT_PIXEL_SIZE,
scoreStr, sizeof scoreStr);
}
}
/*
*-----------------------------------------------------------------------------
*
* PongDrawScreen --
*
* Top-level redraw function for Pong. This does a lot of unnecessary
* drawing to the backbuffer, but we're careful to only send update
* rectangles for a few things:
*
* - When the playfield changes, we update the entire screen.
* - Each sprite (the paddles and ball) gets two rectangles:
* - One for its new position
* - One for its old position
*
* None of these rectangles are ever merged.
*
*-----------------------------------------------------------------------------
*/
static void
PongDrawScreen()
{
PongDrawPlayfield();
if (pong.playfieldDirty) {
Rect r = {0, 0, MODE_WIDTH, MODE_HEIGHT};
BackMarkDirty(r);
pong.playfieldDirty = FALSE;
}
/* Draw all sprites at the current positions */
BackFill(pong.paddles[0]);
BackMarkDirty(pong.paddles[0].r);
BackFill(pong.paddles[1]);
BackMarkDirty(pong.paddles[1].r);
BackFill(pong.ball);
BackMarkDirty(pong.ball.r);
/* Commit this to the front buffer and the host's screen */
BackUpdate();
/* Make sure we erase all sprites at the current positions on the next frame */
BackMarkDirty(pong.paddles[0].r);
BackMarkDirty(pong.paddles[1].r);
BackMarkDirty(pong.ball.r);
}
/*
*-----------------------------------------------------------------------------
*
* PongLaunchBall --
*
* Reset the ball position, and give it a random angle.
*
*-----------------------------------------------------------------------------
*/
static void
PongLaunchBall()
{
/* sin() from 0 to PI/2 */
static const float sineTable[64] = {
0.000000, 0.024931, 0.049846, 0.074730, 0.099568, 0.124344, 0.149042, 0.173648,
0.198146, 0.222521, 0.246757, 0.270840, 0.294755, 0.318487, 0.342020, 0.365341,
0.388435, 0.411287, 0.433884, 0.456211, 0.478254, 0.500000, 0.521435, 0.542546,
0.563320, 0.583744, 0.603804, 0.623490, 0.642788, 0.661686, 0.680173, 0.698237,
0.715867, 0.733052, 0.749781, 0.766044, 0.781831, 0.797133, 0.811938, 0.826239,
0.840026, 0.853291, 0.866025, 0.878222, 0.889872, 0.900969, 0.911506, 0.921476,
0.930874, 0.939693, 0.947927, 0.955573, 0.962624, 0.969077, 0.974928, 0.980172,
0.984808, 0.988831, 0.992239, 0.995031, 0.997204, 0.998757, 0.999689, 1.000000,
};
int t;
float sinT, cosT;
pong.ballPos.x = MODE_WIDTH / 2;
pong.ballPos.y = MODE_HEIGHT / 2;
/* Limit the random angle to avoid those within 45 degrees of vertical */
t = 32 + (Random32() & 31);
sinT = sineTable[t];
cosT = -sineTable[(t + 32) & 63];
sinT *= pong.ballSpeed;
cosT *= pong.ballSpeed;
switch (Random32() & 3) {
case 0:
pong.ballVelocity.x = sinT;
pong.ballVelocity.y = cosT;
break;
case 1:
pong.ballVelocity.x = -sinT;
pong.ballVelocity.y = cosT;
break;
case 2:
pong.ballVelocity.x = -sinT;
pong.ballVelocity.y = -cosT;
break;
case 3:
pong.ballVelocity.x = sinT;
pong.ballVelocity.y = -cosT;
break;
}
}
/*
*-----------------------------------------------------------------------------
*
* PongInit --
*
* Initialize all game variables, including sprite location/size/color.
* Requires that SVGA has already been initialized.
*
*-----------------------------------------------------------------------------
*/
static void
PongInit()
{
pong.scores[0] = 0;
pong.scores[1] = 0;
pong.playfieldDirty = TRUE;
pong.paddlePos[0] = pong.paddlePos[1] = MODE_HEIGHT / 2;
pong.paddles[0].r.x = 10;
pong.paddles[0].r.w = 16;
pong.paddles[0].r.h = 64;
pong.paddles[0].color = PONG_SPRITE_COLOR;
pong.paddles[1].r.x = MODE_WIDTH - 16 - 10;
pong.paddles[1].r.w = 16;
pong.paddles[1].r.h = 64;
pong.paddles[1].color = PONG_SPRITE_COLOR;
pong.ball.r.w = 16;
pong.ball.r.h = 16;
pong.ball.color = PONG_SPRITE_COLOR;
pong.ballSpeed = 400;
PongLaunchBall();
}
/*
*-----------------------------------------------------------------------------
*
* PongUpdateMotion --
*
* Perform motion updates for the ball and paddles. This includes
* bounce/goal detection.
*
*-----------------------------------------------------------------------------
*/
static void
PongUpdateMotion(float dt) // IN
{
int playableWidth = MODE_WIDTH - pong.ball.r.w;
int playableHeight = MODE_HEIGHT - pong.ball.r.h;
int i;
pong.ballPos.x += pong.ballVelocity.x * dt;
pong.ballPos.y += pong.ballVelocity.y * dt;
for (i = 0; i < 2; i++) {
int pos = pong.paddlePos[i] + pong.paddleVelocities[i] * dt;
pong.paddlePos[i] = MIN(MODE_HEIGHT - pong.paddles[i].r.h, MAX(0, pos));
pong.paddles[i].r.y = (int)pong.paddlePos[i];
}
if (pong.ballPos.x >= playableWidth) {
/* Goal off the right edge */
pong.scores[0]++;
pong.playfieldDirty = TRUE;
PongLaunchBall();
}
if (pong.ballPos.x <= 0) {
/* Goal off the left edge */
pong.scores[1]++;
pong.playfieldDirty = TRUE;
PongLaunchBall();
}
if (pong.ballPos.y >= playableHeight) {
/* Bounce off the bottom edge */
pong.ballVelocity.y = -pong.ballVelocity.y;
pong.ballPos.y = playableHeight - (pong.ballPos.y - playableHeight);
}
if (pong.ballPos.y <= 0) {
/* Bounce off the top edge */
pong.ballVelocity.y = -pong.ballVelocity.y;
pong.ballPos.y = -pong.ballPos.y;
}
pong.ballPos.y = MIN(playableHeight, pong.ballPos.y);
pong.ballPos.y = MAX(0, pong.ballPos.y);
pong.ball.r.x = (int)pong.ballPos.x;
pong.ball.r.y = (int)pong.ballPos.y;
/*
* Lame collision detection between ball and paddles. Really we
* should be testing the ball's entire path over this time step,
* not just the ball's new position. Using the current
* implementation, it's possible for the ball to move through a
* paddle if it's going fast enough or our frame rate is slow
* enough.
*/
for (i = 0; i < 2; i++) {
/*
* Only bounce off the paddle when we're moving toward it, to
* prevent the ball from getting stuck inside the paddle
*/
if ((pong.paddles[i].r.x > MODE_WIDTH / 2) == (pong.ballVelocity.x > 0) &&
RectTestIntersection(&pong.ball.r, &pong.paddles[i].r)) {
/*
* Boing! The ball bounces back, plus it gets a little spin
* if the paddle itself was moving at the time.
*/
pong.ballVelocity.x = -pong.ballVelocity.x;
pong.ballVelocity.y += pong.paddleVelocities[i];
pong.ballVelocity.y = MIN(pong.ballVelocity.y, pong.ballSpeed * 2);
pong.ballVelocity.y = MAX(pong.ballVelocity.y, -pong.ballSpeed * 2);
}
}
}
/*
*-----------------------------------------------------------------------------
*
* PongKeyboardPlayer --
*
* A human player, using the up and down arrows on a keyboard.
*
*-----------------------------------------------------------------------------
*/
static void
PongKeyboardPlayer(int playerNum, // IN
float maxSpeed, // IN
float accel) // IN
{
float v = pong.paddleVelocities[playerNum];
Bool up = Keyboard_IsKeyPressed(KEY_UP);
Bool down = Keyboard_IsKeyPressed(KEY_DOWN);
if (up && !down) {
v -= accel;
} else if (down && !up) {
v += accel;
} else {
v = 0;
}
v = MIN(maxSpeed, MAX(-maxSpeed, v));
pong.paddleVelocities[playerNum] = v;
}
/*
*-----------------------------------------------------------------------------
*
* PongAbsMousePlayer --
*
* A human player, controlled with the Y axis of the absolute mouse.
*
*-----------------------------------------------------------------------------
*/
static void
PongAbsMousePlayer(int playerNum) // IN
{
int currentY = pong.paddles[playerNum].r.y;
int newY = currentY;
VMMousePacket p;
Bool mouseMoved = FALSE;
while (VMBackdoor_MouseGetPacket(&p)) {
newY = (p.y * MODE_HEIGHT / 0xFFFF) - pong.paddles[playerNum].r.h / 2;
newY = MAX(0, newY);
newY = MIN(MODE_HEIGHT - pong.paddles[playerNum].r.h, newY);
mouseMoved = TRUE;
}
if (newY != currentY && mouseMoved) {
pong.paddleVelocities[playerNum] = (newY - currentY) * (float)PONG_FRAME_RATE;
}
}
/*
*-----------------------------------------------------------------------------
*
* PongComputerPlayer --
*
* Simple computer player. Always moves its paddle toward the ball.
*
*-----------------------------------------------------------------------------
*/
static void
PongComputerPlayer(int playerNum, // IN
float maxSpeed) // IN
{
int paddleCenter = pong.paddles[playerNum].r.y + pong.paddles[playerNum].r.h / 2;
int ballCenter = pong.ball.r.y + pong.ball.r.h / 2;
int distance = ballCenter - paddleCenter;
pong.paddleVelocities[playerNum] = distance * maxSpeed * (1.0f / MODE_HEIGHT);
}
/*
*-----------------------------------------------------------------------------
*
* main --
*
* Initialization and main loop.
*
*-----------------------------------------------------------------------------
*/
void
main(void)
{
Intr_Init();
SVGA_Init();
SVGA_SetMode(MODE_WIDTH, MODE_HEIGHT, 32);
back.buffer = (uint32*) (gSVGA.fbMem + MODE_WIDTH * MODE_HEIGHT * sizeof(uint32));
Keyboard_Init();
VMBackdoor_MouseInit(TRUE);
PongInit();
Timer_InitPIT(PIT_HZ / PONG_FRAME_RATE);
Intr_SetMask(0, TRUE);
while (1) {
PongKeyboardPlayer(0, 1000, 50);
PongAbsMousePlayer(0);
PongComputerPlayer(1, 2000);
PongUpdateMotion(1.0 / PONG_FRAME_RATE);
PongDrawScreen();
Intr_Halt();
}
}
Reference in a new issue View git blame Copy permalink