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!

I’ve never seen a candidate motivate so many people.  It is liberating to see people of all ages, races, and geography standing up in unison.

Barack Obama is in a unique position to carry our voices beyond deaf ears and shape a better America.

Vote on November 4th, 2008.

Vote for Change.

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.

There’s an elephant in the room when it comes to the internet. Microsoft wishes it was them, Yahoo’s just had too much to drink, and there’s a big purple elephant in the corner — Google.

A Blogger’s Worst Nightmare

It’s a blogger’s worst nightmare. One day you open up your e-mail and receive a message from the Google AdSense team notifying you that your AdSense account has been disabled. Your heart sinks and your stomach is in your throat. The problem is we didn’t do anything. (I say we because La Disputa and Last Stop share an AdSense account.) The AdSense e-mail also provides little chance of recourse. Basically, they provide a link for “more information”. The link explains in roundabout ways that you were a risk to advertisers and then goes on to indirectly say that you committed click fraud. They don’t offer any details as to how they came to this conclusion. Suffice it to say, they have their ways.

Scrambling to get our AdSense account back we quickly filed an appeal. We didn’t know what to say, but we guessed and assumed that maybe our parents clicked our ads since we told them we make money on advertising on ads, but we failed to mention “please don’t click our ads”. The reason for this seems plausible enough, so we wrote up an appeal assuming that this must be it and said we fully support removing any earnings they deemed fraudulent and that we would be sure to always tell people not to click our ads in the future. We really thought we’d be okay, this was just a one-off thing. Heck, we started our blogs only a few months ago and our earnings were really insignificant. Two days later we get another e-mail saying our appeal was denied. And with Google, you only get one appeal. We were screwed. I’ve read other blogs saying sometimes people have gotten lucky on the second or third try, but this didn’t look good.

The truth is we probably made a mistake in assuming (you know what happens when you assume) when coming up with an excuse, as upon conferring with our parents, we now know they weren’t clicking our ads. But the truth was we didn’t know. In fact, we said that in our appeal. With Google’s lack of information, we probably will never know.

The Only Game In Town

In a haste to get advertising back, I scoured the net for AdSense alternatives. I knew Google was pretty much the best out there, but I didn’t know just how desolate the field really was. The only half-way decent options require a huge amount of traffic and the rest are absolute junk. You can tell just by looking at their website. And if you look at the big bloggers, they fully support diversifying your ad networks, but they make most of their money from AdSense. As far as blogs go, we were DOA.

I read up some more on Google Appeals and decided to try again. This time I took a more careful approach, I reviewed our traffic logs and found out that social networking spikes can trip off the google “invalid click detector”. I submitted our traffic logs and said that after conferring with our parents we realized they didn’t click on our ads. The appeal was very cordial and polite and we were hoping against hope we’d get our account enabled. It’s been several weeks.

And we never got a response.

No Warning

It’s strange, but being at the mercy of Google has been a rude awakening. It reminded me of a conversation I had where I argued that any company of large enough size eventually becomes evil. My roommate at the time, knowing I really liked Google, quipped, “How about Google and their ‘Don’t Be Evil’?”. I said, it’d happen eventually.

Eventually

No, I don’t think we’re their yet, but we are starting to see signs of Google increasingly not having the best interests of it’s customer’s at heart. Google has finally ceded censorship and privacy concerns in China and I know of several people who have many big complaints against the Big G. I think Google’s a great company, with some of the best engineers around, but there’s no denying that for Google (or any company) it gets harder and harder to not be evil the more money there is on the table. But this isn’t a story of Google being evil. It’s a case of poor service. Seriously, Google didn’t give us a warning saying they were starting to see invalid click activity. Hell, if they know what it is, why not remove it from our earnings? They never gave us a second chance and reinstated our account. We never physically spoke to someone. It was disabled. That’s it. No number to call, no e-mail address, just an appeal form and automated responses.

The Whole Internet at One’s Whimsy

