Initialisierung des GIT-Repositorys

.gitignore

@@ -0,0 +1,2 @@
+*.o
+*.a

Makefile

@@ -0,0 +1,22 @@
+COMPILER = g++
+OBJECTS = emath.o emath_opengl.o glcolor.o gldrawhelper.o glfontengine.o glrect.o gltexture.o matrix.o quaternion.o rotationsmatrix.o glgui/glgui.a
+VERSION = 0.0.1
+
+
+sgllib: $(OBJECTS)
+
+sglar: $(OBJECTS)
+	rm -f sgllib.a
+	ar rfc sgllib.a $(OBJECTS)
+	
+%.o: %.cpp %.h
+	$(COMPILER) -c `sdl-config --cflags` $<
+	
+	
+glgui/glgui.a:
+	cd glgui; $(MAKE);
+	
+clean:
+	rm -f $(OBJECTS)
+	cd glgui; $(MAKE) clean
+	@echo Done cleaning...

emath.cpp

@@ -0,0 +1,243 @@
+#include "emath.h"
+
+Punkt3D::Punkt3D() {
+	x = y = z = 0.0f;
+}
+
+Punkt3D::Punkt3D(float _x, float _y, float _z) {
+	set(_x, _y, _z);
+}
+
+void Punkt3D::set(float _x, float _y, float _z) {
+	x = _x;
+	y = _y;
+	z = _z;
+}
+
+float Punkt3D::abs() {
+	return sqrt(x*x+y*y+z*z);
+}
+
+Punkt3D Punkt3D::kreuzprodukt(const Punkt3D &b) {
+	Punkt3D erg;
+	erg.x = y*b.z - z*b.y;
+	erg.y = z*b.x - x*b.z;
+	erg.z = x*b.y - y*b.x;
+	
+	return erg;
+}
+
+void Punkt3D::normalize() {
+	float a = abs();
+	x /= a;
+	y /= a;
+	z /= a;
+}
+
+Punkt3D Punkt3D::getNormalized() {
+	Punkt3D ret(*this);
+	ret.normalize();
+	return ret;
+}
+
+bool Punkt3D::isNormalized() {
+	return (abs()==1);
+}
+
+float Punkt3D::calcAngle(Punkt3D b) {
+	if(abs()*b.abs()==0.0f)
+		return 0.0f;
+	return rad2deg(std::acos(((*this)*b)/(abs()*b.abs())));
+}
+
+Punkt3D Punkt3D::getOrtographic() {
+	Punkt3D erg;
+	if(!x) {
+		erg.x = 0.0f;
+		erg.y = z;
+		erg.z = -y;
+	} else if(!y) {
+		erg.x = z;
+		erg.y = 0;
+		erg.z = -x;
+	} else {
+		// z, oder genereller fall
+		erg.x = y;
+		erg.y = -x;
+		erg.z = 0.0f;
+	}
+	return erg;
+}
+
+void Punkt3D::print(std::string coordname) {
+	if(coordname!="")
+		coordname.append(" ");
+	std::cout << coordname << "Coord: (" << x << ", " << y << ", " << z << ")" << std::endl;
+}
+
+
+
+Punkt3D Punkt3D::operator+(const Punkt3D &b) {
+	Punkt3D c;
+	c.x =  x + b.x;
+	c.y =  y + b.y;
+	c.z =  z + b.z;
+	
+	return c;
+}
+
+Punkt3D Punkt3D::operator-(const Punkt3D &b) {
+	Punkt3D c;
+	c.x =  x - b.x;
+	c.y =  y - b.y;
+	c.z =  z - b.z;
+	
+	return c;
+}
+
+Punkt3D& Punkt3D::operator+=(const Punkt3D &b) {
+	x +=  b.x;
+	y +=  b.y;
+	z +=  b.z;
+	
+	return *this;
+}
+
+Punkt3D& Punkt3D::operator-=(const Punkt3D &b) {
+	x -=  b.x;
+	y -=  b.y;
+	z -=  b.z;
+	
+	return *this;
+}
+
+Punkt3D Punkt3D::operator+(const float &_m) {
+	return Punkt3D(x+_m, y+_m, z+_m);
+}
+
+Punkt3D Punkt3D::operator-(const float &_m) {
+	return Punkt3D(x-_m, y-_m, z-_m);
+}
+
+Punkt3D Punkt3D::operator*(const float &_m) {
+	return Punkt3D(x*_m, y*_m, z*_m);
+}
+
+Punkt3D Punkt3D::operator/(const float &_m) {
+	return Punkt3D(x/_m, y/_m, z/_m);
+}
+
+Punkt3D& Punkt3D::operator+=(const float &_m) {
+	x += _m;
+	y += _m;
+	z += _m;
+	return *this;
+}
+Punkt3D& Punkt3D::operator-=(const float &_m) {
+	x -= _m;
+	y -= _m;
+	z -= _m;
+	return *this;
+}
+Punkt3D& Punkt3D::operator*=(const float &_m) {
+	x *= _m;
+	y *= _m;
+	z *= _m;
+	return *this;
+}
+Punkt3D& Punkt3D::operator/=(const float &_m) {
+	x /= _m;
+	y /= _m;
+	z /= _m;
+	return *this;
+}
+
+float Punkt3D::operator*(const Punkt3D& _m) {
+	return x * _m.x + y * _m.y + z * _m.z;
+}
+
+Punkt3D Punkt3D::operator-() {
+	return Punkt3D(-x, -y, -z);
+}
+
+bool Punkt3D::operator==(const Punkt3D& b) {
+	return ( x==b.x && y==b.y && z==b.z);
+}
+bool Punkt3D::operator!=(const Punkt3D& b) {
+	return !(*this==b);
+}
+// Freunde
+
+Punkt3D operator+(const float& _m, const Punkt3D& b) {
+	return Punkt3D(b.x+_m, b.y+_m, b.z+_m);
+}
+
+Punkt3D operator-(const float& _m, const Punkt3D& b) {
+	return Punkt3D(b.x-_m, b.y-_m, b.z-_m);
+}
+
+Punkt3D operator*(const float& _m, const Punkt3D& b) {
+	return Punkt3D(b.x*_m, b.y*_m, b.z*_m);
+}
+
+Punkt3D operator/(const float& _m, const Punkt3D& b) {
+	return Punkt3D(b.x/_m, b.y/_m, b.z/_m);
+}
+
+float abs(Punkt3D p) {
+	return p.abs();
+}
+
+// OpenGL Funktionen für Punkt3D
+
+void glVertex3f(Punkt3D p) {
+	glVertex3f(p.x, p.y, p.z);
+}
+
+void glTranslatef(Punkt3D p) {
+	glTranslatef(p.x, p.y, p.z);
+}
+
+void glNormal(Punkt3D p) {
+	glNormal3f(p.x, p.y, p.z);
+}
+
+void glRotatef(float deg, Punkt3D vec) {
+	glRotatef(deg, vec.x, vec.y, vec.z);
+}
+
+// Trigonometrische Funktionen
+
+float deg2rad(float deg) {
+	return (deg/180.0f)*3.1415926535897932384626433f;
+}
+
+float rad2deg(float rad) {
+	return (rad/3.1415926535897932384626433f)*180.0f;
+}
+
+float ssin(float c) {
+	int t=(int)c;
+	if(t!=c)
+		return sin(deg2rad(c));
+	t = t % 360;
+	if(t<0)
+		t = 360 + t;
+	switch(t) {
+		case 0:
+			return 0.0f;
+		case 90:
+			return 1.0f;
+		case 180:
+			return 0.0f;
+		case 270:
+			return -1.0f;
+		default:
+// 			std::cout << "ssin sollte keinen defaultwert zurückliefern. c=" << c << ", t=" << t << std::endl;
+			return sin(deg2rad(c));
+	}
+}
+
+float scos(float c) {
+	return ssin(c+90.0f);
+}

