Initialisierung des GIT-Repositorys

master
seba 16 年前
当前提交 9de0171fc5

2
.gitignore vendored

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

@ -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...

@ -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);
}

@ -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

@ -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);
}

@ -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

@ -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);
}
}

@ -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

@ -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();
}

@ -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

@ -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;

@ -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

@ -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)

@ -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
}

@ -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

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

@ -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

@ -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();
}

@ -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

@ -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]);
}
}

@ -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

@ -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;
}

@ -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

@ -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;

@ -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

@ -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();
}

@ -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);
}

@ -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

@ -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);
}

@ -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

@ -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() {
}

@ -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

@ -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);
}

@ -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
正在加载...
取消
保存