I guess I’m glad it happened now. Imagine if this blog took off overnight and really started to rake in money. Now what if I quit my job to blog full-time only to find this all happen to me two weeks later? To understand the gravity of this remember that Google has my Social Security number and now that I’m blocked, I’m blocked for life.  This means I don’t have a good way to monetize any webapp I might come up with or another blog idea.  This can happen to anyone and it’s the primary reason why you should diversify your ad inventory. The problem is there really isn’t a good alternative. To even get to the point of blogging full-time, you really need Google. In fact, the internet is very largely dependent on Google. Not for search, but for AdSense. This is especially true when you consider the low-end. A startup today won’t qualify for the other “big” ad networks, they just don’t have enough volume. And without advertising, startups have a very chicken-and-egg problem. This can (and probably is) stifling innovation on the internet. With Google as it’s sole competitor in online advertising, who decides keyword pricing? Who decides pay-out ratios? Who decides whether you’re a risk or not? Certainly not the market.

No Competiton

Here’s a list of the options I’ve tried.

• Yahoo – They’re taking applications, but people on the internet are saying they’re not hearing back from them. It’s been this way for months. I know, I’ve tried too.
• Ask – They have an advertising platform, but I can’t find the sign-up page anymore. I don’t think it’s public. If someone else knows, please clue me in.
• Microsoft – You have to be a big player and they’re a similar to Yahoo, taking on little more ad inventory until they can figure out how to compete against Google.
• Clicksor – They sent me an e-mail saying my e-mail address was incorrect. I reapplied and fixed it and they haven’t gotten back to me.
• Bidvertiser – The only people who got back to me. I’ve set up my ads. I’ve earned zero dollars.
• I’ve tried a few others on this list, but I usually don’t qualify, or they’re too sheisty looking for me to try.

Effectively, there’s absolutely no competition. I’m not the first one to realize this. There’s a very good write-up here.

How Did we get Here?

Upset, I tried to figure out just why Google didn’t have ample competition in this space. It’s funny, because a few days later this article showed up on Slashdot. This article is a great explanation of the sordid love affair of Microsoft, Yahoo, and Google. Basically, Yahoo controls the patent for contextual advertising. (Contextual advertising is nothing more than a patent on mining the advertiser’s page to discover it’s content and then placing a targeted ad on that website.) It’s an important patent and it’s orders of magnitude more effective at targeted advertising than just letting the website owner declare they’re content at sign-up. The crazy outcome of all of this is that, due to an undisclosed settlement, Google ended up the only person able to action on this patent even though Google doesn’t own it. This was absolutely eye-opening and one of the strangest patent stories I’ve ever heard of.

For the time being, it looks like we’re stuck with the unlikely monopoly.

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 = 0×7fffffff;    //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) 0×7fffffff;
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..

You see, in America, and much of the rest of the world, energy is currency. Without rehashing the standard chain at length: oil is gas, it is jet fuel, and it is used to transport, grow, heat, light, build just about everything.

But you know that.

Here’s the interesting thing that’s happened in the last 15 or so years, the development of the derivatives market (no, not those, these), and along with that, the futures variety.

A future is, quite simply, an obligation to buy X quantiy of Y product (usually a commodity) at Z point in the future. Put in English, a contract (the proper name for futures is futures contract) to by 100Million barrels of Oil for $160 dollars a barrel on 01 September 2008.

So what’s the big deal?

By watching the futures market, you have an indicator of the price at some point in the future of a specific commodity. Classically, in markets, you only had the price of something today and the price it was in the past, not the price in the future. This is a big deal, because as long as the future’s market points to the price of oil in the future going up, the price today will have pressure to move up. (Assuming people don’t think the futures market is wrong–which it can be.)

Speculation!

So while people go on yelling and screaming about speculation in the markets, I have one question for you. If you were betting on the price of oil in the future, wouldn’t you bet on it going up? Sure, the speculators, are driving up the price of oil trying to make money–but it isn’t unwarranted. This isn’t speculation, it’s research. Brazil, India, China, Russia, and several other major countries are now exploding in economic development, and with that comes increased need for oil. We are 4% of the world’s population and yet we consume 25% of the global supply! Surely, this isn’t sustainable. This is why you see ex-big-oil moguls singing a different tune. Oil is a finite resource with extraordinary–and growing–demand. Cold, hard, simple, economics. If you had the money, you’d bet this way too. Do I like that the price of oil, gas, and everything is going up? No! I’m stretched pretty good as it is. But this may be good for the environment.

Alternative Energy