emath.h

@@ -0,0 +1,74 @@
+#ifndef __EMATH_H
+#define __EMATH_H
+
+#include <iostream>
+#include <cmath>
+#include <SDL_opengl.h>
+
+class Punkt3D {
+	public:
+		Punkt3D();
+		Punkt3D(float, float, float);
+		
+		float x, y, z;
+		
+		void set(float, float, float);
+		float abs();
+		Punkt3D kreuzprodukt(const Punkt3D&);
+		void normalize();
+		Punkt3D getNormalized();
+		bool isNormalized();
+		float calcAngle(Punkt3D);
+		Punkt3D getOrtographic();
+		
+		void print(std::string="");
+		
+		
+		// Operatoren
+		Punkt3D operator+(const Punkt3D&);
+		Punkt3D operator-(const Punkt3D&);
+		Punkt3D& operator+=(const Punkt3D&);
+		Punkt3D& operator-=(const Punkt3D&);
+		
+		Punkt3D operator+(const float&);
+		Punkt3D operator-(const float&);
+		Punkt3D operator*(const float&);
+		Punkt3D operator/(const float&);
+		Punkt3D& operator+=(const float&);
+		Punkt3D& operator-=(const float&);
+		Punkt3D& operator*=(const float&);
+		Punkt3D& operator/=(const float&);
+		
+		float operator*(const Punkt3D&);
+		
+		Punkt3D operator-();
+
+		bool operator==(const Punkt3D&);
+		bool operator!=(const Punkt3D&);
+		
+		friend Punkt3D operator+(const float&, const Punkt3D&);
+		friend Punkt3D operator-(const float&, const Punkt3D&);
+		friend Punkt3D operator*(const float&, const Punkt3D&);
+		friend Punkt3D operator/(const float&, const Punkt3D&);
+};
+
+float abs(Punkt3D);
+
+// OpenGL-Funktionen für Punkt3D
+
+void glVertex3f(Punkt3D);
+void glTranslatef(Punkt3D);
+void glNormal3f(Punkt3D);
+
+void glRotatef(float, Punkt3D);
+
+float deg2rad(float deg);
+float rad2deg(float rad);
+
+
+
+// *grml* scheiss cmath-sinus
+float ssin(float);
+float scos(float);
+
+#endif

emath_opengl.cpp

@@ -0,0 +1,46 @@
+#include "emath_opengl.h"
+
+void rotFrom2VecTo2Vec(Punkt3D a, Punkt3D b, Punkt3D c, Punkt3D d, Punkt3D *rvec, float *rvecdeg, Punkt3D *rvec2, float *rvecdeg2) {
+	Punkt3D rotvec, rotvec2, nullvec;
+	float rotvecdeg = 0.0f, rotvecdeg2 = 0.0f;
+	
+	rotvec = a.kreuzprodukt(b);
+	rotvecdeg = a.calcAngle(b);
+	if(std::abs(rotvecdeg)==180.0f) {
+		rotvec = a.getOrtographic();
+	}
+	
+	if(rotvec==nullvec) {
+		rotvec.set(1.0f, 0.0f, 0.0f);
+		rotvecdeg = 0.0f;
+	}
+	
+	Rotationsmatrix rotnobj(rotvec, -rotvecdeg);
+	c = Rotationsmatrix(rotvec, rotvecdeg) * c;
+	
+	rotvec2 = c.kreuzprodukt(d);
+	rotvecdeg2 = c.calcAngle(d);
+	if(std::abs(rotvecdeg2)==180.0f) {
+		rotvec2 = b;
+	}
+	
+	if(rotvec2==nullvec) {
+		rotvec2.set(1.0f, 0.0f, 0.0f);
+		rotvecdeg2 = 0.0f;
+	}
+	
+	rotvec2 = rotnobj * rotvec2;
+	
+	*rvec = rotvec;
+	*rvecdeg = rotvecdeg;
+	*rvec2 = rotvec2;
+	*rvecdeg2 = rotvecdeg2;
+}
+
+void rotFrom2VecTo2Vec(Punkt3D a, Punkt3D b, Punkt3D c, Punkt3D d) {
+	Punkt3D rvec, rvec2;
+	float rvecdeg, rvecdeg2;
+	rotFrom2VecTo2Vec(a, b, c, d, &rvec, &rvecdeg, &rvec2, &rvecdeg2);
+	glRotatef(rvecdeg, rvec);
+	glRotatef(rvecdeg2, rvec2);
+}

emath_opengl.h

@@ -0,0 +1,11 @@
+#ifndef __EMATH_OPENGL
+#define __EMATH_OPENGL
+
+#include <cmath>
+#include "emath.h"
+#include "rotationsmatrix.h"
+#include <SDL_opengl.h>
+
+void rotFrom2VecTo2Vec(Punkt3D a, Punkt3D b, Punkt3D c, Punkt3D d, Punkt3D *, float *, Punkt3D *, float *);
+void rotFrom2VecTo2Vec(Punkt3D a, Punkt3D b, Punkt3D c, Punkt3D d);
+#endif

glcolor.cpp

@@ -0,0 +1,30 @@
+#include "glcolor.h"
+
+GLColor::GLColor() {
+	set(0.0f, 0.0f, 0.0f, 1.0f);
+	setalpha = true;
+}
+
+GLColor::GLColor(const SDL_Color &c) {
+	set(c.r/255.0f, c.g/255.0f, c.b/255.0f);
+	setalpha = true;
+}
+
+void GLColor::set(float _r, float _g, float _b, float _a) {
+	r = _r;
+	g = _g;
+	b = _b;
+	a = _a;
+}
+
+SDL_Color GLColor::getSDLColor() {
+	SDL_Color c = {(Uint8)(r*255.0f), (Uint8)(g*255), (Uint8)(b*255), (Uint8)(a*255)};
+}
+
+void glColorGLC(GLColor c) {
+	if(c.setalpha) {
+		glColor4f(c.r, c.g, c.b, c.a);
+	} else {
+		glColor3f(c.r, c.g, c.b);
+	}	
+}

glcolor.h

@@ -0,0 +1,24 @@
+#ifndef __GLCOLOR_H
+#define __GLCOLOR_H
+
+#include <SDL.h>
+#include <SDL_opengl.h>
+
+class GLColor {
+	public:
+		float r, g, b, a;
+		bool setalpha;
+		
+		
+		GLColor();
+		GLColor(const SDL_Color&);
+		
+		void set(float _r, float _g, float _b, float _a=1.0f);
+		SDL_Color getSDLColor();
+};
+
+void glColorGLC(GLColor c);
+// a) setalpha entscheiden lassen
+// b) zwei funktionen, eine setzt alpha mit in richtung 3f, 4f..
+
+#endif

gldrawhelper.cpp

@@ -0,0 +1,24 @@
+#include "gldrawhelper.h"
+
+void GLDrawSDLRect(SDL_Rect *rect, GLRect *tex) {
+	GLRect tmptex;
+	if(tex) {
+		tmptex = *tex;
+	} else {
+		tmptex.set(0.0f, 0.0f, 1.0f, 1.0f);
+	}
+	
+	glBegin(GL_QUADS);
+		glTexCoord2f(tmptex.x, tmptex.y);
+		glVertex2i(rect->x, rect->y+rect->h);
+		
+		glTexCoord2f(tmptex.x+tmptex.w, tmptex.y);
+		glVertex2i(rect->x+rect->w, rect->y+rect->h);
+		
+		glTexCoord2f(tmptex.x+tmptex.w, tmptex.y+tmptex.h);
+		glVertex2i(rect->x+rect->w, rect->y);
+		
+		glTexCoord2f(tmptex.x, tmptex.y+tmptex.h);
+		glVertex2i(rect->x, rect->y);
+	glEnd();
+}

gldrawhelper.h

