Initial import.

43 files changed, 2360 insertions, 0 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 0000000..b30324a
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,6 @@
+
+# set the include path found by configure
+AM_CPPFLAGS =  $(LIBSDL_CFLAGS) $(all_includes)
+
+# the library search path.
+SUBDIRS = common game gl client
diff --git a/src/client/Makefile.am b/src/client/Makefile.am
new file mode 100644
index 0000000..f234f49
--- /dev/null
+++ b/src/client/Makefile.am
@@ -0,0 +1,12 @@
+
+METASOURCES = AUTO
+bin_PROGRAMS = osirion
+osirion_LDADD = $(top_builddir)/src/common/libcommon.la \
+	$(top_builddir)/src/game/libgame.la $(top_builddir)/src/gl/libosiriongl.la -lSDL
+osirion_SOURCES = camera.cc camera.h input.cc input.h main.cc video.cc video.h \
+	view.cc view.h shipdrawer.cc shipdrawer.h stardrawer.cc stardrawer.h
+
+
+
+INCLUDES = -I$(top_srcdir)/src
+osirion_LDFLAGS = -L/usr/X11/lib64
diff --git a/src/client/camera.cc b/src/client/camera.cc
new file mode 100644
index 0000000..ca60d18
--- /dev/null
+++ b/src/client/camera.cc
@@ -0,0 +1,107 @@
+/* camera.cc
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#include "common/functions.h"
+#include "common/osirion.h"
+
+#include "game/game.h"
+#include "gl/osiriongl.h"
+
+namespace camera
+{
+enum Mode {Free, Track};
+Mode mode = Track;
+
+const float track_pitch = 15.0f; // default tracking pitch
+const float offset_inc = 5.0f; // default offset increment
+
+float yaw = 90; // current yaw, angle in XZ plane
+float yaw_offset = 0; // target offset, relative to target yaw
+
+float pitch = -90; // current pitch, angle in XY
+float pitch_offset = track_pitch; // target offset, relative to target pitch
+
+float distance = 2.0f; // distance from the eye to the target
+
+
+void draw(float elapsed) 
+{	
+	// adjust yaw target
+	float yaw_target = game::ship.yaw - yaw_offset;
+	float d = degreesf(yaw - yaw_target);
+	yaw = degreesf( yaw - d * elapsed);
+
+	// adjust pitch target
+	float pitch_target = 0.0f - pitch_offset;
+	d= degreesf(pitch - pitch_target);
+	pitch = degreesf( pitch - d *elapsed);
+	
+	/*
+	gl::translate(distance, 0.0, 0.0);
+	gl::rotate(-pitch,0, 0, 1.0 );
+	gl::rotate(-yaw, 0, 1.0f, 0);
+	*/
+	switch (mode) {
+	case Free:
+		gl::translate(1+distance * GAMESCALE, 0.0f, 0.0f);
+		gl::rotate(-pitch, 0, 0, 1.0f);
+		gl::rotate(-yaw, 0, 1.0f, 0);
+		break;
+	case Track:
+		gl::translate(1+distance* GAMESCALE, -0.5f* GAMESCALE, 0.0f);
+		gl::rotate(-pitch, 0, 0, 1.0f);
+		gl::rotate(-yaw, 0, 1.0f, 0);
+		break;
+	default:
+		break;
+	}
+}
+
+void rotate_right()
+{
+	if (mode == Free ) {
+		yaw_offset = degreesf(  yaw_offset - offset_inc);
+	}
+}
+
+void rotate_left()
+{
+	if (mode == Free ) {
+		yaw_offset = degreesf(  yaw_offset + offset_inc);
+	}
+}
+
+void rotate_up()
+{
+	if (mode == Free ) {
+		pitch_offset = degreesf( pitch_offset + offset_inc);
+	}
+}
+
+void rotate_down()
+{
+	if (mode == Free ) {
+		pitch_offset = degreesf( pitch_offset - offset_inc);
+	}
+}
+
+void nextmode() {
+	switch(mode) {
+	case Free:
+		mode = Track;
+		yaw_offset = 0;
+		yaw = game::ship.yaw;
+		pitch_offset = track_pitch;
+		break;
+	case Track:
+		mode = Free;
+		yaw_offset = 0;
+		break;
+	default:
+		break;
+	}
+}
+
+} //namespace camera
diff --git a/src/client/camera.h b/src/client/camera.h
new file mode 100644
index 0000000..63c7aa5
--- /dev/null
+++ b/src/client/camera.h
@@ -0,0 +1,44 @@
+/* 	camera.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_CAMERA_H__
+#define __INCLUDED_CAMERA_H__
+
+#include "common/vector3f.h"
+
+/// camera functions
+/** The functions in this namespace performs the transformations
+for the camera eye location. The camera always looks at (0,0,0)
+*/
+namespace camera
+{
+	/// draw the OpenGL camera transformation
+	void draw(float elapsed);
+
+	/// rotate the camera left
+	void rotate_left();
+	/// rotate the camera right
+	void rotate_right();
+	/// rotate the camera up
+	void rotate_up();
+	/// rotate the camera down
+	void rotate_down();
+
+	/// switch to next camera mode
+	void nextmode();
+	
+	/// camera target
+	/** The location the camera is looking at */
+	extern Vector3f target;
+
+	/// horizontal viewing angle x/z plane
+	extern float horiz_angle;
+	/// vertical viewing angle z/y plane
+	extern float vert_angle;
+	/// distance from the camera to the target
+	/** The distance in game units from the eye of the camera to the target */
+	extern float distance;
+};
+	
+#endif // __INCLUDED_CAMERA_H__
diff --git a/src/client/hud.cc b/src/client/hud.cc
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/client/hud.cc
diff --git a/src/client/hud.h b/src/client/hud.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/client/hud.h
diff --git a/src/client/input.cc b/src/client/input.cc
new file mode 100644
index 0000000..8af7414
--- /dev/null
+++ b/src/client/input.cc
@@ -0,0 +1,86 @@
+/* input.cc
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+// SDL headers
+#include <SDL/SDL.h>
+
+//project headers
+#include "common/functions.h"
+#include "game/game.h"
+
+#include "view.h"
+#include "camera.h"
+
+namespace input
+{
+
+void init()
+{
+	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY,  SDL_DEFAULT_REPEAT_INTERVAL);
+}
+
+void shutdown()
+{
+}
+
+void handle_keydown(SDL_keysym* keysym)
+{
+	switch( keysym->sym ) {
+	case SDLK_ESCAPE:
+		game::shutdown();
+		break;
+	case SDLK_SPACE:
+		camera::nextmode();
+		break;
+	case SDLK_LEFT:
+		camera::rotate_left();
+		break;
+	case SDLK_RIGHT:
+		camera::rotate_right();
+		break;
+	case SDLK_UP:
+		camera::rotate_up();
+		break;
+	case SDLK_DOWN:
+		camera::rotate_down();
+		break;
+	case SDLK_KP_PLUS:
+		game::ship.thrust_increase();
+		break;
+	case SDLK_KP_MINUS:	
+		game::ship.thrust_decrease();
+		break;
+	case SDLK_KP4:
+		game::ship.turn_left();
+		break;
+	case SDLK_KP6:
+		game::ship.turn_right();
+		break;
+	default:
+        	break;
+	}
+
+}
+
+void process()
+{
+    SDL_Event event;
+
+    while( SDL_PollEvent( &event ) ) {
+        switch( event.type ) {
+//	case SDL_MOUSEBUTTONUP:
+        case SDL_KEYDOWN:
+            handle_keydown( &event.key.keysym );
+            break;
+        case SDL_QUIT:
+            game::shutdown();
+            break;
+        }
+
+    }
+
+}
+
+} // namespace input
diff --git a/src/client/input.h b/src/client/input.h
new file mode 100644
index 0000000..f1e94d9
--- /dev/null
+++ b/src/client/input.h
@@ -0,0 +1,24 @@
+/* input.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#ifndef __INCLUDED_INPUT_H__
+#define __INCLUDED_INPUT_H__
+
+
+namespace input
+{
+	/// initialize the input subsystem
+	void init();
+	/// shutdown the input subsystem
+	void shutdown();
+
+	/// exit the application
+	void quit(int exit_code);
+
+	/// process input events
+	void process();
+};
+
+#endif // __INCLUDED_INPUT_H__
diff --git a/src/client/main.cc b/src/client/main.cc
new file mode 100644
index 0000000..66e0fa3
--- /dev/null
+++ b/src/client/main.cc
@@ -0,0 +1,65 @@
+/* main.cc
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+// SDL headers
+#include <SDL/SDL.h>
+
+// C++ headers
+#include <iostream>
+
+// project headers
+#include "common/osirion.h"
+#include "game/game.h"
+
+#include "input.h"
+#include "video.h"
+
+void quit(int exit_code)
+{
+	SDL_Quit();
+	exit(exit_code);
+}
+
+int main( int argc, char *argv[] )
+{
+	std::cout << "The Osirion project " << OSIRION_VERSION << std::endl;
+
+	// Initialize the video subsystem
+	video::init();
+	if (!video::initialized) {
+		quit(1);
+	}
+
+	// initialize input
+	input::init();
+
+    	// initialize game
+	game::init();
+
+	Uint32 startup = SDL_GetTicks();
+	while(game::initialized) {		
+		Uint32 chrono = SDL_GetTicks();
+	
+		// overflow protection ~49 days
+		if (chrono < startup) {
+			startup = chrono;
+		}
+		
+		// update the game chronometers
+		float elapsed = (float) ( chrono - startup) / 1000.0f;
+		game::update(elapsed);
+
+		// update the video chronometers and draw
+		video::draw(elapsed);
+		startup = chrono;
+
+		// process input
+		input::process();
+	}
+
+	video::shutdown();
+
+	quit(0);
+}
diff --git a/src/client/shipdrawer.cc b/src/client/shipdrawer.cc
new file mode 100644
index 0000000..d889178
--- /dev/null
+++ b/src/client/shipdrawer.cc
@@ -0,0 +1,108 @@
+/* shipdrawer.cc
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#include <iostream>
+
+// project headers
+#include "gl/osiriongl.h"
+#include "gl/box.h"
+
+#include "shipdrawer.h"
+
+Vector3f v0(1.0f, -1.0f, -1.0f);
+Vector3f v1(1.0f,  1.0f, -1.0f);
+Vector3f v2(1.0f,  1.0f,  1.0f);
+Vector3f v3(1.0f, -1.0f,  1.0f);
+
+Vector3f v4(-1.0f, -1.0f, -1.0f);
+Vector3f v5(-1.0f,  1.0f, -1.0f);
+Vector3f v6(-1.0f,  1.0f,  1.0f);
+Vector3f v7(-1.0f, -1.0f,  1.0f);
+
+ShipDrawer::ShipDrawer(Ship *s) 
+{
+    	angle = 0;
+	ship = s;
+}
+
+ShipDrawer::~ShipDrawer() 
+{
+}
+
+void ShipDrawer::draw(float elapsed) 
+{
+	using namespace gl;
+
+	gl::push();
+
+	rotate(ship->yaw, 0.0f, 1.0f, 0.0f );
+
+
+	Vector3f tl(0.25, 0.125, 0.125);
+	Vector3f br(-0.25, -0.125, -0.125);
+	
+	Box box(tl, br);
+	box.draw();
+
+	tl = Vector3f(0, 0.07, 0.25);
+	br = Vector3f(-0.5, -0.07, 0.125);
+	Box engine1(tl, br);
+	engine1.topcolor = Color(0.7, 0.7, 0.7);
+	engine1.bottomcolor = engine1.topcolor * 0.5;
+	engine1.draw();
+
+	tl = Vector3f(0, 0.07, -0.125);
+	br = Vector3f(-0.5, -0.07, -0.25);
+	Box engine2(tl, br);
+	engine2.topcolor = engine1.topcolor;
+	engine2.bottomcolor = engine1.bottomcolor;
+	engine2.draw();
+
+	tl = Vector3f(0.4, 0.07, 0.07);
+	br = Vector3f(0.25, -0.07, -0.07);
+	Box cockpit(tl, br);
+	cockpit.topcolor = engine1.topcolor;
+	cockpit.bottomcolor = engine1.bottomcolor;
+	cockpit.draw();
+
+	if(ship->thrust	> 0 ) {
+		color(1.0f,0 ,0 );
+		begin(Lines);
+		vertex(-0.5f, 0, 0.185);
+		vertex(-0.5f-0.25f*ship->thrust, 0, 0.185);
+	
+		vertex(-0.5f, 0, -0.185f);
+		vertex(-0.5f-0.25f*ship->thrust, 0, -0.185f);
+		end();
+	}
+
+	// shield rotation
+    	rotate(angle, 0.0f, 1.0f, 0.0f );
+    	angle += 180.0f * elapsed;
+    	if( angle > 360.0f ) {
+            angle -= 360.0f;
+    	}
+	
+	// draw the shield
+	color(Color(0.0f, 1.0f ,0.0f , 0.5f));
+	
+	begin(LineStrip);
+        vertex(v0);
+    	vertex(v1);
+        vertex(v2);
+        vertex(v3);
+	vertex(v0);
+	end();
+
+	begin(LineStrip);
+        vertex(v4);
+    	vertex(v5);
+        vertex(v6);
+        vertex(v7);
+	vertex(v4);
+	end();
+
+	gl::pop();
+}
diff --git a/src/client/shipdrawer.h b/src/client/shipdrawer.h
new file mode 100644
index 0000000..8860585
--- /dev/null
+++ b/src/client/shipdrawer.h
@@ -0,0 +1,26 @@
+/* shipdrawer.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#ifndef __INCLUDED_SHIPDRAWER_H__
+#define __INCLUDED_SHIPDRAWER_H__
+
+// project headers
+#include "game/ship.h"
+
+class ShipDrawer
+{
+public:
+	ShipDrawer(Ship *s);
+	~ShipDrawer();
+
+	/// update the model state
+	void draw(float elapsed);
+
+private:
+	Ship *ship;
+	float angle;
+};
+
+#endif // __INCLUDED_SHIPDRAWER_H__
diff --git a/src/client/stardrawer b/src/client/stardrawer
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/client/stardrawer
diff --git a/src/client/stardrawer.cc b/src/client/stardrawer.cc
new file mode 100644
index 0000000..6bdf34c
--- /dev/null
+++ b/src/client/stardrawer.cc
@@ -0,0 +1,22 @@
+/* stardrawer.cc
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#include "gl/osiriongl.h"
+#include "stardrawer.h"
+
+StarDrawer::StarDrawer(Star *s) {
+	star = s;
+	sphere.radius = s->radius;
+	
+}
+StarDrawer::~StarDrawer() {
+	star = 0;
+}
+
+void StarDrawer::draw(float elapsed)
+{
+	gl::color(star->color);
+	sphere.draw();
+}
diff --git a/src/client/stardrawer.h b/src/client/stardrawer.h
new file mode 100644
index 0000000..7656414
--- /dev/null
+++ b/src/client/stardrawer.h
@@ -0,0 +1,26 @@
+/* stardrawer.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#ifndef __INCLUDED_STARDRAWER_H__
+#define __INCLUDED_STARDRAWER_H__
+
+#include "gl/sphere.h"
+#include "game/star.h"
+
+/// Class to draw stars
+class StarDrawer 
+{
+public:
+	StarDrawer(Star *s);
+	~StarDrawer();
+
+	void draw(float elapsed);
+
+private:
+	Star *star;
+	gl::Sphere sphere;
+};
+
+#endif // __INCLUDED_STARDRAWER_H__
diff --git a/src/client/video.cc b/src/client/video.cc
new file mode 100644
index 0000000..eb4297e
--- /dev/null
+++ b/src/client/video.cc
@@ -0,0 +1,109 @@
+/* video.cc
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+// SDL headers
+#include <SDL/SDL.h>
+
+// C++ headers
+#include <iostream>
+
+// project headers
+#include "gl/osiriongl.h"
+#include "view.h"
+
+
+namespace video 
+{
+int width = 0;
+int height = 0;
+bool initialized = false;
+float ratio = 1;
+
+void reset()
+{
+	ratio = (float) width / (float) height;
+
+	// Our shading model--Gouraud (smooth). 
+	gl::shademodel(GL_SMOOTH);
+
+	// Culling
+	gl::cullface( GL_BACK );
+	gl::frontface(GL_CCW );
+	gl::enable( GL_CULL_FACE );
+
+	gl::depthmask(GL_TRUE);       // Depth buffer writing
+	gl::enable(GL_DEPTH_TEST);
+
+	// Set the clear color
+	gl::clearcolor( 0, 0, 0, 0 );
+
+	// Setup our viewport.
+	gl::viewport(0, 0, width, height );
+
+	view::reset();
+}
+
+void init() 
+{
+	if (initialized) {
+		return;
+	}
+
+	int bpp = 0;
+	int flags = 0;
+
+	if( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
+		std::cerr << "SDL_Init() failed: " << SDL_GetError() << std::endl;
+		return;
+	}
+
+	const SDL_VideoInfo* sdl_videoinfo = SDL_GetVideoInfo();
+	if( !sdl_videoinfo) {
+		std::cerr << "SDL_GetVideoInfo() failed: " << SDL_GetError() << std::endl;
+		return;
+	}
+
+	width = 800;
+	height = 600;
+	bpp = sdl_videoinfo->vfmt->BitsPerPixel;
+
+	SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
+	SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
+	SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
+	SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
+	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+	flags = SDL_OPENGL | SDL_FULLSCREEN;
+
+	if(!SDL_SetVideoMode(width, height, bpp, flags )) {
+		std::cerr << "SDL_SetVideoMode() failed: " << SDL_GetError() << std::endl;
+		return;
+	}
+
+	gl::init();
+
+	initialized = true;
+	view::init();
+
+	reset();
+	return;
+}
+
+void draw(float elapsed)
+{
+	view::draw(elapsed);
+}
+
+void shutdown()
+{
+	view::shutdown();
+	gl::shutdown();
+
+	initialized = false;
+	width = 0;
+	height = 0;
+}
+
+} // namespace video
diff --git a/src/client/video.h b/src/client/video.h
new file mode 100644
index 0000000..3b126f1
--- /dev/null
+++ b/src/client/video.h
@@ -0,0 +1,30 @@
+/* 	video.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_VIDEO_H__
+#define __INCLUDED_VIDEO_H__
+
+
+namespace video 
+{
+	/// initialize the video subsystem
+	void init();
+	/// shutdown the video subsystem
+	void shutdown();
+	/// Update the screen state and redraw
+	void draw(float elapsed);
+	/// reset and clear the viewport
+	void reset();
+
+	/// Width of the SDL window in pixels
+	extern int width;
+	/// Height of the SDL window in pixels
+	extern int height;
+	/// True if the video subsystem is initialized
+	extern bool initialized;
+	/// width/height ratio
+	extern float ratio;
+};
+
+#endif // __INCLUDED_VIDEO_H__
diff --git a/src/client/view.cc b/src/client/view.cc
new file mode 100644
index 0000000..3641261
--- /dev/null
+++ b/src/client/view.cc
@@ -0,0 +1,153 @@
+/* view.cc
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+// C++ headers
+#include <iostream>
+
+// SDL headers
+#include <SDL/SDL.h>
+
+// project headers
+#include "common/functions.h"
+#include "common/osirion.h"
+
+#include "game/game.h"
+#include "gl/osiriongl.h"
+
+#include "video.h"
+#include "camera.h"
+
+#include "shipdrawer.h"
+#include "stardrawer.h"
+
+namespace view
+{
+
+ShipDrawer *shipdrawer = 0;
+StarDrawer *stardrawer = 0;
+
+Ship *target =0; // the view's target
+
+void init() {
+	// draw scene
+	if (!shipdrawer) {
+		stardrawer = new StarDrawer(&game::star);
+		shipdrawer = new ShipDrawer(&game::ship);	
+		target = &game::ship;
+	}
+	
+}
+
+void shutdown() 
+{
+	delete stardrawer;
+	stardrawer = 0;
+	delete shipdrawer;
+	shipdrawer = 0;
+}
+
+void reset() {
+	// Change to the projection matrix and set our viewing volume.
+	gl::matrixmode( GL_PROJECTION );
+	gl::loadidentity();
+
+	//glu::perspective( 64.0, video::ratio, 1.0, 1024.0 );
+	const float frustumsize=0.5f;
+	gl::frustum( -frustumsize * video::ratio, frustumsize * video::ratio, -frustumsize, frustumsize, 1.0, 1024.0);
+	/* 
+		map world coordinates to GL coordinates
+	 
+		The world coordinates are identical to GL coordinates, 
+		but the default viewing pitch (0 degrees)
+		is the positive X-axis
+	*/
+	gl::rotate(90.0f, 0, 1.0, 0);
+}
+
+void draw_background()
+{
+	using namespace gl;
+	
+	begin(Lines);
+	color(0.9f, 0.5f, 0.0f);
+	vertex(-2,1,0);
+	color(1.0f, 1.0f, 0.0f);
+	vertex(2,1,0);
+
+	vertex(0,1,-0.5);
+	vertex(0,1,0.5);
+
+	vertex(0,2.0f,0);
+	vertex(0,-1, 0);
+	end();
+
+	int gridsize = 32;
+	float s = 1.0f / gridsize;
+	float y = -4.0f;
+
+	float dx =  target->location.x - floorf(target->location.x);
+	float dz =  target->location.z - floorf(target->location.z);
+
+    	color(0,0, 1.0f); 
+    	begin(Lines);
+    	for (int i=-gridsize; i <= gridsize; i++) {
+		color(0,0, 0);
+		vertex(i-dx, y, -gridsize-dz);
+		color(0,0, (gridsize-abs(i))*s);
+		vertex(i-dx, y, -dz);
+		vertex(i-dx, y, -dz);
+		color(0,0, 0);
+		vertex(i-dx, y, gridsize-dz);
+	
+		vertex(-gridsize-dx, y, i-dz);
+		color(0,0, (gridsize-abs(i))*s);
+		vertex(-dx, y, i-dz);
+		vertex(-dx, y, i-dz);
+		color(0,0, 0);
+		vertex(gridsize-dx, y, i-dz);
+	}	
+	end();
+}
+
+void draw_world(float elapsed)  
+{
+	// draw the world
+	gl::push();
+
+	//std::cerr << "ship at " << game::ship.location << " translate " << game::ship.location - target->location << std::endl;
+	gl::translate(game::ship.location - target->location);
+	gl::scale(GAMESCALE,  GAMESCALE,  GAMESCALE);
+	shipdrawer->draw(elapsed);
+	gl::pop();
+
+	//std::cerr << "star at " << game::star.location << " translate " << game::star.location - game::ship.location << std::endl;
+	gl::translate(game::star.location - target->location);	
+	stardrawer->draw(elapsed);
+
+}
+
+void draw(float elapsed) 
+{
+	// Clear the color and depth buffers.
+	gl::clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+	
+	// We don't want to modify the projection matrix.
+	gl::matrixmode( GL_MODELVIEW );
+	gl::loadidentity();
+
+	// Camera transformation
+	camera::draw(elapsed);
+
+	// draw the semi-static background
+	draw_background();
+
+	// draw the world
+	draw_world(elapsed);
+
+	SDL_GL_SwapBuffers( );
+}
+
+} // namespace view
+
diff --git a/src/client/view.h b/src/client/view.h
new file mode 100644
index 0000000..de73ab9
--- /dev/null
+++ b/src/client/view.h
@@ -0,0 +1,24 @@
+/* view.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#ifndef __INCLUDED_VIEW_H__
+#define __INCLUDED_VIEW_H__
+
+#include "common/vector3f.h"
+
+/// Draws the view of the map
+namespace view
+{
+	void init();
+	void shutdown();
+
+	/// Update the chronometer and draw the game view
+	void draw(float elapsed);
+
+	/// Reset the projection matrix
+	void reset();
+};
+
+#endif // __INCLUDED_VIEW_H__
diff --git a/src/common/Makefile.am b/src/common/Makefile.am
new file mode 100644
index 0000000..4f556bf
--- /dev/null
+++ b/src/common/Makefile.am
@@ -0,0 +1,8 @@
+
+METASOURCES = AUTO
+libcommon_la_LDFLAGS = -avoid-version -no-undefined
+noinst_LTLIBRARIES = libcommon.la
+libcommon_la_SOURCES = color.cc color.h functions.cc functions.h osirion.h\
+	vector3f.cc vector3f.h
+
+
diff --git a/src/common/color.cc b/src/common/color.cc
new file mode 100644
index 0000000..85892c8
--- /dev/null
+++ b/src/common/color.cc
@@ -0,0 +1,84 @@
+/*
+ ***************************************************************************
+ *   Copyright (C) 2002-2004 by Stijn Buys                                 *
+ *   stijn.buys@pandora.be                                                 *
+ *                                                                         *
+ *   This software is redistributed under the terms of the                 *
+ *   GNU General Public License. Please read LICENSE.txt.                  *
+ ***************************************************************************
+*/
+
+#include "color.h"
+
+Color::Color() {
+	_r = _g = _b = 0.0f;
+	_a = 1.0f;
+}
+
+Color::Color(const float red, const float green , const float blue , const float alpha) {
+	_r = red;
+	_g = green;
+	_b = blue;
+	_a = alpha;
+}
+
+Color::Color(const float grey, const float alpha) {
+	_r = _g = _b = grey;
+	_a = alpha;
+}
+
+Color::Color(const Color &other) {
+	this->operator=(other);
+}
+
+const Color & Color::operator=(const Color &other) {
+	this->_r = other._r;
+	this->_g = other._g;
+	this->_b = other._b;
+	this->_a = other._a;
+	return (*this);
+}
+
+void Color::normalize() {
+	float tmp = _r;
+
+	if (_g > tmp)
+		tmp = _g;
+	if ( _b > tmp)
+		tmp = _b;
+
+	if (tmp > 1) {
+		_r /= tmp;
+		_g /= tmp;
+		_b /= tmp;
+	}	
+}
+
+float Color::red() const {
+	return _r;
+}
+
+float Color::green() const {
+	return _g;
+}
+
+float Color::blue() const {
+	return _b;
+}
+
+float Color::alpha() const {
+	return _a;
+}
+
+Color Color::operator*(float scalar) const {
+	return Color(red()*scalar, green()*scalar, blue()*scalar, alpha());
+}
+
+Color operator*(float scalar, const Color& color) {
+	return color * scalar;
+}
+std::ostream &operator<<(std::ostream &os, const Color &c) {
+	os <<  c.red() << " " << c.green() << " " << c.blue() << " " << c.alpha();
+	return os;
+}
+
diff --git a/src/common/color.h b/src/common/color.h
new file mode 100644
index 0000000..d84d1a3
--- /dev/null
+++ b/src/common/color.h
@@ -0,0 +1,50 @@
+/*
+ ***************************************************************************
+ *   Copyright (C) 2004 by Stijn Buys                                      *
+ *   stijn.buys@pandora.be                                                 *
+ *                                                                         *
+ *   This software is redistributed under the terms of the                 *
+ *   GNU General Public License. Please read LICENSE.txt.                  *
+ ***************************************************************************
+*/
+
+#ifndef __COLOR_HEADER__
+#define __COLOR_HEADER__
+
+#include <iostream> 
+
+/// a class representing an RGBA color value
+class Color {
+	public:
+		Color();
+		Color(const float, float  const, const float, const float=1.0f);
+		Color(const float, const float=1.0f);
+		Color(const Color &);
+
+		float red() const;
+		float green() const;
+		float blue() const;
+		float alpha() const;
+		
+		const Color &operator=(const Color &);
+		
+		Color operator*(const float scalar) const;
+		
+		// Some default colors
+		static const Color Black() { return Color(0.0f); };
+		static const Color White() { return Color(1.0f); };
+		static const Color Red() { return Color(1.0f,0.0f,0.0f); };
+		static const Color Green() { return Color(0.0f,1.0f,0.0f); };
+		static const Color Blue()  { return Color(0.0f, 0.0f, 1.0f); };
+		static const Color Yellow() { return Color(1.0f, 1.0f, 0.0f); };
+
+	private:
+		void normalize();
+		float _r, _g, _b, _a;
+};
+
+std::ostream &operator<<(std::ostream &os, const Color &c);
+
+Color operator*(const float scalar, const Color& color);
+
+#endif // ___HEADER__
diff --git a/src/common/functions.cc b/src/common/functions.cc
new file mode 100644
index 0000000..7152c91
--- /dev/null
+++ b/src/common/functions.cc
@@ -0,0 +1,48 @@
+/*	functions.cc
+ *	This file is part of the Osirion project
+ */
+
+#include "functions.h"
+
+float min(float a, float b) {
+	return (a < b ? a : b);
+}
+
+float max(float a, float b) {
+	return (a > b ? a : b);
+}
+
+int min(int a, int b) {
+	return (a < b ? a : b);
+}
+
+int max(int a, int b) {
+	return (a > b ? a : b);
+}
+
+float randomf(const float max) {
+	return ((float) rand() / (float) RAND_MAX) * max;
+}
+
+unsigned randomi(const unsigned int max) {
+	return ((unsigned int)(rand() % max));
+}
+
+float degreesf(float angle) {	
+	float r = angle;
+	while (r <= -180.0f)
+		r += 360.0f;
+	while (r >= 180.0f)
+		r -= 360.0f;
+	return r;
+}
+
+float sgnf(float value)
+{
+	if (value < 0 )
+		return -1;
+	else if (value == 0 )
+		return 0;
+
+	return 1;
+}
diff --git a/src/common/functions.h b/src/common/functions.h
new file mode 100644
index 0000000..02f25da
--- /dev/null
+++ b/src/common/functions.h
@@ -0,0 +1,42 @@
+/* 	functions.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_FUNCTIONS_H__
+#define __INCLUDED_FUNCTIONS_H__
+
+#include <cstdlib>
+#include <cmath>
+
+/// return the smallest of two float values
+float min(float a, float b);
+
+/// return the smallest of two integers
+int min(int a, int b);
+
+/// return the largest of two float values
+float max(float a, float b);
+
+/// return the largest of two integers
+int max(int a, int b);
+
+/// returns a random float
+/*! The value returned will be in the interval [0-max]
+ * @param max the maximum value returned
+**/
+float randomf(const float max = 1);
+
+/// returns a random integer
+/*! The value returned will be in the interval [0-(max-1)]
+ * @param max the maximum value returned
+**/
+unsigned int randomi(const unsigned int max);
+
+/// return the sign of a float value
+float sgnf(float value);
+
+/// return an angle in the ]-180,180] range
+float degreesf(float angle);
+
+#endif // __INCLUDED_FUNCTIONS_H__
+
diff --git a/src/common/osirion.h b/src/common/osirion.h
new file mode 100644
index 0000000..56d8b4e
--- /dev/null
+++ b/src/common/osirion.h
@@ -0,0 +1,11 @@
+/* 	osirion.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_OSIRION_H__
+#define __INCLUDED_OSIRION_H__
+
+#define OSIRION_VERSION "0.0.1"
+#define GAMESCALE 0.2f
+
+#endif // __INCLUDED_OSIRION_H__
diff --git a/src/common/vector3f.cc b/src/common/vector3f.cc
new file mode 100644
index 0000000..3e469b6
--- /dev/null
+++ b/src/common/vector3f.cc
@@ -0,0 +1,151 @@
+/* 	vector3f.h
+	This file is part of the Osirion project
+*/
+#include "vector3f.h"
+#include <cmath>
+
+Vector3f::Vector3f() : 
+	x(coord[0]), y(coord[1]), z(coord[2])
+{
+		for (int i=0; i < 3; i++)
+			coord[i] = 0;
+}
+
+
+Vector3f::Vector3f(const Vector3f &other)  : 
+	x(coord[0]), y(coord[1]), z(coord[2])
+{
+	for (int i=0; i < 3; i++)
+		coord[i] = other.coord[i];
+}
+
+Vector3f::Vector3f(const float xv, const float yv, const float zv) : 
+	x(coord[0]), y(coord[1]), z(coord[2])
+{
+	coord[0] = xv;
+	coord[1] = yv;
+	coord[2] = zv;
+}
+
+Vector3f::~Vector3f() 
+{
+}
+
+
+Vector3f & Vector3f::operator=(const Vector3f & other) 
+{
+	for (int i=0; i < 3; i++)
+		coord[i] = other.coord[i];
+	return (*this);
+}
+
+
+Vector3f & Vector3f::operator*=(const float scalar) 
+{
+		for (int i=0; i < 3; i++)
+			coord[i] *= scalar;
+		return (*this);
+}
+
+
+Vector3f & Vector3f::operator/=(const float scalar) {
+		for (int i=0; i < 3; i++)
+			coord[i] /= scalar;
+		return (*this);
+}
+
+
+Vector3f &Vector3f::operator-=(const Vector3f & other) {
+		for (int i=0; i < 3; i++)
+			coord[i] -= other[i];
+		return (*this);
+}
+
+
+Vector3f &Vector3f::operator+=(const Vector3f &other) {
+		for (int i=0; i < 3; i++)
+			coord[i] += other[i];
+		return (*this);
+}
+
+
+Vector3f Vector3f::operator*(const float scalar) const {
+		Vector3f r(*this);
+  		for (int i=0; i < 3; i++)
+			r.coord[i] *= scalar;
+		return (r);
+	}
+
+
+Vector3f Vector3f::operator/(const float scalar) const {
+		Vector3f r(*this);
+  		for (int i=0; i < 3; i++)
+			r.coord[i] /= scalar;
+		return (r);
+}
+
+
+Vector3f Vector3f::operator-(const Vector3f& other) const {
+		Vector3f r(*this);
+  		for (int i=0; i < 3; i++)
+			r.coord[i] -= other.coord[i];
+		return (r);
+}
+
+
+Vector3f Vector3f::operator+(const Vector3f& other) const {
+		Vector3f r(*this);
+  		for (int i=0; i < 3; i++)
+			r.coord[i] += other.coord[i];
+		return (r);
+}
+
+
+float Vector3f::operator*(const Vector3f& other) const {
+		float r = 0;
+  		for (int i=0; i < 3; i++)
+			r += coord[i] * other.coord[i];
+		return (r);
+}
+
+
+bool Vector3f::operator==(const Vector3f& other) const {
+	for (int i=0; i < 3; i++)
+		if (coord[i] != other.coord[i])
+			return (false);
+	return (true);
+}
+
+float Vector3f::lengthsquared() const {
+		double r = 0;
+		for (int i=0; i < 3; i++)
+			r += coord[i]*coord[i];
+		return ((float) r);
+}
+
+float Vector3f::length() const {
+		double r = 0;
+		for (int i=0; i < 3; i++)
+			r += coord[i]*coord[i];
+
+		return ((float) sqrt(r));
+}
+
+void Vector3f::normalize() {
+		(*this) /= this->length();
+}
+
+std::ostream &operator<<(std::ostream & os, const Vector3f & vector) {
+	os << vector[0] << " " << vector[1] << " " << vector[2];
+	return os;
+}
+
+std::istream &operator>>(std::istream & is, Vector3f & vector) {
+	for (int i=0; i < 3; i++)
+		is >> vector[i];
+	return is;
+}
+
+Vector3f operator*(float scalar, const Vector3f& vector) {
+	return vector * scalar;
+}
diff --git a/src/common/vector3f.h b/src/common/vector3f.h
new file mode 100644
index 0000000..53b2ce7
--- /dev/null
+++ b/src/common/vector3f.h
@@ -0,0 +1,138 @@
+/* 	vector3f.h
+	This file is part of the Osirion project
+*/
+
+ #ifndef __INCLUDED_VECTOR3F_H__
+ #define __INCLUDED_VECTOR3F_H__
+
+ #include <iostream>
+/// A point or vector in 3D-space
+/*!
+ An instance of this class represents a point in 3D-space or a 3D-vector
+ and forms the basic building block for all spatial calculations.
+ */
+class Vector3f {
+
+public:
+	/// Default constructor, creates a Vector3f (0,0,0)
+	Vector3f();
+
+	/// Copy constructor
+	/*! Create a new Vector3f that is a copy from an other
+	 * @param other the vector to copy values from
+	 */
+	Vector3f(const Vector3f &other);
+
+	/// Create a Vector3f with given coordinates
+	/*! Create a new vector at a given position in a 3D-space
+	 * @param xv	the x-coordinate of the location
+	 * @param yv 	the y-coordinate of the location
+	 * @param zv	the z-coordinate of the location
+	 */
+	Vector3f(const float xv, const float yv, const float zv);
+
+	/// Destructor
+	~Vector3f();
+
+	/* -- Assignment operators -- */
+	/// assignment operator
+	Vector3f& operator=(const Vector3f &other);
+
+	/// multiplicate each element of the vector with a given value
+	/// @param scalar multiplication factor
+	Vector3f& operator*=(const float scalar);
+
+	/// divide each element of the vector by a given value
+	/// @param scalar divider
+	Vector3f& operator/=(const float scalar);
+
+	/// perform an element-wise subtraction
+	Vector3f& operator-=(const Vector3f &other);
+
+	/// perform ann element-wise addition
+	Vector3f& operator+=(const Vector3f &other);
+
+	/* -- Mathematical operators -- */
+
+	/// return this Vector multiplied with scalar
+	Vector3f operator*(const float scalar) const;
+
+	/// return this vector divided by a scalar
+	Vector3f operator/(const float scalar) const;
+
+	/// return the element-wise difference between two vectors
+	Vector3f operator-(const Vector3f &other) const;
+
+	/// return the element-wise sumn of two vectors
+	Vector3f operator+(const Vector3f &other) const;
+
+	/// return the vector cross-product
+	float operator*(const Vector3f &other) const;
+
+	/// comparison operator
+	bool operator==(const Vector3f &other) const;
+
+	/// assign a value to an element of this vector
+	/*! WARNING: range is not checked
+	 *  @param index the index of the element to assign to ( 0 <= index < 3 )
+	*/
+	inline float& operator[](const unsigned int index) {
+		return coord[index];
+	}
+
+	/// returns the value of an element of this vector
+	/*! WARNING: range is not checked
+	 *  @param index the index of the element to return ( 0 <= index < 3 )
+	 */
+	inline float operator[](const unsigned int index) const {
+		return coord[index];
+	}
+	
+	
+	float &x;
+	float &y;
+	float &z;
+	
+	/// Return the cartesian length of this vector
+	float length() const;
+	
+	/// Return the cartesian length squared (to speed up calculations)
+	float lengthsquared() const;
+
+	/// Divide this Vector by it's length
+	/// @see normalized()
+	/// WARNING: vector must not be (0, 0, 0)
+	void normalize();
+
+	/* static functions */
+
+	/// Returns the unity vector on the X-axis
+	static inline Vector3f Xaxis() { return Vector3f(1.0f, 0.0f, 0.0f); }
+
+	/// Returns the unity vector on the Y-axis
+	static inline Vector3f Yaxis() { return Vector3f(0.0f, 1.0f, 0.0f); }
+
+	/// Returns the unity vector on the Z-axis
+	static inline Vector3f Zaxis() { return Vector3f(0.0f, 0.0f, 1.0f); }
+
+	/// Return the cartesian length of a vector
+	static inline float length(const Vector3f& vector) { return vector.length(); }
+
+	/// Return a vector divided by it's length
+	/// @see normalize()
+	/// WARNING: vector must not be (0, 0, 0)
+	static inline Vector3f normalized(const Vector3f& vector) { return (vector / vector.length()); }
+
+	float coord[3];
+};
+
+/// Write a Vector3f to a std::ostream
+std::ostream &operator<<(std::ostream & os, const Vector3f & vector);
+
+/// Read a Vector3d from a std::istream
+std::istream &operator>>(std::istream & is, Vector3f& vector);
+
+/// scalar*Vector3f operators
+Vector3f operator*(float scalar, const Vector3f& vector);
+
+#endif // __INCLUDED_VECTOR3F_H__
diff --git a/src/game/Makefile.am b/src/game/Makefile.am
new file mode 100644
index 0000000..754c168
--- /dev/null
+++ b/src/game/Makefile.am
@@ -0,0 +1,9 @@
+
+METASOURCES = AUTO
+libgame_la_LDFLAGS = -avoid-version
+noinst_LTLIBRARIES = libgame.la
+
+libgame_la_SOURCES = game.cc game.h ship.cc ship.h player.h world.h star.cc \
+		star.h sector.h
+INCLUDES = -I$(top_srcdir)/src
+noinst_HEADERS = world.h sector.h
diff --git a/src/game/game.cc b/src/game/game.cc
new file mode 100644
index 0000000..dfa5fe5
--- /dev/null
+++ b/src/game/game.cc
@@ -0,0 +1,31 @@
+/* 	game.cc
+	This file is part of the Osirion project
+*/
+
+// project headers
+#include "ship.h"
+#include "star.h"
+
+namespace game {
+
+Ship ship;
+Star star;
+bool initialized = false;
+
+void init() 
+{
+	star.location = Vector3f(256.0f, 0.0f, 256.0f);
+	initialized = true;
+}
+
+void shutdown()
+{
+	initialized = false;
+}
+
+void update(float elapsed) 
+{
+	ship.update(elapsed);
+}
+	
+}; // namespace game
diff --git a/src/game/game.h b/src/game/game.h
new file mode 100644
index 0000000..7c1cc0c
--- /dev/null
+++ b/src/game/game.h
@@ -0,0 +1,33 @@
+/* 	game.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_GAME_H__
+#define __INCLUDED_GAME_H__
+
+// project headers
+#include "ship.h"
+#include "star.h"
+
+namespace game
+{
+	/// initialize the game
+	void init();
+
+	/// shutdown the game
+	void shutdown();
+
+	/// update the game state
+	void update(float elapsed);
+
+	/// the only ship in the game
+	extern Ship ship;
+
+	/// the only star in the game
+	extern Star star;
+
+	/// true while the game is running
+	extern bool initialized;
+};
+
+#endif // __INCLUDED_GAME_H__
diff --git a/src/game/player.h b/src/game/player.h
new file mode 100644
index 0000000..4c75206
--- /dev/null
+++ b/src/game/player.h
@@ -0,0 +1,20 @@
+/* player.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#ifndef __INCLUDED_PLAyER_H__
+#define __INCLUDED_PLAyER_H__
+
+#include <string>
+
+/// A player in the game
+class Player {
+public:
+	Player();
+	~Player();
+
+	std::string name;
+};
+
+#endif // __INCLUDED_PLAyER_H__
diff --git a/src/game/sector.h b/src/game/sector.h
new file mode 100644
index 0000000..10f548c
--- /dev/null
+++ b/src/game/sector.h
@@ -0,0 +1,26 @@
+/* sector.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#ifndef __INCLUDED_SECTOR_H__
+#define __INCLUDED_SECTOR_H__
+
+#include <string>
+
+namespace game
+{
+class Sector {
+public:
+	Sector();
+	~Sector();
+
+	/// tag used in configuration files, e.g. "terran"
+	std::string tag;
+	/// name to display, e.g. "Terran System"
+	std::string name;
+};
+
+} // namespace game
+
+#endif // __INCLUDED_SECTOR_H__
diff --git a/src/game/ship.cc b/src/game/ship.cc
new file mode 100644
index 0000000..a24be0d
--- /dev/null
+++ b/src/game/ship.cc
@@ -0,0 +1,85 @@
+/* 	ship.cc
+	This file is part of the Osirion project
+*/
+
+// C++ headers
+#include <iostream>
+
+// project headers
+#include "common/functions.h"
+#include "common/osirion.h"
+
+#include "ship.h"
+
+Ship::Ship()
+{
+	speed = 0;
+	yaw = 0;
+	yaw_offset = 0;
+
+	thrust = 0;
+	
+	// ship specs
+	acceleration = 6 * GAMESCALE;
+	max_speed = 16.0f * GAMESCALE;
+	
+	max_yaw_offset = 45;
+	yaw_speed = 4;
+}
+
+Ship::~Ship() 
+{
+}
+
+void Ship::update(float elapsed) 
+{
+	// update yaw
+	float d = yaw_speed * elapsed * yaw_offset;
+	yaw_offset -= d;
+	yaw +=d;
+
+	// update thrust
+	if (speed < thrust * max_speed) {
+		speed += acceleration * elapsed;
+		if (speed > thrust * max_speed) {
+			speed = thrust * max_speed;
+		}
+	} else if(speed > thrust * max_speed) {
+		speed -= acceleration * elapsed;
+		if (speed < 0) speed = 0;
+	}
+
+	// location TODO avoid sin/cos calculations
+	location.x += cosf(yaw * M_PI / 180) * speed * elapsed;
+	location.z -= sinf(yaw * M_PI / 180) * speed * elapsed;
+}
+
+
+void Ship::thrust_increase()
+{
+	thrust += 0.05;
+	if (thrust > 1) thrust = 1;
+}
+
+void Ship::thrust_decrease()
+{
+	thrust -= 0.08;
+	if (thrust < 0) thrust = 0;
+}
+
+void Ship::turn_left() 
+{
+	//yaw = degreesf(yaw + 2);
+	yaw_offset += 2;
+	if (yaw_offset > max_yaw_offset)
+		yaw_offset = max_yaw_offset;
+}
+
+void Ship::turn_right() 
+{
+	//yaw = degreesf(yaw - 2);
+	yaw_offset -= 2;
+	if (yaw_offset < -max_yaw_offset)
+		yaw_offset = - max_yaw_offset;
+}
+
diff --git a/src/game/ship.h b/src/game/ship.h
new file mode 100644
index 0000000..d6a00ba
--- /dev/null
+++ b/src/game/ship.h
@@ -0,0 +1,54 @@
+/* 	ship.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_SHIP_H__
+#define __INCLUDED_SHIP_H__
+
+// project headers
+#include "common/vector3f.h"
+
+class Ship 
+{
+public:
+	Ship();
+	~Ship();
+
+	/// update the ship state
+	void update(float elapsed);
+
+	/// location of the ship in space
+	Vector3f location;
+	/// speed vector in units/second
+	float speed;
+
+	/// turn left, increase yaw_offset
+	void turn_left();
+	/// turn right, decrease yaw_offset
+	void turn_right();
+	/// yaw, angle in the x/z plane
+	float yaw;
+	
+	/// increase thrust
+	void thrust_increase();
+	/// decrease thrust
+	void thrust_decrease();
+	/// forward thruster in % [0-1]
+	float thrust;
+
+	/* -- Ship SPECS --*/
+	/// acceleration
+	float acceleration;
+	/// maximum speed
+	float max_speed;
+	/// maximum yaw_offset
+	float max_yaw_offset;
+	/// yaw turn speed
+	float yaw_speed;
+
+private:
+	float yaw_offset;
+};
+
+#endif // __INCLUDED_SHIP_H__
+
diff --git a/src/game/star.cc b/src/game/star.cc
new file mode 100644
index 0000000..6aa82ac
--- /dev/null
+++ b/src/game/star.cc
@@ -0,0 +1,17 @@
+/* star.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#include "star.h"
+
+Star::Star() : 
+	location(0,0,0), 
+	color(1,1,1,1)
+{
+	radius = 48;
+}
+
+Star::~Star()
+{
+}
diff --git a/src/game/star.h b/src/game/star.h
new file mode 100644
index 0000000..ef33ad5
--- /dev/null
+++ b/src/game/star.h
@@ -0,0 +1,29 @@
+/* star.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#ifndef __INCLUDED_STAR_H__
+#define __INCLUDED_STAR_H__
+
+// C++ headers
+#include <string>
+
+// project headers
+#include "common/vector3f.h"
+#include "common/color.h"
+
+/// A star, that shines so bright
+class Star {
+public:
+	Star();
+	~Star();
+
+	Vector3f location;
+	Color color;
+	float radius;
+
+	std::string name;
+};
+
+#endif // __INCLUDED_STAR_H__
diff --git a/src/game/world.h b/src/game/world.h
new file mode 100644
index 0000000..8cbc232
--- /dev/null
+++ b/src/game/world.h
@@ -0,0 +1,24 @@
+/* world.h
+   This file is part of the Osirion project and is distributed under 
+   the terms and conditions of the GNU General Public License version 2 
+*/
+
+#ifndef __INCLUDED_WORLD_H__
+#define __INCLUDED_WORLD_H__
+
+#include <string>
+
+namespace game
+{
+
+/// The game world
+namespace World {
+	/// load the intial game world into memory 
+	void init();
+	/// unload the game world
+	void shutdown();
+};
+
+} // namespace game
+
+#endif // __INCLUDED_WORLD_H__
diff --git a/src/gl/Makefile.am b/src/gl/Makefile.am
new file mode 100644
index 0000000..e7f6663
--- /dev/null
+++ b/src/gl/Makefile.am
@@ -0,0 +1,10 @@
+
+METASOURCES = AUTO
+
+libosiriongl_la_LDFLAGS = -avoid-version
+noinst_LTLIBRARIES = libosiriongl.la
+
+INCLUDES = -I$(top_srcdir)/src
+libosiriongl_la_SOURCES = box.h box.cc sphere.cc sphere.h osiriongl.cc \
+	osiriongl.h
+noinst_HEADERS = box.h box.h
diff --git a/src/gl/box.cc b/src/gl/box.cc
new file mode 100644
index 0000000..67a8ed0
--- /dev/null
+++ b/src/gl/box.cc
@@ -0,0 +1,96 @@
+/* 	box.cc
+	This file is part of the Osirion project
+*/
+
+// project headers
+#include "box.h"
+#include "osiriongl.h"
+
+namespace gl {
+
+Box::Box(Vector3f const & tl, Vector3f const &br) : 
+	topleft(tl), bottomright(br)
+{
+	topcolor = Color::White();
+	bottomcolor= Color::White() * 0.7f;
+}
+
+Box::Box(const Box & other)
+{
+	(*this) = other;
+}
+
+Box& Box::operator=(const Box &other)
+{
+	bottomcolor = other.bottomcolor;
+	topcolor = other.topcolor;
+
+	topleft = other.topleft;
+	bottomright = other.bottomright;
+	return (*this);
+}
+
+void Box::draw()
+{
+	Vector3f v0(topleft.x, bottomright.y, bottomright.z);
+	Vector3f v1(topleft.x,  topleft.y, bottomright.z);
+	Vector3f v2(topleft.x,  topleft.y,  topleft.z);
+	Vector3f v3(topleft.x, bottomright.y,  topleft.z);
+
+	Vector3f v4(bottomright.x, bottomright.y, bottomright.z);
+	Vector3f v5(bottomright.x,  topleft.y, bottomright.z);
+	Vector3f v6(bottomright.x,  topleft.y,  topleft.z);
+	Vector3f v7(bottomright.x, bottomright.y,  topleft.z);
+
+	begin(Quads);
+
+	// top
+	color(topcolor);	
+	vertex(v2);
+	vertex(v1);
+        vertex(v5);
+	vertex(v6);
+	
+	// sides
+	color(bottomcolor);
+	vertex(v0);
+	color(topcolor);
+    	vertex(v1);
+        vertex(v2);
+	color(bottomcolor);
+        vertex(v3);
+
+        vertex(v3);
+	color(topcolor);
+    	vertex(v2);
+        vertex(v6);
+	color(bottomcolor);
+        vertex(v7);
+
+	vertex(v4);
+	color(topcolor);
+    	vertex(v5);
+        vertex(v1);
+	color(bottomcolor);
+        vertex(v0);
+
+	vertex(v7);
+	color(topcolor);
+    	vertex(v6);
+        vertex(v5);
+	color(bottomcolor);
+        vertex(v4);
+
+	// bottom
+	color(bottomcolor);	
+	vertex(v4);
+	vertex(v0);
+        vertex(v3);
+	vertex(v7);
+
+	end();
+
+}
+
+} // namespace gl
+
diff --git a/src/gl/box.h b/src/gl/box.h
new file mode 100644
index 0000000..f612243
--- /dev/null
+++ b/src/gl/box.h
@@ -0,0 +1,41 @@
+/* 	box.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_BOX_H__
+#define __INCLUDED_BOX_H__
+
+#include "common/vector3f.h"
+#include "common/color.h"
+
+namespace gl {
+
+/// a drawable OpenGL block shape
+class Box 
+{
+public:
+	/// create a new standard cube with edge length 1
+	Box(Vector3f const & tl, Vector3f const &br);
+	/// copy constructor
+	Box(const Box &other);
+	
+	/// assignment operator
+ 	Box& operator=(const Box &other);
+
+	/// top left vertex (1,1,1)
+	Vector3f topleft;
+	/// bottom right vertex (-1,-1,-1)
+	Vector3f bottomright;
+
+	/// draw the block
+	void draw();
+
+	/// Top color
+	Color topcolor;
+	/// bottom color
+	Color bottomcolor;
+};
+
+} // namespace gl
+
+#endif // __INCLUDED_BOX_H__
diff --git a/src/gl/osiriongl.cc b/src/gl/osiriongl.cc
new file mode 100644
index 0000000..0917eec
--- /dev/null
+++ b/src/gl/osiriongl.cc
@@ -0,0 +1,214 @@
+/* 	gl.cc
+ *	This file is part of the Osirion project
+ */
+
+// SDL headers
+#include <SDL/SDL.h>
+
+#include "osiriongl.h"
+
+namespace gl 
+{
+
+typedef void (APIENTRY *glBegin_func)(GLenum);
+typedef void (APIENTRY *glEnd_func)();
+typedef void (APIENTRY *glViewport_func)(GLint, GLint, GLsizei, GLsizei);
+typedef void (APIENTRY *glDepthMask_func)(GLenum);
+typedef void (APIENTRY *glFrontFace_func)(GLenum);
+typedef void (APIENTRY *glCullFace_func)(GLenum);
+typedef void (APIENTRY *glShadeModel_func)(GLenum);
+typedef void (APIENTRY *glEnable_func)(GLenum);
+typedef void (APIENTRY *glClear_func)(GLbitfield);
+typedef void (APIENTRY *glClearColor_func)(GLclampf, GLclampf, GLclampf,GLclampf);
+typedef void (APIENTRY *glRotatef_func)(GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (APIENTRY *glTranslatef_func)(GLfloat, GLfloat, GLfloat);
+typedef void (APIENTRY *glScalef_func)(GLfloat, GLfloat, GLfloat);
+typedef void (APIENTRY *glVertex3f_func)(GLfloat, GLfloat, GLfloat);
+typedef void (APIENTRY *glPushMatrix_func)();
+typedef void (APIENTRY *glPopMatrix_func)();
+typedef void (APIENTRY *glColor4f_func)(GLfloat, GLfloat, GLfloat, GLfloat);
+typedef void (APIENTRY *glMatrixMode_func)(GLenum);
+typedef void (APIENTRY *glLoadIdentity_func)();
+typedef void (APIENTRY *glFrustum_func)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble);
+
+glBegin_func osglBegin = 0;
+glEnd_func osglEnd = 0;
+glViewport_func osglViewport = 0;
+glDepthMask_func osglDepthMask = 0;
+glFrontFace_func osglFrontFace = 0;
+glCullFace_func osglCullFace = 0;
+glShadeModel_func osglShadeModel = 0;
+glEnable_func osglEnable = 0;
+glClear_func osglClear = 0;
+glClearColor_func osglClearColor = 0;
+glRotatef_func osglRotatef = 0;
+glTranslatef_func osglTranslatef = 0;
+glScalef_func osglScalef = 0;
+glVertex3f_func osglVertex3f = 0;
+glPushMatrix_func osglPushMatrix = 0;
+glPopMatrix_func osglPopMatrix = 0;
+glColor4f_func osglColor4f = 0;
+glMatrixMode_func osglMatrixMode = 0;
+glLoadIdentity_func osglLoadIdentity = 0;
+glFrustum_func osglFrustum = 0;
+
+// ------------- INITIALIZE FUNCTION POINTERS --------------//
+void init() 
+{
+	osglBegin = (glBegin_func) SDL_GL_GetProcAddress("glBegin");
+	osglEnd = (glEnd_func) SDL_GL_GetProcAddress("glEnd");
+	osglViewport = (glViewport_func) SDL_GL_GetProcAddress("glViewport");
+	osglDepthMask = (glDepthMask_func) SDL_GL_GetProcAddress("glDepthMask");
+	osglFrontFace = (glFrontFace_func) SDL_GL_GetProcAddress("glFrontFace");
+	osglCullFace = (glCullFace_func) SDL_GL_GetProcAddress("glCullFace");
+	osglShadeModel = (glShadeModel_func) SDL_GL_GetProcAddress("glShadeModel");
+	osglEnable = (glEnable_func) SDL_GL_GetProcAddress("glEnable");
+	osglClear = (glClear_func) SDL_GL_GetProcAddress("glClear");
+	osglClearColor = (glClearColor_func) SDL_GL_GetProcAddress("glClearColor");
+	osglRotatef = (glRotatef_func) SDL_GL_GetProcAddress("glRotatef");
+	osglTranslatef = (glTranslatef_func) SDL_GL_GetProcAddress("glTranslatef");
+	osglScalef = (glScalef_func) SDL_GL_GetProcAddress("glScalef");
+	osglVertex3f = (glVertex3f_func) SDL_GL_GetProcAddress("glVertex3f");
+	osglPushMatrix = (glPushMatrix_func) SDL_GL_GetProcAddress("glPushMatrix");
+	osglPopMatrix = (glPopMatrix_func) SDL_GL_GetProcAddress("glPopMatrix");
+	osglColor4f = (glColor4f_func) SDL_GL_GetProcAddress("glColor4f");
+	osglMatrixMode = (glMatrixMode_func) SDL_GL_GetProcAddress("glMatrixMode");
+	osglLoadIdentity = (glLoadIdentity_func) SDL_GL_GetProcAddress("glLoadIdentity");
+	osglFrustum = (glFrustum_func) SDL_GL_GetProcAddress("glFrustum");
+}
+
+
+void shutdown()
+{
+	osglBegin = 0;
+	osglEnd = 0;
+	osglViewport = 0;
+	osglDepthMask = 0;
+	osglFrontFace = 0;
+	osglCullFace = 0;
+	osglShadeModel = 0;
+	osglEnable = 0;
+	osglClear = 0;
+	osglClearColor = 0;
+	osglRotatef = 0;
+	osglTranslatef = 0;
+	osglScalef = 0;
+	osglVertex3f = 0;
+	osglPushMatrix = 0;
+	osglPopMatrix = 0;
+	osglColor4f = 0;
+	osglMatrixMode = 0;
+	osglLoadIdentity = 0;
+}
+
+void begin(Primitive primitive) { 
+	osglBegin(primitive); 
+}
+
+void end() { 
+	 osglEnd(); 
+}
+
+void viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	osglViewport(x, y, width, height);
+}
+
+void depthmask(GLenum mode)
+{
+	osglDepthMask(mode);
+}
+
+
+void frontface(GLenum mode)
+{
+	osglFrontFace(mode);
+}
+
+void cullface(GLenum mode)
+{
+	osglCullFace(mode);
+}
+
+void shademodel(GLenum mode)
+{
+	osglShadeModel(mode);
+}
+
+void enable(GLenum cap)
+{	
+	osglEnable(cap);
+}
+
+void clear (GLbitfield mask) {
+	osglClear(mask);
+}
+
+void clearcolor(Color const & color) {
+	osglClearColor(color.red(), color.green(), color.blue(), color.alpha());
+}
+
+void clearcolor(const float r, const float g, const float b, const float a) {
+	osglClearColor(r,g,b, a);
+}
+
+void rotate(const float angle, const Vector3f& vector) { 
+	osglRotatef(angle, vector[0], vector[1], vector[2]); 
+}
+
+void rotate(const float angle, const float x, const float y, const float z) { 
+	osglRotatef(angle, x, y, z); 
+}
+
+void translate(const Vector3f& vector) { 
+	osglTranslatef(vector[0], vector[1], vector[2]); 
+}
+
+void translate(const float x, const float y, const float z) { 
+	osglTranslatef(x, y, z); 
+}
+void scale(const Vector3f& vector) { 
+	osglScalef(vector[0], vector[1], vector[2]); 
+}
+
+void scale(const float x, const float y, const float z) { 
+	osglScalef(x, y, z); 
+}
+
+void vertex(const Vector3f& vector) { 
+	osglVertex3f(vector[0], vector[1],  vector[2]);
+}
+
+void vertex(const float x, const float y, const float z) {
+	osglVertex3f(x, y, z);
+}
+
+void push() {
+	osglPushMatrix();
+}
+
+void pop() {
+	osglPopMatrix();
+}
+
+void color(const float r, const float g, const float b, const float a) {
+	osglColor4f(r,g,b,a);
+}
+void color(Color const & color) {
+	osglColor4f(color.red(), color.green(), color.blue(), color.alpha());
+}
+
+void matrixmode(GLenum mode) {
+	osglMatrixMode(mode);
+}
+
+void loadidentity() {
+	osglLoadIdentity();
+}
+
+void frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble znear, GLdouble zfar) 
+{
+	osglFrustum(left, right, bottom, top, znear, zfar);
+}
+
+} // namespace gl
diff --git a/src/gl/osiriongl.h b/src/gl/osiriongl.h
new file mode 100644
index 0000000..92c0db3
--- /dev/null
+++ b/src/gl/osiriongl.h
@@ -0,0 +1,158 @@
+/* 	gl.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_OSIRIONGL_H__
+#define __INCLUDED_OSIRIONGL_H__
+
+// OpenGL headers
+#include <GL/gl.h>
+
+// project headers
+#include "common/vector3f.h"
+#include "common/color.h"
+
+/// wrapper namespace for OpenGL operations
+/*! The GL namespace provides a wrapper to the OpenGL library functions.
+ *  All methods take floats or Vector3f and Color as parameters.
+ */
+namespace gl
+{
+	/// initialize the OpenGL subsystem
+	void init();
+
+	/// shutdown the OpenGL subsystem
+	void shutdown();
+
+	/// enum to denote Vertex drawing modes
+	enum Primitive {
+		Points=GL_POINTS,
+		Lines=GL_LINES,
+		LineStrip=GL_LINE_STRIP,
+		LineLoop=GL_LINE_LOOP,
+		Triangles=GL_TRIANGLES,
+		TriangleStrip=GL_TRIANGLE_STRIP,
+		TriangleFan=GL_TRIANGLE_FAN,
+		Quads=GL_QUADS,
+		QuadStrip=GL_QUAD_STRIP,
+		Polygon=GL_POLYGON
+	};
+
+
+	/// glViewPort
+	void viewport(GLint x, GLint y, GLsizei width, GLsizei height );
+
+	/// set the color used to clear to buffer 
+	void clearcolor(Color const &color);
+	/// set the color used to clear to buffer 
+	void clearcolor(const float r, const float g, const float b, const float a);
+
+	/// clear buffers to preset values
+	void clear (GLbitfield mask);
+
+	/// glMatrixMode
+	void matrixmode(GLenum mode);
+
+	/// glEnable
+	void enable(GLenum cap);
+
+	/// glShadeModel
+	void shademodel(GLenum mode);
+
+	/// glCullFace
+	void cullface(GLenum mode);
+
+	/// glFrontFace
+	void frontface(GLenum mode);
+
+
+	/// glDepthMask
+	void depthmask(GLenum mode);
+
+	/// Delimite the start of a sequence of verteces describing a primitive or group of primitives
+	/*!	@param primitive The type of drawing primitive
+	 *  @see end()
+	 */
+	void begin(Primitive primitive);
+
+	/// Delimit the end of a sequence of verteces describing a primitive or group of primitives
+	/*! @see begin()
+	 */
+	void end();
+
+	/// Add the next vertex the the current drawing operation
+	/*! From the glVertex() description:
+	 *  vertex() commands are used within begin()/end() pairs to specify point,
+	 *	line, and polygon vertices.  The current color, normal, and texture
+	 *	coordinates are associated with the vertex when vertex() is called.
+	 */
+	void vertex(const Vector3f& vector);
+	
+	void vertex(const float x, const float y, const float z);
+	
+	/// Multiply the current matrix by a general rotation matrix
+	/*! @param angle The angle of the rotation, in degrees [0-360]
+	 *  @param vector The rotation axes, relative to the origin (0,0,0)
+	 */
+	void rotate(const float angle, const Vector3f& vector);
+
+	/// Multiply the current matrix by a general rotation matrix
+	/*! @param angle The angle of the rotation, in degrees
+	 *  @param x The x-coordinate of the rotation vector
+	 *  @param y The y-coordinate of the rotation vector
+	 *  @param z The z-coordinate of the rotation vector
+	 */
+	void rotate(const float angle, const float x, const float y, const float z);
+
+	/// Multiply the current matrix by a general translation matrix
+	/*! @param vector The translation vector, relative to the origin (0,0,0)
+	 */
+	void translate(const Vector3f& vector);
+
+	/// Multiply the current matrix by a general translation matrix
+	/*!
+	 * @param x The x-coordinate of the translation vector
+	 * @param y The y-coordinate of the translation vector
+	 * @param z The z-coordinate of the translation vector
+	 */
+	void translate(const float x, const float y, const float z);
+
+	/// Multiply the current matrix by a general scaling matrix
+	/*! @param vector The scale factor for all 3 axes
+	 */
+	void scale(const Vector3f& vector);
+
+	/// Multiply the current matrix by a general scaling matrix
+	/*!
+	 * @param x x-scaling factor
+	 * @param y y-scaling factor
+	 * @param z z-scaling factor
+	 */
+	void scale(const float x, const float y, const float z);
+
+	/// Specify the drawing color for the next GL functions
+	/*! @param color the new drawing color
+	 */
+	void color(Color const & color);
+		
+	/*! @param r red value of the new drawing color
+	 *  @param g green value of the new drawing color
+	 *  @param b blue value of the new drawing color
+	 *  @param a alpha value of the new drawing color
+	 */
+	void color(const float r, const float g, const float b, const float a=1.0f);
+	
+	/// Push the current transformation matrix to the stack
+	void push();
+	
+	/// Replace the transformation matrix with the top from the stack
+	void pop();
+	
+	/// Replace the transformation matrix with the identity matrtix
+	void loadidentity();
+
+	/// Perspective matrix
+	void frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble znear, GLdouble zfar);
+};
+
+#endif // __INCLUDED_OSIRIONGL_H__
diff --git a/src/gl/sphere.cc b/src/gl/sphere.cc
new file mode 100644
index 0000000..5e4e931
--- /dev/null
+++ b/src/gl/sphere.cc
@@ -0,0 +1,89 @@
+/* 	sphere.cc
+	This file is part of the Osirion project
+*/
+
+#include "common/functions.h"
+
+#include "osiriongl.h"
+#include "sphere.h"
+
+namespace gl {
+
+const int segments = 33;
+
+Sphere::Sphere(Vector3f p , float r)
+{
+	position = p;
+	radius = r;
+		
+	// TODO make global sine-cosine lists
+	sintable = new float[segments];
+	costable = new float[segments];
+	float d = 2 * M_PI / segments;
+
+	for (int i=0; i < segments; i++) {
+		sintable[i] = sin( d * (float) i );
+		costable[i] = cos ( d * (float) i );
+	}
+}
+
+Sphere::~Sphere()
+{
+	delete sintable;
+	delete costable;
+}
+
+Sphere::Sphere(const Sphere &other) 
+{
+	(*this) = other;
+}
+	
+Sphere& Sphere::operator=(const Sphere &other)
+{
+	position = other.position;
+	radius = other.radius;
+}
+
+void Sphere::draw()
+{
+	// draw top
+	// TODO upside-down
+	float r = radius*sintable[1];
+	float h = radius*costable[1];
+
+	begin(LineLoop);
+	//begin(Polygon);
+	for (int i = segments-1; i >= 0; i--)
+		vertex(r*costable[i], h, r*sintable[i]);
+	end();
+
+	// draw bottom
+	// TODO upside-down
+	begin(LineLoop);
+	for (int i = 0; i< segments; i++)
+		vertex(r*costable[i], -h, r*sintable[i]);
+	end();
+
+	// draw body
+	for (int j=1; j < segments-1; j++) {
+		r = radius*sintable[j];
+		float r1 = radius*sintable[j+1];
+		
+		begin(QuadStrip);
+		vertex(r1, radius*costable[j+1], 0);
+		vertex(r, radius*costable[j], 0);
+
+		for (int i = segments-1; i >= 0; i--) {			
+			vertex(r1*costable[i], radius*costable[j+1], r1*sintable[i]);
+			vertex(r*costable[i], radius*costable[j], r*sintable[i]);
+			//vertex(r*costable[i-1], radius*costable[j], r*sintable[i-1]);
+			//vertex(r1*costable[i-1], radius*costable[j+1], r1*sintable[i-1]);
+		}
+		end();
+		
+	}
+}
+	
+
+} // namespace gl
+
diff --git a/src/gl/sphere.h b/src/gl/sphere.h
new file mode 100644
index 0000000..f2bbf0a
--- /dev/null
+++ b/src/gl/sphere.h
@@ -0,0 +1,50 @@
+/* 	sphere.h
+	This file is part of the Osirion project
+*/
+
+#ifndef __INCLUDED_SPHERE_H__
+#define __INCLUDED_SPHERE_H__
+
+#include "common/vector3f.h"
+#include "common/color.h"
+
+namespace gl {
+
+/// a drawable OpenGL block shape
+class Sphere 
+{
+public:
+	/// create a new sphere
+	Sphere(Vector3f p = Vector3f(), float r = 1.0f);
+
+	/// copy constructor
+	Sphere(const Sphere &other);
+
+	/// destructor
+	~Sphere();
+	
+	/// assignment operator
+ 	Sphere& operator=(const Sphere &other);
+
+	/// radius of the sphere
+	float radius;
+
+	/// position of the sphere
+	Vector3f position;
+
+	/// draw the sphere
+	void draw();
+
+	/// Top color
+	Color topcolor;
+	/// bottom color
+	Color bottomcolor;
+
+private:
+	float  *sintable;
+	float  *costable;
+};
+
+} // namespace gl
+
+#endif // __INCLUDED_SPHERE_H__