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, 1.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

		glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, teams[0].color);
		// 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);
}