@@ -0,0 +1,12 @@
+#ifndef __GLDRAWHELPER_H
+#define __GLDRAWHELPER_H
+
+#include <SDL.h>
+#include <SDL_opengl.h>
+
+#include "glrect.h"
+
+void GLDrawSDLRect(SDL_Rect *rect, GLRect *tex=0);
+
+
+#endif

glfontengine.cpp

@@ -0,0 +1,231 @@
+#include "glfontengine.h"
+
+
+bool GLFontEngine::addFont(std::string fontfile, std::string fontname) {
+	GLFont *tmp = new GLFont(fontfile, 0.685f);
+	if(!tmp->font->isLoaded()) {
+		delete(tmp);
+		std::cerr << fontfile << " konnte als Font nicht geladen werden" << std::endl;
+		return false;
+	}
+	
+	fontpool[fontname] = tmp;
+	return false;
+}
+
+void GLFontEngine::quit() {
+	for(std::map<std::string, GLFont*>::iterator iter = fontpool.begin(); iter != fontpool.end(); iter++) {
+		delete(iter->second); // unloaded texture.. der dtor
+		fontpool.erase(iter);
+	}
+}
+
+void GLFontEngine::prepare2DbyPushingMatrix() {
+	const SDL_Surface *screen = SDL_GetVideoSurface();
+	glMatrixMode(GL_PROJECTION);
+	glPushMatrix();
+	glLoadIdentity();
+	glOrtho(0, screen->w, screen->h, 0, -1, 1);	
+// 	glOrtho(0, 640, 480, 0, -1, 1);	
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	glLoadIdentity();
+}
+
+void GLFontEngine::regain3DbyPoppingMatrix() {
+	glMatrixMode(GL_PROJECTION);
+	glPopMatrix();
+	glMatrixMode(GL_MODELVIEW);
+	glPopMatrix();
+}
+
+void GLFontEngine::paintSDLRect(SDL_Rect r) {
+	glBegin(GL_QUADS);
+		glTexCoord2f(0.0f, 1.0f);
+		glVertex2i(r.x, r.y);
+			
+		glTexCoord2f(0.0f, 0.0f);
+		glVertex2i(r.x, r.y+r.h);
+		
+		glTexCoord2f(1.0f, 0.0f);
+		glVertex2i(r.x+r.w, r.y+r.h);
+		
+		glTexCoord2f(1.0f, 1.0f);
+		glVertex2i(r.x+r.w, r.y);
+		
+	glEnd();
+}
+
+GLFontEngine::GLFontEngine() {
+	init();
+	fontloaded = fontSelect("");
+}
+
+GLFontEngine::GLFontEngine(std::string fontstr) {
+	init();
+	fontloaded = fontSelect(fontstr);
+}
+
+void GLFontEngine::init() {
+// 	r = g = b = a = 1.0f;
+	fsize = 16;
+}
+
+void GLFontEngine::setColor(float _r, float _g, float _b, float _a) {
+// 	r = _r;
+// 	g = _g;
+// 	b = _b;
+// 	a = _a;
+	col.set(_r, _g, _b, _a);
+}
+
+void GLFontEngine::setColor(GLColor c) {
+	col = c;
+}
+
+bool GLFontEngine::fontSelect(std::string fontstr) {
+	if(fontpool.size()==0) {
+		fontloaded = false;
+		return false;
+	}
+	fontloaded = true; // fontstr oder fallbackfont
+	if(fontpool[fontstr])
+		font = fontpool[fontstr];
+	else {
+		//fallbackfont - ersten aus der liste
+		font = (fontpool.begin())->second;
+	}
+		
+	return true;
+}
+
+void GLFontEngine::renderText(std::string text, SDL_Rect pos) {
+	renderLine(text, pos);
+}
+
+void GLFontEngine::renderLine(std::string text, SDL_Rect pos) {
+// 	glColor4f(r, g, b, a);
+	glColorGLC(col);
+	
+	if(fontloaded) {
+		font->font->selectTexture();
+		
+		float step = pos.w / (float)text.length();
+		float tex_x, tex_y;
+		float tex_len = (1.0f/16.0f);
+		
+		for(unsigned int i=0; i<text.length(); i++) {
+			int ch = text[i];
+			if(ch<0) {
+				ch += 256; // char geht wohl in machen fällen nur von -128 bis +127
+			}
+// 			std::cout << (int)text[i] << " ";
+			tex_x = ((ch-1)%16 / 16.0f);
+			tex_y = 1.0f-(floor((ch-1)/16) / 16.0f)-tex_len;
+
+// 			std::cout << text[i] << " == " <<  tex_x << ", " << tex_y << std::endl;
+			glBegin(GL_QUADS);
+				glTexCoord2f(tex_x, tex_y+tex_len);
+				glVertex2f(pos.x+i*step,			pos.y);
+				
+				glTexCoord2f(tex_x, tex_y);
+				glVertex2f(pos.x+i*step,			pos.y+pos.h);
+				
+				glTexCoord2f(tex_x+tex_len, tex_y);
+				glVertex2f(pos.x+(i+1)*step,	pos.y+pos.h);
+				
+				glTexCoord2f(tex_x+tex_len, tex_y+tex_len);
+				glVertex2f(pos.x+(i+1)*step,	pos.y);
+			glEnd();
+		}
+// 		std::cout << std::endl;
+	} else {
+		glBegin(GL_QUADS);
+			glVertex2f(pos.x, 		pos.y);
+			glVertex2f(pos.x+pos.w, pos.y);
+			glVertex2f(pos.x+pos.w, pos.y+pos.h);
+			glVertex2f(pos.x, 		pos.y+pos.h);
+		glEnd();
+	}
+}
+
+void GLFontEngine::renderLine(std::string str, int x, int y, bool center, SDL_Rect *rendered_to) {
+	SDL_Rect m = { x, y, getTextWidth(str), fsize};
+	if(center)
+		m.x = m.x - m.w/2;
+	
+	renderLine(str, m);
+	
+	if(rendered_to)
+		*rendered_to = m;
+	
+	return;
+}
+
+void GLFontEngine::renderLines(std::string str, int x, int y, bool center, SDL_Rect *rendered_to, int wrap, int paintbackground) {
+	if(wrap) {
+		// \n einfügen, wenns zu groß ist
+		for(unsigned int i=0, a=0; i<str.length(); i++, a++) {
+			if(str[i]!='\n') {
+				if(a*font->charwidth*fsize>wrap) {
+					str.insert(i, "\n");
+				}
+			} else {
+				a=0;
+			}
+		}
+	}
+	
+	if(paintbackground) {
+		std::cout << "Paint Background implementieren.. ;) " << std::endl;
+	}
+	
+	SDL_Rect m;
+	int strlpos;
+	int max_width = 0;
+	int linecount = 0;
+	std::string rstr;
+	
+	while(str!="") {
+		
+		if((strlpos = str.find('\n'))!=std::string::npos) {
+			
+			rstr = str.substr(0, strlpos);
+			str = str.substr(strlpos+1);
+		} else {
+			rstr = str;
+			str = "";
+		}
+		renderLine(rstr, x, y+(int)(1.1*linecount*fsize), center, &m);
+		
+		max_width = std::max(max_width, (int)m.w);
+		linecount++;
+	}
+	
+	if(rendered_to) {
+		m.w = max_width;
+		m.y = y;
+		*rendered_to = m;
+	}
+	
+	return;
+}
+
+void GLFontEngine::setSize(int s) {
+	fsize = s;
+}
+
+int GLFontEngine::getSize() {
+	return fsize;
+}
+
+void GLFontEngine::getSDLRect(const std::string &str, SDL_Rect *r) {
+	r->w = getTextWidth(str);
+	r->h = getSize();
+}
+
+int GLFontEngine::getTextWidth(const std::string &moep) {
+	return (int)(moep.length()*font->charwidth*fsize);
+}
+
+std::map<std::string, GLFont*> GLFontEngine::fontpool;