A word on alternative energy. Why hasn’t Solar Power, Wind Power, or other alternative energy taken off? One reason, price. You see, while the newest and best solar panel may be 12% efficient, or whatever it is, (by the way, power plants are horribly inefficient as well), what matters is how that compares to the current infrastructure. So lets say, after you run all the math, a solar power plant will cost $1 per kWH and an existing plant is $0.70 per kWH, there is no reason for power producers to switch I know, I want them to also. After all, there’s more than plenty enough environmental reasons. But it’s still cheaper to burn stuff. What’s more of a shame is that for producers to switch to solar they it needs to be substantially cheaper to make up for the current investment in other, less clean, technologies. Unfortunately, there’s other things that aren’t quite fair, such as tax breaks for existing energy producers that are not there for solar power providers, but these also represent a current investment (in the form of lobbying–oh joy) by energy providers.

This is why I’m excited, though! As oil goes up, the economics of all these pricing scenarios changes. And one can hope that this will price alternative energy into the picture. So the future’s market is helping to accelerate changes in the market at large, and maybe, just maybe, there’ll be enough change before the ocean levels rise and NY finds itself building a wall around Manhattan. (And I am by no means saying “Crisis Averted” on the Global Warming issue!)

Not So Fast

It’s great to huff and puff about how great free markets are and how the ultimately seem to be triumphing– just as they do in theory–but this has one simple cornerstone. Oil is a finite resource. In fact, the classics of economics are finite resources, infinite demand, but what if oil was so plentiful that we wouldn’t face this scenario for 50 years? Would we curb production “just to save the environment” or “satisfy those hippie jerks”? The plain and simple answer is No. Or at least, probably not in time. Why? Because there’s no price applied to economic damage. In fact, the whole process of doing so is called “Shadow Pricing” as if it’s some black art, but there is a real cost to economic damage–it’s just not immediately evident, or easy to quantify. Environmental damage wouldn’t be priced until well after the fact. It’s just human nature, we don’t curb our habits until we feel the shock. This is why things like carbon markets and agreement between countries to curb C02 emissions are important–because they are not priced in the markets.

Luckily for the planet, oil production may have finally peaked.

OpenGL is the Open Graphics Library and it is maintained by the Kronos Group, which is a consortium of top-tier companies that include board members such as ATI nVidia, Apple, IBM, and more. Microsoft used to be on the consortium, but left and decided to make DirectX, a competing closed graphics library that only runs on Windows (at least without some sort of emulation layer or wrapper like Wine or Cedega).

First off, OpenGL is a huge thing to master (and I am nowhere near mastery). I can’t explain everything about it in one post (or even in hundreds), but I strongly encourage you to get the OpenGL “Red Book” to start out. The “Red Book” is the official and definitive guide to OpenGL and is a must have for any graphics programmer. I also recommend the K&R C Programming book and, if you’re interested in the back-end math, the Real-Time Rendering book.

That being said, in our pong clone, we only use a few OpenGL functions. I’m going to list them and tell you what they do, but it may take until the next post to really understand how they work.

First, a word about primitives. OpenGL has only a few key primitives that you can draw with, but that’s okay, because you can use the primitives to draw more complex shapes!

The OpenGL primitives are:

• Points – a simple point in space
• Lines – a 2-dimension line (although it can occupy 3-dimensional space)
• Polygons – a polygon is a simple 2-dimensional shape comprised of 3 or more points. Triangles, or 3-point polygons, deserve special attention, because OpenGL will break up any other polygon into a combination of triangles. For example, a square can be broken up into two triangles along its diagonal. Just about every object you see in OpenGL is comprised of triangles!

So let’s draw a simple quadrilateral! In OpenGL, you draw polygons by calling a function whenever you want to draw a polygon and then creating a bunch of points in space to create that polygon. Once you’re done, you call another function to say you’re done.

Here’s an example for drawing a rectangle (our pong paddle):

glBegin(GL_QUADS);

glVertex2f(-10, -50);

glVertex2f(-10, 50);

glVertex2f(10, 50);

glVertex2f(10, -50);

glEnd();

We start by calling glBegin() and sending it GL_QUADS to indicate we want to draw a quadrilateral. This basically tells OpenGL take every four points I send you and make a quad out of it. We then call glVertex2f() and send it the coordinates of a two-dimensional point. the 2f indicates that this is the glVertex function which takes 2 floating point values as its arguments (or inputs). We then call glVertex2f() once for all four of each of our points and then call glEnd() when we’re done.

We could have optionally set a color before we began to draw that quadrilateral (the default is black on black) by calling this function:

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

