The latest version of my sample clone!

Here’s the last part of my multi-part series on programming your very own pong clone in c and opengl!  It’s been a long time coming, so I hope you enjoy.  There’s lots of improvements in this version including a completely custom old-style “LED Alarm Clock” scoreboard, flashes on bounce, funky changing colors, improved collision detection, and a round ball!

Here’s the code!

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include <OpenAL/al.h>
#include <GLUT/glut.h>

#define PADDLE_MOVE_SPEED 350
#define CLEAR_COLOR_DECAY 2.0
#define BALL_RADIUS 10
#define BALL_FACETS 60
#define START_SPEED 200

int lastFrameTime = 0, windowWidth = 0, windowHeight = 0, now = 0;
float midWidth = 0, midHeight = 0;
float elapsedTime = 0, elapsedMilliSeconds = 0;
char player1Move = 0, player2Move = 0;
float player1V = 0, player2V = 0;

float PI = 3.14159265358979323846264;

//scores
int player1Score = 0, player2Score = 0;

//the following variables calculate a random starting projectile trajectory
float randomDirection;
long longMax = 0x7fffffff;	//max of longs 2^31-1 (2^(n-1)-1 for 2's complement) float trajectory[2] = {0, 0};

float projMove[2] = {0, 0};
double trajectory[2] = {0, 0};
short moveSpeed = START_SPEED;

//glitz and glamour
float player1ColorDirection[3];
float player2ColorDirection[3];
float player1Color[3];
float player2Color[3];
float colorMoveSpeed = 2.0;
double vectorLength1 = 0;
double vectorLength2 = 0;

float ballColorDirection[3];
float ballColor[3];
double ballVectorLength = 0;

//background explosion color
float clearColor[3];

int i = 0;

//scoreboard
char player1Num1[7] = {1, 1, 1, 0, 1, 1, 1};	//digital display set to zero, (each segment is enabled or disabled)
char player1Num2[7] = {1, 1, 1, 0, 1, 1, 1};
char player2Num1[7] = {1, 1, 1, 0, 1, 1, 1};	//digital display set to zero, (each segment is enabled or disabled)
char player2Num2[7] = {1, 1, 1, 0, 1, 1, 1};

//digit representations
char digit0[7] = {1, 1, 1, 0, 1, 1, 1};
char digit1[7] = {0, 0, 1, 0, 0, 0, 1};
char digit2[7] = {0, 1, 1, 1, 1, 1, 0};
char digit3[7] = {0, 1, 1, 1, 0, 1, 1};
char digit4[7] = {1, 0, 1, 1, 0, 0, 1};
char digit5[7] = {1, 1, 0, 1, 0, 1, 1};
char digit6[7] = {1, 1, 0, 1, 1, 1, 1};
char digit7[7] = {0, 1, 1, 0, 0, 0, 1};
char digit8[7] = {1, 1, 1, 1, 1, 1, 1};
char digit9[7] = {1, 1, 1, 1, 0, 1, 1};

void setSpaceEffect(void) {
for (i=0; i < 3; i++) {
player1ColorDirection[i] = (float) random() / (float) 0x7fffffff; //random vector
player2ColorDirection[i] = (float) random() / (float) 0x7fffffff;
ballColorDirection[i] = (float) random() / (float) 0x7fffffff;
}
//figure out vector lenngth
for (i=0; i < 3; i++) {
vectorLength1 += player1ColorDirection[i] * player1ColorDirection[i];
vectorLength2 += player2ColorDirection[i] * player2ColorDirection[i];
ballVectorLength += ballColorDirection[i] * ballColorDirection[i];
}
sqrt(vectorLength1);
sqrt(vectorLength2);
sqrt(ballVectorLength);
//normalize vector
for (i=0; i < 3; i++) {
player1ColorDirection[i] /= vectorLength1;
player2ColorDirection[i] /= vectorLength2;
ballColorDirection[i] /= ballVectorLength;
}
}

void calculateColor(float color[3], float colorDirection[3]) {
//caculate the next color based on the direction and elapsed time values
for (i=0; i < 3; i++) {
color[i] += colorDirection[i] * colorMoveSpeed * elapsedTime;
if (color[i] > 1) {
color[i] = 1;
colorDirection[i] *= -1;
}
else if (color[i] < 0) {
color[i] = 0;
colorDirection[i] *= -1;
}
}
}

void calculateClearColor(float color[3]) {
for (i=0; i < 3; i++) {
color[i] -= CLEAR_COLOR_DECAY * elapsedTime;
if(color[i] < 0)
color[i] = 0;
}
}

void setClearColor(float color[3]) {
for (i=0; i < 3; i++) {
color[i] = 1.0;
}
}