glfontengine.h

@@ -0,0 +1,70 @@
+#ifndef __GLFONTENGINE_H
+#define __GLFONTENGINE_H
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <map>
+#include <cmath>
+
+
+#include <SDL.h>
+#include <SDL_opengl.h>
+#include "gltexture.h"
+#include "glcolor.h"
+
+class GLFont {
+	public:
+		GLFont(std::string fontfile, float cwdth) {
+			charwidth = cwdth;
+			font = new GLTexture(fontfile);
+		}
+		~GLFont() {
+			delete(font);
+		}
+		GLTexture* font;
+		float charwidth;
+};
+
+class GLFontEngine {
+	private:
+		static std::map<std::string, GLFont*> fontpool;
+		
+		GLFont *font;
+		bool fontloaded;
+		GLColor col;
+// 		float r, g, b, a;
+		int fsize;
+		
+		void init();
+	public:
+		static bool addFont(std::string fontfile, std::string fontname);
+		static void quit();
+		
+		static void prepare2DbyPushingMatrix();
+		static void regain3DbyPoppingMatrix();
+		static void paintSDLRect(SDL_Rect);
+		
+		GLFontEngine();
+		GLFontEngine(std::string);
+		bool fontSelect(std::string);
+		void setColor(float, float, float, float=1.0f);
+		void setColor(GLColor);
+		
+		void renderText(std::string, SDL_Rect); // wrapper
+// 		void renderText(std::string, int x, int y, *SDL_Rect=0, bool center=false);
+// 		void renderLines(std::string, int x, int y, 
+
+		void renderLine(std::string, SDL_Rect);
+		void renderLine(std::string, int x, int y, bool center=false, SDL_Rect *rendered_to=0);
+		void renderLines(std::string, int x, int y, bool center=false, SDL_Rect *rendered_to=0, int wrap=0, int paintbackground=0);
+		
+		void setSize(int);
+		int getSize();
+		void getSDLRect(const std::string&, SDL_Rect*);
+		int getTextWidth(const std::string&);
+		
+};
+
+
+#endif

glgui/Makefile

@@ -0,0 +1,12 @@
+# COMPILER = g++
+OBJECTS = button.o object.o textlabel.o window.o
+
+glguilib: $(OBJECTS)
+	rm glgui.a -f
+	ar rfc glgui.a $(OBJECTS)
+
+%.o: %.cpp %.h
+	$(COMPILER) -c `sdl-config --cflags` $<
+
+clean:
+	rm -f $(OBJECTS)

glgui/button.cpp

@@ -0,0 +1,18 @@
+#include "button.h"
+
+GLGuiButton::GLGuiButton(int _eventid, int _x, int _y, bool _center, int _wrap) : GLGuiTextLabel(_x, _y, _center, _wrap) {
+	highlightable = true;
+	clickable = true;
+	eventid = _eventid;
+	highlightcol.set(1.0f, 0.0f, 0.0f, 1.0f);
+}
+GLGuiButton::GLGuiButton(int _eventid, std::string str, int _x, int _y, bool _center, int _wrap) : GLGuiTextLabel(str, _x, _y, _center, _wrap){
+	highlightable = true;
+	clickable = true;
+	eventid = _eventid;
+	highlightcol.set(1.0f, 0.0f, 0.0f, 1.0f);
+}
+
+void GLGuiButton::onMouseOver(int m_x, int m_y) {
+	// Längste stelle finden, dann collision
+}

glgui/button.h

@@ -0,0 +1,28 @@
+#ifndef __GLGUIBUTTON_H
+#define __GLGUIBUTTON_H
+
+#include <iostream>
+#include <string>
+#include <SDL/SDL.h>
+#include <SDL/SDL_opengl.h>
+
+#include "textlabel.h"
+
+#define GLGUI_BUTTONDOWN 		SDL_USEREVENT+10
+
+class GLGuiButton : public GLGuiTextLabel {
+	protected:
+		int eventid;
+		GLColor highlightcol;
+		
+	public:
+		GLGuiButton(int _eventid, int _x, int _y, bool _center=false, int _wrap=0);
+		GLGuiButton(int _eventid, std::string str, int _x, int _y, bool _center=false, int _wrap=0);
+		
+		void setHighlightColor();
+		
+		void onMouseOver(int m_x, int m_y);
+		void onMouseClick(int m_x, int m_y);
+};
+
+#endif

glgui/object.cpp

@@ -0,0 +1,7 @@
+#include "object.h"
+
+GLGuiObject::GLGuiObject() {
+	highlightable = false;
+	clickable = false;
+	keyboardable = false;
+}

glgui/object.h

@@ -0,0 +1,29 @@
+#ifndef __GLGUIOBJECT_H
+#define __GLGUIOBJECT_H
+
+#include <iostream>
+#include <string>
+#include <SDL/SDL.h>
+#include <SDL/SDL_opengl.h>
+
+class GLGuiObject {
+	protected:
+		SDL_Rect pos;
+		bool highlightable, clickable, keyboardable;
+	public:
+		GLGuiObject();
+		virtual ~GLGuiObject() { };
+	
+		virtual void render()=0;
+		
+		// Optionen
+		bool isHighlightable() { return highlightable; };
+		bool isClickable() { return clickable; };
+		bool isKeyboardable() { return keyboardable; };
+		
+		virtual void onMouseOver(int m_x, int m_y) { };
+		virtual void onMouseClick(int m_x, int m_y, int m_button) { };
+		virtual void onKeyboardInput(char c) { };
+};
+
+#endif

glgui/textlabel.cpp

@@ -0,0 +1,37 @@
+#include "textlabel.h"
+
+GLGuiTextLabel::GLGuiTextLabel(int _x, int _y, bool _center, int _wrap) {
+	setPos(_x, _y);
+	center = _center;
+	wrap = _wrap;
+	col.set(1.0f, 1.0f, 1.0f, 1.0f);
+}
+
+GLGuiTextLabel::GLGuiTextLabel(std::string str, int _x, int _y, bool _center, int _wrap) {
+	setPos(_x, _y);
+	center = _center;
+	wrap = _wrap;
+	setText(str);
+	col.set(1.0f, 1.0f, 1.0f, 1.0f);
+}
+
+void GLGuiTextLabel::setText(std::string str) {
+	text = str;
+}
+
+void GLGuiTextLabel::setColor(GLColor c) {
+	col = c;
+}
+
+void GLGuiTextLabel::setPos(int _x, int _y) {
+	x = _x;
+	y = _y;
+}
+
+void GLGuiTextLabel::render() {
+	glColorGLC(col);
+	
+	GLFontEngine::prepare2DbyPushingMatrix();
+		fontengine.renderLines(text, x, y, center, 0, wrap, 0);
+	GLFontEngine::regain3DbyPoppingMatrix();
+}

glgui/textlabel.h

@@ -0,0 +1,32 @@
+#ifndef __GLGUITEXTLABEL_H
+#define __GLGUITEXTLABEL_H
+
+#include <iostream>
+#include <string>
+#include <SDL/SDL.h>
+#include <SDL/SDL_opengl.h>
+
+#include "object.h"
+#include "../glcolor.h"
+#include "../glfontengine.h"
+
+class GLGuiTextLabel : public GLGuiObject{
+	protected:
+		GLFontEngine fontengine;
+		std::string text;
+		
+		GLColor col;
+		int x, y;
+		bool center;
+		int wrap;
+	public:
+		GLGuiTextLabel(int _x, int _y, bool _center=false, int _wrap=0);
+		GLGuiTextLabel(std::string, int _x, int _y, bool _center=false, int _wrap=0);
+
+		void setText(std::string str);
+		void setColor(GLColor);
+		void setPos(int _x, int _y);
+		virtual void render();
+};
+
+#endif

