gremlin/src/main.cpp

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

#include <GL/glfw.h>

#define MAX_PLAYERS_PER_TEAM 8
#define MAX_TEAMS 8

typedef struct _player {
	unsigned int session;
	double x, y, z;
	double rx, ry, rz, rw;
	double vx, vy, vz;
} player;

typedef struct _team {
	player players[MAX_PLAYERS_PER_TEAM];
	double x, y, z;
	GLfloat color[4];
} team;




GLUquadricObj *quadratic;

void setup_opengl()
{
	// Initialise GLFW
	if( !glfwInit() )
	{
		fprintf( stderr, "Failed to initialize GLFW\n" );
		exit( EXIT_FAILURE );
	}

	// Open OpenGL window
	if( !glfwOpenWindow( 640, 480, 0,0,0,0, 0,0, GLFW_FULLSCREEN ) )
	{
		fprintf( stderr, "Failed to open GLFW window\n" );
		glfwTerminate();
		exit( EXIT_FAILURE );
	}
	glfwDisable(GLFW_MOUSE_CURSOR);
	glfwSetWindowTitle( "Trilinear interpolation" );

	// Enable sticky keys
	glfwEnable( GLFW_STICKY_KEYS );

	// general settings
	glShadeModel(GL_SMOOTH);	
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	glEnable(GL_CULL_FACE);

	// setup depth buffer
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);

	GLfloat LightAmbient[]= { 0.1f, 0.1f, 0.1f, 1.0f }; 	
	GLfloat LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f };
	GLfloat LightPosition[]= { 0.0f, 0.0f, 2.0f, 0.0f };

	// setup directional light
	glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);	
	glLightfv(GL_LIGHT1, GL_POSITION,LightPosition);
	glEnable(GL_LIGHT1);
	glEnable(GL_LIGHTING);

	// Enable vertical sync (on cards that support it)
	glfwSwapInterval( 1 );
}

void setup_team(team *team, size_t id)
{
	team->color[0] = 1.0f * (id+1 & (1 << 0));
	team->color[1] = 1.0f * (id+1 & (1 << 1));
	team->color[2] = 1.0f * (id+1 & (1 << 2));
	team->color[3] = 1.0f;

	team->x = 2000.0 * (id & (1 << 0));
	team->y = 2000.0 * (id & (1 << 1));
	team->z = 2000.0 * (id & (1 << 2));

	size_t i = 0;
	for (i = 0; i < MAX_PLAYERS_PER_TEAM; i++)
	{
		team->players[i].session = 0;
		team->players[i].x = team->x + i * 50.;
		team->players[i].y = team->y;
		team->players[i].z = team->z;
		team->players[i].vx = i * 5.;
		team->players[i].vy = i * 5.;
		team->players[i].vz = i * 5.;
	}

}

void update_team(team *team, double dt)
{
	size_t i;
	for (i = 0; i < MAX_PLAYERS_PER_TEAM; i++)
	{
		if (team->players[i].session == 0)
			continue;
		team->players[i].x += team->players[i].vx * dt;
		team->players[i].y += team->players[i].vy * dt;
		team->players[i].z += team->players[i].vz * dt;
	}
}

void draw_team(team *team)
{
	size_t i = 0;
	glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, team->color);
	glMatrixMode( GL_MODELVIEW );

	glPushMatrix();
	glTranslated(team->x, team->y, team->z);
	gluSphere(quadratic,50.f,32,32);
	glPopMatrix();

	for (i = 0; i < MAX_PLAYERS_PER_TEAM; i++)
	{
		if (team->players[i].session == 0)
			continue;
		glPushMatrix();
		glTranslated(team->players[i].x, team->players[i].y, team->players[i].z);
		gluSphere(quadratic,10.f,32,32);
		glPopMatrix();
	}
}

int main( void )
{
	int width, height, x, y, last_x, last_y;
	double time, last_time, phi = 0.0, theta = 0.0;
	GLboolean running;

	quadratic = gluNewQuadric();
	gluQuadricNormals(quadratic, GLU_SMOOTH);
	gluQuadricTexture(quadratic, GL_TRUE);

	team teams[MAX_TEAMS];

	setup_opengl();

	size_t i;
	for (i = 0; i < MAX_TEAMS; i++)
		setup_team(&teams[i], i);

	running = GL_TRUE;
	last_time = glfwGetTime();
	glfwGetMousePos( &last_x, &last_y );
	while( running )
	{
		// Get time and mouse position
		time = glfwGetTime();
		glfwGetMousePos( &x, &y );
		phi += (x - last_x) * -0.001;
		theta += (y - last_y) * 0.001;
		if (theta > 1.5)
			theta = 1.5;
		if (theta < -1.5)
			theta = -1.5;
		last_x = x;
		last_y = y;

		// Get window size (may be different than the requested size)
		glfwGetWindowSize( &width, &height );
		height = height > 0 ? height : 1;

		// Set viewport
		glViewport( 0, 0, width, height );

		// Clear color buffer
		glClearColor( 0.0f, 0.0f, 0.0f, 0.0f);
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		// Select and setup the projection matrix
		glMatrixMode( GL_PROJECTION );
		glLoadIdentity();
		gluPerspective( 60.0f, (GLfloat)width / (GLfloat)height, 1.0f,
			10000.0f );

		// Select and setup the modelview matrix
		glMatrixMode( GL_MODELVIEW );
		glLoadIdentity();
		gluLookAt( 100.0f,  100.0f, 100.0f,    // Eye-position
			100.0f + cos(phi) * cos(theta) * 10.0f, 100.0f +sin(theta)*10.0f, 100.0f+ sin(phi)*cos(theta)*10.0f,    // View-point
			0.0f,  1.0f,   0.0f );  // Up-vector

		// Draw a textured quad
		glBegin( GL_QUADS );
		glVertex3f( -5000.0f, 5000.0f, -5000.0f );
		glVertex3f(  5000.0f, 5000.0f, -5000.0f );
		glVertex3f(  5000.0f, 5000.0f,  5000.0f );
		glVertex3f( -5000.0f, 5000.0f,  5000.0f );
		glEnd();

		for (i = 0; i < MAX_TEAMS; i++)
			update_team(&teams[i], time-last_time);

		for (i = 0; i < MAX_TEAMS; i++)
			draw_team(&teams[i]);

		// Swap buffers
		glfwSwapBuffers();

		// Check if the ESC key was pressed or the window was closed
		running = !glfwGetKey( GLFW_KEY_ESC ) &&
			glfwGetWindowParam( GLFW_OPENED );

		last_time = time;
	}

	gluDeleteQuadric(quadratic);		

	// Close OpenGL window and terminate GLFW
	glfwTerminate();

	exit( EXIT_SUCCESS );
}