void resetProjectile(void) {
//set starting random trajectory
randomDirection = 2 * PI * (float) random() / (float) 0x7fffffff;
trajectory[0] = (float) cos(randomDirection);
trajectory[1] = (float) sin(randomDirection);
projMove[0] = midWidth;
projMove[1] = midHeight;
}

/*draw a digital (a la clock style) digit some place specified by x and y
*the enabled array is which segments of the display are enabled (counted starting from top left in a snake/8 fasion)
*
* 1 -
* 0| |2
* 3 -
* 4| |6
* 5 -
*/
void drawDigit(char enabled[7], float x, float y) {
glPushMatrix();
glTranslatef(x, y, 0);	//position digit to be drawn
//draw digital number (a la digital clock) segment by segment
glColor3f(1.0, 1.0, 1.0);
//draw segment 5
if(enabled[5]) {
glBegin(GL_QUADS);
glVertex2f(0,0);
glVertex2f(10,0);
glVertex2f(10,2);
glVertex2f(0,2);
glEnd();
}

//draw segment 3
if(enabled[3]) {
glBegin(GL_QUADS);
glVertex2f(0,9);
glVertex2f(10,9);
glVertex2f(10,11);
glVertex2f(0,11);
glEnd();
}

//draw segment 1
if(enabled[1]) {
glBegin(GL_QUADS);
glVertex2f(0,18);
glVertex2f(10,18);
glVertex2f(10,20);
glVertex2f(0,20);
glEnd();
}

//draw segment 4
if(enabled[4]) {
glBegin(GL_QUADS);
glVertex2f(0,2);
glVertex2f(2,2);
glVertex2f(2,9);
glVertex2f(0,9);
glEnd();
}

//draw segment 0
if(enabled[0]) {
glBegin(GL_QUADS);
glVertex2f(0,11);
glVertex2f(2,11);
glVertex2f(2,20);
glVertex2f(0,20);
glEnd();
}

//draw segment 6
if(enabled[6]) {
glBegin(GL_QUADS);
glVertex2f(8,2);
glVertex2f(10,2);
glVertex2f(10,9);
glVertex2f(8,9);
glEnd();
}

//draw segment 2
if(enabled[2]) {
glBegin(GL_QUADS);
glVertex2f(8,11);
glVertex2f(10,11);
glVertex2f(10,20);
glVertex2f(8,20);
glEnd();
}

glPopMatrix();
}

void setDigitEnablePattern(char enabled[7], char digit) {

switch(digit) {
case 0:
for(i=0; i<7; i++) {
enabled[i] = digit0[i];
}
break;
case 1:
for(i=0; i<7; i++) {
enabled[i] = digit1[i];
}
break;
case 2:
for(i=0; i<7; i++) {
enabled[i] = digit2[i];
}
break;
case 3:
for(i=0; i<7; i++) {
enabled[i] = digit3[i];
}
break;
case 4:
for(i=0; i<7; i++) {
enabled[i] = digit4[i];
}
break;
case 5:
for(i=0; i<7; i++) {
enabled[i] = digit5[i];
}
break;
case 6:
for(i=0; i<7; i++) {
enabled[i] = digit6[i];
}
break;
case 7:
for(i=0; i<7; i++) {
enabled[i] = digit7[i];
}
break;
case 8:
for(i=0; i<7; i++) {
enabled[i] = digit8[i];
}
break;
case 9:
for(i=0; i<7; i++) {
enabled[i] = digit9[i];
}
break;
}
}

void drawScore(char player1, char player2) {

if(player1 < 10) {
setDigitEnablePattern(player1Num1, 0);
setDigitEnablePattern(player1Num2, player1);
}
else if (player1 < 100) {
setDigitEnablePattern(player1Num1, player1 / 10);
setDigitEnablePattern(player1Num2, player1 - ((player1/10) * 10));
}
else {	//max out at 99
setDigitEnablePattern(player1Num1, 9);
setDigitEnablePattern(player1Num2, 9);
}

if(player2 < 10) {
setDigitEnablePattern(player2Num1, 0);
setDigitEnablePattern(player2Num2, player2);
}
else if (player2 < 100) {
setDigitEnablePattern(player2Num1, player2 / 10);
setDigitEnablePattern(player2Num2, player2 - ((player2/10) * 10));
}
else {	//max out at 99
setDigitEnablePattern(player2Num1, 9);
setDigitEnablePattern(player2Num2, 9);
}

drawDigit(player1Num1, (windowWidth/4)-15, 20);
drawDigit(player1Num2, (windowWidth/4)+5, 20);
drawDigit(player2Num1, ((windowWidth/4)*3)-15, 20);
drawDigit(player2Num2, ((windowWidth/4)*3)+5, 20);

}