glgui/window.cpp

@@ -0,0 +1,39 @@
+#include "window.h"
+
+GLGuiWindow::GLGuiWindow(SDL_Rect _pos, GLColor _bgcolor) {
+	pos = _pos;
+	bgcolor = _bgcolor;
+}
+
+void GLGuiWindow::addItem(GLGuiObject *gobj) {
+	// Objekt wird in delete gelöscht
+	items.push_back(gobj);
+	if(gobj->isHighlightable())
+		highlightable.push_back(gobj);
+	if(gobj->isClickable())
+		clickable.push_back(gobj);
+	if(gobj->isKeyboardable())
+		keyboardable.push_back(gobj);
+	
+}
+
+void GLGuiWindow::render() {
+	if(renderbackground) {
+		glColorGLC(bgcolor);
+		GLDrawSDLRect(&pos);
+	}
+	
+	for(unsigned int i=0; i<items.size(); i++) {
+		items[i]->render();
+	}
+}
+
+SDL_Rect GLGuiWindow::getPos() {
+	return pos;
+}
+
+GLGuiWindow::~GLGuiWindow() {
+	for(unsigned int i=0; i<items.size(); i++) {
+		delete(items[i]);
+	}
+}

glgui/window.h

@@ -0,0 +1,36 @@
+#ifndef __GLGUIWINDOW_H
+#define __GLGUIWINDOW_H
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <SDL/SDL.h>
+#include <SDL/SDL_opengl.h>
+
+#include "../glcolor.h"
+#include "../gldrawhelper.h"
+#include "object.h"
+
+
+class GLGuiWindow : public GLGuiObject {
+	private:
+		bool renderbackground;
+		SDL_Rect pos;
+		GLColor bgcolor;
+		
+		std::vector<GLGuiObject*> items;
+		
+		std::vector<GLGuiObject*> highlightable;
+		std::vector<GLGuiObject*> clickable;
+		std::vector<GLGuiObject*> keyboardable;
+	public:
+		GLGuiWindow(SDL_Rect _pos, GLColor _bgcolor);
+		~GLGuiWindow();
+		
+		void addItem(GLGuiObject*);
+		SDL_Rect getPos();
+		void render();
+
+};
+
+#endif

glrect.cpp

@@ -0,0 +1,35 @@
+#include "glrect.h"
+
+GLRect::GLRect() {
+	set(0.0f, 0.0f, 0.0f, 0.0f);
+}
+
+GLRect::GLRect(float _x, float _y, float _w, float _h) {
+	set(_x, _y, _w, _h);
+}
+
+GLRect::GLRect(const SDL_Rect &r) {
+	set(r.x, r.y, r.w, r.h);
+}
+
+void GLRect::set(float _x, float _y, float _w, float _h) {
+	x = _x;
+	y = _y;
+	w = _w;
+	h = _h;
+}
+
+void GLRect::setPoint(float _x, float _y) {
+	x = _x;
+	y = _y;
+}
+
+void GLRect::setDim(float _w, float _h) {
+	w = _w;
+	h = _h;
+}
+
+SDL_Rect GLRect::getSDLRect() {
+	SDL_Rect tmp = {(Uint8)x, (Uint8)y, (Uint8)w, (Uint8)h};
+	return tmp;
+}

glrect.h

@@ -0,0 +1,22 @@
+#ifndef __GLRECT_H
+#define __GLRECT_H
+
+#include <SDL.h>
+
+class GLRect {
+	public:
+		float x, y;
+		float w, h;
+		
+		GLRect();
+		GLRect(float, float, float, float);
+		GLRect(const SDL_Rect&);
+		
+		void set(float, float, float, float);
+		void setPoint(float, float);
+		void setDim(float, float);
+		SDL_Rect getSDLRect();
+	
+};
+
+#endif

gltexture.cpp

@@ -0,0 +1,172 @@
+#include "gltexture.h"
+
+GLTexture::GLTexture() {
+	init();
+	alltextures.push_back(this);
+}
+
+GLTexture::GLTexture(std::string fname, GLint _minfilter, GLint _magfilter, GLint _wraps, GLint _wrapt) {
+	init();
+	setParameter(_minfilter, _magfilter, _wraps, _wrapt);
+	loadImage(fname);
+	
+	alltextures.push_back(this);
+}
+
+GLTexture::GLTexture(SDL_Surface *srfc) {
+	init();
+	loadSurface(srfc);
+}
+
+void GLTexture::init() {
+	loaded = false;
+	texconverted = false;
+	keepsurface = false;
+	donotreload = false;
+	
+	minfilter = GL_LINEAR;
+	magfilter = GL_LINEAR;
+	
+	wraps = GL_REPEAT;
+	wrapt = GL_REPEAT;
+	
+	tex = 0;
+	width = height = 0;
+}
+
+bool GLTexture::loadLocalSurface() {
+	if(!texconverted)
+		convertLocalSurface();
+	
+	width  = tex->w;
+	height = tex->h;
+	
+	glGenTextures(1, &texint);
+	glBindTexture(GL_TEXTURE_2D, texint);
+	
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minfilter);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magfilter);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wraps);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapt);
+
+	gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA8, width, height, GL_BGRA, GL_UNSIGNED_BYTE, tex->pixels);
+	
+	loaded = true;
+	
+	return true;
+}
+
+void GLTexture::convertLocalSurface() {
+	tex = SDL_DisplayFormatAlpha(tex);
+	mirrorSurfaceMiddleX(tex);
+	
+	texconverted = true;
+}
+
+bool GLTexture::loadImage(std::string fname) {
+	if(isLoaded())
+		unloadTexture();
+	filename = fname;
+	tex = IMG_Load(filename.c_str());
+	
+	if(!tex) {
+		std::cerr << "Textur konnte nicht geladen werden: " << filename << std::endl;
+		return false;
+	}
+	
+	bool ret = loadLocalSurface();
+	keepsurface = false;
+	SDL_FreeSurface(tex);
+	tex = 0;
+	
+	return ret;
+}
+
+bool GLTexture::loadSurface(SDL_Surface *srfc, bool noreloading) {
+	if(isLoaded())
+		unloadTexture();
+	if(filename!="")
+		filename = "";
+	
+	tex = srfc;
+	
+	keepsurface = true;
+	donotreload = noreloading;
+	
+	return loadLocalSurface();
+}
+
+bool GLTexture::selectTexture() {
+	if(!loaded) {
+		std::cerr << "Textur wurde nicht geladen: " << filename << std::endl;
+		return false;
+	}
+	
+	glBindTexture(GL_TEXTURE_2D, texint);
+	
+	return true;
+}
+
+void GLTexture::unloadTexture() {
+	glDeleteTextures(1, &texint);
+	
+	loaded = false;
+	// Entweder tex == image, wurde schon gelöscht oder wir müssen es nich löschen
+
+}
+
+bool GLTexture::setParameter(GLint _minfilter, GLint _magfilter, GLint _wraps, GLint _wrapt) {
+	if(_minfilter!=0)
+		minfilter = _minfilter;
+	if(_magfilter!=0)
+		magfilter = _magfilter;
+	if(_wraps!=0)
+		wraps = _wraps;
+	if(_wrapt!=0)
+		wrapt = _wrapt;
+	
+	if(!loaded)
+		return true;
+	
+	if(keepsurface&&tex!=0) {
+		unloadTexture();
+		return loadLocalSurface();
+	} else if(filename!="") {
+		return loadImage("filename");
+	} else {
+		// keine datei, kein surface
+		unloadTexture();
+		std::cerr << "Couldn't reload GLTexture " << this << "- No surface, no file!" << std::endl;
+		return false;
+	}
+}
+
+int GLTexture::getW() {
+	return width;	
+}
+
+int GLTexture::getH() {
+	return height;	
+}
+
+bool GLTexture::isLoaded() {
+	return loaded;
+}
+
+void GLTexture::reloadAll() {
+	for(unsigned int i=0; i<alltextures.size(); i++)
+		alltextures[i]->setParameter();
+}
+
+GLTexture::~GLTexture() {
+	if(isLoaded())
+		unloadTexture();
+		
+	for(unsigned int i=0; i<alltextures.size(); i++) {
+		if(alltextures[i]==this) {
+			alltextures.erase(alltextures.begin()+i);
+		}
+	}
+}
+
+std::vector<GLTexture*> GLTexture::alltextures;