Again we see the OpenGL naming convention of starting off a function with gl and then ending it with letters and numbers that indicate its arguments. In this case the 3ub means 3 unsigned bytes. Each unsigned byte is positive (hence unsigned) and can go from 0 to 255. The order of the bytes indicate the amount of Red, Green, and Blue respectively that will mix to give you your final color. (Color theory is another big subject matter I can post more about in another post, so let me know in the comments!)

Two other functions that are usually called at the beginning of every display function are:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glShadeModel(GL_FLAT);

glClear(), quite simply is a function that clears the screen and uses the values specified as its argument for doing so.

glShadeModel() specifies the shading model for how vertexes (points) are shaded or lit. In this case, we’re going for a simple flat colored 2-d look so we use GL_FLAT. This paints everything on screen with whatever colors specified and doesn’t do anything fancy. It’s sort of like painting in mspaint on Windows.

glPushMatrix();

glPopMatrix();

glTranslatef(30.0f, 10.0f, 0.0f);

glPush and Pop Matrix() are important functions. They allow you to draw something as if you are starting from scratch with a new coordinate system. Think about our pong paddle. When you want to draw it some place else, do you really want to respecify the coordinates for how it’s drawn? You could instead push a matrix (a set of points) on the stack, then translate (or move), to a new location and draw the object as you would anywhere else, and then finally pop the matrix which will draw the set of points translated (moved) by the glTranslatef() function. This is a little hard to understand (and explain), so I’ll give an example.

In Part II we talked about drawing a box that moved across the screen. We could draw our box as a point in a 2-dimensional plane. For example, let’s make a square that is 4 across centered at the origin (0,0). So it’s points are, going counter-clockwise, (1,1), (-1,1), (-1,-1), (1,-1). Rather than figuring out how to move it along for every frame. We can do this.

glPushMatrix();

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

glTranslatef(x, 0.0f, 0.0f);

glBegin(GL_QUADS);

glVertex2f(1,1);

glVertex2f(-1,1);

glVertex2f(-1,-1);

glVertex2f(1,-1);

glEnd();

glPopMatrix();

So we push a matrix (a set of points) on the stack, switch the drawing color to red, then Translate x units in the x-direction (horizontal) and then set the drawing mode to GL_QUADS and push the points of our square as it is centered at the origin, and finally pop the matrix! This has OpenGL do all the work of moving our square x units to the right.

Okay, that’s enough for now. I encourage you to scour the web and read up more before we get to our next post, where I’ll finally post the code and go through it!

For reference, you probably want to start out with Part’s II and I here and here.

Last we left off I said I’d get into some of the basic mechanics of GLUT and OpenGL, so let’s hit the ground running.

GLUT

GLUT, or the Graphics Library Utility Toolkit, is a cross-platform C library for generating windows and handling IO events. Basically, GLUT was written so you can get to learning OpenGL very quickly without having to spend enormous amounts of time learning how to handle mouse or keyboard actions in your current OS, or worse, learn how to setup a simple GUI just so you can see your work. On top of making these tasks simpler, GLUT is, as I mentioned, cross-platform. This means that you can take your code and recompile it on another OS as long as you have the appropriate GLUT library referenced in your IDE. There are currently versions of GLUT created for Linux, OS X, Windows, and probably even more operating systems.

So how do we create a simple window?

Here’s a snippet of code for how to do just that!

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;
}

You start off with your regular main function in C. Then you call the glutInit function and pass it is passed any parameters you may have passed to main. For this tutorial you won’t be needing any, so don’t worry about it. If you need to find out more, check out the GLUT Documentation.

Next, you pass the glutInitDisplayMode() function a “logically OR-ed” value of GLUT_RGBA, GLUT_DOUBLE, and GLUT_DEPTH. If you don’t know what logically OR-ed means, just think of it as smooshing all these flags together to set the display mode with all of these properties. (If you want an in-depth explanation of this, just ask and I’ll put up a post about it!).

After this, we set the pixel dimensions (size) of the window to 500×500 pixels with the line “glutInitWindowSize(500,500);”. We next set the window’s title bar with “glutCreateWindow(”Tim GL”);” You can set either of these last two functions to whatever value you wish!