void display(void)
{
//get window parameters
windowWidth = glutGet(GLUT_WINDOW_WIDTH);
windowHeight = glutGet(GLUT_WINDOW_HEIGHT);

midWidth = windowWidth/2;
midHeight = windowHeight/2;

//start timing code
if (lastFrameTime == 0) {
lastFrameTime = glutGet(GLUT_ELAPSED_TIME);
resetProjectile();	//since this is the fist time, this is actually a set 
player1V = midHeight;
player2V = midHeight;
//initialize the space effect colors
setSpaceEffect();
glClearColor(0.0, 0.0, 0.0, 0.0);	//set clear color to black
}

now = glutGet(GLUT_ELAPSED_TIME);
elapsedMilliSeconds = now - lastFrameTime;
elapsedTime = elapsedMilliSeconds/1000.0f;
lastFrameTime = now;

calculateClearColor(clearColor);
glClearColor(clearColor[0], clearColor[1], clearColor[2], 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glShadeModel(GL_FLAT);

//draw score
drawScore(player1Score, player2Score);

//calculate move distances
switch (player1Move) {
case 1:		//move up
player1V += PADDLE_MOVE_SPEED * elapsedTime;
break;
case -1:	//move up
player1V -= PADDLE_MOVE_SPEED * elapsedTime;
break;
default:	//do nothing
break;
}
//check out of bounds
if (player1V > windowHeight-50) {
//bounce back
player1Move = -1;
}
if (player1V < 0+50) {
//bounce back other way
player1Move = 1;
}

switch (player2Move) {
case 1:		//move up
player2V += PADDLE_MOVE_SPEED * elapsedTime;
break;
case -1:	//move up
player2V -= PADDLE_MOVE_SPEED * elapsedTime;
break;
default:	//do nothing
break;
}
//check out of bounds
if (player2V > windowHeight-50) {
//bounce back
player2Move = -1;
}
if (player2V < 0+50) {
//bounce back other way
player2Move = 1;
}

//create and position player 1
glPushMatrix();

calculateColor(player1Color, player1ColorDirection);
glColor3f(player1Color[0], player1Color[1], player1Color[2]);	//player 1 color

glTranslatef(30.0f, player1V, 0.0f);

glBegin(GL_QUADS);
glVertex2f(-10, -50);
glVertex2f(-10, 50);
glVertex2f(10, 50);
glVertex2f(10, -50);
glEnd();

glPopMatrix();

//create and position player 2
glPushMatrix();

calculateColor(player2Color, player2ColorDirection);
glColor3f(player2Color[0], player2Color[1], player2Color[2]);	//player 2 color

glTranslatef(windowWidth-30, player2V, 0.0f);

glBegin(GL_QUADS);
glVertex2f(-10, -50);
glVertex2f(-10, 50);
glVertex2f(10, 50);
glVertex2f(10, -50);
glEnd();

glPopMatrix();

/***************************************
*	Projectile CODE!!!
*
***************************************/

//calculate move distances
projMove[0] += moveSpeed * trajectory[0] * elapsedTime;
projMove[1] += moveSpeed * trajectory[1] * elapsedTime;

//create and move projectile
glPushMatrix();

calculateColor(ballColor, ballColorDirection);
glColor3f(ballColor[0], ballColor[1], ballColor[2]);	//player 1 color

glTranslatef(projMove[0], projMove[1], 0.0f);

glBegin(GL_TRIANGLE_FAN);
for(i=0; i < 360; i += 360 / BALL_FACETS) {
glVertex2f(sin(i * PI / 180) * BALL_RADIUS, cos(i * PI / 180) * BALL_RADIUS);
}
glEnd();

glPopMatrix();

//set bounds for projectile
if (projMove[0] > (windowWidth)) {	//player 1 scored - out of bounds right
player1Score++;
moveSpeed = START_SPEED;
printf("Player 1 Scored!  Score: %f ", player1Score);
resetProjectile();
}

else if (projMove[0] < (0)) {		//player 2 scored - out of bounds left
player2Score++;
moveSpeed = START_SPEED;
resetProjectile();
}

else if (projMove[1] > (windowHeight-10)) {	//out of bounds top
trajectory[1] *= -1;
projMove[1] -= 0.5;
}

else if (projMove[1] < (10)) {	//out of bounds bottom
trajectory[1] *= -1;
projMove[1] += 0.5;
}

//collision detection code
else if (projMove[0] < 50 &amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp; projMove[0] > 49) {		//intersecting with line of left paddle
if (projMove[1] <= player1V + 50 &amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp; projMove[1] >= player1V-50) {
trajectory[0] *= -1;
moveSpeed += 30;
setClearColor(clearColor);
projMove[0] += 0.5;
}
}

else if (projMove[0] > windowWidth-50 &amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp; projMove[0] < windowWidth-49) {		//intersecting with line of right paddle
if (projMove[1] <= player2V + 50 &amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp; projMove[1] >= player2V-50) {
trajectory[0] *= -1;
moveSpeed += 30;
setClearColor(clearColor);
projMove[0] -= 0.5;
}
}

/******************************
*  END PROJECTILE CODE
*
******************************/

glutSwapBuffers();

}

void reshape(int width, int height)
{
glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glMatrixMode(GL_MODELVIEW);
}

void idle(void)
{
glutPostRedisplay();
}

void keyboard(unsigned char key, int x, int y) {
switch (key) {
case 'w':
//do something
player1Move=1;
glutPostRedisplay();
break;
case 's':
//do something
player1Move=-1;
glutPostRedisplay();
break;
case 'o':
//do something
player2Move=1;
glutPostRedisplay();
break;
case 'l':
//do something
player2Move=-1;
glutPostRedisplay();
break;
default:
//some other key
break;
}

}

void keyboardup(unsigned char key, int x, int y) {
switch (key) {
case 'w':
//do something
player1Move=0;
glutPostRedisplay();
break;
case 's':
player1Move=0;
glutPostRedisplay();
break;
case 'o':
player2Move=0;
glutPostRedisplay();
break;
case 'l':
player2Move=0;
glutPostRedisplay();
break;
default:
//some other key
break;
}

}

int main(int argc, char** argv)
{
glutInit(&amp;amp;amp;amp;amp;amp;amp;argc, argv);

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(500, 500);

glutCreateWindow("Tim GL");

glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutKeyboardUpFunc(keyboardup);
glutIdleFunc(idle);

glutMainLoop();
return EXIT_SUCCESS;
}

I delayed so long because I wanted to refactor this code to better separate components and functions, but I didn’t get the time to do so. (That’s why I should do it that way from the start!) You can get a direct copy of the binary here.

/*
* Main.java
*
* Created on November 27, 2008, 3:56 PM
*
*/

package sqlserversample;

import java.sql.*;
import com.microsoft.sqlserver.jdbc.*;

/**
*
* @author Timothy M. Rodriguez
*/

public class Main {

/* jdbc driver name and database url
* ms sql uses port 1433
* replace "mysqlserver" with the ip and host of your database
* if connecting from a *nix box, don't forget to use the FQDN and not just the NetBIOS host
* if not, the ip is a safe bet
*/
private static final String DATABASE_URL = "jdbc:sqlserver://mysqlserver:1433";
private static final String DRIVER = "com.microsoft.sqlserver.jdbc.sqlserverdriver";

//used to connect to the database
private static Connection connection = null;
//used to execute queries on the database
private static Statement statement = null;
//this object is used to store your result sets
private static ResultSet resultSet = null;
//this object is used to stored data about the table
private static ResultSetMetaData metaData = null;

/** Creates a new instance of Main */
public Main() {
//default constructor
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

try {
// load the driver class

//this should work, but doesn't, not sure why, let me know in the comments if you do
// Class.forName(DRIVER);
// instead i created it this way
SQLServerDriver sqlServerDriver = new SQLServerDriver();
/*
* I manually created a SQLServerDriver instance, this is due to
* complications with the classpath establish connection to db
*/
DriverManager.registerDriver(sqlServerDriver);
connection = DriverManager.getConnection(DATABASE_URL,
"user", "password");

// create the statement for querying
statement = connection.createStatement();

//put your query string in the executeQuery method argument
resultSet = statement.executeQuery("SELECT TOP 10 * FROM Table");
metaData = resultSet.getMetaData();
//I didn't use the metadata object, but showed you how to create it
//the metaData object can be used to get column names and indices, column types, etc.

while(resultSet.next()) {
//the get object method is useful if you don't want to bother with the column type
System.out.println(resultSet.getObject(3).toString());
}

} catch (SQLException sqlException) {
//couldn't connect to the db or execute a query
sqlException.printStackTrace();
/* in a real webapp, you don't want to be printing stack traces
* instead print a nice error page that doesn't include internal information
*  For example, "oops, it blew up"
*/
}
}
}

That’s it, I hope that helps!

Everyone’s talking about IP TV and how it’s going to revolutionize things. We’ll be able to get our TV anywhere, any way, but the reality has fallen short of the promise. Your ISP may be beaming Digital channels down to you over IP, but the experience is largely unique to your ISP. Your cable box is not a TV Content browser, no matter how much it tries to be. Heck, you can’t even take your Time Warner Cable box and easily connect it to a Comcast user’s home. The spirit of the IP in IPTV is sorely missing.

That’s why I’m working on a better way–and I need your help.

There are several standards regarding IPTV (and they are used), but while they focus on delivering the content, they do not focus on the programming. If you’re looking at the web to solve your problem, don’t look there either. Every single news or content producer has their own site with their own way of accessing it. You need accounts, you need a pretty hefty browser, and you need to wade through a different interface each and every time.

There is no way to channel surf on the web.

What about RSS?

RSS is great! I love it, but it drastically changes consumption of media, albeit in a very Web way. TiVO’s and DVR’s help bridge this gap on the classic TV side, but what about programming? Sometimes I don’t want to pick what to watch.  Sometimes I just want to flip through channels and see what’s on. RSS does not replace programming. (I’d also like to take this moment to give a big shout-out to Miro, which is an amazing application for automagically downloading and managing video RSS feeds.) We need something more.

A New Way to Surf

What we need is a format for serving up programming that goes beyond a fixed stream.  We need a way of mixing up content, and the web.  We also need a better way of consuming it all.  Without giving it an official name, I’m going to call this protocol LP.  Imagine if you could pull down a link to your favorite channel’s programming and view content live.  It’s not a stream, it’s a url your LP player goes to and it contains all the information you need to find out what’s playing now on your favorite channel.  Heck, why stop with now?  Maybe it’s all pre-recorded and you can skip to what’s playing later?  Maybe, you want to see what was on before?  Who needs a DVR?  The content should stay available and you should be able to consume it.  What I’m talking about is a REST API for navigating video and audio content.

A Trudge Through the Mud

I first started writing this post four months ago and I kept putting it off. Then I wrote some more and put it off a few more months.  I had all these ideas in my head and I wanted to get them all out in one go.  I wanted to have a working prototype of an LP Server and Player, of the “LPXML” format, and have all the whizz-bang features I wanted to put into it.  The fact of the matter is I’m busy and it will take me forever to settle my ideas if I don’t just start and get something out there.  So I’m going to start with just the basics of what I think this “informal” standard should look like.

And I’m definitely looking for feedback.

What I’m proposing is that an LP player take a link to a website (e.g. www.spaceislimited.org/lplayer/) and this will be the root of the lplayer REST interface for my site (the link is hypothetical btw).  The Lplayer application (this could even be Miro if this catches on) would then know the following structure for the REST inteface.

lplayer/now/ – This verb will respond with a page that will contain the URL of the content that is currently now playing.  For example, the Lplayer goes to lplayer/now/ and get this response:

<code>

<a href=”http://spaceislimited.org/videos/awesomevid1.lpxml” />

That’s it.  Nothing else.  Maybe eventually we’ll specify an XML doctype and wrap it in something like:

<?xml version=”1.0″ encoding=”utf-8″?>

<lp version=”0.1″ xmlns:lpxml=”http://www.lpxml.org/lpxml.dtd”>

<program>http://spaceislimited.org/videos/awesomevid1.lpxml</program>

<elapsed>20</elapsed>

</lp>

</code>

The player would then follow that link to get the content and some meta data about the content.  It would also  use the elapsed value to sync up with how far into the program everyone is.  Of course, if it’s a live stream, the elapsed value may not be necessary.  The program link might look something like this:

<code>

<?xml version=”1.0″ encoding=”utf-8″?>

<lp version=”0.1″ xmlns:lpxml=”http://www.lpxml.org/lpxml.dtd”>

<content size=”small” codec=”quicktime” bitrate=”100k”>http://spaceislimited.org/videos/awesomevid1_lowres.mov<content/>

<content size=”medium” codec=”quicktime” bitrate=”200k”>http://spaceislimited.org/videos/awesomevid1_mediumres.mov<content/>

</lp>

</code>

Depending on the player, it can choose one of three files to stream, each with a different bitrate.  For example, if you had an LPlayer on your iPhone, maybe it would choose the 100k stream, while your home computer might opt for the 300k stream.  Also, the rest of the meta-data is standard stuff which could be used within the application.

So what happens when the video is done?  Simple, the player would then go fetch the /lplayer/now/ link again and get what’s playing now!  If it still sees the same entry, it might wait a few seconds and try again (maybe your lp server site is so awesome it’s having trouble responding).  Or the application could try /lplayer/next/ and get what’s playing next.  That way, your iPhone can start buffering what’s next a few seconds before!

A Call to Arms

I’m publishing this as an informal standard and I’d love to see your comments behind this.  More than that, I’d love to see people who are willing to work on this with me on setting up a community around this and implementing a free server and player for the “LP” standard.  For this standard to work, it needs to be open, simple, and platform and codec agnostic.  I haven’t said anything about needing to use the QuickTime codec or having to choose a standard bitrate.  This is about discovery and enabling the player to make the right choice.  Attached is the standard–plain and simple for now.  In the coming weeks I’m going to work on getting a site (lpxml.org), wiki, forum, and mailing list (lpxml [at] googlegroups [dot] com) setup so we as a community can work on this.  I hope you’ll join me.

Enjoy!

In interest of actually finally getting this post out the door, I’m just going to post the code!  This is actually a snapshot of the code from a month or so back and I apologize for not tidying it up.  The reason I’m using a snapshot from a while back is because I have a newer, more glitzy version with a scoreboard and some simple effects that aren’t really necessary to get the basic game down.  I will post that code in a future post though when I’ve polished it up a bit more!  This is also most definitely not up to proper coding standards, but it gets the job done.  It was a late night hack-fest, so please disregard the lack of neatness!

A word on use..

You’re free to use the code however you like.  If you use it though, I would most definitely appreciate it if you post a link to Last Stop on your website or blog and a mention in the credits of the application.  Please also credit the references to Timothy M. Rodriguez.  You don’t have to do this, but it’d be nice.  I’d also very much love an e-mail or comment letting me know about your project!

On to the Code!

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include <GLUT/glut.h>

static int lastFrameTime = 0, windowWidth = 0, windowHeight = 0, now = 0;
static float midWidth = 0, midHeight = 0;
static float elapsedTime = 0, elapsedMilliSeconds = 0;
static char player1Move = 0, player2Move = 0;
static float player1V = 0, player2V = 0;

static float PI = 3.14159265358979323846264;

//scores
static int player1Score = 0, player2Score = 0;

//the following variables calculate a random starting projectile trajectory
static float randomDirection;
static long longMax = 0x7fffffff;    //max of longs 2^31-1 (2^(n-1)-1 for 2′s complement) static float trajectory[2] = {0, 0};

static float projMove[2] = {0, 0};
static double trajectory[2] = {0, 0};
static char moveSpeed = 70;

void resetProjectile(void) {
//set starting random trajectory
randomDirection = 2 * PI * (float) random() / (float) 0x7fffffff;
trajectory[0] = (float) cos(randomDirection);
trajectory[1] = (float) sin(randomDirection);
projMove[0] = midWidth;
projMove[1] = midHeight;
}

void display(void)
{
//get window parameters
windowWidth = glutGet(GLUT_WINDOW_WIDTH);
windowHeight = glutGet(GLUT_WINDOW_HEIGHT);

midWidth = windowWidth/2;
midHeight = windowHeight/2;

//start timing code
if (lastFrameTime == 0) {
lastFrameTime = glutGet(GLUT_ELAPSED_TIME);
resetProjectile();    //since this is the fist time, this is actually a set
}

now = glutGet(GLUT_ELAPSED_TIME);
elapsedMilliSeconds = now – lastFrameTime;
elapsedTime = elapsedMilliSeconds/1000.0f;
lastFrameTime = now;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glShadeModel(GL_FLAT);

//calculate move distances
switch (player1Move) {
case 1:        //move up
player1V += 150 * elapsedTime;
break;
case -1:    //move up
player1V -= 150 * elapsedTime;
break;
default:    //do nothing
break;
}
//check out of bounds
if (player1V > (windowHeight/2)-50) {
//bounce back
player1Move = -1;
}
if (player1V < -(windowHeight/2)+50) {
//bounce back other way
player1Move = 1;
}

switch (player2Move) {
case 1:        //move up
player2V += 150 * elapsedTime;
break;
case -1:    //move up
player2V -= 150 * elapsedTime;
break;
default:    //do nothing
break;
}
//check out of bounds
if (player2V > (windowHeight/2)-50) {
//bounce back
player2Move = -1;
}
if (player2V < -(windowHeight/2)+50) {
//bounc back other way
player2Move = 1;
}

//create and position player 1
glPushMatrix();

glColor3ub(255, 0, 0);    //red

glTranslatef(0.0f, player1V, 0.0f);

glBegin(GL_QUADS);
glVertex2f(20.0f, (midHeight-50));
glVertex2f(20.0f, (midHeight+50));
glVertex2f(50.0f, (midHeight+50));
glVertex2f(50.0f, (midHeight-50));
glEnd();

glPopMatrix();

//create and position player 2
glPushMatrix();

glColor3ub(0, 0, 255);    //blue

glTranslatef(0.0f, player2V, 0.0f);

glBegin(GL_QUADS);
glVertex2f(windowWidth-20.0f, (midHeight-50));
glVertex2f(windowWidth-20.0f, (midHeight+50));
glVertex2f(windowWidth-50.0f, (midHeight+50));
glVertex2f(windowWidth-50.0f, (midHeight-50));
glEnd();

glPopMatrix();

/***************************************
*    Projectile CODE!!!
*
***************************************/

//calculate move distances
projMove[0] += moveSpeed * trajectory[0] * elapsedTime;
projMove[1] += moveSpeed * trajectory[1] * elapsedTime;

//create and move projectile
glPushMatrix();

glColor3ub(255, 255, 255);

glTranslatef(projMove[0], projMove[1], 0.0f);

glBegin(GL_QUADS);
glVertex2f(-10, -10);
glVertex2f(10, -10);
glVertex2f(10, 10);
glVertex2f(-10, 10);
glEnd();

glPopMatrix();

//set bounds for projectile
if (projMove[0] > (windowWidth)) {    //player 1 scored – out of bounds right
player1Score++;
printf(“Player 1 Scored!  Score: %f “, player1Score);
printf(“projMove[0] %f projMove[1] %f “, projMove[0], projMove[1]);
resetProjectile();
}

if (projMove[0] < (0)) {        //player 2 scored – out of bounds left
player2Score++;
resetProjectile();
}

if (projMove[1] > (windowHeight)) {    //out of bounds top
resetProjectile();
}

if (projMove[1] < (0)) {    //out of bounds bottom
resetProjectile();
}

//collision detection code

/******************************
*  END PROJECTILE CODE
*
******************************/

glutSwapBuffers();

}

void reshape(int width, int height)
{
glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glMatrixMode(GL_MODELVIEW);
}

void idle(void)
{
glutPostRedisplay();
}

void keyboard(unsigned char key, int x, int y) {
switch (key) {
case ‘w’:
//do something
player1Move=1;
glutPostRedisplay();
break;
case ‘s’:
//do something
player1Move=-1;
glutPostRedisplay();
break;
case ‘a’:
player1Move=0;
glutPostRedisplay();
break;
case ‘o’:
//do something
player2Move=1;
glutPostRedisplay();
break;
case ‘l’:
//do something
player2Move=-1;
glutPostRedisplay();
break;
case ‘k’:
player2Move=0;
glutPostRedisplay();
break;
default:
//some other key
break;
}

}

void keyboardup(unsigned char key, int x, int y) {
switch (key) {
case ‘i’:
//do something
player1Move=0;
glutPostRedisplay();
break;
case ‘u’:
player2Move=0;
glutPostRedisplay();
break;
default:
//some other key
break;
}

}

int main(int argc, char** argv)
{
glutInit(&argc, argv);

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(500, 500);

glutCreateWindow(“Tim GL”);

glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutKeyboardUpFunc(keyboardup);
glutIdleFunc(idle);

glutMainLoop();
return EXIT_SUCCESS;
}

Well that’s a lot of code, but don’t be intimidated!  If you read through it (maybe a couple of times), you’ll start to understand it.  The main loop is short and sweet.  We start glut, create a window with it, and then register callback functions for displaying the game, reshaping (what to do if someone changes the size of the window), and for keyboard downpress and release events (keyboard func and keyboardupfunct).  Our display function then pretty much does all the work, and I use a bunch of global variables to keep track of state, such as where the projectile and the paddles are.  There’s also some brute force vanilla collision detection, which I hope you can appreciate.  The funny part is that most real collision detection systems use this concept, called the bounding box.  In pong, the bounding box of the paddle is the paddle.

You can get a compiled Mac OS X version here, but if you have your IDE setup right a straight copy and paste should work.  (If you had to make any changes, please let me know.)

Let any and all questions loose in the comments..

One of the orders of the day–much to my dismay–was to install Windows Vista. I advised him not too, but he got his aunt to get it for him for his birthday and he rationalized his defiance of my advice on DirectX 10. (Truth be told, I sabotaged myself by telling him it was one of the only neat features of Vista, outside of massive memory footprint and overall sluggishness.)

And so our journey began..

I’d like to tell you it didn’t take us in excess of 2 days to get Vista installed. I mean, I’ve been building PCs for years now and I’m a recent grad of Computer Engineering (I know the two aren’t the same, but still..). Piece of cake, right?

Wrong.

To be fair (to myself and Microsoft), I had helped him install Vista on his PC after he got his video card a few short months ago, but after we changed all the hardware from under it, it refused to boot. Which left us with the odd job of installing Vista fresh off an upgrade CD. I knew from previous reading on the web, it would probably only take a call to Microsoft and that they were quite helpful in arranging for you to keep your upgrade in these circumstances, so we marched onward.

First things first..

First things first, stick the CD in the tray, make sure the BIOS is set to boot from CD, and let boot. Okay great, we got the usual install screens, but then Vista says it detects a previous version of Windows installed. It then asks me to boot into it and install Vista from there. Fair enough, except I can’t boot from Vista now! We then chose the option to install Vista and have it verified later. This worked great, full of progress for about 20 minutes, after which, it hung. We then went on to try everything to get it installed. Including just plain trying over and over again. Sometimes we got a little bit further, but it always hung. I thought maybe his Vista CD got too scratched up and it was bad. I burned a copy of an ISO I had (a legit one from a student/Microsoft coop my school runs) and tried the same thing with that. No dice. Being that major OEMs don’t ship install CDs anymore (a ridiculous practice) we couldn’t go back and install his copy of Media Center Edition again and upgrade off that. I went home and hunted for some Win2k or XP cds, but I had no serial keys.

While I was home hunting for software, my nephew was calling Microsoft. The first thing they told him was, take out the memory, you have too much. Too much? Vista basically begs for 4 gigs or more (we had exactly 4, for the record). What do you mean Vista won’t install with 4 gigs. “Preposterous,” I said to my nephew when I got back. “There’s no way. XP installs just fine with 4 gigs!,” I yelled. We eventually even tried just putting two sticks or RAM in to see what happened. Still issues. We continued to try to fiddle with the machine for several more hours before I caved and said, “Let’s just call MS Tech Support and see what they say. We’ll get someone real on the phone this time.”

Before I get started, I do have to say, MS Tech support was very nice (yes, even the team in India we were eventually forwarded too). But again, the first thing we were told was “Too much memory. Take all the sticks out and put one back in.” Upset, I agreed and took everything out except for one stick.

Eventually, Vista installed just fine.

Vista just can’t address 4 Gigs of memory on install!

I told the tech this is a major regression, considering XP installs just fine. The tech then proceeded on as if it were not a bug, but just an issue of our hardware setup. Keep in mind, the Tech did not ask us what our board, or our processor, was until much later in the process. The first thing they said was take all the sticks out. After some bickering, I eventually got the tech to let me in on the little secret that Vista can’t address that much memory on installation and that it is a known issue that was resolved in the SP1 discs. Is it just me, or is this an absolutely horrendous oversight? I’m not going to rehash the standard Vista bashing, but this just goes to show why firms and home users alike are staying away from Vista. The irony is that despite it’s massive delays, Vista was rushed. A lot of this has to do with the fact that they threw away all their work and restarted with a far smaller scope than originally intended for Longhorn, but there plain simply still wasn’t enough time.

There’s a great article on Beyond3D about the technology of a 3D engine. The article’s split up into parts and part two was just released (after a several month wait!). Part one discusses a lot of the general concepts for a 3D engine design in an easy to read and abstract level, but part two goes into deeper detail. Both make for interesting reads, though part two sort of jumps into an ocean at no discernible point. (It covers scenegraphs I know, but why start there? Why not animation? Look for my own part two of programming a pong clone to animation and early concepts in game programming.)

• Part One
• Part Two

Today Apple finally added support for Java SE 6. This has been a long time coming and lots of people were clamoring that Apple abandoned Java. While it’s true that Jobs said Java was a “ball and chain,” the context was very much that of the iPhone. And Java, despite ubiquity in the phone market, really hasn’t done much.

There are some caveats to this update though. It’s only compatible with Leopard (Mac OS X.5) and it’s only compatible with 64Bit Intel processors.

But if you’re a Java developer on Mac OS X who’s been getting long in the tooth waiting for this, get going.

The eagle has landed.

Yeah. That’s how I feel.

Why in the hell are they making a web browser? Notice that I’m not providing any criticism on the web browser (it actually implements some pretty neat concepts). I’m asking a simple question, why? What does AT&T want in the browser market? They aren’t working on a browser they can port to handsets. This is a bloated browser, with tons of snazzy 3-D functionality (Check out the Ars Pogo Review). AT&T is going well out of its comfort zone to create a product for a market that is saturated–if you have trouble believing that, try asking Steve Jobs how Safari on Windows is doing. Oh, did I mention? It’s Windows only.

Do we really need another Windows browser?

Why isn’t AT&T focusing their efforts on more worthwhile causes, like I don’t know, unlimited Voice and Data plans for reasonable prices or SMS for something a bit less that highway robbery (The True Price of SMS)?

What do you think? Let loose some confusion in the comments.