gltexture.h

@@ -0,0 +1,63 @@
+#ifndef __GLTEXTUR_H
+#define __GLTEXTUR_H
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <SDL.h>
+#include <SDL_image.h>
+#include <SDL_opengl.h>
+#include "sdlfuncs.h"
+
+class GLTexture {
+	private:
+		GLuint texint;
+		SDL_Surface *tex;
+		int width, height;
+		
+		std::string filename; // wenn von datei geladen
+		
+		// Parameter
+		GLint minfilter;
+		GLint magfilter;
+		GLint wraps;
+		GLint wrapt;
+		
+		bool loaded;
+		bool texconverted;
+		bool keepsurface;
+		bool donotreload;
+		
+		void init();
+		bool loadLocalSurface();
+		void convertLocalSurface();
+		
+		static std::vector<GLTexture*> alltextures;
+	protected:
+		GLTexture(SDL_Surface*);
+		bool loadSurface(SDL_Surface*, bool = false);
+	public:
+		static void reloadAll();
+	
+		GLTexture();
+		GLTexture(std::string, GLint=GL_LINEAR, GLint=GL_LINEAR, GLint=GL_REPEAT, GLint=GL_REPEAT);
+		~GLTexture();
+
+		//load
+		
+		bool loadImage(std::string);
+		
+		bool selectTexture();
+		void unloadTexture();
+		bool setParameter(GLint=0, GLint=0, GLint=0, GLint=0);
+		inline bool select() { return selectTexture(); }
+		
+		int getW();
+		int getH();
+		
+
+		
+		bool isLoaded();
+};
+
+#endif

main.cpp

@@ -0,0 +1,177 @@
+#define VERSION "0.2.2 DEV"
+
+#include <iostream>
+#include <string>
+
+#include <SDL.h>
+#include <SDL_opengl.h>
+
+#include "gltexture.h"
+#include "glfontengine.h"
+
+// #define GL_DEBUG_MOVEMENT false
+
+void setupGL();
+void resizeOpenGLWindow(int, int, float=1.0f, float=100.0f);
+
+int main(int argc, char **argv) {
+	std::cout << "ARGV: " << argv[0] << std::endl;
+	//Vars
+	SDL_Surface *screen;
+	bool quit = false;
+	SDL_Event event;
+	int w_width  = 640;
+	int w_height = 480;
+	int w_bbp    = 32;
+	float znear = 1.0f;
+	float zfar  = 100.0f;
+
+	if(SDL_Init(SDL_INIT_VIDEO)<0) {
+		std::cerr << "Konnte SDL nicht initialisieren" << SDL_GetError() << std::endl;
+		return 1;
+	}
+		
+	// Setting video mode
+	int videoFlags;
+	const SDL_VideoInfo *videoInfo;
+
+	videoInfo = SDL_GetVideoInfo();
+	
+	if(!videoInfo) {
+		std::cerr << "Video query failed: " << SDL_GetError() << std::endl;
+		return 1;
+	}
+	
+	videoFlags  = SDL_OPENGL;
+	videoFlags |= SDL_GL_DOUBLEBUFFER;
+	videoFlags |= SDL_HWPALETTE;
+	videoFlags |= SDL_RESIZABLE;
+	if(videoInfo->hw_available)
+		videoFlags |= SDL_HWSURFACE;
+	else
+		videoFlags |= SDL_SWSURFACE;
+	if(videoInfo->blit_hw)
+		videoFlags |= SDL_HWACCEL;
+		
+// 	videoFlags |=SDL_FULLSCREEN;
+	
+// 	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 );
+	
+	if(!(screen = SDL_SetVideoMode(w_width, w_height, w_bbp, videoFlags))) {
+		std::cerr << "Kein SDL-Screen verfügbar: " << SDL_GetError() << std::endl;
+		return 1;
+	}
+	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+	
+	SDL_WM_SetCaption("GLGui Test, 0);
+	
+	// blank screen
+// 	SDL_FillRect(screen, 0, SDL_MapRGBA(screen->format, 0, 0, 0, 0));
+	
+	// GL Optionen
+	setupGL();
+		
+	resizeOpenGLWindow(w_width, w_height, znear, zfar);
+	
+	// Keyrepeat, falls benötigt auskommentieren
+	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
+	
+	// Fontengine initliaisieren, für alle die Fonts brauchen
+	GLFontEngine::addFont("font_big_better_alpha.png", "default");
+	
+	// Programmvariablen
+	Snake3D snake3d;
+	
+	//movement & keyboardcontrol
+	Uint8 *keys = SDL_GetKeyState(NULL);;
+	SDLKey tkey;
+	typedef enum { move_up=0, move_down, move_left, move_right} nummovekeys;
+	SDLKey movekeys[4];
+	
+	bool pause = true;
+	bool blend = false;
+	bool extralines = false;
+	bool fullscreen = false;
+	
+	// splash screen
+	bool splashscreen = true;
+	snake3d.pause(true);
+	SDL_Rect splashpos = { 40, 40, screen->w -80, 310 };
+	GLFontEngine fontengine("default");
+	
+#ifdef GL_DEBUG_MOVEMENT
+	movekeys[move_up]    = SDLK_i;
+	movekeys[move_down]  = SDLK_k;
+	movekeys[move_left]  = SDLK_j;
+	movekeys[move_right] = SDLK_l;
+#else
+	movekeys[move_up]    = SDLK_UP;
+	movekeys[move_down]  = SDLK_DOWN;
+	movekeys[move_left]  = SDLK_LEFT;
+	movekeys[move_right] = SDLK_RIGHT;
+#endif
+	
+	while(!quit) {
+		if(SDL_PollEvent(&event)) {
+			switch(event.type) {
+				case SDL_QUIT:
+					quit = true;
+				break;
+				case SDL_KEYDOWN:
+					keys = SDL_GetKeyState(NULL);
+					tkey = event.key.keysym.sym;
+
+				break;
+				case SDL_KEYUP:
+					keys = SDL_GetKeyState(NULL);
+				break;
+			}
+		} else {
+		
+			glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+			glLoadIdentity();
+
+			SDL_Delay(10);
+		}
+		
+	}
+	GLFontEngine::quit();
+	SDL_Quit();
+	
+	return 0;
+}
+
+void setupGL() {
+	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+	glClearDepth(1.0f);
+	glDepthFunc(GL_LEQUAL);
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_TEXTURE_2D);
+	glShadeModel(GL_SMOOTH);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+// 	glBlendFunc(GL_SRC_COLOR,GL_DST_COLOR);
+	
+// 	glBlendFunc(GL_DST_COLOR, GL_SRC_ALPHA);
+// 	glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
+	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+	glEnable(GL_ALPHA_TEST);
+	glAlphaFunc(GL_GREATER, 0.1);
+}
+
+void resizeOpenGLWindow(int width, int height, float znear, float zfar) {
+	if(height==0)
+		height = 1;
+
+	glViewport(0, 0, (GLsizei)width, (GLsizei)height);
+	
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, znear, zfar);
+	
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+}

matrix.cpp

