[Add] Adding initial directory structure and initial code.

.gitignore

@@ -0,0 +1,7 @@
+src/LibD
+src/Makefile
+*.pro.user
+moc_*
+*.o
+*.log
+*swp

Bin/Makefile

@@ -0,0 +1,24 @@
+CC = g++
+CFLAGS = -ansi -Wall -g
+LDADD = -lGL -lGLU  -lglut -lSDL -lSDL_image -lSDL_gfx -lSDL_ttf -ltinyxml
+LDADDSTATIC = -Wl,-Bstatic -lSDL -lSDL_image -lopenal -lalut -L/usr/X11 -Wl,-Bdynamic -lasound -lartsc -lesd -lpulse -lpulse-simple -ldirectfb -lvga -laa -lcaca -ljpeg -ltiff -
+
+.PHONY: default static all clean
+
+default: all
+
+all:
+	$(MAKE) -C ../src/Main
+	
+	$(CC) $(CFLAGS) -o LibD ../src/Main/main.cpp ../src/Main/Main/*.o $(LDADD)
+
+static:
+	@echo -e "\033[1;31mThis is an experimental build, if it does not work, don't complain...\033[0m"
+	@sleep 1
+	$(MAKE) -C ../src/Main/Main
+
+	$(CC) $(CFLAGS) -o build/LibD-static ../src/Main/main.cpp ../src/Main/Main/*.o $(LDADDSTATIC)
+
+clean:
+	$(MAKE) -C ../src/Main/Main	       clean
+	rm -f LibD

src/Main/GLWindow.cpp

@@ -0,0 +1,192 @@
+#include <iostream>
+#include <string>
+
+#ifdef _unix_
+#include <sys/time.h>
+#endif
+
+#include "GLWindow.h"
+
+using std::string;
+
+typedef GLXConext (*PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display* dpy, GLXFBConfig config,
+																		GLXContext share_context, bool direct, const int* attrib_list);
+
+unsigned int GetTickCount(void) {
+  struct timeval t;
+  gettimeofdat(&t, NULL);
+  
+  unsigned long secs = t.tv_sec * 1000;
+  	secs += (t.tv_usec / 1000);
+  	return secs;
+}
+
+GLWindow::GLWindow(void) : 
+		_game(NULL),
+		_isRunning(true),
+		_lastTime(0),
+		_display(NULL),
+		_xWindow(0),
+		_glContext(0),
+		_screenID(0),
+		_isFullscreen(false),
+		_width(0),
+		_height(0),
+		_bpp(0),
+		_GL3Supported(false)  {}
+		
+GLWindow::~GLWindow(void) {
+
+}
+
+bool GLWindow::Create(int width, int height, int bpp, bool fullscreen) {
+	// Open the default display.
+	_display = XOpenDisplay(0);
+	if(!_display) {
+		std::cerr << "Could not open the display." << std::endl;
+		return false;
+	}
+	
+	// Get the default screen ID.
+	_screenID = DefaultScreen(_display);
+	
+	int n = 0, modeNum = 0;
+	// Get a frambuffer config useing the default attributes.
+	GLXFBConfig framebufferConfig = (*glXChooseFBConfig(_display, DefaultScreen(_display), 0, &n));
+	
+	XF86VidModeInfo **modes;
+	if(!XF86VidModeGetAllModeLines(_display, _screenID, *modeNum, &modes)) {
+		std::cerr << "Could not query the video modes." << std::endl;
+		return false;
+	}
+	
+	_XF86DeskMode = *modes[0];
+	
+	int bestModes = -1;
+	for(int i = 0; i < modeNum; i++) {
+		if((modes[i]->hdisplay == width) && (modes[i]->vdisplay == height)) {
+			bestModes = i;
+		}
+	}
+	
+	if(bestMode == -1 {
+		std::cerr << "Could not find a suitable graphics mode." << std::endl;
+		return false;
+	}
+	
+	int doubleBufferAttribList[] = {
+		GLX_RGBA,				GLX_DOUBLEBUFFER,
+		GLX_RED_SIZE,		4,
+		GLX_GREEN_SIZE,	4,
+		GLX_BLUE_SIZE, 	4,
+		GLX_DEPTH_SIZE, 16,
+		None
+	};
+	
+	XVisualInfo* vi = NULL;
+	// Attempt to create a double buffered window.
+	vi = glXChooseVisual(_display, _screenID, doubleBufferedAttribList);
+	if(!vi) {
+		std::cerr << "Could not create a double buffere window.. Sux.." <<std::endl;
+	}
+	
+	// Time to create a GL 2.1 context.
+	GLXContext gl2Context = glXCreateContext(_display, vi, 0, GL_TRUE);
+	if(!gl2Context) {
+		std::cerr << "Could Not create a GL 2.1 context, check your darn graphics drivers" << std::endl;
+		return false;
+	}
+	
+	// Get a pointer to the GL 3.0 context creation.
+	PFNGLXCREATECONTECTATTRIBSARBPROC glXCreateContextAttribs 
+				= (PFNGLXCREATECONTECTATTRIBSARBPROC) glXGetProcAddress((GLubyte*)"glXCreateContextAttribsARB");
+	if(!glXCreateContextAttribs == NULL) {
+		std::cerr << "OpenGL 3.0 is not supported, falling back to 2.1" << std::endl;
+		_glContext = gl2Context;
+		_GL3Supported = false;
+	} else {
+		// We create a GL 3.0 context..
+		
+		int attribs[] = {
+			GLX_CONTEXT_MAJOR_VERSION_ARB, 3, // We want a 3.0 context.
+			GLX_CONTEXT_MINOR_VERSION_ARB, 0, 
+			0 // Zero indicates the end of the array.		
+		};
+		
+		_glContext = glCreateContextAttribs(_display, frameBufferConfig, 0, true, &attribs[0]);
+		// We can destroy thr GL 2.0 context once the 3.0 one has been checked.
+		glXDestroyContext(_display, gl2Context);
+		_gl3Supported = true;
+	}
+	
+	Colormap cmap = XCreateColorMap(_display, RootWindow(_display, vi->screen), vi->visual, AllocNone);
+	_XSetAttr.colormap = cmap;
+	_XSetAttr.border_pixel = 0;
+	_XSetAttr.even_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | 
+																											StructureNotifyMask;
+	_XSetAttr.override_redirect = False;
+	
+	unsigned long windowAttributes = CWBorderPixel | CWColorMap | CWEventMask;
+	
+	if(fullscreen) {
+		windowAttributes = CWBorderPixel | CWColorMap | CWColorMap | CWEventMask | CWOverrideRedirect;
+		
+		XF86VidModeSwitchToMode(_display, _screenID, modes[bestModes]);
+		XF86VidModeSetViewPort(_display, _screenID, 0, 0);
+		_XSetAttr.override_redirect = True;
+	}																		
+	
+	_xWindow = XCreateWindow(_display, RootWindow(_display, vi->screen),
+													0, 0, width, height, 0, vi->depth, InputOutput, vi->visual,
+													CWBorderPixel | CWColorMap | CWEventMask, &_XSetAttr);
+	string title = "Some GL Demo stuff..";
+	
+	// TODO;
+	if(fullscreen) {
+	  // Some code here..
+	} else {
+		// Some more code here..
+	}
+	
+	XFree(modes);
+	
+	glXMakeCurrent(_display, _xWindow, _glContext);
+	
+	int posX = 0;
+	int posY = 0;
+	Window winDummy;
+	unsigned int borderDummy;	
+	
+	_width 	= (unsigned) width;
+	_height = (unsigned) height;
+	_bpp		= (unsigned) bpp;
+	
+	XGetGeometry(_display, _xWindow, &winDummy, &posX, &posY, 
+								&_width, &_height, &borderDummy, &_bpp);
+
+	// Init the time.
+	_lastTime = GetTickCount();
+	return true;
+}
+							
+void GLWindow::Destroy(void) {
+	if(_glContext) {
+		// Some code here.
+	}
+	if(_isFullscreen) {
+		// And here..
+	}
+	
+	XCloseDisplay(_display);
+}													
+
+void GLWindow::ProcessEvents(void) {
+	// Events are boring.. do the later.
+}
+
+float GLWindow::GetElapsedSeconds(void) {
+	unsigned int currentTime = GetTickCount();
+	unsigned int diff = currentTime - _lastTime;
+	_lastTime = currentTime;
+	return float(diff) / 1000.0f);
+}						

src/Main/GLWindow.h

@@ -0,0 +1,50 @@
+#pragma once
+#include <GL/glx.h>
+#include <glx/glxext.h>
+
+#include <X11/keysym.h>
+#include <ctime>
+
+class Game;
+
+class GLWindow {
+public:
+	GLWindow(void);
+	virtual ~GLWindow(void);
+	
+	bool Create(int width, int hight, int bpp, bool fullscreen);
+	void Destroy(void);
+	void ProcessEvents(void);
+	void AttachGame(Game* game) { _game = game; }
+	
+	bool IsRunning(void) { return _isRunning; }
+	
+	void SwapBuffers(void) { glxSwapBuffers(_display, _xWindow); }
+	
+	float GetElapsedSeconds(void);
+	
+private:
+	// A pointer to our game thingy..
+	Game* _game;
+	// Check to see if the window is still running FFS.
+	bool _isRunning;
+	
+	Game* GetAttachedGame(void) { return _game; }
+	
+	unsigned int _lastTime;
+	
+	Display								_display;
+	Window								_xWindow;
+	GLXContext						_glContext;
+	XF86VidModeInfo				_XF86DeskMode;
+	XSetWindowAttributes 	_XSetAttr;
+	int 									_screenID;
+	
+	bool 						_isFullscreen;
+	unsigned int 		_width;
+	unsigned int 		_height;
+	unsigned int 		_bpp;
+	
+	bool _GL3Supported;
+	// I think that's about all I need for now.. FOR NOW!!!
+}

src/Main/Makefile

@@ -0,0 +1,20 @@
+CC	= g++
+CFLAGS	= -ansi -Wall -g
+LDADD	= -lGL -lGLU -lSDL -lSDL_image
+
+objects = GLWindow.o \
+
+
+.PHONY: default all clean
+
+default: all
+
+%.cpp: %.h
+
+%.o: %.cpp
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+all: $(objects)
+
+clean:
+	rm -f $(objects)