Next, is the pretty interesting part. And to understand it you need to understand a little bit about Call-Back functions. Call-Back functions are functions that hold a pointer to another function and call it when some event happens. (This is also why Call-Back functions are usually regarded as “Event-Driven Programming”.) To explain this it’s best to show you by example. I’ll start with the glutKeyboardFunc(keyboard). Whenever a key is pressed down, we have set glutKeyboardFunc() to call ANOTHER function called keyboard that WE have defined. The function is not show here, but we will get to that in the next post! Suffice it to say, our keyboard function will handle certain things like “what to do when the up arrow is pressed” in our Pong clone.

It is important to understand that we can’t just write a function that constantly checks the keyboard like this

while(TRUE) {

whatIsTheKeyboardDoing();

}

because we’d be in an infinite loop and never be able to do anything else. The Call-Back function allows us to be “called back” whenever someone presses the keyboard.

Now that we’ve explained that, the rest of the functions are easy to describe:

• glutDisplayFunc() is called most of the time and is the function that paints our screen with whatever we tell it to with OpenGl
• glutReshapeFunc() is what is called whenever the user resizes the window (In case we need to do anything special if the user all of a sudden changes the screen size on us.)
• glutKeyboardFuncUp() is a tricky one, and it’s what is called whenever a key is “depressed”, or let go. This is a subtle point, but it is useful to know when someone presses a key and let’s go of one. Without this, you wouldn’t be able to tell when someone was holding a key.
• glutIdleFunc() this is the function that is called whenever there is nothing to do!

So that’s it! That’s about all you need to know for GLUT for now! Check out the next post for OpenGL.

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.

Before I start with anything, we have to think about simple animation. In fact, animation is just simply a series of static images, with each image slightly displaced from the last.

So what does that mean?

For example, if I’m going to draw animate a ball falling from mid-air, I would first start with an image of the ball in mid-air, precisely as it would look the moment it began to fall. The next frame, or image, would be exactly that, but with the ball a little bit lower down. I would then continue to draw sequential images of the ball, with each image showing it a little bit further than the last. This is how every moving image you see works (well, just about). A series of images is drawn in front of you, quick enough that you can’t tell.

So the next question is, what’s quick enough? It turns out, this isn’t such a simple question. In fact, the answer is different for different animals! But for humans, it turns out, about 30fps, or 30 frames-per-second, is what it takes to fool us. The movies you see in the theatre are (at-the-moment anyways) displayed at 24fps, but most computer screens require 60fps to prevent you from seeing the flicker (some, like myself, need an 85Hz (fps) refresh rate, others up to 120!). The reasons for these differences has a lot to do with the way the image is drawn and the way your eye views things. It’s a pretty involved topic, but if you guys would like me to go into it more, let me know in the comments.

A Simple Animation Loop

Taking what we just learned, let’s think about how to draw a box moving across the screen. Let’s pretend we have a function that draws a box centered at a point we specify on the screen (in 2-D Space). It’s C function prototype would look something like this:

void drawbox(int x, int y);

So if we were going to draw a box that just infinitely moved to the right (or at least until it was off screen). We might decide to create a loop that drew it a little bit further each time. That might look something like this:

#define TRUE 1

int x=0;

while(TRUE) {

drawbox(0+x, 0);

x++;

}

This little snippet of code, runs an infinite loop and draws a box at a point 0+x, 0 and then increments x. Let’s look a little further. First it draws a box at point(0,0) since x is 0 on first count. Then x is incremented and the loop goes on again. Next, it draws a box at (1,0) and increments x. And so on. Congratulations, you just made your first animation loop!

Marching Onward

In the beginning, video games were hand-coded in assembly directly to a particular hardware. This had a lot of benefits, primarily speed, which was very important when hardware was relatively expensive. But as computers progressed and the market expanded, it became necessary to program for a multitude of different hardwares. And this is when a nasty problem reared it’s head. You see, when you decide to have the computer draw something on the screen, it doesn’t just do it instantaneously. The computer has to go and draw each individual pixel on the screen (also a topic for another discussion).

This

takes

time.

Moreover, the time it takes on your brand-spanking new ultra-super processor is not the same time it takes your friend down the street who isn’t as enthusiastic as you are. This is a problem, because if you set up all your animations expecting the processor to draw 30 frames per second on your machine. It’s going to run at less than that on your friends machine. (In fact, there’s some math that shows it will be a fraction/multiple of their refresh rate). Great, so your fast-action shoot-em-up just got stuck in the mud.