@@ -0,0 +1,149 @@
+#include "matrix.h"
+
+Matrix::Matrix(int _m, int _n) {
+	m = _m;
+	n = _n;
+	allocate();
+}
+
+Matrix::Matrix(int _m, int _n, const float **src) {
+	m = _m;
+	n = _n;
+	allocate();
+	copyFromSource(src);
+}
+
+Matrix::Matrix(Punkt3D d) {
+	m = 3;
+	n = 1;
+	allocate();
+	c[0][0] = d.x;
+	c[1][0] = d.y;
+	c[2][0] = d.z;
+}
+
+Matrix::Matrix(const Matrix& mat) {
+	m = mat.m;
+	n = mat.n;
+	allocate();
+	copyFromSource(mat.getMatrix());
+}
+
+void Matrix::allocate() {
+	c = new float*[m];
+	for(int i=0; i<m; i++) {
+		c[i] = new float[n];
+		for(int t=0; t<n; t++)
+			c[i][t] = 0;
+	}
+}
+
+void Matrix::copyFromSource(const float** src) {
+	for(int i=0; i<m; i++) {
+		for(int t=0; t<n; t++)
+			c[i][t] = src[i][t];
+	}
+}
+
+const float **Matrix::getMatrix() const {
+	return (const float**)c;
+}
+
+bool Matrix::set(float d, int _m, int _n) {
+	if(_m>=m||_n>=n)
+		return false;
+	c[_m][_n] = d;
+	return true;
+}
+
+Matrix Matrix::operator*(const Matrix &d) {
+	
+	if(n!=d.m)
+		return Matrix(1,1);
+	Matrix erg(m, d.n);
+	
+	
+	for(int a=0; a<m; a++) {
+		for(int b=0; b<d.n; b++) {
+			float zerg = 0.0f;
+			for(int _c=0; _c<n; _c++) {
+				zerg += c[a][_c] * d.c[_c][b];
+			}
+			erg.c[a][b] = zerg;
+		}
+	}
+
+	return erg;
+}
+
+Matrix& Matrix::operator=(const Matrix& mat) {
+	if(mat.m<=m&&mat.n<=n) {
+		copyFromSource(mat.getMatrix());
+	}
+	return *this;
+}
+
+// Matrix Matrix::operator+(const float &f) {
+// 	Matrix tmp(*this);
+// 	for(int i=0; i<m; i++) {
+// 		for(int j=0; j<n; j++) {
+// 			tmp.c[i][j] += f;
+// 		}
+// 	}
+// 	return tmp;
+// }
+// 
+// Matrix Matrix::operator-(const float &f) {
+// 	Matrix tmp(*this);
+// 	for(int i=0; i<m; i++) {
+// 		for(int j=0; j<n; j++) {
+// 			tmp.c[i][j] -= f;
+// 		}
+// 	}
+// 	return tmp;
+// }
+// 
+// Matrix Matrix::operator*(const float &f) {
+// 	Matrix tmp(*this);
+// 	for(int i=0; i<m; i++) {
+// 		for(int j=0; j<n; j++) {
+// 			tmp.c[i][j] *= f;
+// 		}
+// 	}
+// 	return tmp;
+// }
+// 
+// Matrix Matrix::operator/(const float &f) {
+// 	Matrix tmp(*this);
+// 	for(int i=0; i<m; i++) {
+// 		for(int j=0; j<n; j++) {
+// 			tmp.c[i][j] /= f;
+// 		}
+// 	}
+// 	return tmp;
+// }
+
+int Matrix::getM() const {
+	return m;
+}
+
+int Matrix::getN() const {
+	return n;
+}
+
+void Matrix::print(std::string s) const {
+	std::cout << "Matrix " << s << "(" << m << "," << n << ")" << std::endl;
+	for(int a=0; a<m; a++) {
+		for(int b=0; b<n; b++) {
+			std::cout << std::setw(10) << c[a][b];
+		}
+		std::cout << std::endl;
+	}
+}
+
+Matrix::~Matrix() {
+	for(int i=0; i<m; i++) {
+		delete[](c[i]);
+	}
+	delete[](c);
+}

matrix.h

@@ -0,0 +1,42 @@
+#ifndef __MATRIX_H
+#define __MATRIX_H
+
+#include <iostream>
+#include <iomanip>
+
+#include "emath.h"
+
+class Matrix {
+	protected:
+		float **c;
+		int m, n;
+	
+		void allocate();
+		void copyFromSource(const float**);
+	public:
+		Matrix(int, int);
+		Matrix(int, int, const float**);
+		Matrix(Punkt3D);
+		Matrix(const Matrix&);
+		~Matrix();
+		
+		const float **getMatrix() const;
+		bool set(float, int, int);
+		int getM() const;
+		int getN() const;
+		
+		Matrix operator*(const Matrix&);
+		Matrix& operator=(const Matrix&);
+		
+// 		Matrix operator+(const float&);
+// 		Matrix operator-(const float&);
+// 		Matrix operator*(const float&);
+// 		Matrix operator/(const float&);
+
+		void print(std::string="") const;
+
+};
+
+
+
+#endif

quaternion.cpp

@@ -0,0 +1,77 @@
+#include "quaternion.h"
+
+Quaternion::Quaternion() {
+	w = 1.0f;
+	x = y = z = 0.0f;
+}
+
+void Quaternion::createFromRotation(float deg, float _x, float _y, float _z) {
+	float tmpres = sin(deg2rad(deg) / 2.0f);
+	
+	w = cos(deg2rad(deg) / 2.0f);
+	x = _x * tmpres;
+	y = _y * tmpres;
+	z = _z * tmpres;
+}
+
+Quaternion Quaternion::operator*(const Quaternion &q) {
+	Quaternion ret;
+
+	ret.w = w*q.w - x*q.x - y*q.y - z*q.z;
+	ret.x = w*q.x + x*q.w + y*q.z - z*q.y;
+	ret.y = w*q.y + y*q.w + z*q.x - x*q.z;
+	ret.z = w*q.z + z*q.w + x*q.y - y*q.x;
+
+	return ret;
+}
+
+void Quaternion::createGlMatrix(GLfloat *matrix) {
+	if(!matrix)
+		return;
+
+	matrix[0]  = 1.0f - 2.0f * ( y*y + z*z);
+	matrix[1]  = 2.0f * ( x*y + z*w);
+	matrix[2]  = 2.0f * ( x*z - y*w);
+	matrix[3]  = 0.0f;
+
+	matrix[4]  = 2.0f * ( x*y - z*w);
+	matrix[5]  = 1.0f - 2.0f * ( x*x + z*z);
+	matrix[6]  = 2.0f * ( z*y + x*w);
+	matrix[7]  = 0.0f;
+
+	matrix[8]  = 2.0f * ( x*z + y*w);
+	matrix[9]  = 2.0f * ( y*z - x*w);
+	matrix[10] = 1.0f - 2.0f * ( x*x + y*y);
+	matrix[11] = 0.0f;
+
+	matrix[12] = 0.0f;
+	matrix[13] = 0.0f;
+	matrix[14] = 0.0f;
+	matrix[15] = 1.0f;
+	
+}
+
+Punkt3D Quaternion::getDirectionVector() {
+	GLfloat matrix[16];
+	createGlMatrix(matrix);
+	
+	return getDirectionVector(matrix);
+}
+
+Punkt3D Quaternion::getDirectionVector(GLfloat *matrix) {
+	if(!matrix)
+		return Punkt3D();
+	Punkt3D tmp;
+	
+	tmp.x = matrix[8];
+	tmp.y = matrix[9];
+	tmp.z = matrix[10];
+	
+	return tmp;
+}
+
+void glMultMatrixf(Quaternion q) {
+	GLfloat matrix[16];
+	q.createGlMatrix(matrix);
+	glMultMatrixf(matrix);
+}

quaternion.h

@@ -0,0 +1,30 @@
+#ifndef __QUATERNION_H
+#define __QUATERNION_H
+
+#include <iostream>
+#include <cmath>
+#include <SDL_opengl.h>
+
+#include "emath.h"
+
+class Quaternion {
+	private:
+		float w;
+		float x,y,z;
+	public:
+		Quaternion();
+		void createFromRotation(float, float, float, float);
+		
+
+		void createGlMatrix(GLfloat*);
+		Punkt3D getDirectionVector();
+		Punkt3D getDirectionVector(GLfloat*);
+		
+		Quaternion operator*(const Quaternion&);
+		
+
+};
+
+void glMultMatrixf(Quaternion);
+
+#endif

rotationsmatrix.cpp

@@ -0,0 +1,91 @@
+#include "rotationsmatrix.h"
+
+Rotationsmatrix::Rotationsmatrix() : Matrix(3,3) {
+	set(x_axis, 0.0f);
+}
+
+Rotationsmatrix::Rotationsmatrix(axis _ax, float _deg) : Matrix(3,3) {
+	set(_ax, _deg);
+}
+
+Rotationsmatrix::Rotationsmatrix(Punkt3D _rotvec, float _deg) : Matrix(3,3) {
+	set(_rotvec, _deg);	
+}
+
+void Rotationsmatrix::set(Punkt3D _rotvec, float _deg) {
+	rotvec = _rotvec;
+	rotvec.normalize();
+	deg = _deg;
+	initRot();
+}
+
+void Rotationsmatrix::set(axis _ax, float _deg) {
+	deg = _deg;
+	
+	switch(_ax) {
+		case x_axis:
+			rotvec.set(1.0f, 0.0f, 0.0f);
+		break;
+		case y_axis:
+			rotvec.set(0.0f, 1.0f, 0.0f);
+		break;
+		case z_axis:
+			rotvec.set(0.0f, 0.0f, 1.0f);
+		break;	
+	}
+	initRot();
+}
+
+void Rotationsmatrix::set(float _deg) {
+	deg = _deg;
+	initRot();
+}
+
+void Rotationsmatrix::initRot() {
+	c[0][0] = scos(deg) + pow(rotvec.x,2.0f) * (1 - scos(deg));
+	c[0][1] = rotvec.x * rotvec.y * (1 - scos(deg)) - rotvec.z * ssin(deg);
+	c[0][2] = rotvec.x * rotvec.z * (1 - scos(deg)) + rotvec.y * ssin(deg);
+
+	c[1][0] = rotvec.y * rotvec.x * (1 - scos(deg)) + rotvec.z * ssin(deg);
+	c[1][1] = scos(deg) + pow(rotvec.y,2.0f) * (1 - scos(deg));
+	c[1][2] = rotvec.y * rotvec.z * (1 - scos(deg)) - rotvec.x * ssin(deg);
+
+	c[2][0] = rotvec.z * rotvec.x * (1 - scos(deg)) - rotvec.y * ssin(deg);
+	c[2][1] = rotvec.z * rotvec.y * (1 - scos(deg)) + rotvec.x * ssin(deg);
+	c[2][2] = scos(deg) + pow(rotvec.z,2.0f) * (1 - scos(deg));
+}
+
+Punkt3D Rotationsmatrix::operator*(const Punkt3D &p) {
+	Matrix erg(3,1);
+	Punkt3D erg2;
+
+	erg =  (((Matrix*)(this))->operator*(Matrix(p)));
+
+	const float **mat = erg.getMatrix();
+	erg2.set(mat[0][0], mat[1][0], mat[2][0]);
+
+	return erg2;
+}
+
+Rotationsmatrix Rotationsmatrix::operator*(const Rotationsmatrix &p) {
+	Matrix m(3, 3);
+	Rotationsmatrix rotmat;
+	m = ((Matrix)(*this) * (Matrix)p);
+	const float **mat = m.getMatrix();
+	rotmat.c[0][0] = mat[0][0];
+	rotmat.c[0][1] = mat[0][1];
+	rotmat.c[0][2] = mat[0][2];
+	rotmat.c[1][0] = mat[1][0];
+	rotmat.c[1][1] = mat[1][1];
+	rotmat.c[1][2] = mat[1][2];
+	rotmat.c[2][0] = mat[2][0];
+	rotmat.c[2][1] = mat[2][1];
+	rotmat.c[2][2] = mat[2][2];
+
+	return rotmat;
+}
+
+
+Rotationsmatrix::~Rotationsmatrix() {
+
+}

rotationsmatrix.h

@@ -0,0 +1,30 @@
+#ifndef __ROTATIONSMATRIX_H
+#define __ROTATIONSMATRIX_H
+
+#include <cmath>
+#include "emath.h"
+#include "matrix.h"
+
+enum axis { x_axis=0, y_axis, z_axis };
+
+class Rotationsmatrix : public Matrix {
+	private:
+		float deg;
+		Punkt3D rotvec;
+		
+		void initRot();
+	public:
+		Rotationsmatrix();
+		Rotationsmatrix(axis, float);
+		Rotationsmatrix(Punkt3D, float);
+		~Rotationsmatrix();
+		
+		void set(float);
+		void set(axis, float);
+		void set(Punkt3D, float);
+		
+		Punkt3D operator*(const Punkt3D&);
+		Rotationsmatrix operator*(const Rotationsmatrix&);
+};
+
+#endif

sdlfuncs.cpp

@@ -0,0 +1,82 @@
+#include "sdlfuncs.h"
+
+Uint32 getPixel(SDL_Surface *surface, int x, int y)
+{
+    int bpp = surface->format->BytesPerPixel;
+    /* Here p is the address to the pixel we want to retrieve */
+    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
+
+    switch(bpp) {
+    case 1:
+        return *p;
+
+    case 2:
+        return *(Uint16 *)p;
+
+    case 3:
+        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
+            return p[0] << 16 | p[1] << 8 | p[2];
+        else
+            return p[0] | p[1] << 8 | p[2] << 16;
+
+    case 4:
+        return *(Uint32 *)p;
+
+    default:
+        return 0;       /* shouldn't happen, but avoids warnings */
+    }
+}
+
+void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
+{
+    int bpp = surface->format->BytesPerPixel;
+    /* Here p is the address to the pixel we want to set */
+    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
+
+    switch(bpp) {
+    case 1:
+        *p = pixel;
+        break;
+
+    case 2:
+        *(Uint16 *)p = pixel;
+        break;
+
+    case 3:
+        if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+            p[0] = (pixel >> 16) & 0xff;
+            p[1] = (pixel >> 8) & 0xff;
+            p[2] = pixel & 0xff;
+        } else {
+            p[0] = pixel & 0xff;
+            p[1] = (pixel >> 8) & 0xff;
+            p[2] = (pixel >> 16) & 0xff;
+        }
+        break;
+
+    case 4:
+        *(Uint32 *)p = pixel;
+        break;
+    }
+}
+
+void swapPixel(SDL_Surface *surface, int x1, int y1, int x2, int y2) {
+	Uint32 a,b;
+	a = getPixel(surface, x1, y1);
+	b = getPixel(surface, x2, y2);
+	
+	setPixel(surface, x1, y1, b);
+	setPixel(surface, x2, y2, a);
+}
+
+void mirrorSurfaceMiddleX(SDL_Surface *surface) {
+	SDL_LockSurface(surface);
+	int upto = surface->h / 2;
+
+	for(int i=0; i<upto; i++) {
+		for(int x=0; x<surface->w; x++) {
+			swapPixel(surface, x, i, x, surface->h-1-i);
+		}
+	}
+	SDL_UnlockSurface(surface);
+}

sdlfuncs.h

@@ -0,0 +1,12 @@
+#ifndef __SDLFUNCS_H
+#define __SDLFUNCS_H
+
+#include <iostream>
+#include <SDL.h>
+
+Uint32 getPixel(SDL_Surface *surface, int x, int y);
+void setPixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
+void swapPixel(SDL_Surface *surface, int x1, int y1, int x2, int y2);
+void mirrorSurfaceMiddleX(SDL_Surface *surface);
+
+#endif