What’s a game programmer to do?

There’s a really simple answer to all of this–use our friend (archenemy) time. You see, rather than making your animation speed depend on the animation loop (which depends on your processor speed), have the your animation be a fixed function of time.

Take another look at our first example. The movement speed of the box can really be expressed as 1 unit in the x direction per loop iteration. Really what we want is for the box to move some number of units in the x direction per second (our hour if you like). To do this we need to express our box movement as a function of time and then know how long its been since the computer last drew the box. Essentially, we want our animation loop to look like this.

#define TRUE 1

int speed = 1; //1 unit per second

int x = 0;

startTime = 0;

elapsedTime = 0;

while(TRUE) {

startTime = getTime();

x += speed * elapsedTime;

drawbox(0+x, 0)

elapsedTime = getTime() – startTime;

}

As you can see, this simple example becomes a lot more complicated once we add timing to the mix. First, we defined a universal speed for our box. We still kept the x value, as this represents the boxes point in space, not it’s speed. Then we created variables for keep track when we started our animation loop and how long we were in it. We’re also assuming we have a function that gives us the time, called getTime() here, and that it returns us the current time in seconds.

First we enter our loop and fetch our start time from the getTime() function. Next we set our x position based on how long it’s been since our last loop. We multiply our elapsedTime by the speed of our box and add that distance to our x-position. Then, we draw our box at it’s new position. Finally, we figure out how long it took us to draw that box by setting our elapsed time equal to the current time minus the time we started drawing the box. Now, no matter the computer, our box will move along the screen at the same speed. Note, this does not mean the animation is fluid! If your friend’s computer is really slow (and I mean really if it can’t draw a box) it may only get to draw a box once every 5 seconds. By then, our box may already be off the screen!

So I hope that’s enough for you to digest for a while. Stay tuned for my next post on some of the basic mechanics of GLUT and OpenGL. Until then, it might be useful to brush up on your C programming on the interwebs!

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

If you ever wanted to program your own video game, this is a good place to start. I remember when I started learning programming it was surprisingly difficult to find out how to make an honest and simple game. In fact, after reading most programming books, the only type of game you could make would be a Zork clone.

You are in a dank cave and you can see nothing, but you hear a walrus in the distance.

What do you do?

1. Look for the walrus.
2. Watch The Big Lebowski
3. Decide that the walrus is Paul.

This is not to knock Zork in any way! Zork is a clever, well written, and extremely well thought out game (even if my pseudo-quote isn’t). But in a world where we’re spoiled by moving objects, you want to know how to move and interact with something on screen. The problem is it takes a lot of different knowledge sets to get the job done. But in this post, you’ll get started learning how to make your very own Pong clone.

A Few Notes..

First, a few notes about setting up. I’m writing this tutorial from the Mac OS X perspective. However, everything we are about to code is, essentially, cross-platform. This is because, it is written using plaing old C, OpenGL, and GLUT. All of these things are themselves cross-platform, and therefore, can be compiled anywhere you have a C compiler (OpenGL and GLUT are just C libraries).

Setting up your environment

Mac OS X

For some reason, this always seems to be the hardest part whenever learning something new in programming. Fortunately, I found a great blog post that makes setting up XCode for compiling an app using OpenGL and GLUT very easy. Read all about setting up your XCode.

Windows

The process in Windows is actually a bit easier (gasp!) than in Mac OS X and there’s plenty of resources available on Google for getting setup. Here’s one in particular.

Linux

Here’s something unusual, you guys get a video.

Congratulations, the hardest part is done! In my next blog post. We’ll start to get knee deep in game programming concepts.

Update!

Part II is Up!

Sure, that maintenance goes to something. It pays for the pool, the trash collectors, the gym, and the community. Some Condos even go so far as to have Supermarkets, Starbucks, and Ice Cream Shops right below. Oh, the horrible convenience!

But that word community is the clincher. The gyms at these places are usually terrible, and what happens if you want to go to your own gym? Or, hell, get a Bowflex, or whatever it is Chuck Norris is selling now? You can, but you’re not going to get any of your maintenance money back. It’s assigned for the community. And tomorrow, the community may decide it needs more maintenance.

Then it occurred to me.

Condos are nothing more than little communist societies. They are the absolutely hypocritical hallmark of capitalistic American wealth. And we love them.

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.