Initial repository layout

+CC=gcc
+CPP=g++
+MAKE=make
+LD=ld
+
+# CFLAGS=-ggdb
+CXXFLAGS=
+
+LDFLAGS_X11=-L/usr/X11R6/lib -lX11 -lXext
+INC_X11=-I/usr/X11R6/include
+
+# LDFLAGS=$(LDFLAGS_X11) -lefence
+LDFLAGS=$(LDFLAGS_X11)
+INC=$(INC_X11)
+
+OBJECTS=gra_app.o dispatcher.o event_source.o rasterize.o
+XWIN_OBJ=xwin/canvas_x11.o xwin/canvas_x11_shm.o xwin/disp_x11.o xwin/xclass.o
+GEOM_OBJ=geometry/vertex.o geometry/polygon.o geometry/polyeder.o
+HELPER_OBJ=
+MATH_OBJ=math/sin_cos.o
+CANVAS_IMP_OBJ=canvas_imps/canvas_imp_rgb.o
+
+OBJ=$(OBJECTS) $(GEOM_OBJ) $(HELPER_OBJ) $(MATH_OBJ) $(XWIN_OBJ) 
+OBJ+=$(CANVAS_IMP_OBJ)
+
+%.o: %.cpp
+	$(CPP) $(CFLAGS) $(CXXFLAGS) $(INC) -c $*.cpp
+
+.PHONY : all geometry helper math xwin canvas_imps geometry_clean helper_clean math_clean xwin_clean canvas_imps_clean clean
+
+all: engage
+
+engage: geometry helper math xwin canvas_imps $(OBJECTS)
+	$(CPP) $(CFLAGS) $(CXXFLAGS) $(INC) $(LDFLAGS) -o $@ $(OBJ)
+
+geometry:
+	@cd geometry && $(MAKE)
+
+helper:
+	@cd helper && $(MAKE)
+
+math:
+	@cd math && $(MAKE)
+
+xwin:
+	@cd xwin && $(MAKE)
+
+canvas_imps:
+	@cd canvas_imps && $(MAKE)
+
+geometry_clean:
+	@cd geometry && $(MAKE) clean
+
+helper_clean:
+	@cd helper && $(MAKE) clean
+
+math_clean::
+	@cd math && $(MAKE) clean
+
+xwin_clean::
+	@cd xwin && $(MAKE) clean
+
+canvas_imps_clean::
+	@cd canvas_imps && $(MAKE) clean
+
+clean: geometry_clean helper_clean math_clean xwin_clean canvas_imps_clean
+	@rm -f gra_app
+	@rm -f *.o

+/**
+ * \file callback.h
+ *
+ * \brief Implementiert callbacks aus Membern und Funktionen.
+ *
+ * Enthält alle nötigen Klassen, um sowohl aus Klassenmembern
+ * als auch aus normalen Funktionen Callbacks zu machen. Das heißt
+ * das sowohl die Adresse des Objekts als auch die der Methode/Funktion
+ * gespeichert wird und bei bedarf richtig aufgerufen wird. Es lassen sich
+ * also Methoden in Arrays oder Listen vorhalten.
+ *
+ * \author Georg Steffers <georg@steffers.org>
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2001 (Georg Steffers): erste implementation
+ * \version 2001-2003 (Georg Steffers): diverse Modifikationen
+ * \version 04.12.2003 (Georg Steffers): beginn der Dokumentation via doxygen
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+using namespace std;
+
+#include <cstring>
+
+// enthaelt die adressen unserer callbackfunktion bzw. der Klasse und des
+// Members die wir aufrufen moechten....(dies hier ist die Basisklasse
+// diese wird gleich spezifiziert
+class FunctorBase {
+    public:
+        // dient wohl nur dazu die groesse eines Member-Pointers zu bestimmen.
+        typedef void (FunctorBase::*t_MemberFunc)();
+
+        // hierdrin wird der Quatsch gespeichert....
+        union {
+            const void* Callback;
+            char CallbackMember[sizeof(t_MemberFunc)];
+        };
+        void* Class;
+
+        // Konstruktoren
+
+        // wichtig, wenn ein Object der Klasse FunctorBase oder einer
+        // abgeleiteten Klasse kopiert werden soll.
+        FunctorBase() : Class(0), Callback(0) {}
+
+        // Hiermit wird eine FunctorBase angelegt.
+        FunctorBase(const void* _Class, const void* _Callback, size_t Size) {
+            if(_Class) { //Mit nem Member initialisiert
+                Class=(void*)_Class;
+                memcpy(CallbackMember, _Callback, Size);
+            }
+            else { // Mit ner normalen Funktion initialisiert
+                Class=NULL;
+                Callback=_Callback;
+            }
+        }
+};
+
+// dies wird nu ein Functor, der einen Callback aufnehmen kann, der einen
+// beliebiegen Parameter hat und void zurueckgibt.
+template <class P1, class P2>
+class callback : protected FunctorBase {
+    // wir machen einen protected Konstruktor fuer die Klasse, damit nur
+    // abgeleitete Klassen einen callback erzeugen koennen. Diese mussen dann
+    // sicherstellen, das Funktor1 nur mit Methoden oder Funktionen erzeugt
+    // wird, die genau einen Parameter akzeptieren und void zurueckliefern.
+    // Der Teil RestoreTypeAndCall(_RTAC) initialisiert RestoreTypeAndCall
+    // auf _RTAC.
+    protected:
+        typedef void (*t_RestoreTypeAndCall)(const FunctorBase&, P1, P2);
+        callback(t_RestoreTypeAndCall _RTAC, const void *_Class,
+                 const void *_Callback, size_t _Size) :
+            FunctorBase (_Class, _Callback, _Size), RestoreTypeAndCall(_RTAC) {}
+
+    private:
+        t_RestoreTypeAndCall RestoreTypeAndCall;
+
+    public:
+        callback() {}
+        void operator() (P1 p1, P2 p2) const { // ueber den koennen wir nachher
+                                               // den Callback aufrufen.
+            if(Class)  // Wir haben nen Member...
+                RestoreTypeAndCall(*this, p1, p2);
+            else       // normale Funktion, koennen wir direkt aufrufen...
+                ((void (*)(P1,P2))Callback)(p1, p2);
+        }
+        const void* getcb(void) { return Callback; }
+
+        int is_null(void) {
+            if(Class != 0 || Callback != 0)
+                return false;
+            return true;
+        }
+};
+
+// beim speichern der Klasse als void* ist uns der Typ der Klasse und 
+// auch das eigentliche Object verloren gegangen. 
+// Deshalb kommt hier jetzt ne Klasse, die den Typ kennt und 
+// bei bedarf (jedesmal wenn eine Memberfunktion als Callback aufgerufen
+// werden soll) zurueckwandelt.
+// Ein template: Callee ist jede beliebige Klasse und Func jeder Member
+template <class Callee, class Func, class P1, class P2>
+class MemberTranslator : public callback<P1,P2> {
+    public:
+        MemberTranslator(Callee &Class, const Func &MemberFunction) :
+            callback<P1,P2>(RestoreTypeAndCall, &Class, &MemberFunction, 
+                            sizeof(Func)) {}
+
+        static void RestoreTypeAndCall(const FunctorBase &ftor, P1 p1, P2 p2) {
+            Callee* Who = (Callee*)(ftor.Class);
+            Func TheMemberFunction=*(Func*)(void*)(ftor.CallbackMember);
+            (Who->*TheMemberFunction)(p1, p2);
+        }
+};
+
+// Da der Konstruktor von callback protected ist brauchen wir noch einen
+// Translator um aus normalen Funktionen Callbacks zu machen.
+template <class P1, class P2>
+class FunctionTranslator : public callback<P1,P2> {
+    public:
+        FunctionTranslator(void *regularFunc) :
+            callback<P1,P2>(NULL,NULL,regularFunc,0) {}
+};
+
+// und jetzt noch 2 makeCallback Templates um das erstellen von Callbacks zu
+// erleichtern.
+template <class Callee, class P1, class P2>
+callback<P1, P2> mk_callback(Callee &Class, void (Callee::*Member)(P1, P2)) {
+    return MemberTranslator<Callee,void (Callee::*)(P1,P2),P1,P2>(Class, 
+                                                                   Member);
+}
+
+template <class P1, class P2>
+callback<P1, P2> mk_callback(void (*theFunc)(P1, P2)) {
+    return FunctionTranslator<P1, P2>((void*)theFunc);
+}

+/**
+ * \file canvas.h
+ *
+ * \brief Ein canvas ist etwas worauf gezeichnet werden kann.
+ *
+ * <p>Diese beschreibt einen Speicherbereich in dem gezeichnet werden kann 
+ * und Methoden zum "blitten" also dem darstellen dieses Speicherbereichs 
+ * auf dem Bildschirm. Außerdem werden Funktionen zur Farbverwaltung zur 
+ * verf&uuml;gung gestellt.</p>
+ * <p>canvas ist von event-source abgeleitet, da es events erzeugen kann
+ * wie z.B. ein redraw-request u.&auml;.</p>
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 [gs]: erste funktionierende Implementation
+ * \version 04.12.2003 [gs]: beginn der Dokumentation via doxygen
+ * \version 19.12.2003 [gs]: draw_text hinzugefügt, das ist hier eigentlich
+ *                           nicht ganz richtig, aber damit ich nicht meinen
+ *                           eigenen Font-Renderer schreiben muss um debug
+ *                           Ausgaben zu machen und daf&uuml;e die 
+ *                           X11-Funktionen nutzen kann, ist der hier.
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __canvas_h__
+#define __canvas_h__
+
+#include "canvas_imps/canvas_imp.h"
+#include "event_source.h"
+#include "rasterize.h"
+#include <cstdio>
+
+typedef enum blit_status {NO_BLIT, BLIT, DRAW};
+
+class canvas : public event_source {
+    protected:
+        unsigned x_size, y_size;
+        canvas_imp* sinfo;
+
+        blit_status blit; 
+        unsigned long draw_color;
+
+    public:
+        virtual void draw_text(int x, int y, char* text, int length) = 0;
+        canvas(unsigned xs, unsigned ys) : event_source() {
+            x_size=xs;
+            y_size=ys;
+
+            sinfo=NULL;
+            blit=NO_BLIT;
+        }
+        virtual ~canvas() {
+            close_screen();
+        }
+
+        virtual rasterizer* create_rasterizer(void) = 0;
+        virtual void refresh_palette(void) {};
+        virtual void open_screen(void)=0;
+        virtual void close_screen(void) {};
+        virtual void blit_screen(void)=0;
+        blit_status& blitting(void) { return blit; }
+        unsigned long get_color(unsigned red, unsigned green, unsigned blue) {
+            return sinfo->ext_to_native(red, green, blue);
+        }
+        void set_color(unsigned long col) { draw_color=col; }
+        void set_color(unsigned red, unsigned green, unsigned blue) {
+            draw_color=sinfo->ext_to_native(red, green, blue);
+        }
+        void light_native(unsigned long* col, unsigned intens) {
+           sinfo->light_native(col, intens);
+        }
+
+        char bpp(void) { return sinfo->bytes_per_pixel; }
+
+        virtual unsigned get_x_size(void) const { return x_size; }
+        virtual unsigned get_y_size(void) const { return y_size; }
+};
+
+class canvas_factory {
+    public:
+        virtual canvas* create(unsigned xs, unsigned ys) const=0;
+};
+
+#endif // __canvas_h__

+CC=gcc
+CPP=g++
+#CFLAGS=-ggdb
+CXXFLAGS=
+MAKE=make
+
+OBJECTS=canvas_imp_rgb.o
+
+%.o: %.cpp
+	$(CPP) $(CFLAGS) $(CXXFLAGS) -c $*.cpp
+
+.PHONY : all clean
+
+all: $(OBJECTS)
+
+clean:
+	@rm -f *.o

+/**
+ * \file canvas_imp.h
+ *
+ * \brief ein Prototyp einer Canvas Implementation
+ *
+ * Die Canvas Implementation dient Hauptsächlich dazu color,
+ * light und fogtables passend zum canvas zur verfügung zu stellen.
+ * Es werden auch Methoden bereit gestellt, über die man externe
+ * Farbdefinitionen (z.B. für jeweils rot, grün und blau
+ * Werte zwischen 0 und 255) in das von dem canvas benutzte Farbschema
+ * zu convertieren.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 [gs]: erste funktionierende Implementation
+ * \version 22.12.2003 [gs]: <ul><li>
+ *                           beginn der Dokumentation via doxygen
+ *                           </li><li>
+ *                           Light und Fogtables hinzugef&uuml;gt
+ *                           </li></ul>
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __canvas_imp_h__
+#define __canvas_imp_h__
+
+#define MAX_LIGHT_LEVELS 255
+#define NUM_LIGHT_LEVELS (MAX_LIGHT_LEVELS+1)
+
+#define MAX_FOG_LEVELS        255
+#define NUM_FOG_LEVELS        (MAX_FOG_LEVELS + 1)
+
+class canvas;
+class rasterizer;
+
+class canvas_imp {
+    friend class canvas;
+    friend class rasterizer;
+
+    protected:
+        unsigned ext_max_red;
+        unsigned ext_max_green;
+        unsigned ext_max_blue;
+
+        virtual void compute_light_table(void)=0;
+        virtual void compute_fog_table(void)=0;
+
+    public:
+        virtual unsigned long ext_to_native(unsigned red,
+                                            unsigned green,
+                                            unsigned blue)=0;
+        virtual ~canvas_imp() {};
+
+        // virtual void light_to_native(unsigned char* pcolor,
+        //                              int intensity)=0;
+        // virtual void fog_to_native(unsigned char* pcolor,
+        //                            int intensity)=0;
+
+        virtual void set_color(unsigned long col) {};
+
+        virtual void light_native(unsigned long* col, unsigned intense) = 0;
+
+        unsigned char* p_screenbuf;
+        char bytes_per_pixel;
+};
+
+#endif // __canvas_imp_h__

+#include "canvas_imp_rgb.h"
+#include <cstdio>
+
+void canvas_imp_rgb::compute_color_resolution(void) {
+    for(unsigned rgb=red; rgb<=blue; rgb++) {
+       unsigned mask_tmp=col_mask[rgb];
+
+       for(col_shift[rgb]=0; (mask_tmp & 0x01) == 0; col_shift[rgb]++)
+           mask_tmp>>=1;
+       for(col_max[rgb]=1; mask_tmp & 0x01 == 1; col_max[rgb]*=2)
+           mask_tmp>>=1;
+       col_max[rgb]--;
+    }
+}
+
+void canvas_imp_rgb::compute_light_table(void) {
+   for(unsigned rgb=red; rgb<=blue; rgb++)
+      for(unsigned c=0; c<=col_max[rgb]; c++)
+         for(unsigned i=0; i<NUM_LIGHT_LEVELS; i++)
+            light_table[rgb][c*NUM_LIGHT_LEVELS+i]=c*i/MAX_LIGHT_LEVELS;
+}
+
+void canvas_imp_rgb::compute_fog_table(void) {
+   for(unsigned rgb=red; rgb<=blue; rgb++)
+      for(unsigned c=0; c<=col_max[rgb]; c++)
+         for(unsigned i=0; i<NUM_FOG_LEVELS; i++)
+            fog_table[rgb][c*NUM_FOG_LEVELS+i]=
+               c+(unsigned)(((float)i/MAX_FOG_LEVELS)*(col_max[rgb]-c));
+}
+
+canvas_imp_rgb::canvas_imp_rgb(unsigned long red_mask,
+                               unsigned long green_mask,
+                               unsigned long blue_mask,
+                               char bytes_per_pixel,
+                               char bytes_per_rgb) {
+    this->col_mask[red]=red_mask;
+    this->col_mask[green]=green_mask;
+    this->col_mask[blue]=blue_mask;
+
+    this->bytes_per_pixel=bytes_per_pixel;
+    this->bytes_per_rgb=bytes_per_rgb;
+
+    ext_max_red=255;
+    ext_max_green=255;
+    ext_max_blue=255;
+
+    compute_color_resolution();
+
+    light_table[red]=new unsigned[(col_max[red]+1)*NUM_LIGHT_LEVELS];
+    light_table[green]=new unsigned[(col_max[green]+1)*NUM_LIGHT_LEVELS];
+    light_table[blue]=new unsigned[(col_max[blue]+1)*NUM_LIGHT_LEVELS];
+    fog_table[red]=new unsigned[(col_max[red]+1)*NUM_FOG_LEVELS];
+    fog_table[green]=new unsigned[(col_max[green]+1)*NUM_FOG_LEVELS];
+    fog_table[blue]=new unsigned[(col_max[blue]+1)*NUM_FOG_LEVELS];
+
+    compute_light_table();
+    compute_fog_table();
+}
+
+unsigned long canvas_imp_rgb::ext_to_native(unsigned red,
+                                            unsigned green,
+                                            unsigned blue) {
+    unsigned long red_rescaled=red * col_max[this->red] / ext_max_red;
+    unsigned long green_rescaled=green * col_max[this->green] / ext_max_green;
+    unsigned long blue_rescaled=blue * col_max[this->blue] / ext_max_blue;
+
+    return (red_rescaled << col_shift[this->red]) |
+           (green_rescaled << col_shift[this->green]) |
+           (blue_rescaled << col_shift[this->blue]);
+}
+
+void canvas_imp_rgb::light_native(unsigned long* col, unsigned intense) {
+  unsigned char* c2=(unsigned char*)col;
+
+  unsigned long color=0;
+  unsigned long color_shift=0;
+
+  for(register int p=0; p<bytes_per_rgb; p++) {
+     color += (*c2++) << color_shift;
+     color_shift += 8;  // 8=BITS_PER_BYTE
+  }
+
+  // mögliche restliche bytes zwischen bytes_per_rgb und
+  // bytes_per_pixel überspringen (warum muss ich nochmal
+  // rausfinden.
+  for(register int p=bytes_per_rgb; p<bytes_per_pixel; p++)
+     c2++;
+
+  unsigned long r=(color&col_mask[red]) >> col_shift[red];
+  unsigned long g=(color&col_mask[green]) >> col_shift[green];
+  unsigned long b=(color&col_mask[blue]) >> col_shift[blue];
+
+  color=(light_table[red][r*NUM_LIGHT_LEVELS+intense] << 
+         col_shift[red]) |
+        (light_table[green][g*NUM_LIGHT_LEVELS+intense] << 
+         col_shift[green]) |
+        (light_table[blue][b*NUM_LIGHT_LEVELS+intense] << 
+         col_shift[blue]);
+
+  {
+     register int i;
+     unsigned long mask = 255;
+     char shift = 0;
+
+     for(c2-=bytes_per_pixel, i=0; i<bytes_per_pixel; i++) {
+        *c2 = (color & mask) >> shift;
+        c2++;
+        mask <<= 8;
+        shift += 8;
+     }
+  }
+}

+/**
+ * \file canvas_imp_rgb.h
+ *
+ * \brief eine Canvas Implementation für ein rgb Canvas.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 [gs]: erste funktionierende Implementation
+ * \version 22.12.2003 [gs]: <ul><li>
+ *                           beginn der Dokumentation via doxygen
+ *                           </li><li>
+ *                           Light und Fogtables hinzugef&uuml;gt
+ *                           eine Methode f&uuml;r perPixel Shading
+ *                           eingebaut, (soll heissen ein gesetztes
+ *                           Pixel kann nachtr&aum;glich noch
+ *                           geshaded werden.
+ *                           </li></ul>
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __canvas_imp_rgb_h__
+#define __canvas_imp_rgb_h__
+
+#include "canvas_imp.h"
+
+class canvas_imp_rgb : public canvas_imp {
+    private:
+        enum rgb_e_t { red=0, green, blue };
+
+        unsigned* light_table[3];
+        unsigned* fog_table[3];
+
+        char bytes_per_rgb;
+
+        unsigned long col_mask[3];
+        unsigned col_shift[3];
+        unsigned col_max[3];
+
+        void compute_color_resolution(void);
+        void compute_light_table(void);
+        void compute_fog_table(void);
+
+    public:
+        canvas_imp_rgb(unsigned long, unsigned long, unsigned long,
+                       char, char);
+        virtual ~canvas_imp_rgb() {}
+
+        unsigned long ext_to_native(unsigned, unsigned, unsigned);
+
+        void light_native(unsigned long* col, unsigned intense);
+
+        // und wieder fehlt alles für light und fog.
+};
+
+#endif // __canvas_imp_rgb_h__

+/**
+ * \file dispatcher.cpp
+ *
+ * \brief Stadardimplementation der virtuellen Member des Dispatcher-Managers.
+ *
+ * Für eine detailierte Beschreibung von Dispatcher und 
+ * Dispatcher-Manager schauen Sie bitte unter \ref dispatcher.h
+ * 
+ * \author Georg Steffers <georg@steffers.org>
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 (Georg Steffers): erste funktionierende Implementation
+ * \version 04.12.2003 (Georg Steffers): beginn der Dokumentation via doxygen
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+using namespace std;
+
+#include <cstring>
+
+#include "dispatcher.h"
+
+disp_manager::disp_manager(dispatcher* d) {
+    disp_count=0;
+    disp=NULL;
+
+    if(d!=NULL) {
+        disp=new dispatcher*[1];
+        disp[0]=d;
+        disp_count++;
+    }
+}
+
+dispatcher*& disp_manager::operator[](unsigned index) {
+    if(index+1>disp_count) {
+        dispatcher** disp_tmp=new dispatcher*[index+1];
+        memcpy(disp_tmp, disp, sizeof(dispatcher*)*disp_count);
+
+        delete [] disp;
+        disp=disp_tmp;
+        disp_count=index+1;
+    }
+
+    return disp[index];
+}
+
+void disp_manager::start(void) {
+    run=true;
+
+    while(run)
+        do_once();
+}
+
+void disp_manager::do_once(void) {
+    for(int i=0; i<disp_count; i++)
+        if(disp[i]->e_src)
+            disp[i]->go();
+}

+/**
+ * \file dispatcher.h
+ *
+ * \brief Deklaration eines abstrakten Event-Dispatchers und des 
+ *        Dispatcher-Managers.
+ *
+ * <p>In einem Dispatcher werden callbacks eingetragen, die bei bestimmten
+ * Events aufgerufen werden sollen, Der Dispatcher k&uuml;mmert sich dann
+ * darum das diese zum richtigen Zeitpunk und f&uuml;r das richtige Event
+ * aufgerufen werden. Der Dispatcher wird mit der Event-Quelle initialisiert,
+ * die die Events erzeugt. Die hier definierte Dispatcher Klasse ist abstrakt
+ * und mu&szlig; noch in einer abgeleiteten Klasse konkretisiert werden. So
+ * kann ich diverse Dispatcher erzeugen, die intern unterschiedlich arbeiten,
+ * im Moment existiert die X11 implementation eines Dispatches.</p>
+ * <p>Im Dispatcher Manager werden die einzelnen Dispatcher registriert. Er
+ * sorgt dann dann standartm&auml;&szlig;ig daf&uuml;r, das die einzelnen
+ * Dispatcher immer wieder nacheinenader in der Reihenfolge in der sie dem
+ * Manager hinzugef&uuml;gt wurden ausgeführt werden und so alle Events immer
+ * wieder gecheckt werden. Dieses verhalten kann man aber &auml;ndern indem
+ * man einen neuen Manager von diesem ableitet und die virtuellen Methoden
+ * entsprechend &uuml;berschreibt.</p>
+ * 
+ * \author Georg Steffers <georg@steffers.org>
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 (Georg Steffers): erste funktionierende Implementation
+ * \version 04.12.2003 (Georg Steffers): beginn der Dokumentation via doxygen
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __dispatcher_h__
+#define __dispatcher_h__
+
+#include "callback.h"
+#include "event_source.h"
+
+class disp_manager;
+class dispatcher {
+    friend class disp_manager;
+
+    protected:
+        callback<event_source*,void*> cb[MaxEvent];
+        event_source* e_src;
+        int halt_f;
+
+    public:
+        dispatcher(event_source* es=NULL) {
+            e_src=es;
+            halt_f=false;
+        }
+        virtual ~dispatcher() {}
+
+        void register_callback(event e, callback<event_source*, void*> _cb) {
+            if(e_src)
+                cb[e]=_cb;
+        }
+
+        virtual void go(void)=0;
+        virtual void trigger_event(event)=0;
+        void halt(void) { halt_f=true; }
+        void cont(void) { halt_f=false; }
+};
+
+// Da ich u.U. mehrere Eventquellen in einem Programm habe brauche
+// ich eine Klasse die die verschiedenen Dispatcher-Klassen kontrolliert
+// nacheinander aufruft.
+class disp_manager {
+    private:
+        dispatcher** disp;
+        unsigned disp_count;
+        unsigned run;
+
+    public:
+        disp_manager(dispatcher* = NULL);
+        ~disp_manager() {
+            delete [] disp;
+        }
+
+        dispatcher*& operator[](unsigned index);
+
+        unsigned count(void) { return disp_count; }
+        virtual void start(void);
+        virtual void stop(event_source*, void*) { 
+            run=false; 
+        }
+        virtual void do_once(void);
+};
+
+class dispatcher_factory {
+    public:
+        virtual dispatcher* create(event_source* es) const=0;
+};
+
+#endif // __dispatcher_h__

+/**
+ * \file event_source.cpp
+ *
+ * \brief definition und initialisierung von max_id
+ *
+ * Für eine detailierte Beschreibung von event_source
+ * schauen Sie bitte unter \ref event_source.h
+ * 
+ * \author Georg Steffers <georg@steffers.org>
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 (Georg Steffers): erste funktionierende Implementation
+ * \version 04.12.2003 (Georg Steffers): beginn der Dokumentation via doxygen
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "event_source.h"
+
+unsigned event_source::max_id=0;

+/**
+ * \file event_source.h
+ *
+ * \brief Interface für Events generierende Klassen
+ *
+ * Alle Klassen die Events erzeugen wollen müssen von diesem
+ * Interface abgeleitet werden, damit man einen Dispatcher f&uuml:r Sie
+ * erzeugen kann.
+ *
+ * \author Georg Steffers <georg@steffers.org>
+ *
+ * \date 04.12.2003
+ *        
+ * \version ..2002 (Georg Steffers): erste funktionierende Implementation
+ * \version 04.12.2003 (Georg Steffers): beginn der Dokumentation via doxygen
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __event_source_h__
+#define __event_source_h__
+
+class event_source {
+    private:
+        static unsigned max_id;
+        unsigned id;
+
+    public:
+        event_source() {
+            id=max_id++;
+        }
+};
+
+typedef enum event {Key, Update, Draw, Idle, Stop, MaxEvent};
+
+#endif // __event_source_h__

+/**
+ * \file factory.h
+ *
+ * \brief erzeugt auf Anfrage passende Objekte.
+ *
+ * \author Georg Steffers <georg@steffers.org>
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 (Georg Steffers): erste funktionierende Implementation
+ * \version 04.12.2003 (Georg Steffers): beginn der Dokumentation via doxygen
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __factory_h__
+#define __factory_h__
+
+#include "xwin/disp_x11.h"
+#include "xwin/canvas_x11_shm.h"
+#include "xwin/canvas_x11.h"
+#include "canvas_imps/canvas_imp_rgb.h"
+#include "rasterize.h"
+
+class factory_manager {
+    public:
+        canvas_factory* canvas_f;
+        dispatcher_factory* dispatcher_f;
+        //rasterizer_factory* rasterizer_f;
+
+        factory_manager() : canvas_f(new canvas_x11_shm_factory), 
+                            dispatcher_f(new disp_x11_factory) {}
+        virtual ~factory_manager() {
+            delete canvas_f;
+            delete dispatcher_f;
+        };
+};
+
+#endif // __factory_h__

+CC=gcc
+CPP=g++
+#CFLAGS=-ggdb
+CXXFLAGS=
+MAKE=make
+
+OBJECTS=vertex.o polygon.o polyeder.o
+TEMPLATES=../helper/container.h ../helper/container_tpl.h
+TEMPLATES+=../math/Mmn.h ../math/Mmn_tpl.h ../math/V_K4.h ../math/V_K4_tpl.h
+
+%.o: %.c++ $(TEMPLATES)
+	$(CPP) $(CFLAGS) $(CXXFLAGS) -c $*.c++
+
+.PHONY : all clean
+
+all: $(OBJECTS)
+
+clean:
+	@rm -f *.o

+/**
+ * \file movable.h
+ *
+ * \brief Definition eines Templates für bewegte Objekte
+ *
+ * Organisiert, verwaltet und steuert die Bewegung bewegter Objekte.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 19.12.2003
+ *
+ * \version 19.12.2003 [gs]: erste Implementation aus gra_app gezogen.
+ * \version 21.12.2003 [gs]: Bug in rotate_im_axis(double, vertex, vertex)
+ *                           gefixt. Dort wurden immer die Objektkoordinaten
+ *                           auf den Weltursprung verschoben und nicht die
+ *                           Vektorbasis wie es eigentlich sein sollte.
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __movable_h__
+#define __movable_h__
+
+#include "vertex.h"
+#include "../math/Mmn.h"
+
+/**
+ * \brief Ein Interface f&uuml;r bewegte Objekte
+ *
+ * alle Objektklassen, die auch Kind dieses komplett &ouml;ffentlichen
+ * Interfaces sind lassen sich dadurch rotieren und bewegen, das man die
+ * Rotations- und Bewegungsgeschwindigkeit bez&uuml;glich der lokalen,
+ * bzw. der Weltkoordinaten angibt.
+ * jeder Aufruf der Methode update aktualisiert dann die Positionen der
+ * Vektoren dieses Objekts.
+ */
+class movable {
+   protected:
+      vertex vrp;    //!< \brief \<Punkt\> (view reference point) 
+                     //! das Zentrum des Objekts
+      vertex vfw_t;  //!< \<Punkt\> Spitze von \ref vfw
+      vertex vup_t;  //!< \<Punkt\> Spitze von \ref vup
+      vertex vri_t;  //!< \<Punkt\> Spitze von \ref vri
+      vertex vfw;    //!< \brief \<Vektor\> (vektor forward) 
+                     //! Objektkoordinatensystem z
+      vertex vup;    //!< \brief \<Vektor\> (vektor up) 
+                     //! Objektkoordinatensystem y
+      vertex vri;    //!< \brief \<Vektor\> (vektor right) 
+                     //! Objektkoordinatensystem x
+
+      Mmn<double> t_mat; //!< Die aktuelle Transformationsmatrize
+      
+      //! \brief Geschwinidigkeiten
+      //! relativ zu Weltkoordinaten
+      double speed_x, speed_y, speed_z, rot_speed_x, rot_speed_y, rot_speed_z;
+      //! \brief Geschwinidigkeiten
+      //! relativ zu Objekt
+      double speed_vfw, speed_vri, speed_vup, 
+             rot_speed_vfw, rot_speed_vri, rot_speed_vup;
+
+
+      time_t last_transform;     //!<\brief Zeitpunkt der letzten Transformation
+                                 //!
+                                 //! Damit l&auml;&szlig;t sich der genaue
+                                 //! Zeitraum seit der letzten Transformation
+                                 //! berechnen und in alle Transformations
+                                 //! Berechnungen mit einf&uuml;gen, so das
+                                 //! wir wirkliche Echtzeit bekommen.
+
+      //! Speed-Falloffs pro Sekunde
+      double speed_x_falloff, 
+             speed_y_falloff, 
+             speed_z_falloff, 
+             rot_speed_x_falloff, 
+             rot_speed_y_falloff, 
+             rot_speed_z_falloff;
+      double speed_vfw_falloff, 
+             speed_vri_falloff, 
+             speed_vup_falloff, 
+             rot_speed_vfw_falloff, 
+             rot_speed_vri_falloff, 
+             rot_speed_vup_falloff;
+
+      //! \brief Konstruktor
+      //!
+      //! privater Kontruktor, da man von dem Interface
+      //! keinen Eigenen Instanzen bilden k&ouml;nnen soll.
+      movable() {
+         vrp=vertex(0,0,0,1);
+         vfw_t=vertex(0,0,1,1);
+         vup_t=vertex(0,1,0,1);
+         vri_t=vertex(1,0,0,1);
+         vfw=vfw_t-vrp;
+         vup=vup_t-vrp;
+         vri=vri_t-vrp;
+         t_mat=Mmn<double>(4);
+      }
+
+   public:
+      virtual const Mmn<double>& get_t_mat(void) { return t_mat; }
+
+      virtual void reset(void) {
+         vrp.reset();
+         vfw_t.reset();
+         vup_t.reset();
+         vri_t.reset();
+         vfw=vfw_t-vrp;
+         vup=vup_t-vrp;
+         vri=vri_t-vrp;
+
+         t_mat=Mmn<double>(4);
+      }
+
+      /** 
+       * \param t_st Transformationsstufe
+       */
+      virtual void transform(unsigned t_st) {
+         vrp.transform(t_mat, t_st);
+         vfw_t.transform(t_mat, t_st);
+         vup_t.transform(t_mat, t_st);
+         vri_t.transform(t_mat, t_st);
+         vfw=vfw_t-vrp;
+         vup=vup_t-vrp;
+         vri=vri_t-vrp;
+      }
+
+      void print(void) {
+         t_mat.print();
+      }
+
+      const vertex& get_vrp(void) { 
+         return vrp; 
+      }
+
+      const vertex& get_vfw_t(void) { 
+         return vfw_t; 
+      }
+
+      const vertex& get_vup_t(void) { 
+         return vup_t; 
+      }
+
+      const vertex& get_vri_t(void) { 
+         return vri_t; 
+      }
+
+      const vertex& get_vfw(void) { 
+         return vfw; 
+      }
+
+      const vertex& get_vup(void) { 
+         return vup; 
+      }
+
+      const vertex& get_vri(void) { 
+         return vri; 
+      }
+
+      /**
+       * \brief direkte Ver&auml;nderung der Position &uuml;ber eine
+       *        vorberechnete Matrize.
+       * \param trans_mat Eine komplette vorberechnete Transformationsmatrix
+       */
+      void move_im(const Mmn<double>& trans_mat) {
+         t_mat=trans_mat%t_mat;
+      }
+      /**
+       * \brief Verschiebung &uuml;ber (lokale) Objekkoordinaten
+       * \param axe Achse entlang der verschoben wird
+       * \param step wie weit verschoben wird
+       */
+      void translate_im_axe(vertex axe, double step) {
+         axe=axe.norm()*step;
+         t_mat=mat_translate(axe[X], axe[Y], axe[Z])%t_mat;
+      }
+      /**
+       * \brief Verschiebung &uuml;ber (globale) Weltkoordinaten
+       * \param x Verschiebung in VRI 
+       * \param y Verschiebung in VUP 
+       * \param z Verschiebung in VFW 
+       */
+      void translate_im_global(double x, double y, double z) {
+         t_mat=mat_translate(x, y, z)%t_mat;
+      }
+      /**
+       * \brief Drehung &uuml;ber (lokale) Objekkoordinaten vfw
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_vfw(double angle) {
+         vfw_t.transform(t_mat, 1);
+         vrp.transform(t_mat, 1);
+
+         rotate_im_axis(angle, vfw_t, vrp);
+
+         vfw_t.reset();
+         vrp.reset();
+      }
+      /**
+       * \brief Drehung &uuml;ber (lokale) Objekkoordinaten vup
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_vup(double angle) {
+         vup_t.transform(t_mat, 1);
+         vrp.transform(t_mat, 1);
+
+         rotate_im_axis(angle, vup_t, vrp);
+
+         vup_t.reset();
+         vrp.reset();
+      }
+      /**
+       * \brief Drehung &uuml;ber (lokale) Objekkoordinaten vri
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_vri(double angle) {
+         vri_t.transform(t_mat, 1);
+         vrp.transform(t_mat, 1);
+
+         rotate_im_axis(angle, vri_t, vrp);
+
+         vri_t.reset();
+         vrp.reset();
+      }
+      /**
+       * \brief Drehung um X-Achse im Weltkoordinaten-Zentrum
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_g_x(double angle) {
+         t_mat=mat_rot_x(angle)%t_mat;
+      }
+      /**
+       * \brief Drehung um Y-Achse im Weltkoordinaten-Zentrum
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_g_y(double angle) {
+         t_mat=mat_rot_y(angle)%t_mat;
+      }
+      /**
+       * \brief Drehung um Z-Achse im Weltkoordinaten-Zentrum
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_g_z(double angle) {
+         t_mat=mat_rot_z(angle)%t_mat;
+      }
+      /**
+       * \brief Drehung um X-Achse im Objektkoordinaten-Zentrum
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_l_x(double angle) {
+         Mmn<double> mat_center(4);
+         Mmn<double> mat_reset(4);
+
+         mat_center.a(0,3)=-t_mat.a(0,3);
+         mat_center.a(1,3)=-t_mat.a(1,3);
+         mat_center.a(2,3)=-t_mat.a(2,3);
+
+         mat_reset.a(0,3)=t_mat.a(0,3);
+         mat_reset.a(1,3)=t_mat.a(1,3);
+         mat_reset.a(2,3)=t_mat.a(2,3);
+
+         t_mat=mat_reset%mat_rot_x(angle)%mat_center%t_mat;
+      }
+      /**
+       * \brief Drehung um Y-Achse im Objektkoordinaten-Zentrum
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_l_y(double angle) {
+         Mmn<double> mat_center(4);
+         Mmn<double> mat_reset(4);
+
+         mat_center.a(0,3)=-t_mat.a(0,3);
+         mat_center.a(1,3)=-t_mat.a(1,3);
+         mat_center.a(2,3)=-t_mat.a(2,3);
+
+         mat_reset.a(0,3)=t_mat.a(0,3);
+         mat_reset.a(1,3)=t_mat.a(1,3);
+         mat_reset.a(2,3)=t_mat.a(2,3);
+
+         t_mat=mat_reset%mat_rot_y(angle)%mat_center%t_mat;
+      }
+      /**
+       * \brief Drehung um Z-Achse im Objektkoordinaten-Zentrum
+       * \param angle Wieviel Grad soll gedreht werden
+       */
+      void rotate_im_l_z(double angle) {
+         Mmn<double> mat_center(4);
+         Mmn<double> mat_reset(4);
+
+         mat_center.a(0,3)=-t_mat.a(0,3);
+         mat_center.a(1,3)=-t_mat.a(1,3);
+         mat_center.a(2,3)=-t_mat.a(2,3);
+
+         mat_reset.a(0,3)=t_mat.a(0,3);
+         mat_reset.a(1,3)=t_mat.a(1,3);
+         mat_reset.a(2,3)=t_mat.a(2,3);
+
+         t_mat=mat_reset%mat_rot_z(angle)%mat_center%t_mat;
+      }
+      /**
+       * \brief Drehung um eine beliebige Achse
+       * \param angle Wieviel Grad soll gedreht werden
+       * \param axe Die Achse um die gedreht werden soll als 
+       *        Ursprungsvektor (also einer der in WC(0,0,0) beginnt)
+       */
+      void rotate_im_axis(double angle, const vertex& axe) {
+         t_mat=mat_rot_axe(angle, axe.get_t())%t_mat;
+      }
+
+      /**
+       * \brief Drehung um Z-Achse im Objektkoordinaten-Zentrum
+       * \param angle Wieviel Grad soll gedreht werden
+       * \param tip Vertexspitze der Rotationsachse
+       * \param base Vertexbasis der Rotationsachse
+       */
+      void rotate_im_axis(double angle, vertex tip, vertex base) {
+         Mmn<double> mat_center(4);
+         Mmn<double> mat_reset(4);
+
+         mat_center.a(0,3)=-base[X];
+         mat_center.a(1,3)=-base[Y];
+         mat_center.a(2,3)=-base[Z];
+
+         mat_reset.a(0,3)=base[X];
+         mat_reset.a(1,3)=base[Y];
+         mat_reset.a(2,3)=base[Z];
+
+//         if(angle==0 || angle==180) {
+//            cout << "------------------------------\n";
+//            cout << "Winkel: " << angle << "Grad\n";
+//            t_mat.print();
+//         }
+         t_mat=mat_reset%mat_rot_axe(angle, (tip-base).get_t())%mat_center%t_mat;
+//         if(angle==0 || angle==180) {
+//            t_mat.print();
+//            cout << "------------------------------\n";
+//         }
+      }
+      // sowohl für translatio, als auch für Rotation sollte ich denke
+      // ich eigene Methoden für jede Richtung schreiben.!!!
+};
+
+#endif // __movable_h__

+#include "polyeder.h"
+
+polyeder::polyeder(const polygon& p, const vertex_list& vl) : 
+          container<polygon>(p), vl(vl) {
+    for(unsigned i=0; i<count; i++) {
+        content[i].set_vertex_list(&this->vl);
+        content[i]._init_normal_();
+        content[i].set_polyeder(this);
+    }
+}
+
+polyeder::polyeder(const polygon* p, unsigned c, const vertex_list& vl) : 
+          container<polygon>(p, c), vl(vl) {
+    for(unsigned i=0; i<count; i++) {
+        content[i].set_vertex_list(&this->vl);
+        content[i]._init_normal_();
+        content[i].set_polyeder(this);
+    }
+}
+
+polyeder::polyeder(const polyeder& p) : 
+          container<polygon>(p), vl(p.vl) {
+    for(unsigned i=0; i<count; i++) {
+        content[i].set_vertex_list(&this->vl);
+        content[i].set_polyeder(this);
+    }
+}
+
+const polyeder& polyeder::operator=(const polyeder& p) {
+    if(this==&p)
+        return *this;
+
+    container<polygon>::operator=(p);
+    vl=p.vl;
+
+    for(unsigned i=0; i<count; i++) {
+        content[i].set_vertex_list(&vl);
+        content[i].set_polyeder(this);
+    }
+
+    return *this;
+}
+
+void polyeder::transform(const Mmn<double>& tm, int p) {
+    for(unsigned i=0; i<count; i++) {
+        content[i].transform(tm, p);
+    }
+}
+
+void polyeder::transform_normals(const Mmn<double>& tm, int p) {
+    for(unsigned i=0; i<count; i++) {
+        content[i].transform_normal(tm, p);
+    }
+}
+
+void polyeder::reset(void) {
+    vl.reset();
+
+    for(unsigned i=0; i<count; i++) {
+        content[i].reset();
+    }
+}
+
+void polyeder::trans_poly(unsigned i, const Mmn<double>& tm, int p) {
+    content[i].transform(tm, p);
+}
+
+void polyeder::project_2d(double lcx, double sw, double sh, 
+                          double ph_ar, double sy, int p) {
+    for(unsigned i=0; i<count; i++) {
+        content[i].project_2d(lcx, sw, sh, ph_ar, sy, p+1);
+    }
+    for(unsigned i=0; i<vl.card(); i++) {
+        vl[i].set_trans_stage(p);
+    }
+}

+/**
+ * \file polyeder.h
+ *
+ * \brief Ein Polyeder (eine gruppe von Polygonen)
+ *
+ * Ein Polyeder organisier die Vertexliste und Anordnung von Polygonen
+ * die zu einem Körper gehören.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 19.12.2003
+ *
+ * \version ..2002 [gs]: erste Implementation
+ * \version 19.12.2003 [gs]: <ul><li>
+ *                           Vergleichsoperator hinzugef&uuml;gt
+ *                           </li><li>
+ *                           polyeder_movable von gra_app nach hier hin
+ *                           &uuml;bertragen
+ *                           </li><li>
+ *                           Member world_coordinate rausgesmissen, vielleicht
+ *                           bau ich den noch mal wieder ein, aber er darf nie
+ *                           implizit benutzt werden, ich denke es ist besser
+ *                           Alle Positionen und Ausrichtungen von Objekten in
+ *                           einer Weltklasse zu speichern.
+ *                           </li></ul>
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __polyeder_h__
+#define __polyeder_h__
+
+#include "../helper/container.h"
+#include "../math/Mmn.h"
+#include "polygon.h"
+#include "vertex.h"
+#include "movable.h"
+
+class polyeder : public container<polygon> {
+    public:
+        vertex_list vl;
+
+    public:
+        polyeder() : container<polygon>() {}
+        polyeder(const polygon&, const vertex_list&);
+        polyeder(const polygon*, unsigned, const vertex_list&);
+        polyeder(const polyeder&);
+        ~polyeder() {}
+
+        const polyeder& operator=(const polyeder&);
+        const polygon& operator[](unsigned index) const {
+            return content[index];
+        }
+        polygon& operator[](unsigned index) {
+            return content[index];
+        }
+
+        virtual void transform(const Mmn<double>&, int=0);
+        virtual void transform_normals(const Mmn<double>&, int=0);
+        void trans_poly(unsigned, const Mmn<double>&, int=0);
+        virtual void reset(void);
+        /**
+         * \param lcx (lens coverage(x)) = Sichtfeld(x)
+         * \param sw (screen width) = Breite des Projektionsfensters
+         * \param sh (screen height) = Hoehe des Projektionsfensters
+         * \param ph_ar (physical aspect ratio) = Seitenverhaeltnis des 
+         *        Anzeigegeraets
+         * \param sy (scale y) = Wenn Anzeigegeraet und Projektionfenster die 
+         *        selbe Groesse haben 1, ansonsten der Wert um y proportional
+         *        zu x zu projezieren.
+         * \param p Transformationsstufe
+         */
+        void project_2d(double lcx, double sw, double sh, 
+                        double ph_ar, double sy=1, int p=0);
+};
+
+class polyeder_movable : public polyeder, public movable {
+   public:
+      polyeder_movable() : polyeder(), movable() {}
+      polyeder_movable(const polygon& p, const vertex_list& vl) :
+         polyeder(p, vl) {}
+      polyeder_movable(const polygon* p, unsigned c, const vertex_list& vl) :
+         polyeder(p, c, vl) {}
+      polyeder_movable(const polyeder& p) :
+         polyeder(p) {}
+
+      void transform(int transstage) {
+         polyeder::transform(t_mat, transstage);
+         movable::transform(transstage);
+      }
+
+      void transform_normals(int p) {
+         polyeder::transform_normals(t_mat, p);
+      }
+
+      void reset(void) {
+         polyeder::reset();
+         movable::reset(); 
+      }
+};
+
+#endif

+#include "polygon.h"
+
+void polygon::_init_normal_(void) {
+    if(vl && count>0) {
+        for(unsigned i=0; i<count; i++) {
+            center[O_X]+=(*vl)[content[i]][O_X];
+            center[O_Y]+=(*vl)[content[i]][O_Y];
+            center[O_Z]+=(*vl)[content[i]][O_Z];
+        }
+    
+        center[X]=center[O_X]/=count;
+        center[Y]=center[O_Y]/=count;
+        center[Z]=center[O_Z]/=count;
+        center[W]=center[O_W]=1;
+    
+        normal=center+
+               (((*vl)[content[1]]-(*vl)[content[0]])|
+               ((*vl)[content[count-1]]-(*vl)[content[0]])).norm();
+    }
+    else {
+        center=vertex();
+        normal=vertex();
+    }
+}
+
+void polygon::transform(const Mmn<double>& tm, int p) {
+    for(unsigned i=0; i<count; i++) {
+        (*vl)[content[i]].transform(tm, p);
+    }
+
+    transform_normal(tm, p);
+}
+
+void polygon::transform_normal(const Mmn<double>& tm, int p) {
+    center.transform(tm, p);
+    normal.transform(tm, p);
+}
+
+void polygon::reset(void) {
+/*    for(unsigned i=0; i<count; i++) {
+        (*vl)[content[i]].reset();
+    }*/
+
+    center.reset();
+    normal.reset();
+}
+
+/**
+ * \brief Clipping gegen eine vordere Z-Ebene
+ *
+ * Dieser Algorithmus clippt das polygon gegen eine vordere Z-Ebene
+ *
+ * \param this Das ungeclippte unprojezierte Polygon.
+ * \return ein geclipptes Polygon.
+ */
+polygon polygon::clip_front_z(double min_Z) const {
+   container<unsigned> clip;
+   polygon ret;
+
+   for(unsigned j=0; j<(*this).card(); j++) {
+      double x0=(*vl)[container<unsigned>::operator[](j)][X],
+             y0=(*vl)[container<unsigned>::operator[](j)][Y],
+             z0=(*vl)[container<unsigned>::operator[](j)][Z],
+             x1=(*vl)[container<unsigned>::operator[]((j+1)%(*this).card())][X],
+             y1=(*vl)[container<unsigned>::operator[]((j+1)%(*this).card())][Y],
+             z1=(*vl)[container<unsigned>::operator[]((j+1)%(*this).card())][Z];
+
+      // Wenn beide drin sind den zweiten übernehmen.
+      if(z0>min_Z && z1>min_Z)
+         // Nur P2 nach clip übernehmen
+         clip[clip.card()]=
+            container<unsigned>::operator[]((j+1)%(*this).card());
+
+      // Wenn nur P2 drin ist 
+      if(z0<=min_Z && z1>min_Z) {
+         // Schnittpunkt berechnen und nach temp übernehmen
+         unsigned idx=(*vl).card();
+         double t=(min_Z-z0)/(z1-z0);
+         double x=x0+t*(x1-x0);
+         double y=y0+t*(y1-y0);
+
+         // neuen Vertex zur Vertexliste.
+         (*vl)[idx]=vertex(x, y, min_Z, COORD);
+
+         // und ins geclippte polygon
+         clip[clip.card()]=idx;
+         // und P2 ins geclippte polygon
+         clip[clip.card()]=
+            container<unsigned>::operator[]((j+1)%(*this).card());
+      }
+
+      // Wenn nur P1 drin ist 
+      if(z0>min_Z && z1<=min_Z) {
+         // Schnittpunkt berechnen und nach temp übernehmen
+         unsigned idx=(*vl).card();
+         double t=(min_Z-z1)/(z0-z1);
+         double x=x1+t*(x0-x1);
+         double y=y1+t*(y0-y1);
+
+         // neuen Vertex zur Vertexliste.
+         (*vl)[idx]=vertex(x, y, min_Z, COORD);
+
+         // und ins geclippte polygon
+         clip[clip.card()]=idx;
+      }
+   }
+
+   // Das geclippte Polygon zurückliefern.
+   ret=polygon(clip, vl);
+   ret.set_id(id);
+   return ret;
+}
+
+/** 
+* \brief Clippings nach Sutherland-Hodgman
+*
+* Cliped das Polygon an dem Polygon p. Es wird ein neues Polygon
+* erzeugt, das diesem Polygon innerhalb des Polygons p entspricht.
+* Dieses neue Polygon nutzt die selbe Vertexliste.
+*
+* \param p Das Polygon an dem geclipped werden soll.
+* \returns Ein in p passendes Polygon.
+*/
+polygon polygon::clip_2d(const polygon& p) const {
+  //! enth&auml;lt w&auml;hrend des clippings die aktuellen
+  //! Vertex_listen indizies.
+  container<unsigned> clip;
+
+  // Zuerst Origialdaten sichern.
+  clip=(container<unsigned>)*this;
+
+  // Solange unbearbeitete Kanten im Clippolygon sind...
+  for(unsigned i=0; i<p.card(); i++) {
+     //! enth&auml;lt immer die neuen geclippten VL-Indizies
+     container<unsigned> temp;
+
+     //! Hole nächste Kante des Clippolygons und sichere sie als 
+     //! Vektor. Diese ist definiert über die beiden Punkte 
+     //! p[i] und p[(i+1)%p.card()]
+     double x0=p[i][X],
+            y0=p[i][Y],
+            x1=p[(i+1)%p.card()][X],
+            y1=p[(i+1)%p.card()][Y];
+
+     // Jetzt muss zunaechst ein Vektor erzeugt werden der senkrecht
+     // von der Kante ins Poligon zeigt 
+     // chk=(X=P1.Y-P2.Y, Y=P2.X-P1.X, 0)
+     vertex chk(y0-y1, x1-x0, 0, VEKTOR);
+
+     // Solange Kanten nicht bearbeitet wurden
+     for(unsigned j=0; j<clip.card(); j++) {
+        //! hole nächste Kante aus clipped Prüfe ob Punkt1 und/oder 
+        //! Punkt2 immerhalb des Clippolygons sind.
+        //! Kante ist (*vl)[clip[j]] und (*vl)[clip[(j+1)%clip.count]]
+        double x0s=(*vl)[clip[j]][X],
+               y0s=(*vl)[clip[j]][Y],
+               x1s=(*vl)[clip[(j+1)%clip.card()]][X],
+               y1s=(*vl)[clip[(j+1)%clip.card()]][Y];
+
+        //! Liegt der erste Punkt innerhalb des Clippolygons
+        //! chk%(P1 - clipP1) > 0.05 und/oder
+        double chk_p1=chk%((*vl)[clip[j]] - (*p.vl)[i]);
+        //! liegt der zweite Punkt innerhalb des Clippolygons
+        //! chk%(P2 - clipP1) > 0.05
+        double chk_p2=chk%((*vl)[clip[(j+1)%clip.card()]] - 
+                           (*p.vl)[i]);
+
+        // 0.05 ist ein Epsilon um Ungenauigkeiten auszugleichen und
+        // ganz sicher zu gehen das der Punkt wirklich innerhalb liegt.
+
+        // Wenn beide drin sind
+        if(chk_p1>0.05 && chk_p2>0.05)
+            // Nur P2 nach temp übernehmen
+            temp[temp.card()]=clip[(j+1)%clip.card()];
+
+        // Wenn nur P1 drin ist 
+        if(chk_p1>0.05 && chk_p2<=0.05) {
+            // Schnittpunkt berechnen und nach temp übernehmen
+            unsigned idx=(*vl).card();
+            double x,y;
+
+            x=x0+((((x1s-x0s)*(y0-y0s))+((y1s-y0s)*(x0s-x0)))/
+              (((x1-x0)*(y1s-y0s))-((y1-y0)*(x1s-x0s))))*(x1-x0);
+
+            y=y0+((((x1s-x0s)*(y0-y0s))+((y1s-y0s)*(x0s-x0)))/
+              (((x1-x0)*(y1s-y0s))-((y1-y0)*(x1s-x0s))))*(y1-y0);
+
+            // neuen Vertex zur Vertexliste.
+            (*vl)[idx]=vertex(x, y, 0, COORD);
+
+            temp[temp.card()]=idx;
+        }
+
+        // Wenn nur P2 drin ist
+        if(chk_p1<=0.05 && chk_p2>0.05) {
+            // Schnittpunkt berechnen und nach temp übernehmen
+            unsigned idx=(*vl).card();
+            double x,y;
+
+            x=x0+((((x1s-x0s)*(y0-y0s))+((y1s-y0s)*(x0s-x0)))/
+              (((x1-x0)*(y1s-y0s))-((y1-y0)*(x1s-x0s))))*(x1-x0);
+
+            y=y0+((((x1s-x0s)*(y0-y0s))+((y1s-y0s)*(x0s-x0)))/
+              (((x1-x0)*(y1s-y0s))-((y1-y0)*(x1s-x0s))))*(y1-y0);
+
+            // neuen Vertex zur Vertexliste.
+            (*vl)[idx]=vertex(x, y, 0, COORD);
+
+            temp[temp.card()]=idx;
+
+            // P2 nach temp übernehmen
+            temp[temp.card()]=clip[(j+1)%clip.card()];
+        }
+
+        // Wenn keiner drin ist
+        // Nichts nach temp
+     }
+
+     // temp enth&auml;lt jetzt die aktuellen Vertexindizies,
+     // f&uuml;r den n&auml;chsten durchlauf mu&szlig; clip
+     // darauf gesetzt werden.
+     clip=temp;
+  }
+
+  // Das geclippte Polygon zurückliefern.
+  return polygon(clip, vl);
+}
+
+void polygon::project_2d(double lcx, double sw, double sh, 
+                          double ph_ar, double sy, int p) {
+    for(unsigned i=0; i<count; i++) {
+        (*vl)[content[i]].project_2d(lcx, sw, sh, ph_ar, sy, p);
+    }
+}

+/**
+ * \file polygon.h
+ *
+ * \brief definiert alle Klassen zu Polygonen (Gruppen mehrerer Vertexe die
+ *        eine Fläche bilden.
+ *
+ * Hier ist die Klasse polygon definiert, die die zentrale Klasse der
+ * 3D-Application ist. Es werden immer Polygone dargestellt.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 16.12.2003
+ *
+ * \version ..2002 [gs]: erste Implementation
+ * \version 16.12.2003 [gs]: <ul><li>
+ *                           Beginn der Dokumentation mir Doxygen
+ *                           </li><li>
+ *                           Den Sutherland-Hodgman Clipping Algorithmus
+ *                           eingebaut. Er scheint zu funktionieren, muss
+ *                           aber noch ausgiebig getestet werden.
+ *                           </li></ul>
+ * \version 19.12.2003 [gs]: <ul><li>
+ *                           Vergleichsoprator hinzugef&uuml;gt
+ *                           </li><li>
+ *                           polygon_movable von gra_app &uuml;bertragen
+ *                           </li></ul>
+ * \version 21.12.2003 [gs]: vorderes z-clipping eingebaut.
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __polygon_h__
+#define __polygon_h__
+
+#include "../helper/container.h"
+#include "../math/Mmn.h"
+#include "vertex.h"
+#include "movable.h"
+
+
+class polyeder;
+
+class polygon : public container<unsigned> {
+    private:
+        vertex_list* vl;
+        vertex center;
+        vertex normal;
+
+        polyeder* pe;
+        char id[30];
+
+    public:
+        polygon() 
+            : container<unsigned>(), vl(NULL), center(vertex()), 
+              normal(vertex()), pe(NULL) {}
+        polygon(vertex_list *const vl) 
+            : container<unsigned>(), vl(vl), center(vertex()), 
+              normal(vertex()), pe(NULL) {}
+        polygon(const unsigned& p, vertex_list *const vl) 
+            : container<unsigned>(p), vl(vl), pe(NULL) { _init_normal_(); }
+        polygon(const container<unsigned>& p, vertex_list *const vl) 
+            : container<unsigned>(p), vl(vl), pe(NULL) { _init_normal_(); }
+        polygon(const unsigned* idxs, unsigned count, vertex_list *const vl) 
+            : container<unsigned>(idxs, count), vl(vl), 
+              pe(NULL) { _init_normal_(); }
+        polygon(const polygon& p) 
+            : container<unsigned>(p), vl(p.vl), 
+              center(p.center), normal(p.normal), pe(p.pe) { strncpy(id, p.id, 29); }
+        ~polygon() {}
+
+        virtual void _init_normal_();
+
+        virtual bool operator==(const polygon& p) const {
+           if(this->container<unsigned>::operator==((container<unsigned>)p)&&
+              center==p.center &&
+              normal==p.normal)
+              return true;
+
+           return false;
+        }
+
+        void set_id(const char* i) { strncpy(id, i, 29); }
+        const char* get_id(void) const { return id; }
+
+        virtual polygon clip_2d(const polygon& p) const;
+        virtual polygon clip_front_z(double min_Z) const;
+
+        virtual const polygon& operator=(const polygon& p) {
+            if(this==&p)
+                return *this;
+
+            container<unsigned>::operator=(p);
+            vl=p.vl;
+            center=p.center;
+            normal=p.normal;
+            pe=p.pe;
+            strncpy(id, p.id, 29);
+
+            return *this;
+        }
+        virtual void set_vertex_list(vertex_list *const vl) {
+            this->vl=vl;
+            // dachte ich zuerst, aber eigentlich sollte alles richtig
+            // gesetzt sein, da sich ja die indizies in der neuen Vertexliste
+            // nicht aender sondern nur die Adressen!
+            //if(normal==0 || center==0)
+            //    _init_normal_();
+        }
+        virtual void set_polyeder(polyeder *const pe) {
+           this->pe=pe;
+        }
+        virtual const polyeder& get_polyeder(void) {
+           return *pe;
+        }
+        virtual const vertex& operator[](unsigned index) const {
+            return (*vl)[content[index]];
+        }
+        virtual vertex& operator[](unsigned index) {
+            return (*vl)[content[index]];
+        }
+
+        virtual unsigned vl_idx(unsigned index) {
+           return content[index];
+        }
+
+        /*
+         * Ich sollte den Normalenvektor aus der Vertexliste nehmen und
+         * bei bedarf neu berechnen oder aber die transformation für 
+         * normalenvektoren benutzen wenn ich ihn transformiere.
+         */
+        virtual vertex const& center_p(void) { 
+           return center;
+        }
+
+        virtual vertex const& normal_p(void) const { 
+           return normal; 
+        }
+
+        virtual void transform(const Mmn<double>&, int=0);
+        virtual void transform_normal(const Mmn<double>&, int=0);
+        virtual void reset(void);
+        virtual void project_2d(double lcx, double sw, double sh, 
+                                double ph_ar, double sy=1, int p=0);
+};
+
+class polygon_movable : public polygon, public movable {
+   public:
+      polygon_movable() : polygon(), movable() {}
+      polygon_movable(vertex_list *const vl) :
+         polygon(vl) {}
+      polygon_movable(const unsigned& p, vertex_list *const vl) :
+         polygon(p, vl) {}
+      polygon_movable(const unsigned* idxs, unsigned count, 
+                      vertex_list *const vl) :
+         polygon(idxs, count, vl) {}
+      polygon_movable(const polygon& p) :
+         polygon(p) {}
+
+      void transform(int transstage) {
+         polygon::transform(t_mat, transstage);
+         movable::transform(transstage);
+      }
+
+      void transform_normal(int p) {
+          polygon::transform_normal(t_mat, p);
+      }
+
+      void reset(void) {
+         polygon::reset();
+         movable::reset(); 
+      }
+};
+
+
+#endif // __polygon_h__

+#include "vertex.h"
+
+const vertex& vertex::operator=(const vertex& v) {
+    if(this==&v)
+        return *this;
+
+    original=v.original;
+    transformed=v.transformed;
+    trans_stage=v.trans_stage;
+
+    return *this;
+}
+
+vertex operator*(const double& a, const vertex& v) {
+    return v * a;
+}
+
+vertex vertex::operator*(const double& a) const {
+    vertex v=*this;
+    v.original=v.original*a;
+    v.transformed=v.transformed*a;
+    return v;
+}
+
+double vertex::operator% (const vertex& v) const {
+    return transformed%v.transformed;
+}
+
+vertex vertex::operator| (const vertex& v) const {
+    vertex w=*this;
+    w.original=w.original|v.original;
+    w.transformed=w.transformed|v.transformed;
+    return w;
+}
+
+vertex vertex::operator+ (const vertex& v) const {
+    vertex w=*this;
+    w.original=w.original+v.original;
+    w.transformed=w.transformed+v.transformed;
+    return w;
+}
+
+vertex vertex::operator- (const vertex& v) const {
+    vertex w=*this;
+    w.original=w.original-v.original;
+    w.transformed=w.transformed-v.transformed;
+    return w;
+}
+
+vertex vertex::norm(void) const { 
+    vertex w;
+    w.original=original*(1/original.v_betr()); 
+    w.transformed=transformed*(1/transformed.v_betr());
+    return w;
+}
+
+double vertex::betr(void) const { 
+    return transformed.v_betr(); 
+}
+
+void vertex::reset(void) { 
+    if(trans_stage!=0) {
+        trans_stage=0; 
+        transformed=original; 
+    }
+}
+
+void vertex::transform(const Mmn<double>& t_mat, int p) {
+   if(trans_stage < p) {
+      transformed=t_mat % transformed;
+      trans_stage=p;
+   }
+}
+
+void vertex::project_2d(double lcx, double sw, double sh, 
+                        double ph_ar, double sy, int p) {
+    if(trans_stage < p) {
+        transformed[X]=transformed[X]/transformed[Z] * 
+                       (lcx * sw) + 0.5*sw;
+        transformed[Y]=-transformed[Y]/transformed[Z] * 
+                       (lcx * ph_ar * sh) + 0.5*sy*sh;
+        transformed[Z]=1/transformed[Z]; // 1/Z ist linear im projezierten
+                                         // Polygon kann ich also über die
+                                         // Polygonkanten interpolieren
+                                         // brauche ich fuer z-Buffer, 
+                                         // Texturemapping und evtl. noch mehr.
+
+        trans_stage=p;
+    }
+}
+
+inline double vertex::unproject_X(double tx, double tz, 
+                                    double lcx, double sw) {
+   return (tx - 0.5*sw) / (lcx * sw) / tz;
+}
+
+inline double vertex::unproject_Y(double ty, double tz,
+                                    double lcx, double sh, 
+                                    double ph_ar, double sy) {
+   return (ty - 0.5*sy*sh) / (lcx * ph_ar * sh) / tz;
+}
+
+inline double vertex::unproject_Z(double tz) {
+   return 1/tz;
+}
+
+inline double vertex::unproject_U(double tu, double tz, 
+                                    double lcx, double sw) {
+   return (tu - 0.5*sw) / (lcx * sw) / tz;
+}
+
+inline double vertex::unproject_V(double tv, double tz,
+                                    double lcx, double sh, 
+                                    double ph_ar, double sy) {
+   return (tv - 0.5*sy*sh) / (lcx * ph_ar * sh) / tz;
+}
+
+void vertex_list::reset(void) {
+    for(unsigned i=0; i<count; i++)
+        content[i].reset();
+
+    if(variable) {
+       delete [] variable;
+       variable=NULL;
+       var_count=0;
+    }
+}

+/**
+ * \file vertex.h
+ *
+ * \brief Definiert eine Klasse für einen Vertex und eine Klasse fü
+ *        einen Vertexliste
+ * 
+ * Ein Vertex ist bei mir ein transformbares 4-Tupel, das sowohl einen Vektor
+ * als auch eine Coordinate darstellen kann. Ich bezeichne beides als Vertex,
+ * weil auch der Vektor einen Coordinate darstellen kann (falls man ihn als
+ * Ursprungsvektor betrachtet)
+ * Eine Vertexliste ist ein Container der Vertexe aufnehmen kann und
+ * insbesondere zwei getrennte Sepicherbereiche zur aufnahme von Vertexen hat,
+ * über die aber mit dem gleichen Zugriffsmechanismus zugegriffen wird.
+ * Die wird gebraucht um leicht Vertexe für das clipping hinzufügen
+ * zu können.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 16.12.2003
+ *
+ * \version ..2002 [gs]: erste Implementation
+ * \version 16.12.2003 [gs]: <ul><li>
+ *                           Beginn der Dokumentation mir Doxygen
+ *                           </li><li>
+ *                           Vertexlist zu einer zweiteiligen Liste gemacht,
+ *                           damit Sie f&uuml;r clipping geeignet ist.
+ *                           </li></ul>
+ * \version 19.12.2003 [gs]: Vergleichsoperator hinzugef&uuml;gt und
+ *                           clip_2d_mask rausgeshmissen.
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __vertex_h__
+#define __vertex_h__
+
+#include "../math/Mmn.h"
+#include "../math/V_K4.h"
+#include "../helper/container.h"
+
+#define X       0
+#define Y       1
+#define Z       2
+#define W       3
+#define O_X     4
+#define O_Y     5
+#define O_Z     6
+#define O_W     7
+
+//! W=0 hei&szlig;t der Vertex stellt einen Vektor dar.
+#define VEKTOR  0
+//! W=0 hei&szlig;t der Vertex stellt einen Coordinate dar.
+#define COORD   1
+
+class vertex {
+    private:
+        V_K4<double> original;
+        V_K4<double> transformed;
+        int trans_stage;
+//        char clip_mask_2d;
+
+    public:
+        vertex() : trans_stage(0) {}
+        vertex(double x, double y, double z, double w=VEKTOR) 
+            : original(x,y,z,w), transformed(x,y,z,w), 
+              trans_stage(0) {}
+        vertex(const vertex& v) : original(v.original),
+                                  transformed(v.transformed),
+                                  trans_stage(v.trans_stage) {}
+
+        const vertex& operator=(const vertex& v);
+        const double& operator[](unsigned xyzw) const { 
+            if(xyzw < X) { xyzw=X; }
+            if(xyzw > O_W) { xyzw=O_W; }
+
+            if(xyzw <= W)
+                return transformed.a(xyzw, 0); 
+            else
+                return original.a(xyzw-O_X, 0);
+        }
+        double& operator[](unsigned xyzw) {
+            if(xyzw < X) { xyzw=X; }
+            if(xyzw > O_W) { xyzw=O_W; }
+
+            if(xyzw <= W)
+                return transformed.a(xyzw, 0); 
+            else
+                return original.a(xyzw-O_X, 0);
+        }
+        vertex operator*(const double&) const;
+        friend vertex operator*(const double&, const vertex&);
+
+        double operator% (const vertex&) const;
+        vertex operator| (const vertex&) const;
+        vertex operator+ (const vertex&) const;
+        vertex operator- (const vertex&) const;
+        bool operator== (const vertex& v) const {
+           if(this->original == v.original &&
+              this->transformed == v.transformed &&
+              this->trans_stage == v.trans_stage)
+              return true;
+
+           return false;
+        }
+
+        vertex norm(void) const;
+        double betr(void) const;
+
+        void reset(void);
+        void set_trans_stage(int p=0) { trans_stage=p; }
+        unsigned get_trans_stage(void) const { return trans_stage; }
+        V_K4<double> const& get_o(void) const {return original;}
+        V_K4<double> const& get_t(void) const {return transformed;}
+
+        void transform(const Mmn<double>&, int=0);
+        void project_2d(double lcx, double sw, double sh, 
+                        double ph_ar, double sy, int p);
+
+        double unproject_X(double, double, double, double);
+        double unproject_Y(double, double, double, double, double, double);
+        double unproject_Z(double);
+        double unproject_U(double, double, double, double);
+        double unproject_V(double, double, double, double, double, double);
+
+        void print() {
+           original.print();
+           transformed.print();
+           cout << "---\n";
+        }
+};
+
+vertex operator*(const double& a, const vertex& v);
+
+class vertex_list : public container<vertex> {
+    protected:
+       vertex* variable;
+       unsigned var_count;
+
+    public:
+        vertex_list() 
+           : container<vertex>(), variable(NULL), var_count(0) {}
+        vertex_list(const vertex& v) 
+           : container<vertex>(v), variable(NULL), var_count(0) {}
+        vertex_list(const vertex* idxs, unsigned count) 
+           : container<vertex>(idxs, count), variable(NULL), var_count(0) {}
+        vertex_list(const vertex_list& v) 
+           : container<vertex>(v), var_count(v.var_count) {
+            if(var_count > 0)
+               variable=new vertex[var_count];
+            else
+               variable=NULL;
+                        
+            for(unsigned i=0; i<var_count; i++)
+               variable[i]=v.variable[i];
+        }
+        ~vertex_list() {
+            if(variable) {
+               delete [] variable;
+               variable=NULL;
+               var_count=0;
+            }
+        }
+
+        vertex& operator[](unsigned index) {
+           if(index+1 <= count)
+              return content[index];
+           else
+              index-=count-1;
+
+            if(index+1 > var_count) {
+                vertex* content_tmp=new vertex[index+1];
+
+                for(unsigned i=0; i<var_count; i++)
+                    content_tmp[i]=variable[i];
+
+                delete [] variable;
+                variable=content_tmp;
+                var_count=index+1;
+            }
+
+            return variable[index];
+        }
+
+        void resize(unsigned size) {
+            if(size < count) {
+               if(variable) {
+                  delete [] variable;
+                  variable=NULL;
+                  var_count=0;
+               }
+               return;
+            }
+            else
+               size-=count;
+
+            vertex* content_tmp;
+            if(size>0) {
+               content_tmp=new vertex[size];
+     
+               for(unsigned i=0; i<size<var_count?size:var_count; i++)
+                   content_tmp[i]=variable[i];
+            }
+            else
+               content_tmp=NULL;
+  
+            delete [] variable;
+            variable=content_tmp;
+            var_count=size;
+        }
+
+        unsigned fix_card(void) { return container<vertex>::card(); }
+        unsigned var_card(void) { return var_count; }
+        unsigned card(void) { return fix_card()+var_card(); }
+        void reset(void);
+};
+
+#endif // __vertex_h__

+/**
+ * \file gra_app.cpp
+ *
+ * \brief Testapplication zu engage
+ *
+ * Dieses kleine Prog testet die bestehenden Funktionen von engage und
+ * dient dazu neue Funktionen testweise einzubauen, bevor sie endgültig
+ * in die lib kommen.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 16.12.2003
+ *
+ * \version ..2002 [gs]: erste Implementation
+ * \version 13.12.2003 [gs]: movable eingefügt mit Funktionen f&uuml;r die
+ *                           wichtigsten Bewegungen (muss aber noch eine
+ *                           gro&szlig;es cleanup und fixing her) schient aber
+ *                           f&uuml;r die momentanen bed&uuml;rfnisse zu
+ *                           reichen.
+ * \version 16.12.2003 [gs]: <ul><li>
+ *                           Beginn der Dokumentation mit Doxygen
+ *                           </li><li>
+ *                           einige kleinere Fixes an movable
+ *                           </li></ul>
+ * \version 19.12.2003 [gs]: <ul><li>
+ *                           Eine Polygonliste eingebaut und diese sortiert,
+ *                           so das die am Weitesten vom Betrachter entfernten
+ *                           Polygone zuerst gezeichnet werden.
+ *                           Dazu musste auch eine Methode geschaffen werden
+ *                           mit der man feststellen konnte zu welchem Polyeder
+ *                           welches Polygon geh&ouml;rt. Dies habe ich mit
+ *                           der Methode contains in der Klasse container
+ *                           eingebaut.
+ *                           </li><li>
+ *                           Die Klasse movable in eine eigenen Datei verschoben
+ *                           geometry/movable.h. Au&szlig;erdem die Klassen
+ *                           polygon_movable nach geometry/polygon.h und 
+ *                           polyeder_movable nach geometry/polyeder.h
+ *                           verschoben.
+ *                           </li><li>
+ *                           Ein viertes Polygon hinzugefügt, das erst 
+ *                           verschoben und dann um die Weltachsen gedreht wird.
+ *                           Nur um zu demonstrieren was diese Reihenfolge
+ *                           der transformation f&uuml;r eine Wirkung hat.
+ *                           </li><li>
+ *                           kleinere &Auml;nderungen im Darstellungsteil.
+ *                           </li><li>
+ *                           &uuml;ber die in canvas neu geschaffene Methode
+ *                           draw_text die Zeit ss:ms die f&uuml;r einen
+ *                           kompletten Transformations/Zeichenvorgang 
+ *                           ben&ouml;tigt wird angezeigt.
+ *                           </li></ul>
+ * \version 21.12.2003 [gs]: <ul><li>
+ *                           Herausgefunden warum die Würfel so gross sind
+ *                           obwohl sie nur eine Kantenl&auml;nge von 10 haben.
+ *                           Es ligt daran das sie mathematisch vor dem 
+ *                           screen liegen, dadurch werden sie bei der
+ *                           projection gr&ouml;&szlig;er skaliert.
+ *                           </li><li>
+ *                           Die Klasse Camera eingef&uuml;gt und das 
+ *                           Hauptprogramm so umgeschrieben das es eine
+ *                           Camera-Instanz nutzt um
+ *                           <ol><li>
+ *                           eine Kameratransformation zu machen
+ *                           </li><li>
+ *                           die 2D-Projektion durchzuf&uuml;hren.
+ *                           </li></ol>
+ *                           </li><li>
+ *                           so modifiziert das erst nur die Vertices von
+ *                           movable und die Normalenvektoren der Polygone
+ *                           berechnet werden, nur wenn das Polygon auch
+ *                           wirklich gezeichnet wird werden die weiteren
+ *                           Vertices transformiert und projeziert.
+ *                           </li><li>
+ *                           So umgebaut das das vordere z-clipping der
+ *                           Polygone genutzt wird.
+ *                           </li></ul>
+ * \version 22.12.2003 [gs]: Beleuchtung &uuml;ber die in canvas_imp neu
+ *                           eingebauten light_table eingebaut.
+ */
+
+/**
+ * \mainpage Referenzmanual zu ENGAGE
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ * \date 22.12.2003
+ * \version 0.0.0: Erster Aufbau, jede Menge immer noch zu tun.
+ *
+ * Dies Projekt war zu anfang eine kleine app um ein wenig x-lib zu
+ * Programmieren. Als das ein wenig langweilig wurde und zumindest
+ * rudiment&auml;r funktionierte habe ich angefangen eine kleine 3D-Engine
+ * dazuzuschreiben.<br>
+ * Heute habe ich das Ziel dies ganze in irgendeinem Spiel zu verwenden.
+ * Bis dahin ist allerdings noch jede Menge zu tun.
+ * Was bislang fertig ist:
+ * <ul>
+ * <li>Klassen um die X-Lib auf einfacher Ebene anzusprechen, allerdings
+ * noch komplett ohne kommunikation mit dem Windowmanager.
+ * </li><li>
+ * Klasse um Manipulationen und Berechnungen verschiedenster Art an
+ * Matrizen und Vektoren mit 4 Tupeln zu machen, wie gauss, verschiedene
+ * Wege die Determinante zu berechnen, Inverse &uuml;ber Adjunkte oder
+ * &uuml;ber Gauss, Transponieren, Skalarprodukt, Matritzenprodunkt, Addition
+ * Subtraktion, etc.
+ * </li><li>
+ * Das Muster eines Event-Dispatchers sowie ein template von dem dich
+ * Klassen ableiten m&uuml;ssen, die Events f&uuml;r diesen erzeugen.
+ * </li><li>
+ * einen abstrakten canvas der events erzeugt, M&ouml;glihkeiten zur 
+ * Farbverwaltung bietet und einen passenden rasterer erzeugt. Davon
+ * abgeleitet ein canvas f&uuml;r X11 und wiederum davon abgeleitete ein
+ * canvas f&uuml;r X11-SHM.
+ * rasterizer ist wiederum eine abstrakte Klasse die eine Schnittstelle bietet
+ * um auf einen canvas zu schreiben. davon abgeleitet existiert eine Klasse
+ * rasterizer_rgb, der speziell auf ein RGB Canvas schreibt, wie das z.B.
+ * in einem Truecolor Grafikmodus unter X11 n&ouml;tig ist.
+ * </li><li>
+ * Eine Helferklasse container, die verschiedene Daten speichen und
+ * organisieren kann. Diese sollte in zukunft abstrakt werden und
+ * Implementierungen versiedener Datenstrukturierungsmethoden verdecken,
+ * wie z.B. diverse Listenformen, B&auml;me oder einfache Arrays.
+ * Im Moment organisiert sie die Daten in einem Array. Einige wichtige Klassen
+ * (eigentlich alle die mehrere Elemente nicht bekannter Anzahl verwalten 
+ * m&uuml;ssen) leiten sich von dieser Klasse ab. Das ist insbesondere
+ * vertex_list, polygon und polyeder.
+ * </li><li>
+ * Die grundlegenden Geometrieklassen (unterliegen nach wie vor starken
+ * Ver&auml;nderungen. Das sind im einzelnen:
+ * <ol><li>
+ * <b>vertex:</b> Diese Struktur nimmt einen 4-Tupel Vektor auf, der
+ * entweder eine 3D-Coordinate oder aber einen Vektor im 3D-Raum beschreibt.
+ * es werden sowohl die Originaldaten sowie transformierte Daten gespeichert.
+ * Au&szlig;erdem wird der transformationsstatus zwischengespeicher. (Das
+ * verhindert das, wenn sich z.B. ein Polygon einen Vertex mit einem anderen
+ * teilt, transformationen nur einmal an dem Vertex vorgenommen werden.
+ * </li><li>
+ * <b>vertex_list:</b> Eine Struktur um mehrere Vertexe zu verwalten.
+ * Sie besteht aus einem fixen und einem Variablen Teil, daher modifiziert
+ * sie einige Operatoren, die sie von container erbt. Die zweigeteiltheit
+ * ist wichtig, da bei einigen Operationen (insb. Clipping) zus&auml;tzliche
+ * Vertexe entstehen k&ouml;nnen, die aber nur tempor&auml;r wichtig sind.
+ * Durch die Zweigeteiltheit l&auml;&szlig;t sich immer genau unterscheiden
+ * was erzeugte und was originale Vertexe waren. Weiterhin ist wichtig,
+ * das auf beide Teile mit derselben Zugriffsfunktion zugegriffen werden kann.
+ * </li><li>
+ * <b>polygon:</b> ist eine Liste von Indexen in eine Vertexliste, die
+ * ein Polygon beschreibt. Leitet sich von container ab und verwaltet ihren
+ * container teil die indexe. Weiterhin enth&auml;lt polygon einen pointer auf
+ * eine vertex_list, auf die sich die Indexwerte bezieht und die Informationen
+ * zu einem Normalenvektor (als Basispunkt und Spitze Paar).
+ * Seit neustem enth&auml;lt ein Polygon auch noch einen pointer auf den
+ * polyeder zu dem es geh&ouml;rt (wenn es zu einem geh&ouml;rt, ansonsten null)
+ * und es sollte auch noch den index in diesem Polyeder enth&auml;ten.
+ * Damit w&auml;re es dann einfach von einem polygon wieder auf seinen
+ * Polyeder zu schlie&szlig;en (es kann aber auch sein das ich dieses Konzept
+ * wieder verwerfe und versuche irgendwie &uuml;ber den container eine 
+ * M&ouml;glichkeit der zuordnung zu schaffen.<br>
+ * Da dies eine polygonale Engine ist enth&auml;lt polygon einige wichtige
+ * Methoden, wie das clipping zur vorderen z-ebene und das clipping ein einem
+ * weiteren polygon (nach der 2D-Projektion, um das Polygon gegen die
+ * Canvas (Rasterer)-Grenzen zu clippen.
+ * </li><li>
+ * <b>polyeder:</b> ist eine von container abgeleitete Klasse die eine
+ * Gruppe zusammengeh&ouml;riger polygone verwaltet. Zusammengeh&ouml;rend
+ * bedeutet in diesem Fall vor allem, das sie die gleiche Vertexliste nutzen.
+ * </li></ol></li></ul>
+ *
+ * Was die Engine bislang (mehr oder weniger sauber implementiert) macht:
+ * <ul><li>
+ * beliebige transformtion beliebiger polygone im 3D-Raum.
+ * </li><li>
+ * Perspektivische Projektion
+ * </li><li>
+ * clipping der projezierten Vertexe gegen die canvas-Grenzen
+ * </li><li>
+ * clipping der 3D-Coordinaten gegen eine vordere Z-Ebene
+ * </li><li>
+ * falls gew&uuml;nscht Backface-Culling
+ * </li><li>
+ * definieren einer Kamera und positionieren dieser.
+ * </li><li>
+ * Darstellung flatshaded, wireframe oder kombiniert.
+ * </li><li>
+ * Sortiert die polygone nach z, damit die hintersten zuerst gezeichnet werden.
+ * </li></ul>
+ *
+ * \bug [gs] Mein Backfaceculling funktioniert nicht, das scheint daran zu 
+ *      liegen, das eine projezierte Seite die 90 Grad zu mir aber stark am 
+ *      Rand des sichtbaren Bereichs ist sehr wohl von mir gesehen werden kann.
+ *      In die berechnung des cullings muss also irgendwie das Scihtfeld 
+ *      bzw der Blickwinkel mit einbezogen werden.
+ *      -- Gefixed: man muss als Blickwinkel nur den vrp nehmen, dann klappts.
+ * \bug [gs] Das Programm darf nicht mehr mit -ffast-math compiliert werden,
+ *      da dann anscheinend irgendwas bei der berechnung der inversen
+ *      Camera-Matrix kaputtoptimiert wird.
+ *
+ * \todo [gs] Evtl. sollte ich f&uuml;r den Rasterizer imlib2 oder evas
+ *       verwenden (bzw ich baue einen rasterizer der diese Libs nutzt). 
+ *       Evtl. kann evas auch einen kompletten canvas für mich bilden, incl.
+ *       Rasterizer. (Auch ein GL Rasterizer sollte noch geschrieben werden.
+ * \todo [gs] Eine menge cleanups.
+ * \todo [gs] Java Version schreiben und hoffen das sie schnell genug ist.
+ * \todo [gs] Nat&uuml;rlich noch jede Menge, Lightmapping, Texturemapping,
+ *       Schadowmapping, vorne und hinten z-clipping usw.
+ * \todo [gs] gutes Konzept finden um z-clipping, transformieren und
+ *       projezieren zu machen (es darf z.B. nich projeziert werden, solange
+ *       das z-clipping l&auml;uft.
+ * \todo [gs] ein gutes konzept finden ein polygon einem polyeder zuzuweisen,
+ *       und den index innerhalb des Polyeders zu bestimmen, auch wenn
+ *       das polygon bereits transformiert wurde...in diesem zusammenhang
+ *       glaube ich immer mehr, das es doch besser währe, das polygon
+ *       wuerde beim clipping doch nicht einfach ein neues Polygon erzeugen
+ *       und stattdessen sich selbst modifizieren und eine referenz auf
+ *       sich zur&uuml;ckgeben. (Bei den == Operatoren würde ich dann immer
+ *       checken ob es sich wirklich um eine Referenz auf die selbe Instanz
+ *       (sprich Adressen gleich) ist.
+ *
+ * Copyright &copy;2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * <br><br><br>
+ */
+
+#ifndef __XProto_h__
+#define __XProto_h__
+
+using namespace std;
+
+#include <cmath>
+#include <time.h>
+#include <unistd.h>
+
+#include "factory.h"
+#include "dispatcher.h"
+#include "canvas.h"
+#include "rasterize.h"
+#include "math/Mmn.h"
+#include "math/V_K4.h"
+#include "math/sin_cos.h"
+#include "geometry/vertex.h"
+#include "geometry/polygon.h"
+#include "geometry/polyeder.h"
+
+#include <time.h>
+#include <sys/timeb.h>
+
+int compf(const void* a, const void* b) {
+   polygon* _a=(polygon*)a;
+   polygon* _b=(polygon*)b;
+
+   return (int)(_a->center_p()[Z] - _b->center_p()[Z])*-1;
+}
+
+class light {
+   protected:
+      unsigned intensity;
+      double dist_falloff;
+
+   public:
+      light(unsigned intense=255) : intensity(intense) {}
+
+      virtual unsigned get_intensity(void) { return intensity; }
+      virtual void set_intensity(unsigned in) { intensity=in; }
+};
+
+class ambient_light : public light {
+   public:
+      ambient_light(unsigned intense=255) : light(intense) {}
+};
+
+// Diese Lampe ist &auml;hnlich wie die Sonne, sie beleuchtet die
+// gesamte Scenen aus einer Richtung. Diese definiere ich einfach
+// als fvw des movable.
+class direct_light : public light, public movable {
+   public:
+      direct_light(unsigned intense=255) : light(intense), movable() {}
+
+      const vertex& get_direction(void) {
+         return vfw;
+      }
+};
+
+class camera : public movable {
+   private:
+        double lcxa; //!< (lens coverage(x) angle = Sichtfeld(x)-Winkle
+        double lcx;    //!< (lens coverage(x)) = Sichtfeld(x)
+        double sw;     //!< (screen width) = Breite des Projektionsfensters
+        double sh;     //!< (screen height) = Hoehe des Projektionsfensters
+        double ph_ar;  /**< \brief (physical aspect ratio) = Seitenverhaeltnis 
+                        *          des Anzeigegeraets 
+                        */
+        double sy;     //!< (scale y) = Wert um y proportional zu projezieren.
+        double dz;     //!< (delta z) = Abstand des Auges zum screen
+
+        Mmn<double> cam_trans;
+
+   public:
+        camera(double lcxa=60) : movable() {
+            this->set_lens_coverage(lcxa);
+        }
+
+        camera(const rasterizer& scr, double lcxa=60) : movable() {
+            this->set_lens_coverage(lcxa);
+            this->sw=scr.get_x_size();
+            this->sh=scr.get_y_size();
+            this->ph_ar=this->sw/this->sh;
+            this->sy=this->sh/this->sw*this->ph_ar;
+            this->dz=(this->sh/2)/tan(RAD(this->lcxa/2));
+        }
+
+        camera(const rasterizer& scr, double ph_ar, 
+               double lcxa) : movable() {
+            this->set_lens_coverage(lcxa);
+            this->sw=scr.get_x_size();
+            this->sh=scr.get_y_size();
+            this->ph_ar=ph_ar;
+            this->sy=this->sh/this->sw*this->ph_ar;
+            this->dz=(this->sh/2)/tan(RAD(this->lcxa/2));
+        }
+
+        camera(double sw, double sh, double lcxa=60) : movable() {
+            this->set_lens_coverage(lcxa);
+            this->sw=sw;
+            this->sh=sh;
+            this->ph_ar=this->sw/this->sh;
+            this->sy=this->sh/this->sw*this->ph_ar;
+            this->dz=(this->sh/2)/tan(RAD(this->lcxa/2));
+        }
+
+        camera(double sw, double sh, 
+               double ph_ar, double lcxa=60) : movable() {
+            this->set_lens_coverage(lcxa);
+            this->sw=sw;
+            this->sh=sh;
+            this->ph_ar=ph_ar;
+            this->sy=this->sh/this->sw*this->ph_ar;
+            this->dz=(this->sh/2)/tan(RAD(this->lcxa/2));
+        }
+
+        /** 
+         * \brief Setze Sichtfeld. (zwischen 10 und 170)
+         *
+         * lcx ist eine Konstante die die gr&ouml;&szlig;e der Sichtfeldes
+         * beschreibt. Diese Funktion ermittelt diese Konstante anhand von
+         * Werten zwischen 10 und 170 wobei das volle menschliche Sichtfeld
+         * einem Wert von 100 entspricht. 10 ist extrem Tele und 170 extrem
+         * Weitwinkel.
+         *
+         * \param angle Winkel f&uuml;rs Sichtfeld (zwischen 10 und 170)
+         *
+         * \pre 10 < angel < 170
+         */
+        void set_lens_coverage(double angle) {
+            lcxa=angle;
+
+            if(lcxa>170) lcxa=170;
+            if(lcxa<10) lcxa=10;
+
+            lcx=0.5*(1/tan(lcxa*M_PI/(180.0*2.0)));
+        }
+
+        const Mmn<double>& cam_trans_mat(void) {
+           cam_trans=t_mat.inv_Ad();
+
+           if(cam_trans.is_null())
+              cam_trans=t_mat.gauss(INVERSE);
+
+           return cam_trans;
+        }
+
+        double get_lcx(void) const {
+           return lcx;
+        }
+
+        double get_sw(void) const {
+           return sw;
+        }
+
+        double get_sh(void) const {
+           return sh;
+        }
+
+        double get_ph_ar(void) const {
+           return ph_ar;
+        }
+
+        double get_sy(void) const {
+           return sy;
+        }
+
+        double get_dz(void) const {
+           return dz;
+        }
+};
+
+/**
+ * \brief Das eigentliche Programm
+ *
+ * Hier werden alle Teile zu einem kleinen Testprogramm zusammengef&uuml;gt.
+ */
+class app {
+    private:
+        canvas* scr;          //!< Der Canvas auf dem gezeichnet wird
+        rasterizer* ras;      //!< Der Rasterizer zu dem \ref scr
+        dispatcher* d;        //!< Der X11-Dispatcher
+        disp_manager manager; //!< Der Dispatcher-Manager
+
+        polyeder_movable p;           //!< erster Polyeder
+        polyeder_movable p2;          //!< zweiter Polyeder
+        polyeder_movable p3;          //!< dritter Polyeder
+        polyeder_movable p4;          //!< und weils so lustig ist noch einer
+
+        camera cam;
+        direct_light li;
+        direct_light li2;
+        ambient_light li3;
+
+        double winkel;
+        int stepping;
+        double cam_winkel;
+        int cam_stepping;
+        double li_winkel;
+        int li_stepping;
+        double li2_winkel;
+        int li2_stepping;
+
+        double clip_front;
+
+        unsigned secs, secs_tmp;
+        unsigned short ms;
+
+        /**
+         * \brief Bringt den Canvas auf den Bildschirm
+         *
+         * Dies ist eine Callback-Methode die zu jedem expose-event u.&auml;.
+         * aufgerufen wird um den Inhalt des Canvas auf das Fenster zu
+         * &uuml;bertragen. Diese Methode wird ausschlie&szlig;lich vom
+         * Dispatcher \ref d aufgerufen.
+         *
+         * \param es Die Quelle des Events, in diesem Fall also der canvas
+         * \param key Wird nicht benutzt
+         *
+         * \pre redraw mu&szlig; als callback in \ref d registriert sein.
+         * \pre \ref scr mu&szlig; ein g&uuml;ltiger canvas sein.
+         */
+        void redraw(event_source* es, void* key) {
+            char buffer[10]="\0";
+
+            sprintf(buffer, "%02d:%03d", secs, ms);
+
+            scr->blit_screen();
+            scr->draw_text(5,15,buffer,strlen(buffer));
+            //usleep(10);
+        }
+
+        /**
+         * \brief verarbeitet Tastendr&uuml;cke im Canvas
+         *
+         * Dies ist eine Callback-Methode die zu jedem keypress-event
+         * im Canvas aufgerufen wird. Hier&uuml;ber ist es m&ouml;glich
+         * das Programm zu steuern. Diese Methode wird ausschlie&szlig;lich
+         * vom Dispatcher \ref d aufgerufen.
+         *
+         * \param es Die Quelle des Events, in diesem Fall also der Canvas
+         * \param key Der Ascii-Code der gedr&uuml;ckten Taste.
+         *
+         * \pre exitOnEsc mu&szlig; als callback in \ref d registriert sein.
+         * \pre \ref scr mu&szlig; ein g&uuml;ltiger canvas sein.
+         *
+         * \post Falls ESC gedr&uuml;ckt wurde -> Programmende
+         * \post Falls s oder S gedr&uuml;ckt wurde Dispatcher anhalten
+         * \post Falls c oder C gedr%uuml;ckt wurde Dispatcher starten
+         */
+        void exitOnEsc(event_source* es, void* key) {
+            switch (*(char*)key) {
+                case 27:
+                    d->trigger_event(Stop);
+                case 'x':
+                case 'X':
+                    d->halt();
+                    break;
+                case 'c':
+                case 'C':
+                    d->cont();
+                    break;
+                case '+':
+                    cam_stepping=(cam_stepping+1)%11;
+                    break;
+                case '-':
+                    cam_stepping=cam_stepping>0?(cam_stepping-1)%11:10;
+                    break;
+                case 'q':
+                case 'Q':
+                    clip_front=clip_front>0?clip_front-10:0;
+                    break;
+                case 'w':
+                case 'W':
+                    clip_front=clip_front<100?clip_front+10:100;
+                    break;
+                case 'r':
+                case 'R':
+                    li_stepping=(li_stepping+1)%11;
+                    break;
+                case 'e':
+                case 'E':
+                    li_stepping=li_stepping>0?(li_stepping-1)%11:10;
+                    break;
+                case 'z':
+                case 'Z':
+                    li2_stepping=(li2_stepping+1)%11;
+                    break;
+                case 't':
+                case 'T':
+                    li2_stepping=li2_stepping>0?(li2_stepping-1)%11:10;
+                    break;
+                case 'd':
+                case 'D':
+                    stepping=(stepping+1)%11;
+                    break;
+                case 's':
+                case 'S':
+                    stepping=0;
+                    break;
+                case 'a':
+                case 'A':
+                    stepping=stepping>0?(stepping-1)%11:10;
+                default:
+                    break;
+            }
+        }
+
+        /**
+         * \brief Rotiert, projeziert und zeichnet die drei Polyeder 
+         *        \ref p, \ref p2 und \ref p3
+         *
+         * Hier werden mit Hilfe der Klassen aus \ref Mmn.h, \ref sin_cos.h und 
+         * \ref V_K4.h die Polyeder gedreht, skaliert, projeziert und 
+         * schlie&szlig;lich mit Hilfe der Methoden des Rasterizers \ref ras
+         * auch noch gezeichnet. Am ende wird dann ein Expose-Event 
+         * ausgel&ouml;st, damit die &Auml;nderungen auch am Bildschirm
+         * sichtbar werden.
+         *
+         * \note Im Moment wir rotate auch über disp_x11 aufgerufen, das ist 
+         * nicht notwendig, und eigentlich sogar falsch, denn es wird überhaupt
+         * nicht auf ein X-Event reagiert. Was ich brauche ist ein weiteren 
+         * Dispatcher (disp_app) der Application-Events aufführt,
+         * Die Rotation müsste dann quasi im idle-Fall ausgeführt werden.
+         * Es würde sicherlich Sinn machen diesen dispatcher dann irgendwie
+         * als thread zu implementieren. Immerhin ist X ja auch ein eigener
+         * Prozess. (OK, der Vergleich hinkt, da ich die XEvents auch im
+         * Hauptprozess abarbeite.
+         *
+         * \param es Die Quelle des Events, in diesem Fall also der canvas
+         * \param dummy Wird nicht benutzt
+         *
+         * \pre redraw mu&szlig; als callback in \ref d registriert sein.
+         * \pre \ref scr mu&szlig; ein g&uuml;ltiger canvas sein.
+         *
+         * \post Die Polyeder sind transformiert und auf dem Canvas
+         *       gezeichnet. Ein Expose-Event wurde ausgel&ouml;st.
+         */
+        void rotate(event_source* es, void* dummy) {
+            struct timeb tb1;
+            struct timeb tb2;
+
+            ftime(&tb1);
+            
+            winkel=WINKEL(winkel+stepping);
+
+            cam_winkel=WINKEL(cam_winkel+cam_stepping);
+            li_winkel=WINKEL(li_winkel-li_stepping);
+            li2_winkel=WINKEL(li2_winkel+li2_stepping);
+
+            container<polygon> po_list, po_list_zclipped;
+
+            //if(winkel==3)
+            //   sleep(10);
+
+            p.rotate_im_g_x(45);
+            p.translate_im_global(-30.0*sin(RAD(winkel)), 
+                                  5.0*cos(RAD(winkel)),
+                                  10.0*cos(RAD(winkel)));
+            p.rotate_im_vfw(WINKEL(2*winkel));
+
+            p2.translate_im_global(5.0*cos(RAD(winkel)), 
+                                   20.0*sin(RAD(winkel)),
+                                   20.0*cos(RAD(winkel)));
+            p2.rotate_im_l_z(WINKEL(winkel));
+            p2.rotate_im_l_y(WINKEL(360-winkel));
+            p2.translate_im_global(0,0,-5);
+
+            //p3.translate_im_global(0,0,5);
+            
+            p4.translate_im_global(0,0,15);
+            p4.rotate_im_g_x(WINKEL(winkel));
+            p4.rotate_im_g_y(WINKEL(winkel));
+            p4.translate_im_global(0,0,5);
+
+            cam.translate_im_global(0,0,-60);
+            cam.rotate_im_g_y(WINKEL(-cam_winkel));
+            cam.rotate_im_axis(WINKEL(cam_winkel), 
+                               vertex(1,0,1,COORD), vertex(0,0,0,COORD));
+
+            li.translate_im_global(0,0,-10);
+            li.rotate_im_g_y(WINKEL(45.0));
+            li.rotate_im_axis(WINKEL(li_winkel), 
+                              vertex(1,0,-1,COORD), vertex(0,0,0,COORD));
+
+            li2.translate_im_global(0,0,-10);
+            li2.rotate_im_g_x(WINKEL(li2_winkel));
+
+            Mmn<double> ctm(cam.cam_trans_mat());
+
+            p.move_im(ctm);
+            p2.move_im(ctm);
+            p3.move_im(ctm);
+            p4.move_im(ctm);
+            li.move_im(ctm);
+            li2.move_im(ctm);
+
+            /* p.transform(1);
+            p2.transform(1);
+            p3.transform(1);
+            p4.transform(1);
+
+            cam.transform(1); */
+
+            // Zu Anfang reicht es die Vertexe für die Objektposition und
+            // die Normalenvertexe zu transformieren, dann kommt das
+            // backface culling und nur wenn ein polygon wirklich gezeichnet
+            // wird mache ich die letzten transformationen und die
+            // projektion.
+            p.transform_normals(1);
+            p2.transform_normals(1);
+            p3.transform_normals(1);
+            p4.transform_normals(1);
+
+            p.movable::transform(1);
+            p2.movable::transform(1);
+            p3.movable::transform(1);
+            p4.movable::transform(1);
+
+            li.transform(1);
+            li2.transform(1);
+
+            /* p.project_2d(cam.get_lcx(), cam.get_sw(), cam.get_sh(), 
+                         cam.get_ph_ar(), cam.get_sy(), 2);
+            p2.project_2d(cam.get_lcx(), cam.get_sw(), cam.get_sh(), 
+                          cam.get_ph_ar(), cam.get_sy(), 2);
+            p3.project_2d(cam.get_lcx(), cam.get_sw(), cam.get_sh(), 
+                          cam.get_ph_ar(), cam.get_sy(), 2);
+            p4.project_2d(cam.get_lcx(), cam.get_sw(), cam.get_sh(), 
+                          cam.get_ph_ar(), cam.get_sy(), 2); */
+
+            // Ich muss nach einem verdammt guten Weg suchen herauszufinden
+            // zu welchem polyeder ein polygon gehoert, ich denke das beste ist
+            // einen pointer auf den polyeder im polygon zu speichern wenn
+            // es einem polyeder zugeordnet wird.
+            vertex view, normal, center, norm_v;
+
+            for(unsigned i=0; i<p.card(); i++) {
+               view=p.get_vrp();
+
+               center=p[i].center_p();
+               normal=p[i].normal_p();
+               norm_v=normal-center;
+
+               if(((norm_v%view)/(norm_v.betr()*view.betr())) < 0.0) {
+                  po_list[po_list.card()]=p[i];
+                  po_list[po_list.card()-1].transform(p.get_t_mat(), 1);
+               }
+            }
+
+            for(unsigned i=0; i<p2.card(); i++) {
+               view=p2.get_vrp();
+
+               center=p2[i].center_p();
+               normal=p2[i].normal_p();
+               norm_v=normal-center;
+
+               if(((norm_v%view)/(norm_v.betr()*view.betr())) < 0.0) {
+                  po_list[po_list.card()]=p2[i];
+                  po_list[po_list.card()-1].transform(p2.get_t_mat(), 1);
+               }
+            }
+
+            for(unsigned i=0; i<p3.card(); i++) {
+               //hier kein backface-culling...
+
+               //view=p3.get_vrp();
+
+               //center=p3[i].center_p();
+               //normal=p3[i].normal_p();
+               //norm_v=normal-center;
+
+               //if(((norm_v%view)/(norm_v.betr()*view.betr())) < 0.0) {
+                  po_list[po_list.card()]=p3[i];
+                  po_list[po_list.card()-1].transform(p3.get_t_mat(), 1);
+               //}
+            }
+
+            for(unsigned i=0; i<p4.card(); i++) {
+               view=p4.get_vrp();
+
+               center=p4[i].center_p();
+               normal=p4[i].normal_p();
+               norm_v=normal-center;
+
+               if(((norm_v%view)/(norm_v.betr()*view.betr())) < 0.0) {
+                  po_list[po_list.card()]=p4[i];
+                  po_list[po_list.card()-1].transform(p4.get_t_mat(), 1);
+               }
+            }
+
+            po_list.sort(compf);
+
+            for(unsigned i=0; i<po_list.card(); i++) {
+               po_list_zclipped[i]=po_list[i].clip_front_z(clip_front);
+            }
+
+            ras->clear_buffer();
+
+            double normal_X[6];
+            double normal_Y[6];
+
+            for(unsigned i=0; i<po_list.card(); i++) {
+               int idx;
+
+               if((idx=p3.contains(po_list[i])) >= 0) {
+                  unsigned long col;
+
+                  vertex center=po_list[i].center_p();
+                  vertex normal=po_list[i].normal_p();
+                  vertex norm_v=normal-center;
+
+
+                  if(idx==1)
+                     col=scr->get_color(0,0,255);
+                  else
+                     col=scr->get_color(0,255,255);
+
+                  vertex light(li.get_direction());
+
+                  unsigned in=0, in_tmp;
+                  double intense=(norm_v.norm()%light.norm())*-1;
+                  intense=intense<0.02?0.02:intense;
+                  intense=intense>1.0?1.0:intense;
+
+                  in_tmp=(unsigned)(intense*li.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+
+                  light=li2.get_direction();
+
+                  intense=(norm_v.norm()%light.norm())*-1;
+                  intense=intense<0.02?0.02:intense;
+                  intense=intense>1.0?1.0:intense;
+
+                  in_tmp=(unsigned)(intense*li2.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+                  in_tmp=(unsigned)(li3.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+
+                  scr->light_native(&col, in);
+
+                  if(po_list_zclipped[i].card() >= 3) {
+                     po_list_zclipped[i].project_2d(cam.get_lcx(), cam.get_sw(),
+                                                 cam.get_sh(), cam.get_ph_ar(), 
+                                                 cam.get_sy(), 2);
+                     ras->draw_polygon_flat(po_list_zclipped[i], col);
+                  }
+               }
+
+               if((idx=p4.contains(po_list[i])) >= 0) {
+                  unsigned long col=scr->get_color(0,0,255);
+
+                  vertex center=po_list[i].center_p();
+                  vertex normal=po_list[i].normal_p();
+                  vertex norm_v=normal-center;
+
+                  vertex light(li.get_direction());
+
+                  unsigned in=0, in_tmp;
+                  double intense=(norm_v.norm()%light.norm())*-1;
+                  intense=intense<0.02?0.02:intense;
+                  intense=intense>1.0?1.0:intense;
+
+                  in_tmp=(unsigned)(intense*li.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+
+                  light=li2.get_direction();
+
+                  intense=(norm_v.norm()%light.norm())*-1;
+                  intense=intense<0.02?0.02:intense;
+                  intense=intense>1.0?1.0:intense;
+
+                  in_tmp=(unsigned)(intense*li2.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+                  in_tmp=(unsigned)(li3.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+
+                  scr->light_native(&col, in);
+
+                  if(po_list_zclipped[i].card() >= 3) {
+                     po_list_zclipped[i].project_2d(cam.get_lcx(), cam.get_sw(),
+                                               cam.get_sh(), cam.get_ph_ar(), 
+                                               cam.get_sy(), 2);
+                     ras->draw_polygon_flat(po_list_zclipped[i], col);
+                     //ras->draw_polygon_wire(po_list_zclipped[i], 
+                     //                    scr->get_color(255, 255, 255));
+                  }
+               }
+
+               if((idx=p.contains(po_list[i])) >= 0) {
+                  unsigned long col=scr->get_color(255,0,0);
+
+                  vertex center=po_list[i].center_p();
+                  vertex normal=po_list[i].normal_p();
+                  vertex norm_v=normal-center;
+
+                  vertex light(li.get_direction());
+
+                  unsigned in=0, in_tmp;
+                  double intense=(norm_v.norm()%light.norm())*-1;
+                  intense=intense<0.02?0.02:intense;
+                  intense=intense>1.0?1.0:intense;
+
+                  in_tmp=(unsigned)(intense*li.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+
+                  light=li2.get_direction();
+
+                  intense=(norm_v.norm()%light.norm())*-1;
+                  intense=intense<0.02?0.02:intense;
+                  intense=intense>1.0?1.0:intense;
+
+                  in_tmp=(unsigned)(intense*li2.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+                  in_tmp=(unsigned)(li3.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+
+                  scr->light_native(&col, in);
+
+                  center.project_2d(cam.get_lcx(), cam.get_sw(), 
+                                    cam.get_sh(), cam.get_ph_ar(), 
+                                    cam.get_sy(), 
+                                    center.get_trans_stage()+1);
+                  normal.project_2d(cam.get_lcx(), cam.get_sw(), 
+                                    cam.get_sh(), cam.get_ph_ar(), 
+                                    cam.get_sy(), 
+                                    center.get_trans_stage()+1);
+
+                  if(po_list_zclipped.card() >= 3) {
+                     po_list_zclipped[i].project_2d(cam.get_lcx(), cam.get_sw(),
+                                               cam.get_sh(), cam.get_ph_ar(), 
+                                               cam.get_sy(), 2);
+                     ras->draw_polygon_flat(po_list_zclipped[i], col);
+                     //ras->draw_polygon_wire(po_list_zclipped[i], 
+                     //                    scr->get_color(255, 255, 255));
+                     ras->line(center[X], center[Y], normal[X], normal[Y],
+                               scr->get_color(0, 0, 0));
+                  }
+               }
+
+               if((idx=p2.contains(po_list[i])) >= 0) {
+                  unsigned long col=scr->get_color(0,255,0);
+
+                  vertex center=po_list[i].center_p();
+                  vertex normal=po_list[i].normal_p();
+                  vertex norm_v=normal-center;
+
+                  vertex light(li.get_direction());
+
+                  unsigned in=0, in_tmp;
+                  double intense=(norm_v.norm()%light.norm())*-1;
+                  intense=intense<0.02?0.02:intense;
+                  intense=intense>1.0?1.0:intense;
+
+                  in_tmp=(unsigned)(intense*li.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+
+                  light=li2.get_direction();
+
+                  intense=(norm_v.norm()%light.norm())*-1;
+                  intense=intense<0.02?0.02:intense;
+                  intense=intense>1.0?1.0:intense;
+
+                  in_tmp=(unsigned)(intense*li2.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+                  in_tmp=(unsigned)(li3.get_intensity());
+                  in=in_tmp>in?in_tmp:in;
+
+                  scr->light_native(&col, in);
+
+                  center.project_2d(cam.get_lcx(), cam.get_sw(), cam.get_sh(), 
+                                    cam.get_ph_ar(), cam.get_sy(), 
+                                    center.get_trans_stage()+1);
+                  normal.project_2d(cam.get_lcx(), cam.get_sw(), cam.get_sh(), 
+                                    cam.get_ph_ar(), cam.get_sy(), 
+                                    center.get_trans_stage()+1);
+
+                  if(po_list_zclipped[i].card() >= 3) {
+                     po_list_zclipped[i].project_2d(cam.get_lcx(), cam.get_sw(),
+                                            cam.get_sh(), cam.get_ph_ar(), 
+                                            cam.get_sy(), 2);
+                     ras->draw_polygon_flat(po_list_zclipped[i], col);
+                     //ras->draw_polygon_wire(po_list_zclipped[i], 
+                     //                     scr->get_color(255, 255, 255));
+                     ras->line(center[X], center[Y], normal[X], normal[Y],
+                               scr->get_color(0, 0, 0));
+                  }
+               }
+            }
+
+            //ras->draw_polyeder_wire(p, scr->get_color(255,255,255));
+            //ras->draw_polyeder_wire(p2, scr->get_color(255,255,255));
+
+            p.reset();
+            p2.reset();
+            p3.reset();
+            p4.reset();
+            cam.reset();
+            li.reset();
+            li2.reset();
+
+            ftime(&tb2);
+
+            secs_tmp=tb2.time-tb1.time;
+            ms=(secs_tmp*1000+tb2.millitm)-tb1.millitm;
+            secs=(secs_tmp>0)?ms/(secs_tmp*1000):0;
+            ms=(secs_tmp>0)?ms%(secs_tmp*1000):ms;
+
+            d->trigger_event(Draw);
+        }
+
+    public:
+        /**
+         * \brief Konstruktor
+         *
+         * Alle Grundlegenden Initialisierungen. Canvas, Dispatcher und
+         * Rasterizer erzeugen. Callbacks registrieren und
+         * Polyeder erzeugen. Eckwerte f&uuml;r die 2D-Projektion festlegen.
+         */
+        app() {
+            // Der factory_manager erzeugt mir den gew&uuml;nschten 
+            // Canvas und Dispatcher.
+            factory_manager f;
+
+            // Erzeuge den Canvas, Dispatcher und Rasterizer
+            scr=f.canvas_f->create(400, 300);
+            d=f.dispatcher_f->create(scr);
+            ras=scr->create_rasterizer();
+
+            // Registriere die Callbacks und trage Dispatcher in Manager ein
+            d->register_callback(Key, mk_callback(*this, &app::exitOnEsc));
+            d->register_callback(Idle, mk_callback(*this, &app::rotate));
+            d->register_callback(Draw, mk_callback(*this, &app::redraw));
+
+            manager[0]=d;
+            d->register_callback(Stop, 
+                                 mk_callback(manager, &disp_manager::stop));
+
+            // Dann wolln wir die cam mal initilisieren.
+            cam=camera(*ras, 50.0);
+            li2.set_intensity(127);
+            li3.set_intensity(40);
+
+            // zuerst werden alle n&ouml;tigen Vertexe erzeugt
+            vertex v[]={vertex(5,5,5,1),
+                        vertex(5,-5,5,1),
+                        vertex(-5,-5,5,1),
+                        vertex(-5,5,5,1),
+                        vertex(5,5,-5,1),
+                        vertex(5,-5,-5,1),
+                        vertex(-5,-5,-5,1),
+                        vertex(-5,5,-5,1)};
+
+            // und in einer Vertexliste gespeicher.
+            vertex_list vl(v, 8);
+
+            // ein Hilfsarray erzeugt um damit
+            unsigned v_idx[][4]={{3,2,1,0},  // hinten
+                                 {0,1,5,4},  // rechts
+                                 {4,5,6,7},  // vorne
+                                 {7,6,2,3},  // links
+                                 {4,0,3,7},  // oben
+                                 {1,5,6,2}}; // unten
+
+            // die Polygone zu definieren.
+            // (Der letzte Parameter ist die Vertexliste die das Polygon
+            //  nutzen soll. Hier kann ich NULL nehmen, da sie beim erzeugen
+            //  der Polyeders auf dessen Vertexliste gesetzt werden. 
+            //  (siehe unten))
+            /*polygon_movable pa[]={
+               polygon_movable((unsigned*)v_idx[0], 4, NULL),
+               polygon_movable((unsigned*)v_idx[1], 4, NULL),
+               polygon_movable((unsigned*)v_idx[2], 4, NULL),
+               polygon_movable((unsigned*)v_idx[3], 4, NULL),
+               polygon_movable((unsigned*)v_idx[4], 4, NULL),
+               polygon_movable((unsigned*)v_idx[5], 4, NULL)};*/
+            polygon pa[]={
+               polygon((unsigned*)v_idx[0], 4, NULL),
+               polygon((unsigned*)v_idx[1], 4, NULL),
+               polygon((unsigned*)v_idx[2], 4, NULL),
+               polygon((unsigned*)v_idx[3], 4, NULL),
+               polygon((unsigned*)v_idx[4], 4, NULL),
+               polygon((unsigned*)v_idx[5], 4, NULL)};
+
+
+            // Jetzt definieren wir mit der oben erzeugten Vertexlist und
+            // dem Array aus Polygonen 2 Polyeder, die wir beide vom
+            // Ursprung auf der Z-Achse weg bewegen.
+            p=polyeder(pa, 6, vl);
+            p2=polyeder(pa, 6, vl);
+            p4=polyeder(pa, 6, vl);
+ 
+            p[2].set_id("DEBUG");
+            cout << "BLA: " << p[2].get_id() << "\n";
+
+            polygon pa3[]={polygon((unsigned*)v_idx[0], 4, NULL),
+                           polygon((unsigned*)v_idx[2], 4, NULL)};
+            p3=polyeder(pa3, 2, vl);
+
+            winkel=0;
+            stepping=0;
+            cam_winkel=0;
+            cam_stepping=0;
+            li_winkel=WINKEL(-45.0);
+            li_stepping=0;
+            li2_winkel=WINKEL(90.0);
+            li2_stepping=0;
+            clip_front=0;
+            //halt=false;
+        }
+
+        /**
+         * \brief Destruktor
+         *
+         * freigeben und entfernen alles dynamisch erzeugten Elemente.
+         */
+        ~app() {
+            delete ras;
+            delete d;
+            delete scr;
+        }
+
+        /**
+         * \brief startet den Manager und damit das Programm.
+         */
+        void go(void) {
+            manager.start();
+        }
+};
+
+int main(int argc, char* argv[]) {
+    app a;
+
+    a.go();
+
+    // cout << "jokus\n"; 
+
+    return 0;
+}
+
+#endif

+CC=gcc
+CPP=g++
+#CFLAGS=-ggdb
+CXXFLAGS=
+MAKE=make
+
+OBJECTS=
+
+%.o: %.cpp
+	$(CPP) $(CFLAGS) $(CXXFLAGS) -c $*.cpp
+
+.PHONY : all clean
+
+all: $(OBJECTS)
+
+clean:
+	@rm -f *.o

+/**
+ * \file container.h
+ *
+ * \brief Definition eines Container-Templates
+ *
+ * Hiermit können alle möglichen Daten organisiert werden.
+
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 [gs]: erste funktionierende Implementation
+ * \version 04.12.2003 [gs]: beginn der Dokumentation via doxygen
+ * \version 19.12.2003 [gs]: <ul><li>
+ *                           Vergleichsoperator hinzugef&uuml;gt.
+ *                           </li><li>
+ *                           die Methode contains hinzugefügt, die
+ *                           &uuml;ber den Vergleichsoperator eines
+ *                           Elements pr&uuml;ft ob es in diesem Container
+ *                           existiert.
+ *                           </li></ul>
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __container_h__
+#define __container_h__
+
+#include <stdlib.h>
+
+template <class C>
+class container {
+    protected:
+        C* content;
+        unsigned count;
+
+    public:
+        container();
+        container(const C& c);
+        container(const C* c, unsigned co);
+        container(const container<C>& c);
+        virtual ~container();
+
+        virtual const container<C>& operator=(const container<C>& c);
+        virtual bool operator==(const container<C>& c) const {
+           if(count==c.count) {
+              for(unsigned i=0; i<count; i++)
+                 if(!(content[i]==c[i]))
+                    return false;
+           }
+           else
+              return false;
+
+           return true;
+        }
+
+        const C& operator[](unsigned index) const;
+        C& operator[](unsigned index);
+
+        //! Pr&uuml;ft ob ein Element in dem Container ist.
+        //! Gibt -1 zur&uuml;ck falls nicht, ansonsten den index an dem
+        //! sich das Element vefindet
+        int contains(const C& c) {
+           for(unsigned i=0; i<count; i++)
+              if(content[i]==c)
+                 return i;
+
+           return -1;
+        }
+
+        void sort(int (*comp)(const void*, const void*)) {
+           qsort(content, count, sizeof(C), comp);
+        }
+
+        void resize(unsigned size);
+        unsigned card(void) const { return count; }
+        virtual void insert(unsigned idx, const C& value);
+};
+
+#include "container_tpl.h"
+
+#endif // __container_h__

+/**
+ * \file container_tpl.h
+ * 
+ * \brief ein Template das als Behälter für alles mögliche dient.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 16.12.2003
+ *
+ * \version ..2002 [gs]: erste Implementation
+ * \version 16.12.2003 [gs]: <ul><li>
+ *                                       Beginn der Dokumentaion mit Doxygen
+ *                                       </li><li>
+ *                                       Einige &Auml;nderungen, so das
+ *                                       content in einem leeren container
+ *                                       NULL ist und dann entsprechen auch
+ *                                       nicht alle Aktionen mit diesem
+ *                                       container m&ouml;glich sind.
+ *                                       </li></ul>
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+using namespace std;
+
+#include <cstring>
+#include "container.h"
+
+template <class C>
+container<C>::container() : content(NULL), count(0) {
+    //content=new C[1];
+}
+
+template <class C>
+container<C>::container(const C& c) : count(1) {
+    content=new C[1];
+    content[0]=c;
+}
+
+template <class C>
+container<C>::container(const C* c, unsigned co) : count(co) {
+   if(count > 0)
+       content=new C[count];
+   else
+      content=NULL;
+
+    for(unsigned i=0; i<count; i++)
+        content[i]=c[i];
+}
+
+template <class C>
+container<C>::container(const container<C>& c) : count(c.count) {
+    if(count > 0)
+       content=new C[count];
+    else
+       content=NULL;
+            
+    for(unsigned i=0; i<count; i++)
+        content[i]=c.content[i];
+}
+
+template <class C>
+container<C>::~container() {
+    if(content) {
+        delete [] content;
+        content=NULL;
+    }
+     count=0;
+}
+
+template <class C>
+const container<C>& container<C>::operator=(const container<C>& c) {
+    if(this==&c)
+        return *this;
+
+    if(count != c.count) {
+        delete [] content;
+        if(c.count > 0)
+           content=new C[c.count];
+        else
+           content=NULL;
+    }
+
+    count=c.count;
+
+    for(unsigned i=0; i<count; i++)
+        content[i]=c.content[i];
+
+    return *this;
+}
+
+template <class C>
+const C& container<C>::operator[](unsigned index) const {
+    if(index+1 > count)
+        return content[0];
+
+    return content[index];
+}
+
+template <class C>
+C& container<C>::operator[](unsigned index) {
+    if(index+1 > count) {
+        C* content_tmp=new C[index+1];
+
+        for(unsigned i=0; i<count; i++)
+            content_tmp[i]=content[i];
+//        memcpy(content_tmp, content, count*sizeof(C));
+
+        delete [] content;
+        content=content_tmp;
+        count=index+1;
+    }
+
+    return content[index];
+}
+
+// WARNUNG!!! Diese funktion verkleiner auch ohne weitern check. d.h. ist
+// size < count, dann verliert man alle Einträge >size.
+template <class C>
+void container<C>::resize(unsigned size) {
+    C* content_tmp;
+
+    if(size>0) {
+       content_tmp=new C[size];
+
+       for(unsigned i=0; i<size<count?size:count; i++)
+           content_tmp[i]=content[i];
+    }
+    else
+       content_tmp=NULL;
+
+    delete [] content;
+    content=content_tmp;
+    count=size;
+}
+
+template <class C>
+void container<C>::insert(unsigned idx, const C& value) {
+   C* content_tmp=new C[count+1];
+
+   memcpy(content_tmp, content, idx*sizeof(C));
+   content_tmp[idx]=value;
+
+   for(unsigned i=0; i<count; i++)
+      content_tmp[i]=content[i];
+//   memcpy(&content_tmp[idx+1], &content[idx], (count-idx)*sizeof(C));
+
+   delete [] content;
+   content=content_tmp;
+   count++;
+}

+CC=gcc
+CPP=g++
+#CFLAGS=-ggdb
+CXXFLAGS=
+MAKE=make
+
+OBJECTS=sin_cos.o
+
+%.o: %.cpp
+	$(CPP) $(CFLAGS) $(CXXFLAGS) -c $*.cpp
+
+.PHONY : all clean
+
+all: $(OBJECTS)
+
+clean:
+	@rm -f *.o

+/**
+ * \file Mmn.h
+ *
+ * \brief Matrizenmanipulation beliebiger Matrizen
+ *
+ * Stellt eine Klasse zur verfügung, mit der sich alle denkbaren
+ * algebraischen Manipulationen an Matrizen beliebiger größe
+ * ausführen lassen, incl. lösen eines Gleichungssystems dessen
+ * erweiterte Koeffizientenmatrix diese Matrix ist.
+ *
+ * \author Georg Steffers <georg@steffers.org> [GS]
+ *
+ * \date 06.12.2003
+ *
+ * \version ..2002 erste funktionierende Version [GS]
+ * \version 06.12.2003 beginn der Dokumentation via doxygen [GS]
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __MMN_H__
+#define __MMN_H__
+
+using namespace std;
+
+#include <cmath>
+#include <iostream>
+
+#include "sin_cos.h"
+
+typedef enum gauss_typ {TREPPENNORMALE, INVERSE}; //!< \brief Was soll mit dem
+                                                  //! Gauss-Algorithmus
+                                                  //! ermittelt werden?
+
+template <class K>
+class Mmn;
+
+//! Skalarmultiplikation Skalar * Matrize
+template <class K>
+Mmn<K> operator*(const K&, const Mmn<K>&);
+
+/**
+ * \brief Darstellung einer Matrize und der auf ihr m&ouml;glichen
+ *        algebraischen Operationen
+ *
+ * Diese Klasse stellt meinen Lernerfolg in Lineare Algebra I dar.
+ */
+template <class K>
+class Mmn {
+    protected:
+        K** _a;         //!< \brief Die Matrize als doppelter Pointer auf
+                        //! den skalaren Typ K
+        unsigned m, n;  //!< Zeilen, Spalten der Matrize
+        unsigned Rg;    //!< \brief Der Rang der Matrize
+                        //!
+                        //! wird nur gefüllt wenn die Matrize &uuml;ber 
+                        //! Gauss in Treppennormalform gebracht wurde.
+        bool Det_F;     //!< enth&auml;lt Det einen g&uuml;ltigen Wert?
+        K Det;          //!< \brief Die Determinante der Matrize
+                        //!
+                        //! Sobald sie errechnet wurde wird sie hier
+                        //! gespeichert, bis die Matrize ver&auml;ndert
+                        //! wird, damit sie nicht immer wieder neu berechnet
+                        //! werden mu&szlig;
+
+        void freeall(void);             //!< die matrize wieder freigeben
+        K sarrus(void) const;  //!< \brief Sarrusregel
+                               //!
+                               //! zum ermitteln
+                               //! der Determinante einer 3x3 Matrize
+        K laplace(void) const; //!< \brief Laplace'scher Entwicklungssatz
+                               //!
+                               //! zum ermitteln der Determinante bei
+                               //! gr&ouml;&szlig;eren Matrizen als 3x3
+
+    public:
+        // Konstruktoren
+        //! Defaultkontruktor
+        Mmn() : _a(NULL), m(0), n(0), Rg(0), Det_F(false) {}
+        Mmn(unsigned);                   //!< EinheitsMatrix
+        Mmn(unsigned, unsigned);         //!< NullMatrix
+        Mmn(K*, unsigned, unsigned);     //!< \brief Konstruktor für eine 
+                                         //!         beliebige Matrix
+        Mmn(const Mmn<K>&);              //!< Copykonstruktor
+        virtual ~Mmn();                  //!< Destruktor
+
+        //! Zuweisungsoperator
+        const Mmn<K>& operator=(const Mmn<K>&);
+
+        //! Skalarmultiplikation (Matrix * Skalar)
+        Mmn<K> operator*(const K&) const;
+        //! Als friend damit auch Parameter 1 ein Skalar sein kann
+        friend Mmn<K> operator*<>(const K&, const Mmn<K>&);
+
+        // Hier können eh nur Matrizen verwendet werden. Daher sind
+        // keine weiteren friends nötig
+        Mmn<K> operator%(const Mmn<K>&) const;   //!< Matrizenprodukt
+        Mmn<K> operator+(const Mmn<K>&) const;   //!< Matrizensumme
+        Mmn<K> operator-(void) const;            //!< Negation
+        Mmn<K> operator-(const Mmn<K>&) const;   //!< Subtraktion
+       
+        //! eine NullMatrix derselben Groesse
+        Mmn<K> null(void) const { return Mmn<K>(m,n); }
+
+        bool is_null(void) const {
+           for(unsigned i=0; i<m; i++)
+              for(unsigned j=0; j<n; j++)
+                 if(_a[i][j]!=(K)0)
+                    return false;
+
+           return true;
+        }
+
+        // Einheitsmatrizen, entweder zu Anzahl Spalten, oder Zeilen
+        //! Einheitsmatrizen zu Anzahl Spalten
+        Mmn<K> In(void) const { return Mmn<K>(n); }
+        //! Einheitsmatrizen zu Anzahl Zeilen
+        Mmn<K> Im(void) const { return Mmn<K>(m); }
+
+        //! Ein Element aij der Matrize
+        K& a(unsigned i, unsigned j) { Det_F=false; return _a[i][j]; } 
+        const K& a(unsigned i, unsigned j) const { return _a[i][j]; } 
+
+        //! Determinante
+        K det(void);
+        K det(void) const;
+        
+        //! Transponierte
+        Mmn<K> T(void) const;
+
+        // Zeile und/oder Spalte aus matrize enftfernen
+        //! Zeile aus matrize enftfernen
+        Mmn<K> Ai(unsigned) const;
+        //! Spalte aus matrize enftfernen
+        Mmn<K> Aj(unsigned) const;
+        //! Zeile und Spalte aus matrize enftfernen
+        Mmn<K> Aij(unsigned, unsigned) const;
+
+        // Adjunkten ermitteln (2 verschiedene Verfahren)
+        Mmn<K> Ad_det(void) const;  //!< Adjunkte ueber Determinanten entwickelt
+        Mmn<K> Ad_inv(void) const;  //!< Inverse=>Adjunkte / gauss=>Adj.-Satz
+
+        // Inverse ermitteln (2 verschiedene Verfahren)
+        Mmn<K> gauss(gauss_typ) const; //!< \brief inverse Matrix ueber 
+                                       //!         Gauss-Algorithmus
+        Mmn<K> inv_Ad(void) const;     //!< \brief Adjunkte=>Inverse / 
+                                       //!         Ad_det=>Adj.-Satz
+
+        // lineare Gleichungssysteme
+        Mmn<K> solve(void) const;         //!< Gleichungssystem loesen
+        Mmn<K> special_solve(void) const; //!< \brief eine Spezielle Loesung des
+                                          //!         mit an=1, damit alle xi!=0
+
+        // formatierte Ausgabe
+        void print(ostream& = cout) const;    //!< Daten der Matrize ausgeben
+};
+
+template <class K>
+Mmn<K> operator*(const K& a, const Mmn<K>& A) {
+    return A * a;
+}
+
+template <class K>
+inline ostream& operator<<(ostream& strm, const Mmn<K>& A) {
+    A.print(strm);
+
+    return strm;
+}
+
+template <class K>
+inline void Mmn<K>::print(ostream& strm) const {
+    strm << "lines: " << m << "\n";
+    strm << "cols: " << n << "\n";
+
+    for(unsigned i=0; i<m; i++) {
+        for(unsigned j=0; j<n; j++)
+            strm << _a[i][j] << "\t";
+        strm << "\n";
+    }
+}
+
+#include "Mmn_tpl.h"
+#endif // __MMN_H__

+using namespace std;
+
+#include <cstdio>
+
+#include "Mmn.h"
+
+/****************************************************************
+ * die Klasse "Mmn"                                           *
+ ****************************************************************/
+//------ Kontruktoren -------------------------------------------
+template <class K>
+Mmn<K>::Mmn(K* a, unsigned m, unsigned n) : m(m), n(n), Rg(0), Det_F(false) {
+    _a=new (K*)[m];
+
+    for(unsigned i=0; i<m; i++) {
+        _a[i]=new K[n];
+        for(unsigned j=0; j<n; j++)
+            _a[i][j]=*(a+n*i+j);
+    }
+}
+
+template <class K>
+Mmn<K>::Mmn(unsigned m) : m(m), n(m), Rg(0), Det_F(false) {
+    _a=new (K*)[m];
+
+    for(unsigned i=0; i<m; i++) {
+        _a[i]=new K[n];
+        for(unsigned j=0; j<n; j++)
+            _a[i][j]=(j==i)?1:0;
+    }
+}
+
+template <class K>
+Mmn<K>::Mmn(unsigned m, unsigned n) : m(m), n(n), Rg(0), Det_F(false) {
+    _a=new (K*)[m];
+    for(unsigned i=0; i<m; i++) {
+        _a[i]=new K[n];
+        for(unsigned j=0; j<n; j++)
+            _a[i][j]=0;
+    }
+}
+
+template <class K>
+Mmn<K>::Mmn(const Mmn<K>& A) 
+   : m(A.m), n(A.n), Rg(A.Rg), Det(A.Det), Det_F(A.Det_F) {
+    _a=new (K*)[m];
+
+    for(unsigned i=0; i<m; i++) {
+        _a[i]=new K[n];
+        for(unsigned j=0; j<n; j++)
+            _a[i][j]=A._a[i][j];
+    }
+}
+
+template <class K>
+Mmn<K>::~Mmn() {
+    freeall();
+}
+//---------------------------------------------------------------
+
+//------ Operatoren ---------------------------------------------
+template <class K>
+const Mmn<K>& Mmn<K>::operator=(const Mmn<K>& A) {
+    if(this==&A)
+        return *this;
+
+    if(!_a || m != A.m || n != A.n) {
+        freeall();
+
+        _a=new (K*)[A.m];
+        for(unsigned i=0; i<A.m; i++)
+            _a[i]=new K[A.n];
+    }
+
+    m=A.m;
+    n=A.n;
+    Rg=A.Rg;
+    Det=A.Det;
+    Det_F=A.Det_F;
+
+    for(unsigned i=0; i<m; i++)
+        for(unsigned j=0; j<n; j++)
+            _a[i][j]=A._a[i][j];
+
+    return *this;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::operator*(const K& a) const {
+    Mmn<K> A(m,n);
+
+    for(unsigned i=0; i<m; i++)
+        for(unsigned j=0; j<n; j++)
+            A._a[i][j]=_a[i][j]*a;
+
+    return A;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::operator%(const Mmn<K>& A) const {
+    if(n != A.m)
+        return null();
+
+    Mmn<K> B(m,A.n);
+
+    for(unsigned i=0; i<m; i++)
+        for(unsigned j=0; j<A.n; j++) {
+            B._a[i][j]=0;
+
+            for(unsigned ji=0; ji<n; ji++)
+                B._a[i][j]+=_a[i][ji]*A._a[ji][j];
+        }
+
+    return B;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::operator+(const Mmn<K>& A) const {
+    if(n != A.n || m != A.m)
+        return null();
+
+    Mmn<K> B(m,n);
+
+    for(unsigned i=0; i<m; i++)
+        for(unsigned j=0; j<n; j++)
+            B._a[i][j]=_a[i][j]+A._a[i][j];
+
+    return B;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::operator-(const Mmn<K>& A) const {
+    Mmn<K> B(m,n);
+
+    for(unsigned i=0; i<m; i++)
+        for(unsigned j=0; j<n; j++)
+            B._a[i][j]=-A._a[i][j];
+
+    return *this+B;
+}
+//---------------------------------------------------------------
+
+//------ Hilfsfunktionen ----------------------------------------
+template <class K>
+void Mmn<K>::freeall(void) {
+    if(_a) {
+        for(unsigned i=0; i<m; i++) {
+            delete [] _a[i];
+        }
+        delete [] _a;
+        _a=NULL;
+    }
+
+    m=n=Rg=0;
+    Det_F=false;
+}
+//---------------------------------------------------------------
+
+//------ Determinantenberechnung --------------------------------
+template <class K>
+K Mmn<K>::sarrus(void) const {
+    return _a[0][0]*_a[1][1]*_a[2][2]\
+          +_a[0][1]*_a[1][2]*_a[2][0]\
+          +_a[0][2]*_a[1][0]*_a[2][1]\
+          -_a[0][1]*_a[1][0]*_a[2][2]\
+          -_a[0][0]*_a[1][2]*_a[2][1]\
+          -_a[0][2]*_a[1][1]*_a[2][0];
+}
+
+template <class K>
+K Mmn<K>::laplace(void) const {
+    K detA=0;
+    Mmn<K> A;
+
+    // analytisches optimieren des Laplace-Algorithmus, durch finden der
+    // Zeile/Spalte mit den meisten Nullen.
+    //-------------------------------------------------------------------
+    unsigned nulls_in_line[m];
+    for(unsigned i=0; i<m; nulls_in_line[i++]=0);
+    unsigned nulls_in_col[n];
+    for(unsigned j=0; j<m; nulls_in_col[j++]=0);
+    unsigned max_nulls=0;
+    int max_nulls_line=0;
+    int max_nulls_col=0;
+
+    for(unsigned i=0; i<m; i++)
+        for(unsigned j=0; j<n; j++)
+            if(_a[i][j]==(K)0) {
+                nulls_in_line[i]++;
+                nulls_in_col[j]++;
+
+                if(nulls_in_line[i]>max_nulls)
+                    max_nulls=nulls_in_line[i];
+                if(nulls_in_col[i]>max_nulls)
+                    max_nulls=nulls_in_col[i];
+
+                // ist eine komplette Zeile oder Spalte 0, so koennen wir
+                // direkt abbrechen und 0 zurueckgeben.
+                if(max_nulls==m)
+                    return (K)0;
+
+                max_nulls_line=(max_nulls==nulls_in_line[i])?i:max_nulls_line;
+                max_nulls_col=(max_nulls==nulls_in_col[j])?j:max_nulls_col;
+            }
+
+    if(nulls_in_line[max_nulls_line] > nulls_in_col[max_nulls_col]) {
+        A=T(); 
+        max_nulls_col=max_nulls_line;
+    }
+    else
+        A=*this;
+    //-------------------------------------------------------------------
+
+    for(unsigned i=0; i<A.m; i++)
+        if(A._a[i][0]!=(K)0)
+            detA+=((K)(int)pow((double)-1,(double)(i+max_nulls_col)))
+                  *A._a[i][max_nulls_col]
+                  *A.Aij(i,max_nulls_col).det();
+
+    return detA;
+}
+
+template <class K>
+K Mmn<K>::det(void) const {
+    K Det=(K)0;
+
+    if(m!=n) {
+        return Det;
+    }
+    else {
+        switch(m) {
+            case 1: Det=_a[0][0];
+                    break;
+            case 2: Det=_a[0][0]*_a[1][1]-_a[0][1]*_a[1][0];
+                    break;
+            case 3: Det=sarrus();
+                    break;
+            default: Det=laplace();
+        }
+
+        return Det;
+    }
+}
+
+template <class K>
+K Mmn<K>::det(void) {
+    if(m!=n) {
+        Det=(K)0;
+        Det_F=false;
+
+        return Det;
+    }
+    else {
+        switch(m) {
+            case 1: Det=_a[0][0];
+                    break;
+            case 2: Det=_a[0][0]*_a[1][1]-_a[0][1]*_a[1][0];
+                    break;
+            case 3: Det=sarrus();
+                    break;
+            default: Det=laplace();
+        }
+
+        Det_F=true;
+        return Det;
+    }
+}
+//---------------------------------------------------------------
+
+//------ Matrizenmanipulationen ---------------------------------
+template <class K>
+Mmn<K> Mmn<K>::Aij(unsigned i, unsigned j) const {
+    Mmn<K> A(m-1,n-1);
+    unsigned _i, _l, _j, _k;
+
+    for(_i=0, _l=0; _i<m; _i++, _l++) {
+        if(_i==i) _i++;
+        if(_i>=m) break;
+
+        for(_j=0, _k=0; _j<n; _j++, _k++) {
+            if(_j==j) _j++;
+            if(_j>=n) break;
+
+            A._a[_l][_k]=_a[_i][_j];
+        }
+    }
+
+    return A;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::Ai(unsigned i) const {
+    Mmn<K> A(m-1,n);
+    unsigned _i, l;
+
+    for(_i=0, l=0; i<m; _i++, l++) {
+        if(_i==i) _i++;
+        if(_i>=m) break;
+
+        for(unsigned j=0; j<n; j++)
+            A._a[l][j]=_a[_i][j];
+    }
+
+    return A;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::Aj(unsigned j) const {
+    Mmn<K> A(m,n-1);
+    unsigned _j, k;
+
+    for(unsigned i=0; i<m; i++)
+        for(_j=0, k=0; _j<n; _j++, k++) {
+            if(_j==j) _j++;
+            if(_j>=n) break;
+
+            A._a[i][k]=_a[i][_j];
+        }
+
+    return A;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::T(void) const {
+    Mmn<K> A(n,m);
+
+    for(unsigned i=0; i<m; i++)
+        for(unsigned j=0; j<n; j++)
+            A._a[j][i]=_a[i][j];
+
+    return A;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::Ad_det(void) const {
+    Mmn<K> A(n,m);
+
+    for(unsigned i=0; i<m; i++)
+        for(unsigned j=0; j<n; j++)
+            A._a[j][i]=((K)(int)pow((double)-1,(double)(i+j)))*Aij(i,j).det();
+
+    return A;
+}
+
+template <class K>
+Mmn<K> Mmn<K>::Ad_inv(void) const {
+    // Das geht nur wenn die Determinante nicht 0 ist, da sonst die ganze
+    // Ergebnismatrix automatisch 0 wird, was aber nicht unbedingt sein muß.
+    // Dies gilt insbesondere Wenn die Matrize eine Null-Zeile oder Spalte
+    // enthaelt.
+    K d=Det_F?Det:det();
+
+    if(d != (K)0)
+        return d*gauss(INVERSE);
+    else
+        return Ad_det();
+}
+
+template <class K>
+Mmn<K> Mmn<K>::inv_Ad(void) const {
+    K Adet; 
+
+    if((Adet=Det_F?Det:det())==(K)0) {
+        return null();
+    }
+    else {
+        return Ad_det()*((K)1/Adet);
+    }
+}
+
+template <class K>
+Mmn<K> Mmn<K>::gauss(gauss_typ T) const {
+    Mmn<K> A=*this;
+    Mmn<K> B(m);
+
+    for(unsigned i=0; i<A.m; i++) {
+        unsigned j;
+
+        for(j=i; j<A.n; j++) {
+            unsigned k;
+
+            for(k=i; k<A.m && A._a[k][j]==(K)0; k++);
+            if(k==A.m)
+                continue;
+            if(k!=i) {
+                K* tmp=A._a[i];
+                A._a[i]=A._a[k];
+                A._a[k]=tmp;
+
+                if(T==INVERSE) {
+                    tmp=B._a[i];
+                    B._a[i]=B._a[k];
+                    B._a[k]=tmp;
+                }
+            }
+            break;
+        }
+
+        if(j==A.m) break;
+
+        if(A._a[i][j]!=(K)0) {
+            K aii_inv=(K)1/A._a[i][j];
+            A._a[i][j]=1;
+            A.Rg++;
+            B.Rg++;
+
+            for(unsigned k=j+1; k<A.n; k++)
+                A._a[i][k]*=aii_inv;
+            if(T==INVERSE) {
+                for(unsigned k=0; k<B.n; k++)
+                    B._a[i][k]*=aii_inv;
+            }
+
+            for(unsigned k=0; k<A.m; k++) {
+                if(k != i) {
+                    K akj_neg=-A._a[k][j];
+
+                    for(unsigned l=j; l<A.n; l++)
+                        A._a[k][l]+=A._a[i][l]*akj_neg;
+                    if(T==INVERSE) {
+                        for(unsigned l=0; l<B.n; l++)
+                            B._a[k][l]+=B._a[i][l]*akj_neg;
+                    }
+                }
+            }
+        }
+    }
+
+    if(T==TREPPENNORMALE)
+        return A;
+    else {
+        // Es gibt nur eine Inverse wenn Rg(A)=m ist
+        if(B.Rg==m)
+            return B;
+        else
+            return null();
+    }
+}
+//---------------------------------------------------------------
+
+//------ lineare Gleichungssysteme ------------------------------
+template <class K>
+Mmn<K> Mmn<K>::solve(void) const {
+    Mmn<K> A=gauss(TREPPENNORMALE);
+    Mmn<K> B=Aj(n-1).gauss(TREPPENNORMALE);
+
+    // Gibt es eine Loesung???
+    if(B.Rg != A.Rg)
+        return null();
+    else {
+        K l[B.n][B.n-B.Rg+1];
+        K a[B.n][A.n];
+
+        for(unsigned i=0, j=0; j<B.n && i<B.n; j++) {
+            if(i>=A.m || A._a[i][j] != (K)1) {
+                for(unsigned k=0; k<A.n; k++) {
+                    if(k==j)
+                        a[j][k]=(K)-1;
+                    else
+                        a[j][k]=(K)0;
+                }
+            }
+            else {
+                for(unsigned k=0; k<A.n; k++)
+                    a[j][k]=A._a[i][k];
+                i++;
+            }
+        }
+
+        unsigned j=0;
+        for (unsigned i=0; i<B.n; i++)
+            l[i][j]=a[i][A.n-1];
+        j++;
+
+        for(unsigned k=0; k<B.n; k++) {
+            if(a[k][k]==(K)-1) {
+                for (unsigned i=0; i<B.n; i++)
+                    l[i][j]=a[i][k];
+                j++;
+            }
+        }
+
+        return Mmn<K>((K*)l, B.n, B.n-B.Rg+1);
+    }
+}
+
+template <class K>
+Mmn<K> Mmn<K>::special_solve(void) const {
+    Mmn<K> S=solve();
+    Mmn<K> A(S.m,1);
+
+    for(unsigned i=0; i<S.m; i++) {
+        A._a[i][0]=(K)0;
+
+        for(unsigned j=0; j<S.n; j++)
+            A._a[i][0]+=S._a[i][j];
+    }
+
+    return A;
+}
+
+//---------------------------------------------------------------
+/****************************************************************/

+/**
+ * \file V_K4.h
+ *
+ * \brief Klasse die einen 4er-Vektor mathematisch beschreibt und handled.
+ *
+ * Hier gibt alles was man für Vektoren so braucht (Vektorprodukt,
+ * Skalarprodukt, Addition, Subtraktion, Multiplikation mit Matrize)
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 [gs]: erste funktionierende Implementation
+ * \version 18.12.2003 [gs]: Vergleichsoperator hinzugef&uuml;gt.
+ */ 
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __V_K4_H__
+#define __V_K4_H__
+
+#include <cmath>
+#include <iostream>
+
+#include "Mmn.h"
+
+/**
+ * \brief Winkel auf -360 bis +360 beschr&auml;nken und als double
+ *        handhaben.
+ *
+ * Wird ein Winkel < -360 oder > +360 angegeben, so wird sein Vorkommateil
+ * auf diesen Bereich gestuzt und der Nachkommateil hinzuaddiert.
+ */
+#define WINKEL(x)    ((double)((int)(x)%360)+(double)(x)-(int)(x))
+#define BOGENMASS(x) (WINKEL((x))*M_PI/180)
+#define RAD(x)       (BOGENMASS((x)))
+#define GRAD(x)      (WINKEL((x))*180/M_PI)
+#define SQR(x)       ((x)*(x))
+
+using namespace std;
+
+template <class K>
+class V_K4 : public Mmn<K> {
+    public:
+        V_K4() : Mmn<K>(4, 1) {}
+        V_K4(Mmn<K> m) : Mmn<K>(m) {}
+        V_K4(K* a) : Mmn<K>(a, 4, 1) {}
+        V_K4(K e1, K e2, K e3, K e4=0) : Mmn<K>(4,1) {
+            _a[0][0]=e1; _a[1][0]=e2; 
+            _a[2][0]=e3; _a[3][0]=e4;
+        }
+
+        const K& operator[](unsigned i) const {  return _a[i>m-1?m-1:i][0]; }
+        K& operator[](unsigned i) { return _a[i>m-1?m-1:i][0]; }
+        K& X(unsigned i) { return (*this)[0]; }
+        K& Y(unsigned i) { return (*this)[1]; }
+        K& Z(unsigned i) { return (*this)[2]; }
+        K& W(unsigned i) { return (*this)[3]; }
+
+        K v_betr(void) const { return sqrt(*this % *this); }
+
+        V_K4<K> v_norm(void) const { return *this * (1/v_betr()); }
+
+        K operator% (const V_K4<K>&) const;
+        V_K4<K> operator| (const V_K4<K>&) const;
+        bool operator== (const V_K4<K>& v) const {
+           if(this->m==v.m &&
+              this->n==v.n) {
+              for(unsigned i=0; i<m; i++)
+                 for(unsigned j=0; j<n; j++)
+                    if(_a[i][j]!=v._a[i][j])
+                       return false;
+           }
+           else
+              return false;
+
+           return true;
+        }
+};
+
+template <class K>
+inline ostream& operator<<(ostream& strm, const V_K4<K>& A) {
+    A.print(strm);
+
+    return strm;
+}
+
+#include "V_K4_tpl.h"
+
+/**
+ * \brief Liefert die Matrize zur Rotation eines Punktes um einen
+ *        beliebigen Vektor
+ */
+class mat_rot_axe : public Mmn<double> {
+   public:
+      mat_rot_axe(double* a) : Mmn<double>(a, 4, 4) {}
+      mat_rot_axe(double w=0, 
+            V_K4<double> const& axe=V_K4<double>(0,0,1,0)) {
+         V_K4<double> u(axe.v_norm());
+
+         double A[4][4]={{SQR(u[0])+cos(RAD(w))*(1-SQR(u[0])),
+                          u[0]*u[1]*(1-cos(RAD(w)))-u[2]*sin(RAD(w)),
+                          u[2]*u[0]*(1-cos(RAD(w)))+u[1]*sin(RAD(w)),
+                          0},
+                         {u[0]*u[1]*(1-cos(RAD(w)))+u[2]*sin(RAD(w)),
+                          SQR(u[1])+cos(RAD(w))*(1-SQR(u[1])),
+                          u[1]*u[2]*(1-cos(RAD(w)))-u[0]*sin(RAD(w)),
+                          0},
+                         {u[2]*u[0]*(1-cos(RAD(w)))-u[1]*sin(RAD(w)),
+                          u[1]*u[2]*(1-cos(RAD(w)))+u[0]*sin(RAD(w)),
+                          SQR(u[2])+cos(RAD(w))*(1-SQR(u[2])),
+                          0},
+                         {0,0,0,1}};
+
+         *this=mat_rot_axe((double*)A);
+      }
+};
+
+/**
+ * \brief Liefert die Matrize zur Rotation eines Punktes um die
+ *        X-Achse
+ */
+class mat_rot_x : public Mmn<double> {
+   public:
+      mat_rot_x(double* a) : Mmn<double>(a, 4, 4) {}
+      mat_rot_x(double w=0) {
+         double A[4][4]={{1,0,0,0},
+                         {0,cos(RAD(w)),-sin(RAD(w)),0},
+                         {0,sin(RAD(w)),cos(RAD(w)),0},
+                         {0,0,0,1}};
+
+         *this=mat_rot_x((double*)A);
+      }
+};
+
+/**
+ * \brief Liefert die Matrize zur Rotation eines Punktes um die
+ *        Y-Achse
+ */
+class mat_rot_y : public Mmn<double> {
+   public:
+      mat_rot_y(double* a) : Mmn<double>(a, 4, 4) {}
+      mat_rot_y(double w=0) {
+         double A[4][4]={{cos(RAD(w)),0,sin(RAD(w)),0},
+                         {0,1,0,0},
+                         {-sin(RAD(w)),0,cos(RAD(w)),0},
+                         {0,0,0,1}};
+
+         *this=mat_rot_y((double*)A);
+      }
+};
+
+/**
+ * \brief Liefert die Matrize zur Rotation eines Punktes um die
+ *        Z-Achse
+ */
+class mat_rot_z : public Mmn<double> {
+   public:
+      mat_rot_z(double* a) : Mmn<double>(a, 4, 4) {}
+      mat_rot_z(double w=0) {
+         double A[4][4]={{cos(RAD(w)),-sin(RAD(w)),0,0},
+                         {sin(RAD(w)),cos(RAD(w)),0,0},
+                         {0,0,1,0},
+                         {0,0,0,1}};
+
+         *this=mat_rot_z((double*)A);
+      }
+};
+
+/**
+ * \brief Liefert die Matrize zur Verschiebung eines Punktes um 
+ *        tx. ty und tz
+ */
+class mat_translate : public Mmn<double> {
+   public:
+      mat_translate(double* a) : Mmn<double>(a, 4, 4) {}
+      mat_translate(double tx=0, double ty=0, double tz=0) {
+         double A[4][4]={{1,0,0,tx},
+                         {0,1,0,ty},
+                         {0,0,1,tz},
+                         {0,0,0,1}};
+
+         *this=mat_translate((double*)A);
+      }
+};
+
+/**
+ * \brief Liefert die Matrize zur Verformung eines Punktes um 
+ *        sx. sy und sz
+ */
+class mat_transform : public Mmn<double> {
+   public:
+      mat_transform(double* a) : Mmn<double>(a, 4, 4) {}
+      mat_transform(double sx=0, double sy=0, double sz=0) {
+         double A[4][4]={{sx,0,0,0},
+                         {0,sy,0,0},
+                         {0,0,sz,0},
+                         {0,0,0,1}};
+
+         *this=mat_transform((double*)A);
+      }
+};
+
+#endif // __V_K4_H__

+#include "V_K4.h"
+
+template <class K>
+K V_K4<K>::operator% (const V_K4<K>& A) const {
+    return (T() % (Mmn<K>)A).a(0,0);
+}
+
+template <class K>
+V_K4<K> V_K4<K>::operator| (const V_K4<K>& A) const {
+    V_K4<K> B;
+
+    // Was jetzt kommt ist eine Loesung (a,b,c) des folgenden Gleichungssystems
+    // a*v1+b*v2+c*v3=0 und a*w1+b*w2+c*w3=0. Das heißt es ist ein Vektor
+    // (a,b,c) der wenn man ihn mit den uebergebenen Vektoren v und w mult.
+    // jeweils Null ergibt. Dieser Sachverhalt bedeutet geometrisch betrachtet
+    // das dieser Vektor 90 Grad zu beiden übergebenen Vektoren bildet, also
+    // eine Senkrechte zu der Ebene die diese beiden Vektoren aufziehen 
+    // bildet. (Den Beweis das es eine spezielle Lösung ist bleibe ich hier
+    // schuldig, wers ausprobieren möchte und nich weis wie kann sich gerne
+    // an mich wenden.)
+    B[0]=_a[1][0]*A[2] - _a[2][0]*A[1];
+    B[1]=_a[0][0]*A[2] - _a[2][0]*A[0];
+    B[2]=_a[0][0]*A[1] - _a[1][0]*A[0];
+    B[3]=0;
+
+    return B;
+}

+using namespace std;
+
+#include <cmath>
+
+#include "sin_cos.h"
+
+const double SIN[360]={sin(0*M_PI/180), sin(1*M_PI/180), sin(2*M_PI/180), sin(3*M_PI/180), sin(4*M_PI/180),
+                       sin(5*M_PI/180), sin(6*M_PI/180), sin(7*M_PI/180), sin(8*M_PI/180), sin(9*M_PI/180),
+                       sin(10*M_PI/180), sin(11*M_PI/180), sin(12*M_PI/180), sin(13*M_PI/180), sin(14*M_PI/180),
+                       sin(15*M_PI/180), sin(16*M_PI/180), sin(17*M_PI/180), sin(18*M_PI/180), sin(19*M_PI/180),
+                       sin(20*M_PI/180), sin(21*M_PI/180), sin(22*M_PI/180), sin(23*M_PI/180), sin(24*M_PI/180),
+                       sin(25*M_PI/180), sin(26*M_PI/180), sin(27*M_PI/180), sin(28*M_PI/180), sin(29*M_PI/180),
+                       sin(30*M_PI/180), sin(31*M_PI/180), sin(32*M_PI/180), sin(33*M_PI/180), sin(34*M_PI/180),
+                       sin(35*M_PI/180), sin(36*M_PI/180), sin(37*M_PI/180), sin(38*M_PI/180), sin(39*M_PI/180),
+                       sin(40*M_PI/180), sin(41*M_PI/180), sin(42*M_PI/180), sin(43*M_PI/180), sin(44*M_PI/180),
+                       sin(45*M_PI/180), sin(46*M_PI/180), sin(47*M_PI/180), sin(48*M_PI/180), sin(49*M_PI/180),
+                       sin(50*M_PI/180), sin(51*M_PI/180), sin(52*M_PI/180), sin(53*M_PI/180), sin(54*M_PI/180),
+                       sin(55*M_PI/180), sin(56*M_PI/180), sin(57*M_PI/180), sin(58*M_PI/180), sin(59*M_PI/180),
+                       sin(60*M_PI/180), sin(61*M_PI/180), sin(62*M_PI/180), sin(63*M_PI/180), sin(64*M_PI/180),
+                       sin(65*M_PI/180), sin(66*M_PI/180), sin(67*M_PI/180), sin(68*M_PI/180), sin(69*M_PI/180),
+                       sin(70*M_PI/180), sin(71*M_PI/180), sin(72*M_PI/180), sin(73*M_PI/180), sin(74*M_PI/180),
+                       sin(75*M_PI/180), sin(76*M_PI/180), sin(77*M_PI/180), sin(78*M_PI/180), sin(79*M_PI/180),
+                       sin(80*M_PI/180), sin(81*M_PI/180), sin(82*M_PI/180), sin(83*M_PI/180), sin(84*M_PI/180),
+                       sin(85*M_PI/180), sin(86*M_PI/180), sin(87*M_PI/180), sin(88*M_PI/180), sin(89*M_PI/180),
+                       sin(90*M_PI/180), sin(91*M_PI/180), sin(92*M_PI/180), sin(93*M_PI/180), sin(94*M_PI/180),
+                       sin(95*M_PI/180), sin(96*M_PI/180), sin(97*M_PI/180), sin(98*M_PI/180), sin(99*M_PI/180),
+                       sin(100*M_PI/180), sin(101*M_PI/180), sin(102*M_PI/180), sin(103*M_PI/180), sin(104*M_PI/180),
+                       sin(105*M_PI/180), sin(106*M_PI/180), sin(107*M_PI/180), sin(108*M_PI/180), sin(109*M_PI/180),
+                       sin(110*M_PI/180), sin(111*M_PI/180), sin(112*M_PI/180), sin(113*M_PI/180), sin(114*M_PI/180),
+                       sin(115*M_PI/180), sin(116*M_PI/180), sin(117*M_PI/180), sin(118*M_PI/180), sin(119*M_PI/180),
+                       sin(120*M_PI/180), sin(121*M_PI/180), sin(122*M_PI/180), sin(123*M_PI/180), sin(124*M_PI/180),
+                       sin(125*M_PI/180), sin(126*M_PI/180), sin(127*M_PI/180), sin(128*M_PI/180), sin(129*M_PI/180),
+                       sin(130*M_PI/180), sin(131*M_PI/180), sin(132*M_PI/180), sin(133*M_PI/180), sin(134*M_PI/180),
+                       sin(135*M_PI/180), sin(136*M_PI/180), sin(137*M_PI/180), sin(138*M_PI/180), sin(139*M_PI/180),
+                       sin(140*M_PI/180), sin(141*M_PI/180), sin(142*M_PI/180), sin(143*M_PI/180), sin(144*M_PI/180),
+                       sin(145*M_PI/180), sin(146*M_PI/180), sin(147*M_PI/180), sin(148*M_PI/180), sin(149*M_PI/180),
+                       sin(150*M_PI/180), sin(151*M_PI/180), sin(152*M_PI/180), sin(153*M_PI/180), sin(154*M_PI/180),
+                       sin(155*M_PI/180), sin(156*M_PI/180), sin(157*M_PI/180), sin(158*M_PI/180), sin(159*M_PI/180),
+                       sin(160*M_PI/180), sin(161*M_PI/180), sin(162*M_PI/180), sin(163*M_PI/180), sin(164*M_PI/180),
+                       sin(165*M_PI/180), sin(166*M_PI/180), sin(167*M_PI/180), sin(168*M_PI/180), sin(169*M_PI/180),
+                       sin(170*M_PI/180), sin(171*M_PI/180), sin(172*M_PI/180), sin(173*M_PI/180), sin(174*M_PI/180),
+                       sin(175*M_PI/180), sin(176*M_PI/180), sin(177*M_PI/180), sin(178*M_PI/180), sin(179*M_PI/180),
+                       sin(180*M_PI/180), sin(181*M_PI/180), sin(182*M_PI/180), sin(183*M_PI/180), sin(184*M_PI/180),
+                       sin(185*M_PI/180), sin(186*M_PI/180), sin(187*M_PI/180), sin(188*M_PI/180), sin(189*M_PI/180),
+                       sin(190*M_PI/180), sin(191*M_PI/180), sin(192*M_PI/180), sin(193*M_PI/180), sin(194*M_PI/180),
+                       sin(195*M_PI/180), sin(196*M_PI/180), sin(197*M_PI/180), sin(198*M_PI/180), sin(199*M_PI/180),
+                       sin(200*M_PI/180), sin(201*M_PI/180), sin(202*M_PI/180), sin(203*M_PI/180), sin(204*M_PI/180),
+                       sin(205*M_PI/180), sin(206*M_PI/180), sin(207*M_PI/180), sin(208*M_PI/180), sin(209*M_PI/180),
+                       sin(210*M_PI/180), sin(211*M_PI/180), sin(212*M_PI/180), sin(213*M_PI/180), sin(214*M_PI/180),
+                       sin(215*M_PI/180), sin(216*M_PI/180), sin(217*M_PI/180), sin(218*M_PI/180), sin(219*M_PI/180),
+                       sin(220*M_PI/180), sin(221*M_PI/180), sin(222*M_PI/180), sin(223*M_PI/180), sin(224*M_PI/180),
+                       sin(225*M_PI/180), sin(226*M_PI/180), sin(227*M_PI/180), sin(228*M_PI/180), sin(229*M_PI/180),
+                       sin(230*M_PI/180), sin(231*M_PI/180), sin(232*M_PI/180), sin(233*M_PI/180), sin(234*M_PI/180),
+                       sin(235*M_PI/180), sin(236*M_PI/180), sin(237*M_PI/180), sin(238*M_PI/180), sin(239*M_PI/180),
+                       sin(240*M_PI/180), sin(241*M_PI/180), sin(242*M_PI/180), sin(243*M_PI/180), sin(244*M_PI/180),
+                       sin(245*M_PI/180), sin(246*M_PI/180), sin(247*M_PI/180), sin(248*M_PI/180), sin(249*M_PI/180),
+                       sin(250*M_PI/180), sin(251*M_PI/180), sin(252*M_PI/180), sin(253*M_PI/180), sin(254*M_PI/180),
+                       sin(255*M_PI/180), sin(256*M_PI/180), sin(257*M_PI/180), sin(258*M_PI/180), sin(259*M_PI/180),
+                       sin(260*M_PI/180), sin(261*M_PI/180), sin(262*M_PI/180), sin(263*M_PI/180), sin(264*M_PI/180),
+                       sin(265*M_PI/180), sin(266*M_PI/180), sin(267*M_PI/180), sin(268*M_PI/180), sin(269*M_PI/180),
+                       sin(270*M_PI/180), sin(271*M_PI/180), sin(272*M_PI/180), sin(273*M_PI/180), sin(274*M_PI/180),
+                       sin(275*M_PI/180), sin(276*M_PI/180), sin(277*M_PI/180), sin(278*M_PI/180), sin(279*M_PI/180),
+                       sin(280*M_PI/180), sin(281*M_PI/180), sin(282*M_PI/180), sin(283*M_PI/180), sin(284*M_PI/180),
+                       sin(285*M_PI/180), sin(286*M_PI/180), sin(287*M_PI/180), sin(288*M_PI/180), sin(289*M_PI/180),
+                       sin(290*M_PI/180), sin(291*M_PI/180), sin(292*M_PI/180), sin(293*M_PI/180), sin(294*M_PI/180),
+                       sin(295*M_PI/180), sin(296*M_PI/180), sin(297*M_PI/180), sin(298*M_PI/180), sin(299*M_PI/180),
+                       sin(300*M_PI/180), sin(301*M_PI/180), sin(302*M_PI/180), sin(303*M_PI/180), sin(304*M_PI/180),
+                       sin(305*M_PI/180), sin(306*M_PI/180), sin(307*M_PI/180), sin(308*M_PI/180), sin(309*M_PI/180),
+                       sin(310*M_PI/180), sin(311*M_PI/180), sin(312*M_PI/180), sin(313*M_PI/180), sin(314*M_PI/180),
+                       sin(315*M_PI/180), sin(316*M_PI/180), sin(317*M_PI/180), sin(318*M_PI/180), sin(319*M_PI/180),
+                       sin(320*M_PI/180), sin(321*M_PI/180), sin(322*M_PI/180), sin(323*M_PI/180), sin(324*M_PI/180),
+                       sin(325*M_PI/180), sin(326*M_PI/180), sin(327*M_PI/180), sin(328*M_PI/180), sin(329*M_PI/180),
+                       sin(330*M_PI/180), sin(331*M_PI/180), sin(332*M_PI/180), sin(333*M_PI/180), sin(334*M_PI/180),
+                       sin(335*M_PI/180), sin(336*M_PI/180), sin(337*M_PI/180), sin(338*M_PI/180), sin(339*M_PI/180),
+                       sin(340*M_PI/180), sin(341*M_PI/180), sin(342*M_PI/180), sin(343*M_PI/180), sin(344*M_PI/180),
+                       sin(345*M_PI/180), sin(346*M_PI/180), sin(347*M_PI/180), sin(348*M_PI/180), sin(349*M_PI/180),
+                       sin(350*M_PI/180), sin(351*M_PI/180), sin(352*M_PI/180), sin(353*M_PI/180), sin(354*M_PI/180),
+                       sin(355*M_PI/180), sin(356*M_PI/180), sin(357*M_PI/180), sin(358*M_PI/180), sin(359*M_PI/180)};
+
+const double COS[360]={cos(0*M_PI/180), cos(1*M_PI/180), cos(2*M_PI/180), cos(3*M_PI/180), cos(4*M_PI/180),
+                       cos(5*M_PI/180), cos(6*M_PI/180), cos(7*M_PI/180), cos(8*M_PI/180), cos(9*M_PI/180),
+                       cos(10*M_PI/180), cos(11*M_PI/180), cos(12*M_PI/180), cos(13*M_PI/180), cos(14*M_PI/180),
+                       cos(15*M_PI/180), cos(16*M_PI/180), cos(17*M_PI/180), cos(18*M_PI/180), cos(19*M_PI/180),
+                       cos(20*M_PI/180), cos(21*M_PI/180), cos(22*M_PI/180), cos(23*M_PI/180), cos(24*M_PI/180),
+                       cos(25*M_PI/180), cos(26*M_PI/180), cos(27*M_PI/180), cos(28*M_PI/180), cos(29*M_PI/180),
+                       cos(30*M_PI/180), cos(31*M_PI/180), cos(32*M_PI/180), cos(33*M_PI/180), cos(34*M_PI/180),
+                       cos(35*M_PI/180), cos(36*M_PI/180), cos(37*M_PI/180), cos(38*M_PI/180), cos(39*M_PI/180),
+                       cos(40*M_PI/180), cos(41*M_PI/180), cos(42*M_PI/180), cos(43*M_PI/180), cos(44*M_PI/180),
+                       cos(45*M_PI/180), cos(46*M_PI/180), cos(47*M_PI/180), cos(48*M_PI/180), cos(49*M_PI/180),
+                       cos(50*M_PI/180), cos(51*M_PI/180), cos(52*M_PI/180), cos(53*M_PI/180), cos(54*M_PI/180),
+                       cos(55*M_PI/180), cos(56*M_PI/180), cos(57*M_PI/180), cos(58*M_PI/180), cos(59*M_PI/180),
+                       cos(60*M_PI/180), cos(61*M_PI/180), cos(62*M_PI/180), cos(63*M_PI/180), cos(64*M_PI/180),
+                       cos(65*M_PI/180), cos(66*M_PI/180), cos(67*M_PI/180), cos(68*M_PI/180), cos(69*M_PI/180),
+                       cos(70*M_PI/180), cos(71*M_PI/180), cos(72*M_PI/180), cos(73*M_PI/180), cos(74*M_PI/180),
+                       cos(75*M_PI/180), cos(76*M_PI/180), cos(77*M_PI/180), cos(78*M_PI/180), cos(79*M_PI/180),
+                       cos(80*M_PI/180), cos(81*M_PI/180), cos(82*M_PI/180), cos(83*M_PI/180), cos(84*M_PI/180),
+                       cos(85*M_PI/180), cos(86*M_PI/180), cos(87*M_PI/180), cos(88*M_PI/180), cos(89*M_PI/180),
+                       cos(90*M_PI/180), cos(91*M_PI/180), cos(92*M_PI/180), cos(93*M_PI/180), cos(94*M_PI/180),
+                       cos(95*M_PI/180), cos(96*M_PI/180), cos(97*M_PI/180), cos(98*M_PI/180), cos(99*M_PI/180),
+                       cos(100*M_PI/180), cos(101*M_PI/180), cos(102*M_PI/180), cos(103*M_PI/180), cos(104*M_PI/180),
+                       cos(105*M_PI/180), cos(106*M_PI/180), cos(107*M_PI/180), cos(108*M_PI/180), cos(109*M_PI/180),
+                       cos(110*M_PI/180), cos(111*M_PI/180), cos(112*M_PI/180), cos(113*M_PI/180), cos(114*M_PI/180),
+                       cos(115*M_PI/180), cos(116*M_PI/180), cos(117*M_PI/180), cos(118*M_PI/180), cos(119*M_PI/180),
+                       cos(120*M_PI/180), cos(121*M_PI/180), cos(122*M_PI/180), cos(123*M_PI/180), cos(124*M_PI/180),
+                       cos(125*M_PI/180), cos(126*M_PI/180), cos(127*M_PI/180), cos(128*M_PI/180), cos(129*M_PI/180),
+                       cos(130*M_PI/180), cos(131*M_PI/180), cos(132*M_PI/180), cos(133*M_PI/180), cos(134*M_PI/180),
+                       cos(135*M_PI/180), cos(136*M_PI/180), cos(137*M_PI/180), cos(138*M_PI/180), cos(139*M_PI/180),
+                       cos(140*M_PI/180), cos(141*M_PI/180), cos(142*M_PI/180), cos(143*M_PI/180), cos(144*M_PI/180),
+                       cos(145*M_PI/180), cos(146*M_PI/180), cos(147*M_PI/180), cos(148*M_PI/180), cos(149*M_PI/180),
+                       cos(150*M_PI/180), cos(151*M_PI/180), cos(152*M_PI/180), cos(153*M_PI/180), cos(154*M_PI/180),
+                       cos(155*M_PI/180), cos(156*M_PI/180), cos(157*M_PI/180), cos(158*M_PI/180), cos(159*M_PI/180),
+                       cos(160*M_PI/180), cos(161*M_PI/180), cos(162*M_PI/180), cos(163*M_PI/180), cos(164*M_PI/180),
+                       cos(165*M_PI/180), cos(166*M_PI/180), cos(167*M_PI/180), cos(168*M_PI/180), cos(169*M_PI/180),
+                       cos(170*M_PI/180), cos(171*M_PI/180), cos(172*M_PI/180), cos(173*M_PI/180), cos(174*M_PI/180),
+                       cos(175*M_PI/180), cos(176*M_PI/180), cos(177*M_PI/180), cos(178*M_PI/180), cos(179*M_PI/180),
+                       cos(180*M_PI/180), cos(181*M_PI/180), cos(182*M_PI/180), cos(183*M_PI/180), cos(184*M_PI/180),
+                       cos(185*M_PI/180), cos(186*M_PI/180), cos(187*M_PI/180), cos(188*M_PI/180), cos(189*M_PI/180),
+                       cos(190*M_PI/180), cos(191*M_PI/180), cos(192*M_PI/180), cos(193*M_PI/180), cos(194*M_PI/180),
+                       cos(195*M_PI/180), cos(196*M_PI/180), cos(197*M_PI/180), cos(198*M_PI/180), cos(199*M_PI/180),
+                       cos(200*M_PI/180), cos(201*M_PI/180), cos(202*M_PI/180), cos(203*M_PI/180), cos(204*M_PI/180),
+                       cos(205*M_PI/180), cos(206*M_PI/180), cos(207*M_PI/180), cos(208*M_PI/180), cos(209*M_PI/180),
+                       cos(210*M_PI/180), cos(211*M_PI/180), cos(212*M_PI/180), cos(213*M_PI/180), cos(214*M_PI/180),
+                       cos(215*M_PI/180), cos(216*M_PI/180), cos(217*M_PI/180), cos(218*M_PI/180), cos(219*M_PI/180),
+                       cos(220*M_PI/180), cos(221*M_PI/180), cos(222*M_PI/180), cos(223*M_PI/180), cos(224*M_PI/180),
+                       cos(225*M_PI/180), cos(226*M_PI/180), cos(227*M_PI/180), cos(228*M_PI/180), cos(229*M_PI/180),
+                       cos(230*M_PI/180), cos(231*M_PI/180), cos(232*M_PI/180), cos(233*M_PI/180), cos(234*M_PI/180),
+                       cos(235*M_PI/180), cos(236*M_PI/180), cos(237*M_PI/180), cos(238*M_PI/180), cos(239*M_PI/180),
+                       cos(240*M_PI/180), cos(241*M_PI/180), cos(242*M_PI/180), cos(243*M_PI/180), cos(244*M_PI/180),
+                       cos(245*M_PI/180), cos(246*M_PI/180), cos(247*M_PI/180), cos(248*M_PI/180), cos(249*M_PI/180),
+                       cos(250*M_PI/180), cos(251*M_PI/180), cos(252*M_PI/180), cos(253*M_PI/180), cos(254*M_PI/180),
+                       cos(255*M_PI/180), cos(256*M_PI/180), cos(257*M_PI/180), cos(258*M_PI/180), cos(259*M_PI/180),
+                       cos(260*M_PI/180), cos(261*M_PI/180), cos(262*M_PI/180), cos(263*M_PI/180), cos(264*M_PI/180),
+                       cos(265*M_PI/180), cos(266*M_PI/180), cos(267*M_PI/180), cos(268*M_PI/180), cos(269*M_PI/180),
+                       cos(270*M_PI/180), cos(271*M_PI/180), cos(272*M_PI/180), cos(273*M_PI/180), cos(274*M_PI/180),
+                       cos(275*M_PI/180), cos(276*M_PI/180), cos(277*M_PI/180), cos(278*M_PI/180), cos(279*M_PI/180),
+                       cos(280*M_PI/180), cos(281*M_PI/180), cos(282*M_PI/180), cos(283*M_PI/180), cos(284*M_PI/180),
+                       cos(285*M_PI/180), cos(286*M_PI/180), cos(287*M_PI/180), cos(288*M_PI/180), cos(289*M_PI/180),
+                       cos(290*M_PI/180), cos(291*M_PI/180), cos(292*M_PI/180), cos(293*M_PI/180), cos(294*M_PI/180),
+                       cos(295*M_PI/180), cos(296*M_PI/180), cos(297*M_PI/180), cos(298*M_PI/180), cos(299*M_PI/180),
+                       cos(300*M_PI/180), cos(301*M_PI/180), cos(302*M_PI/180), cos(303*M_PI/180), cos(304*M_PI/180),
+                       cos(305*M_PI/180), cos(306*M_PI/180), cos(307*M_PI/180), cos(308*M_PI/180), cos(309*M_PI/180),
+                       cos(310*M_PI/180), cos(311*M_PI/180), cos(312*M_PI/180), cos(313*M_PI/180), cos(314*M_PI/180),
+                       cos(315*M_PI/180), cos(316*M_PI/180), cos(317*M_PI/180), cos(318*M_PI/180), cos(319*M_PI/180),
+                       cos(320*M_PI/180), cos(321*M_PI/180), cos(322*M_PI/180), cos(323*M_PI/180), cos(324*M_PI/180),
+                       cos(325*M_PI/180), cos(326*M_PI/180), cos(327*M_PI/180), cos(328*M_PI/180), cos(329*M_PI/180),
+                       cos(330*M_PI/180), cos(331*M_PI/180), cos(332*M_PI/180), cos(333*M_PI/180), cos(334*M_PI/180),
+                       cos(335*M_PI/180), cos(336*M_PI/180), cos(337*M_PI/180), cos(338*M_PI/180), cos(339*M_PI/180),
+                       cos(340*M_PI/180), cos(341*M_PI/180), cos(342*M_PI/180), cos(343*M_PI/180), cos(344*M_PI/180),
+                       cos(345*M_PI/180), cos(346*M_PI/180), cos(347*M_PI/180), cos(348*M_PI/180), cos(349*M_PI/180),
+                       cos(350*M_PI/180), cos(351*M_PI/180), cos(352*M_PI/180), cos(353*M_PI/180), cos(354*M_PI/180),
+                       cos(355*M_PI/180), cos(356*M_PI/180), cos(357*M_PI/180), cos(358*M_PI/180), cos(359*M_PI/180)};

+#ifndef __sin_cos_h__
+#define __sin_cos_h__
+extern const double SIN[360];
+extern const double COS[360];
+#endif // __sin_cos_h__

+/**
+ * \file rasterize.cpp
+ *
+ * \brief Implementation des Software-Rasterizers
+ *
+ * Für eine detailierte Beschreibung von Rasterizer und
+ * Software-Rasterizer schauen Sie bitte unter \ref rasterize.h
+ * 
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 [gs]: erste funktionierende Implementation
+ * \version 04.12.2003 [gs]: beginn der Dokumentation via doxygen
+ * \version 16.12.2003 [gs]: <ul><li>
+ *                           Linienclipping gefixed. Die alte
+ *                           Version versuchte Linien zu zeichnen
+ *                           die sich nach dem Clipping in 
+ *                           Area 1001, 1010, 0101, 0110, also den
+ *                           Ecken rechtoben, linksoben, 
+ *                           rechtsunten und linksunten neben dem
+ *                           darstellbaren Bereich befanden.
+ *                           </li><li>
+ *                           Außerdum mussten nach jedem Clipping
+ *                           die Masken aktualisiert werden, damit
+ *                           der Algoritmus abbricht wenn die 
+ *                           Linie gezeichnet werden kann.
+ *                           Ansosnten führte weiters clipping zu
+ *                           fehlerhaften Ergebnissen.
+ *                           </li><li>
+ *                           draw_polygon_flat ruft jetzt den in
+ *                           polygon.h neu geschriebene 
+ *                           Sutherland-Hodgen Clipper auf und
+ *                           zeichnet nur das geclippte Polygon
+ *                           das dieser Zurückliefert.
+ *                           </li></ul>
+ * \version 19.12.2003 [gs]: <ul><li>
+ *                           draw_polyeder_wire neu geschrieben. (Der
+ *                           alte Code existiert noch auskommentiert.
+ *                           </li><li>
+ *                           draw_polygon_wire geschrieben. Es macht was man
+ *                           sich denkt, es zeichnte ein Polygon alse linien.
+ *                           </li></ul>
+ *
+ * \todo (siehe \ref draw_polygon_flat)
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+using namespace std;
+
+#include <cstdlib>
+#include <climits>
+#include <cstring>
+#include <values.h>
+
+#include <iostream>
+
+#include "geometry/polygon.h"
+#include "rasterize.h"
+
+#define CLIP_MASK_LEFT   (0x1<<0)
+#define CLIP_MASK_RIGHT  (0x1<<1)
+#define CLIP_MASK_BOTTOM (0x1<<2)
+#define CLIP_MASK_TOP    (0x1<<3)
+
+rasterizer::rasterizer(unsigned xs, unsigned ys, canvas_imp* ci) {
+    x_size=xs;
+    y_size=ys;
+
+    sinfo=ci;
+
+    zbuf=new (double*)[xs];
+    for(unsigned i=0; i<xs; i++) {
+       zbuf[i]=new double[ys];
+       for(unsigned j=0; j<ys; zbuf[i][j++]=MAXDOUBLE);
+    }
+
+    unsigned sp[]={0,1,2,3};
+    vertex v[]={vertex(0,y_size,0,1),
+                vertex(0,0,0,1),
+                vertex(x_size,0,0,1),
+                vertex(x_size,y_size,0,1)};
+
+    screen_p_vl=vertex_list(v, 4);
+    screen_p=polygon((unsigned*)sp, 4, &screen_p_vl);
+}
+
+unsigned char* sw_rasterizer::adr_of_point(unsigned x, unsigned y) const {
+    return sinfo->p_screenbuf + (x+(y*x_size))*sinfo->bytes_per_pixel;
+}
+
+void sw_rasterizer::draw_point_at_paddress(unsigned char** p, 
+                                           unsigned long col) const {
+    unsigned long mask = 0xFF;
+    char shift = 0;
+
+    // farbytes in Little-Endian order in den Puffer
+    for(int i=0; i<sinfo->bytes_per_pixel; i++) {
+        **p = (col & mask) >> shift;
+        (*p)++;
+        mask <<= 8;
+        shift += 8;
+    }
+}
+
+void sw_rasterizer::clear_buffer(void) const {
+    memset(sinfo->p_screenbuf, 0x00, 
+           (size_t)x_size*y_size*sinfo->bytes_per_pixel);
+
+    for(unsigned i=0; i<x_size; i++) {
+       for(unsigned j=0; j<y_size; zbuf[i][j++]=MAXDOUBLE);
+    }
+}
+
+void sw_rasterizer::draw_point(unsigned x, unsigned y, 
+                               unsigned long col) const {
+    unsigned char *p = adr_of_point(x, y);
+    draw_point_at_paddress(&p, col);
+}
+
+void sw_rasterizer::line(double ax, double ay, double bx, double by, 
+                         unsigned long col) const {
+    /* Line-Clipping (nach Cohen-Sutherland) */
+    char clip_mask_a=0;
+    char clip_mask_b=0;
+    unsigned x_size=this->x_size-1;
+    unsigned y_size=this->y_size-1;
+
+    if(ax<0)        clip_mask_a |= CLIP_MASK_LEFT;
+    if(ax>x_size)   clip_mask_a |= CLIP_MASK_RIGHT;
+    if(ay>y_size)   clip_mask_a |= CLIP_MASK_BOTTOM;
+    if(ay<0)        clip_mask_a |= CLIP_MASK_TOP;
+
+    if(bx<0)        clip_mask_b |= CLIP_MASK_LEFT;
+    if(bx>x_size)   clip_mask_b |= CLIP_MASK_RIGHT;
+    if(by>y_size)   clip_mask_b |= CLIP_MASK_BOTTOM;
+    if(by<0)        clip_mask_b |= CLIP_MASK_TOP;
+
+    if((clip_mask_a & clip_mask_b) != 0)
+        return;
+
+    double dx=bx-ax;
+    double dy=by-ay;
+    double xinc=dx/dy;
+    double yinc=dy/dx;
+
+    if(clip_mask_a != 0) {
+        if((clip_mask_a&CLIP_MASK_LEFT)!=0) {
+            ay+=(0-ax)*yinc;
+            ax=0;
+        }
+        else if(clip_mask_a & CLIP_MASK_RIGHT) {
+            ay+=(x_size-ax)*yinc;
+            ax=x_size;
+        }
+
+        clip_mask_a=0;
+        if(ax<0)        clip_mask_a |= CLIP_MASK_LEFT;
+        if(ax>x_size)   clip_mask_a |= CLIP_MASK_RIGHT;
+        if(ay>y_size)   clip_mask_a |= CLIP_MASK_BOTTOM;
+        if(ay<0)        clip_mask_a |= CLIP_MASK_TOP;
+
+        if(clip_mask_a & CLIP_MASK_TOP) {
+            ax+=(0-ay)*xinc;
+            ay=0;
+        }
+        else if(clip_mask_a & CLIP_MASK_BOTTOM) {
+            ax+=(y_size-ay)*xinc;
+            ay=y_size;
+        }
+    }
+
+    if(clip_mask_b != 0) {
+        if(clip_mask_b & CLIP_MASK_LEFT) {
+            by+=(0-bx)*yinc;
+            bx=0;
+        }
+        else if(clip_mask_b & CLIP_MASK_RIGHT) {
+            by+=(x_size-bx)*yinc;
+            bx=x_size;
+        }
+
+        clip_mask_b=0;
+        if(bx<0)        clip_mask_b |= CLIP_MASK_LEFT;
+        if(bx>x_size)   clip_mask_b |= CLIP_MASK_RIGHT;
+        if(by>y_size)   clip_mask_b |= CLIP_MASK_BOTTOM;
+        if(by<0)        clip_mask_b |= CLIP_MASK_TOP;
+
+        if(clip_mask_b & CLIP_MASK_TOP) {
+            bx+=(0-by)*xinc;
+            by=0;
+        }
+        else if(clip_mask_b & CLIP_MASK_BOTTOM) {
+            bx+=(y_size-by)*xinc;
+            by=y_size;
+        }
+    }
+
+    clip_mask_a=0;
+    if(ax<0)        clip_mask_a |= CLIP_MASK_LEFT;
+    if(ax>x_size)   clip_mask_a |= CLIP_MASK_RIGHT;
+    if(ay>y_size)   clip_mask_a |= CLIP_MASK_BOTTOM;
+    if(ay<0)        clip_mask_a |= CLIP_MASK_TOP;
+
+    clip_mask_b=0;
+    if(bx<0)        clip_mask_b |= CLIP_MASK_LEFT;
+    if(bx>x_size)   clip_mask_b |= CLIP_MASK_RIGHT;
+    if(by>y_size)   clip_mask_b |= CLIP_MASK_BOTTOM;
+    if(by<0)        clip_mask_b |= CLIP_MASK_TOP;
+
+    if((clip_mask_a | clip_mask_b) == (CLIP_MASK_LEFT | CLIP_MASK_TOP) ||
+       (clip_mask_a | clip_mask_b) == (CLIP_MASK_LEFT | CLIP_MASK_BOTTOM) ||
+       (clip_mask_a | clip_mask_b) == (CLIP_MASK_RIGHT | CLIP_MASK_TOP) ||
+       (clip_mask_a | clip_mask_b) == (CLIP_MASK_RIGHT | CLIP_MASK_BOTTOM))
+        return;
+    /* ----------- */
+
+    /* Linie nach Bresenham */
+    int Ax=(int)ax;
+    int Bx=(int)bx;
+    int Ay=(int)ay;
+    int By=(int)by;
+
+    int dX = abs(Bx-Ax);
+    int dY = abs(By-Ay);
+
+    int Xincr=(Ax > Bx)?-1:1;
+    int Yincr=(Ay > By)?-1:1;
+
+    if (dX >= dY) {           
+        int dPr 	= dY<<1;
+        int dPru 	= dPr - (dX<<1);
+        int P 		= dPr - dX;
+
+        for (; dX>=0; dX--) {
+            draw_point(Ax, Ay, col);
+            if (P > 0) { 
+                Ax+=Xincr;
+                Ay+=Yincr;
+                P+=dPru;
+            }
+            else {
+                Ax+=Xincr;
+                P+=dPr;
+            }
+        }		
+    }
+    else {
+        int dPr 	= dX<<1;
+        int dPru 	= dPr - (dY<<1);
+        int P 		= dPr - dY;
+
+        for (; dY>=0; dY--) {
+            draw_point(Ax, Ay, col);
+            if (P > 0) { 
+                Ax+=Xincr;
+                Ay+=Yincr;
+                P+=dPru;
+            }
+            else {
+                Ay+=Yincr;
+                P+=dPr;
+            }
+        }		
+    }		
+    /*------------------*/
+}
+
+void sw_rasterizer::draw_polygon_wire(const polygon& p, 
+                                      unsigned long col) const {
+   for(unsigned i=0; i<p.card(); i++) {
+      line((int)p[i][X], (int)p[i][Y], 
+           (int)p[(i+1)%p.card()][X], (int)p[(i+1)%p.card()][Y], col);
+   }
+}
+
+void sw_rasterizer::draw_polyeder_wire(const polyeder& p, 
+                                      unsigned long col) const {
+/*    for(unsigned i=0; i<p.card(); i++) {
+        int oldx, oldy;
+        int firstx, firsty;
+
+        oldx=oldy=firstx=firsty=0;
+
+        for(unsigned j=0; j<p[i].card(); j++) {
+            if(oldx)
+                line(oldx, oldy, (int)p[i][j][X], (int)p[i][j][Y], col);
+
+            oldx=(int)p[i][j][X], oldy=(int)p[i][j][Y];
+
+            if(j==0) 
+                firstx=(int)p[i][j][X], firsty=(int)p[i][j][Y];
+        }
+
+        line(oldx, oldy, firstx, firsty, col);
+    }*/
+    for(unsigned i=0; i<p.card(); i++) {
+        for(unsigned j=0; j<p[i].card(); j++) {
+            line((int)p[i][j][X], (int)p[i][j][Y], 
+                 (int)p[i][(j+1)%p.card()][X], 
+                 (int)p[i][(j+1)%p.card()][Y], col);
+        }
+    }
+}
+
+/**
+ * \todo Ein funktionierendes z-buffering und texturemapping usw.
+ *       Aktuell ist ein Prototyp-Code f&uuml;r einen z-Buffer drin,
+ *       aber der funktioniert aus irgendeinem Grund nicht richtig.
+ */
+void sw_rasterizer::draw_polygon_flat(const polygon& p, 
+                                      unsigned long col) const {
+    int top=0, bottom=0, o_top=0;
+    int start_left, end_left;
+    int start_right, end_right;
+
+    /* Clipping..... */
+    /* Sutherland-Hodgman */
+    polygon clipped=p.clip_2d(screen_p);
+
+    // Sind nach dem Clipping weniger als 3 Vertices übrig, so ist das 
+    // Polygon nicht mehr im sichtbaren Bereich und darf nicht gezeichnet
+    // werden.
+    if(clipped.card()<3)
+       return;
+
+    // oberes und unterstes Vertex finden...
+    // außerdem den oberen Vertex fuer die erste rechte und linke Kante
+    for(unsigned i=1; i<clipped.card(); i++) {
+        end_left=end_right=top=(clipped[i][Y]<clipped[top][Y])?i:top;
+        bottom=(clipped[i][Y]>clipped[bottom][Y])?i:bottom;
+    }
+
+    for(unsigned i=1; i<p.card(); i++) {
+        o_top=(p[i][Y]<p[o_top][Y])?i:o_top;
+    }
+
+    // Startpositionen
+    double act_y=clipped[top][Y];
+    int act_ceily=(int)ceil(act_y);
+    double act_x_l, act_x_r;
+    double act_z_l, act_z_r;
+
+    // !!! Das erste mal wenn act_z ermittelt wird muss ich die Verchiebung
+    // auf die Integer Koordinaten (x,y) mit berechnen, da der gezeichnete Punkt
+    // nicht exact dem geometrischen entspricht.
+
+    // calculate gradients (!!!NICHT VOM GECLIPPTEN!!!)
+    // nur anwendbar über Werte die über das gesamte Polygon (screenspace)
+    // linear interpolierbar sind, also nicht gourard-shading, da diese
+    // Werte nur entlang einer Kante linier sind.
+    // !!! Ich brauche eine Methode, ein Dreieck zu finden, das einen Punkt
+    // oben, den zweiten als linke Seite und den dritten als rechte Seite bildet
+    // dazu muss ich die x,y Werte der Puntke analysieren. Die Lage der 
+    // Punkte ist wichtig, damit die Vorzeichen der Gradienten stimmen, bzw.
+    // überhaupt erstmal welche berechnet werden können, es gibt Punkt
+    // kombinationen für die die Gradientenberechnung kein Ergebnis liefert.
+    // Das ermittelte Dreieck lässt sich dann allerdings zur ermittlung aller
+    // Gradienten gebrauchen.
+
+    // den obersten Vertex raussuchen, dann den davor und den danach.
+    // !!!ACHTUNG!!! Bei allen Berechnungen lasse ich im moment einen Fall
+    // ganz außer acht und zwar den, wenn das Dreiech zu einer Linie
+    // entartet.
+    unsigned gr_v0=o_top;
+    unsigned gr_v1=(o_top+1)%p.card();
+    unsigned gr_v2=(o_top-1<0)?o_top-1+p.card():o_top-1;
+
+    // der kleinere X soll gr_v1 sein wenn sein Y größer ist.
+    if((p[gr_v1][X]>p[gr_v2][X] && p[gr_v1][Y]>=p[gr_v2][Y]) ||
+       (p[gr_v1][X]<p[gr_v2][X] && p[gr_v1][Y]<p[gr_v2][Y]))
+       swap<unsigned>(gr_v1, gr_v2);
+
+    double dx21=p[gr_v2][X]-p[gr_v1][X];
+    double dx10=p[gr_v1][X]-p[gr_v0][X];
+    double dy21=p[gr_v2][Y]-p[gr_v1][Y];
+    double dy01=p[gr_v0][Y]-p[gr_v1][Y];
+    double d_z21=p[gr_v2][Z]-p[gr_v1][Z];
+    double d_z10=p[gr_v1][Z]-p[gr_v0][Z];
+
+    double dx01=p[gr_v0][X]-p[gr_v1][X];
+    double dy10=p[gr_v1][Y]-p[gr_v0][Y];
+
+    double v3_x=p[gr_v0][X];
+    double v4_y=p[gr_v0][Y];
+    double v3_y=((dy21*dx01) / dx21) + p[gr_v1][Y];
+    double v3_z=((d_z21*dx01) / dx21) + p[gr_v1][Z];
+    double v4_x=((dx21*dy01) / dy21) + p[gr_v1][X];
+    double v4_z=((d_z21*dy01) / dy21) + p[gr_v1][Z];
+
+    // zuallererst müsste ich mal überprüfen ob alle drei Punkte in 
+    // einer Linie liegen, also dx01/dy01 == dx02/dy02 ist...da ich aber
+    // noch nicht weiss wie ich diesen Fall behandeln soll ignorier ich 
+    // ihn im moment und nehme die entstehenden Fehler in kauf.
+
+    double d_zdx_denominator=0;
+    double d_zdy_denominator=0;
+    double d_zdx, d_zdy;
+    // zuerst dc/dx ermitteln. (einfach wenn y1==y2)
+    // zu den Bezeichnern: _x == 1/x, _? == 1/?
+    if(p[gr_v0][Y] == p[gr_v1][Y])
+       d_zdx=(p[gr_v1][Z]-p[gr_v0][Z]) / (p[gr_v1][X]-p[gr_v0][X]);
+    else if(p[gr_v0][Y] == p[gr_v2][Y])
+       d_zdx=(p[gr_v2][Z]-p[gr_v0][Z]) / (p[gr_v2][X]-p[gr_v0][X]);
+    else if(p[gr_v1][Y] == p[gr_v2][Y])
+       d_zdx=(p[gr_v2][Z]-p[gr_v1][Z]) / (p[gr_v2][X]-p[gr_v1][X]);
+    else {
+       d_zdx_denominator=(dx21*dy01)+(dx10*dy21);
+       d_zdx=((d_z21*dy01)+(d_z10*dy21))/d_zdx_denominator;
+    }
+
+    // jetzt dc/dy...(einfach falls es eine Sekrechte gibt.)
+    if(p[gr_v0][X] == p[gr_v1][X])
+       d_zdy=(p[gr_v1][Z]-p[gr_v0][Z]) / p[gr_v1][Y]-p[gr_v0][Y];
+    else if(p[gr_v0][X] == p[gr_v2][X])
+       d_zdy=(p[gr_v2][Z]-p[gr_v0][Z]) / p[gr_v2][Y]-p[gr_v0][Y];
+    else if(p[gr_v1][X] == p[gr_v2][X])
+       d_zdy=(p[gr_v2][Z]-p[gr_v1][Z]) / p[gr_v2][Y]-p[gr_v1][Y];
+    else {
+       d_zdy_denominator=d_zdx_denominator!=0?-d_zdx_denominator:
+                                              (dy21*dx01)+(dy10*dx21);
+       d_zdy=((d_z21*dx01)+(d_z10*dx21))/d_zdy_denominator;
+    }
+
+/*    if(!strncmp(p.get_id(), "DEBUG", 29)) {
+       cout << "---Polygon: " << &p << "----------\n";
+
+       for(unsigned i=0; i<p.card(); i++) {
+          cout << "p[" << i << "][X]: " << p[i][X] << ", ";
+          cout << "p[" << i << "][Y]: " << p[i][Y] << ", ";
+          cout << "p[" << i << "][1/Z]: " << p[i][Z] << ", ";
+          cout << "p[" << i << "][Z]: " << 1/p[i][Z] << "\n";
+       }
+       for(unsigned i=0; i<clipped.card(); i++) {
+          cout << "clipped[" << i << "][X]: " << clipped[i][X] << ", ";
+          cout << "clipped[" << i << "][Y]: " << clipped[i][Y] << ", ";
+          cout << "clipped[" << i << "][1/Z]: " << clipped[i][Z] << ", ";
+          cout << "clipped[" << i << "][Z]: " << 1/clipped[i][Z] << "\n";
+       }
+       cout << "gr_v0: " << gr_v0 << " | ";
+       cout << "gr_v0[X]: " << p[gr_v0][X] << " | ";
+       cout << "gr_v0[Y]: " << p[gr_v0][Y] << " | ";
+       cout << "gr_v0[Z]: " << p[gr_v0][Z] << "\n";
+       cout << "gr_v1: " << gr_v1 << " | ";
+       cout << "gr_v1[X]: " << p[gr_v1][X] << " | ";
+       cout << "gr_v1[Y]: " << p[gr_v1][Y] << " | ";
+       cout << "gr_v1[Z]: " << p[gr_v1][Z] << "\n";
+       cout << "gr_v2: " << gr_v2 << " | ";
+       cout << "gr_v2[X]: " << p[gr_v2][X] << " | ";
+       cout << "gr_v2[Y]: " << p[gr_v2][Y] << " | ";
+       cout << "gr_v2[Z]: " << p[gr_v2][Z] << "\n";
+       cout << "d_zdx: " << d_zdx << "\n";
+       cout << "d_zdy: " << d_zdy << "\n";
+       cout << "-------------------------------\n";
+    } */
+    
+    //if(!strncmp(p.get_id(), "DEBUG", 29)) {
+    // solange zeichnen, bis der unterste y erreicht ist
+    while(act_ceily < y_size) {
+        double x_inc_l, x_inc_r, z_inc_l, z_inc_r;
+
+        // naechste linke und rechte Kante finden deren hoehe>0 und
+        // das linke und rechte x-Increment ermitteln.
+        if((int)ceil(clipped[end_left][Y]) == act_ceily) {
+            do {
+                start_left=end_left;
+                if(start_left == bottom) {
+                   return;
+                }
+                end_left=(end_left-1<0)?end_left-1+clipped.card():end_left-1;
+            } while((int)ceil(clipped[end_left][Y]) == act_ceily);
+
+            act_y=clipped[start_left][Y];
+            act_ceily=(int)ceil(act_y);
+
+            x_inc_l=(clipped[end_left][X]-clipped[start_left][X])/
+                    (clipped[end_left][Y]-clipped[start_left][Y]);
+            z_inc_l=x_inc_l*d_zdx;
+
+            act_x_l=clipped[start_left][X];
+            // Subpixelkorrektur
+            act_x_l+=((double)act_ceily-act_y)*x_inc_l;
+            act_z_l=clipped[start_left][Z];
+            act_z_l+=((double)act_ceily-act_y)*z_inc_l;
+        }
+        if((int)ceil(clipped[end_right][Y]) == act_ceily) {
+            do {
+                start_right=end_right;
+                if(start_right == bottom) {
+                   return;
+                }
+                end_right=(end_right+1)%clipped.card();
+            } while((int)ceil(clipped[end_right][Y]) == act_ceily);
+
+            act_y=clipped[start_right][Y];
+            act_ceily=(int)ceil(act_y);
+
+            x_inc_r=(clipped[end_right][X]-clipped[start_right][X])/
+                    (clipped[end_right][Y]-clipped[start_right][Y]);
+            z_inc_r=x_inc_r*d_zdx;
+
+            act_x_r=clipped[start_right][X];
+            // Subpixelkorrektur
+            act_x_r+=((double)act_ceily-act_y)*x_inc_r;
+            act_z_r=clipped[start_right][Z];
+            act_z_r+=((double)act_ceily-act_y)*z_inc_r;
+        }
+
+        // bis zu welchem der beiden Vertexe (links o. rechts) muss ich?
+        unsigned togo=((int)ceil(clipped[end_left][Y])-act_ceily <=
+                       (int)ceil(clipped[end_right][Y])-act_ceily)?
+            end_left:end_right;
+
+        for(; act_ceily < (int)ceil(clipped[togo][Y]); act_ceily++) {
+            unsigned char* adr=adr_of_point((act_x_l<act_x_r)?
+                                            (int)ceil(act_x_l):
+                                            (int)ceil(act_x_r), 
+                                            act_ceily);
+
+            unsigned len=abs((int)ceil(act_x_r)-(int)ceil(act_x_l));
+            int _X=(act_x_l<act_x_r)?(int)ceil(act_x_l):(int)ceil(act_x_r);
+
+            //double act_z=(act_x_l<act_x_r)?act_z_l:act_z_r;
+            double act_row_z=(act_x_l<act_x_r)?act_z_l:act_z_r;
+
+            for(unsigned i=0; i<len; i++) {
+                double _Z=1/act_row_z;
+                //if(zbuf[_X+i][act_ceily] > _Z) {
+                   draw_point_at_paddress(&adr, col);
+                   zbuf[_X+i][act_ceily]=_Z;
+                //}
+                // if(!strncmp(p.get_id(), "DEBUG", 29)) {
+                //    printf("%03ld,%03ld,%10.7f ", _X+i, act_ceily, act_row_z);
+                // }
+                act_row_z+=d_zdx;
+            }
+
+            act_x_l+=x_inc_l;
+            act_x_r+=x_inc_r;
+            act_z_l+=z_inc_l;
+            act_z_l+=d_zdy;
+            act_z_r+=z_inc_r;
+            act_z_r+=d_zdy;
+
+            // if(!strncmp(p.get_id(), "DEBUG", 29)) {
+            //    cout << "\n";
+            // }
+        }
+    }
+    //}
+}

+/**
+ * \file rasterize.h
+ *
+ * \brief Methoden um auf ein Canvas zu zeichnen
+ *
+ * Der rasterizer stellt Methoden zur verfügung um auf ein canvas zu
+ * zeichnen. Darunter den Canvas zu leeren, Punkt, Linie, Polygon 
+ * (gefüllt und ungefüllt) und Polyeder zeichnen und die Farbe
+ * eines bestimmten Punktes im Zeichenpuffer ermitteln.
+ * Diese Klasse ist abstrakt. Ein Rasterizer wird immer von einem
+ * Canvas erzeugt werden, damit man einen zu diesem Canvas passenden
+ * Rasteriser hat. Implementiert ist ein Software-Rasterizer zum zeichnen
+ * auf ein X11 oder X11-shm Canvas.
+ *
+ * \author Georg Steffers <georg@steffers.org>
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 (Georg Steffers): erste funktionierende Implementation
+ * \version 04.12.2003 (Georg Steffers): beginn der Dokumentation via doxygen
+ */ 
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __rasterizer_h__
+#define __rasterizer_h__
+
+#include "canvas_imps/canvas_imp.h"
+#include "geometry/polygon.h"
+#include "geometry/polyeder.h"
+
+class rasterizer {
+    protected:
+        unsigned x_size;
+        unsigned y_size;
+
+        canvas_imp* sinfo;
+
+        vertex_list screen_p_vl;
+        polygon screen_p;
+
+        double** zbuf;
+
+    public:
+        rasterizer(unsigned = 0, unsigned = 0, canvas_imp* = NULL);
+
+        virtual void clear_buffer(void) const=0;
+        virtual void draw_point(unsigned x, unsigned y, 
+                                unsigned long col) const=0;
+        virtual void line(double, double, double, double, 
+                          unsigned long) const=0;
+        virtual void draw_polygon_flat(const polygon&, unsigned long) const=0;
+        virtual void draw_polygon_wire(const polygon&, unsigned long) const=0;
+        virtual void draw_polyeder_wire(const polyeder&, unsigned long) const=0;
+        unsigned long get_color(unsigned red, unsigned green, unsigned blue) {
+            return sinfo->ext_to_native(red, green, blue);
+        }
+
+        virtual unsigned get_x_size(void) const { return x_size; }
+        virtual unsigned get_y_size(void) const { return y_size; }
+};
+
+class sw_rasterizer : public rasterizer {
+    private:
+        unsigned char* adr_of_point(unsigned, unsigned) const;
+        void draw_point_at_paddress(unsigned char**, unsigned long) const;
+
+    public:
+        sw_rasterizer(unsigned xs, unsigned ys, canvas_imp* ci) :
+            rasterizer(xs, ys, ci) {}
+
+        void clear_buffer(void) const;
+        void draw_point(unsigned x, unsigned y, unsigned long col) const;
+        void line(double, double, double, double, unsigned long) const;
+        void draw_polygon_flat(const polygon&, unsigned long) const;
+        void draw_polygon_wire(const polygon&, unsigned long) const;
+        void draw_polyeder_wire(const polyeder&, unsigned long) const;
+};
+
+#endif // __rasterize_h__

+#include "math/Mmn.h"
+#include <time.h>
+#include <sys/timeb.h>
+
+int main(void) {
+   double x0=-1, x1=1, y0=0, y1=0;
+   double x0s=-1, x1s=1, y0s=1, y1s=-2;
+   time_t secs;
+   unsigned short ms;
+   struct timeb tb1;
+   struct timeb tb2;
+   int i;
+   double x, y;
+
+   double a[2][3]={{y1-y0, -(x1-x0), -(x1*y0-y1*x0)},
+                   {y1s-y0s, -(x1s-x0s), -(x1s*y0s-y1s*x0s)}};
+   Mmn<double> mat((double*)a, 2, 3);
+
+   mat.print();
+   ftime(&tb1);
+   for(i=0; i<1000; i++)
+      mat.solve();
+   ftime(&tb2);
+
+   cout << tb1.time << ":" << tb1.millitm << "\n";
+   cout << tb2.time << ":" << tb2.millitm << "\n";
+   cout << tb2.time-tb1.time << ":" << tb2.millitm-tb1.millitm << "\n";
+
+   ftime(&tb1);
+   for(i=0; i<1000; i++) {
+      x=x0+((((x1s-x0s)*(y0-y0s))+((y1s-y0s)*(x0s-x0)))/
+                  (((x1-x0)*(y1s-y0s))-((y1-y0)*(x1s-x0s))))*(x1-x0);
+
+      y=y0+((((x1s-x0s)*(y0-y0s))+((y1s-y0s)*(x0s-x0)))/
+                  (((x1-x0)*(y1s-y0s))-((y1-y0)*(x1s-x0s))))*(y1-y0);
+   }
+   ftime(&tb2);
+
+   cout << tb1.time << ":" << tb1.millitm << "\n";
+   cout << tb2.time << ":" << tb2.millitm << "\n";
+   cout << tb2.time-tb1.time << ":" << tb2.millitm-tb1.millitm << "\n";
+
+   /* 
+    * Fazit: nach einigen Testläufen mit diesem Programm hat sich ergeben, das
+    * beide Methoden keine messbaren Zeitunterschied im 1000stel Sekundenbereich
+    + haben, daher faworisiere ich die Methode über das lösen des
+    * Gleichungssystems, da diese universeller (auch mit 3 Geraden) einsetzbar
+    * und auch verständlicher ist (man braucht keine Formeln herleiten.
+    *
+    * Wenn ich die berechnungen 1000 mal ausführe habe die Gleichungen einen
+    * deutlichen vorteil. Daher nehme ich wohl doch sie...
+    */
+   return 0;
+}

+CC=gcc
+CPP=g++
+#CFLAGS=-ggdb
+CXXFLAGS=
+MAKE=make
+
+INC_X11=-I/usr/X11R6/include
+
+OBJECTS=canvas_x11.o canvas_x11_shm.o disp_x11.o xclass.o
+
+%.o: %.cpp
+	$(CPP) $(CFLAGS) $(CXXFLAGS) $(INC_X11) -c $*.cpp
+
+.PHONY : all clean
+
+all: $(OBJECTS)
+
+clean:
+	@rm -f *.o

+using namespace std;
+
+#include <cstdlib>
+
+#include "canvas_x11.h"
+#include "../canvas_imps/canvas_imp_rgb.h"
+
+canvas_x11::canvas_x11(unsigned xs, unsigned ys) : canvas(xs, ys) {
+    disp=new xdisplay();
+    scr=disp->defaultscreen();
+    win=new xwindow(scr->getrootwin(), 100, 100, 1, x_size, y_size);
+    win->map();
+
+    switch(scr->getvisual()->c_class) {
+        XVisualInfo vi;
+        int result;
+
+        case TrueColor:
+            result=XMatchVisualInfo(disp->getdisplay(), disp->defaultscreenid(),
+                                    scr->getdepth(), TrueColor, &vi);
+            if(result)
+                sinfo=new canvas_imp_rgb(scr->getvisual()->red_mask,
+                                         scr->getvisual()->green_mask,
+                                         scr->getvisual()->blue_mask,
+                                         scr->getbytespp(), vi.depth/8);
+            else {
+                exit(EXIT_FAILURE);
+            }
+            break;
+
+        case PseudoColor:
+        case StaticColor:
+        case GrayScale:
+        case StaticGray:
+        case DirectColor:
+            exit(EXIT_FAILURE);
+    }
+
+    sinfo->p_screenbuf=new unsigned char[x_size*y_size*scr->getbytespp()];
+
+    ximg=XCreateImage(disp->getdisplay(), scr->getvisual(), scr->getdepth(),
+                      ZPixmap, 0, (char*)sinfo->p_screenbuf,
+                      x_size, y_size, scr->getscanlinepad(), 0);
+}
+
+canvas_x11::~canvas_x11() {
+    delete sinfo;
+    if(ximg) {
+        XDestroyImage(ximg);
+        ximg=NULL;
+    }
+    delete disp;
+}
+
+void canvas_x11::create_buffer(void) {
+    // wenn ich factorys habe sollte ich irgendwie das buffer erzeugen
+    // auslagern, da ich bei shm den buffer aus dem ximg erzeuge und
+    // ansonsten andersherum, sonst hab ich noch keine rechte idee wie
+    // ich das konsistent bewerkstelligen kann...
+}
+
+void canvas_x11::blit_screen(void) {
+    while(blit != NO_BLIT) {}
+
+    blit=BLIT;
+    XPutImage(disp->getdisplay(), win->getwindow(), scr->getgc(), 
+              ximg, 0,0,0,0, x_size, y_size);
+    blit=NO_BLIT;
+}

+/**
+ * \file canvas_x11.h
+ *
+ * \brief Ein X11-Canvas
+ *
+ * Die X11-Implementaton eines Canvas, hier ist ein XImage der Speicherbereich
+ * in den geschrieben wird.
+ *
+ * \author Georg Steffers <georg@steffers.org> [gs]
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2002 [gs]: erste funktionierende Implementation
+ * \version 04.12.2003 [gs]: beginn der Dokumentation via doxygen
+ * \version 19.12.2003 [gs]: draw_text hinzugefügt, es schreibt &uuml;ber
+ *                           XDrawImageString einen Text in meine
+ *                           Window. (Brauche ich f&uuml;r DEBUG-Ausgaben)
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __canvas_x11_h__
+#define __canvas_x11_h__
+
+#include "xclass.h"
+#include "../canvas.h"
+#include "../event_source.h"
+
+class disp_x11;
+class canvas_x11 : public canvas {
+    friend class disp_x11;
+
+    protected:
+        xdisplay* disp;
+        xscreen* scr;
+        xwindow* win;
+
+        XImage* ximg;
+
+        virtual void create_buffer(void);
+
+    public:
+        virtual void draw_text(int x, int y, char* text, int length) {
+           XDrawImageString(disp->getdisplay(), 
+                            win->getwindow(), 
+                            scr->getgc(),
+                            x, y, text, length);
+        }
+
+        canvas_x11(unsigned, unsigned);
+        virtual ~canvas_x11();
+
+        virtual rasterizer* create_rasterizer(void) {
+            return new sw_rasterizer(x_size, y_size, sinfo);
+        }
+        Display* get_display(void) { return disp->getdisplay(); }
+        Window get_window(void) { return win->getwindow(); }
+        virtual void open_screen(void) {}
+        virtual void blit_screen(void);
+};
+
+class canvas_x11_factory : public canvas_factory {
+    public:
+        canvas* create(unsigned xs, unsigned ys) const {
+            return new canvas_x11(xs, ys);
+        }
+};
+
+#endif // __canvas_x11_h__

+using namespace std;
+
+#include <cstdlib>
+
+#include "canvas_x11_shm.h"
+
+canvas_x11_shm::canvas_x11_shm(unsigned xs, unsigned ys) : 
+                canvas_x11(xs, ys) {
+    XDestroyImage(ximg);
+    //delete [] sinfo->p_screenbuf;
+
+    ximg = XShmCreateImage(disp->getdisplay(), scr->getvisual(),
+                           scr->getdepth(), ZPixmap, 0, &shminfo,
+                           x_size, y_size);
+
+    shminfo.shmid=shmget(IPC_PRIVATE, ximg->bytes_per_line*ximg->height,
+                         IPC_CREAT | 0777);
+
+    if(shminfo.shmid < 0) {
+        XDestroyImage(ximg);
+        ximg=NULL;
+        exit(EXIT_FAILURE);
+    }
+    else {
+        shminfo.shmaddr=ximg->data=(char*)shmat(shminfo.shmid,0,0);
+        if(shminfo.shmaddr == (char*)-1) {
+            XDestroyImage(ximg);
+            ximg=NULL;
+            exit(EXIT_FAILURE);
+        }
+        else {
+            shminfo.readOnly=false;
+            XShmAttach(disp->getdisplay(), &shminfo);
+        }
+    }
+
+    sinfo->p_screenbuf=(unsigned char*)(ximg->data);
+}
+
+canvas_x11_shm::~canvas_x11_shm() {
+    XShmDetach(disp->getdisplay(), &shminfo);
+    if(ximg) {
+        XDestroyImage(ximg);
+        ximg=NULL;
+    }
+    shmdt(shminfo.shmaddr);
+    shmctl(shminfo.shmid, IPC_RMID, NULL);
+}
+
+void canvas_x11_shm::blit_screen(void) {
+    while(blit != NO_BLIT) {}
+
+    blit=BLIT;
+    XShmPutImage(disp->getdisplay(), win->getwindow(), scr->getgc(), 
+                 ximg, 0,0,0,0, x_size, y_size, false);
+    blit=NO_BLIT;
+}

+#ifndef __canvas_x11_shm_h__
+#define __canvas_x11_shm_h__
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XShm.h>
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#include "canvas_x11.h"
+#include "xclass.h"
+
+class canvas_x11_shm : public canvas_x11 {
+    protected:
+        XShmSegmentInfo shminfo;
+
+        virtual void create_buffer(void) {}
+
+    public:
+        canvas_x11_shm(unsigned, unsigned);
+        virtual ~canvas_x11_shm();
+
+        virtual void open_screen(void) {}
+        virtual void blit_screen(void);
+};
+
+class canvas_x11_shm_factory : public canvas_factory {
+    public:
+        canvas* create(unsigned xs, unsigned ys) const {
+            return new canvas_x11_shm(xs, ys);
+        }
+};
+
+#endif // __canvas_x11_shm_h__

+using namespace std;
+
+#include <cstdlib>
+#include <iostream>
+
+#include "disp_x11.h"
+
+void disp_x11::go(void) {
+    XEvent event;
+    char ch;
+    KeySym keysym;
+    bool e_chk;
+
+    canvas_x11* screen=(canvas_x11*)e_src;
+    xwindow* win=screen->win;
+
+    if(!halt_f)
+        e_chk=XCheckWindowEvent(win->getxscr()->getxdisp()->getdisplay(), 
+                                win->getwindow(), KeyPressMask|ExposureMask,
+                                &event);
+    else {
+        e_chk=true;
+        XWindowEvent(win->getxscr()->getxdisp()->getdisplay(), 
+                     win->getwindow(), KeyPressMask|ExposureMask,
+                     &event);
+    }
+    if(e_chk) {
+        switch(event.type) {
+            case KeyPress:
+                XLookupString(&event.xkey, &ch, 1, &keysym, NULL);
+                if(!cb[Key].is_null())
+                    cb[Key](e_src, (void*)&ch);
+                break;
+
+            case Expose:
+                if(event.xexpose.count==0) {
+                    if(!cb[Draw].is_null()) {
+                        //semop(working, &work, 1);
+                        cb[Draw](e_src, (void*)&ch);
+                        //semop(working, &no_work, 1);
+                    }
+                }
+                break;
+        }
+    }
+    else {
+        if(!halt_f) {
+            if(!cb[Idle].is_null()) {
+                //semop(working, &work, 1);
+                cb[Idle](e_src, NULL);
+                //semop(working, &no_work, 1);
+            }
+        }
+    }
+
+    if(!halt_f)
+        XSync(win->getxscr()->getxdisp()->getdisplay(), false);
+}
+
+void disp_x11::trigger_event(event ev) {
+    canvas_x11* screen=(canvas_x11*)e_src;
+    xwindow* win=screen->win;
+
+    switch(ev) {
+        case Draw:
+            XEvent e;
+            e.type = Expose;
+            e.xexpose.send_event = true;
+            e.xexpose.display = win->getxscr()->getxdisp()->getdisplay();
+            e.xexpose.window = win->getwindow();
+            e.xexpose.x = e.xexpose.y = 0;
+            e.xexpose.width = e.xexpose.height = 0;
+            e.xexpose.count = 0;
+
+            XSendEvent(win->getxscr()->getxdisp()->getdisplay(),
+                       win->getwindow(),
+                       true,
+                       ExposureMask,
+                       &e);
+            break;
+
+        case Stop:
+            if(!cb[Stop].is_null())
+                cb[Stop](e_src, NULL);
+    }
+}

+#ifndef __disp_x11_h__
+#define __disp_x11_h__
+
+#include "canvas_x11.h"
+#include "../dispatcher.h"
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+
+class disp_x11 : public dispatcher {
+    private:
+        int working;
+        struct sembuf work;
+        struct sembuf no_work;
+
+    public:
+        canvas_x11* a;
+
+        disp_x11(event_source* w) : dispatcher(w) {
+            working=semget(IPC_PRIVATE, 1, IPC_CREAT);
+            work.sem_num=0;
+            work.sem_op=-1;
+            work.sem_flg=0;
+            no_work.sem_num=0;
+            no_work.sem_op=1;
+            no_work.sem_flg=0;
+        }
+        disp_x11(disp_x11& d) : dispatcher(d) {}
+        ~disp_x11() {
+            semctl(working, 0, IPC_RMID, NULL);
+        }
+
+        void go(void);
+        void trigger_event(event);
+};
+
+class disp_x11_factory : public dispatcher_factory {
+    public:
+        dispatcher* create(event_source* es) const {
+            return new disp_x11(es);
+        }
+};
+
+#endif // __disp_x11__

+using namespace std;
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "xclass.h"
+
+xdisplay::xdisplay(char* name) {
+    if(name) {
+        display_name=new char[strlen(name)+1];
+        strcpy(display_name, name);
+    }
+    else {
+        display_name=NULL;
+    }
+
+    /* Connect to X server */
+    if ((display=XOpenDisplay(display_name)) == NULL)
+        throw noconnect_exception();
+
+    wincount=0;
+    screen_anz=ScreenCount(display);
+    default_screen=DefaultScreen(display);
+    screens=new xscreen*[screen_anz];
+
+    for(int i=0; i<screen_anz; i++) {
+        screens[i]=new xscreen(this, i);
+    }
+
+    font_info=NULL;
+}
+
+xdisplay::xdisplay(const xdisplay& xd) {
+    if(xd.display_name) {
+        display_name=new char[strlen(xd.display_name)+1];
+        strcpy(display_name, xd.display_name);
+    }
+    else {
+        display_name=NULL;
+    }
+
+    display=xd.display;
+    wincount=xd.wincount;
+    screen_anz=xd.screen_anz;
+    default_screen=xd.default_screen;
+    screens=new xscreen*[screen_anz];
+
+    for(int i=0; i<screen_anz; i++) {
+        screens[i]=(xd.screens)[i];
+    }
+
+    font_info=NULL;
+}
+
+xdisplay::~xdisplay() {
+    if(display_name)
+        delete [] display_name;
+
+    // das ueberlass ich dem Destructor von xscreen!
+//    for(int i=0; i<wincount; i++)
+//        delete wins[i];
+//    delete [] wins;
+
+    //for(int i=0; i<screen_anz; i++)
+    //    delete screens[i];
+    //delete [] screens;
+
+    XCloseDisplay(display);
+}
+
+xdisplay& xdisplay::operator=(const xdisplay& xd) {
+    if(xd.display_name) {
+        display_name=new char[strlen(xd.display_name)+1];
+        strcpy(display_name, xd.display_name);
+    }
+    else {
+        display_name=NULL;
+    }
+
+    display=xd.display;
+    wincount=xd.wincount;
+    screen_anz=xd.screen_anz;
+    default_screen=xd.default_screen;
+    screens=new xscreen*[screen_anz];
+
+    for(int i=0; i<screen_anz; i++) {
+        screens[i]=(xd.screens)[i];
+    }
+
+    font_info=NULL;
+
+    return *this;
+}
+
+xscreen* xdisplay::defaultscreen(void) { 
+    return screens[default_screen]; 
+}
+
+void xdisplay::loadfont(char* fname) {
+    /* Load font and get font information structure */
+    if((font_info = XLoadQueryFont(display,fname)) == NULL)
+        throw nofont_exception();
+}
+
+xscreen::xscreen(xdisplay* d, int screen_num) {
+    this->screen_num=screen_num;
+    this->x_disp=d;
+
+    if(screen_num!=-1) {
+        XPixmapFormatValues* pixmap_formats;
+        int count;
+
+        screen=XScreenOfDisplay(d->display, screen_num);
+
+        width=WidthOfScreen(screen);
+        height=HeightOfScreen(screen);
+
+        default_cm=DefaultColormapOfScreen(screen);
+        black_pixel=XBlackPixelOfScreen(screen);
+        white_pixel=XWhitePixelOfScreen(screen);
+
+        rootwin=new xwindow(this); // Ich kann nicht this nehmen, 
+                                   // da das aktuelle Object dem 
+                                   // Array zugewiesen wird und
+                                   // danach weg is.
+
+        vis=DefaultVisual(d->display, 0);
+
+        pixmap_formats=XListPixmapFormats(d->display, &count);
+
+        depth=0;
+        for(int i=0, result=0; i<count; i++) {
+            if(pixmap_formats[i].depth > depth) {
+                // OK, das vi existiert jetzt nur fuer TrueColor, ich muss
+                // noch fuer alle anderen VisualTypes eins einbauen.
+                if(XMatchVisualInfo(d->display, d->default_screen,
+                                    pixmap_formats[i].depth, TrueColor, &vi)) {
+                    depth=pixmap_formats[i].depth;
+                    bytespp=pixmap_formats[i].bits_per_pixel/8;
+                    scanline_pad=pixmap_formats[i].scanline_pad;
+                }
+            }
+        }
+
+        gc=DefaultGC(d->display, d->defaultscreenid());
+    }
+    else {
+        screen=NULL;
+        rootwin=NULL;
+    }
+}
+
+xscreen::xscreen(const xscreen& scr) {
+    x_disp=scr.x_disp;
+    screen_num=scr.screen_num;
+    screen=scr.screen;
+    rootwin=scr.rootwin;
+
+    width=scr.width;
+    height=scr.height;
+    vis=scr.vis;
+
+    memcpy(&vi, &scr.vi, sizeof(XVisualInfo));
+
+    depth=scr.depth;
+    bytespp=scr.bytespp;
+    scanline_pad=scr.scanline_pad;
+
+    memcpy(&gc, &scr.gc, sizeof(GC));
+
+    default_cm=scr.default_cm;
+    black_pixel=scr.black_pixel;
+    white_pixel=scr.white_pixel;
+}
+
+xscreen::~xscreen() {
+    delete rootwin;
+
+    XFreeGC(x_disp->display, gc);
+    XFreeColormap(x_disp->display, default_cm);
+}
+
+xscreen& xscreen::operator=(const xscreen& scr) {
+    x_disp=scr.x_disp;
+    screen_num=scr.screen_num;
+    screen=scr.screen;
+    rootwin=scr.rootwin;
+
+    width=scr.width;
+    height=scr.height;
+    vis=scr.vis;
+
+    memcpy(&vi, &scr.vi, sizeof(XVisualInfo));
+
+    depth=scr.depth;
+    bytespp=scr.bytespp;
+    scanline_pad=scr.scanline_pad;
+
+    memcpy(&gc, &scr.gc, sizeof(GC));
+
+    default_cm=scr.default_cm;
+    black_pixel=scr.black_pixel;
+    white_pixel=scr.white_pixel;
+
+    return *this;
+}
+
+xwindow* xdisplay::getXwinById(Window id) {
+    int i;
+
+    for(i=0; i<wincount; i++)
+        if(wins[i]->window == id)
+            return wins[i];
+
+    return NULL;
+}
+
+xwindow::xwindow(xscreen* xs) {
+    screen=xs;
+    window=XRootWindowOfScreen(xs->screen);
+
+    screen->x_disp->wincount++;
+    xwindow** temp=new xwindow*[screen->x_disp->wincount];
+
+    for(int i=0; i<screen->x_disp->wincount-1; i++)
+        temp[i]=screen->x_disp->wins[i];
+
+    temp[screen->x_disp->wincount-1]=this;
+    delete[] screen->x_disp->wins;
+    screen->x_disp->wins=temp;
+}
+
+xwindow::xwindow(xwindow* win, int x, int y, 
+                 unsigned int bwidth, unsigned int width, 
+                 unsigned int height) {
+    screen=win->screen;
+
+    window=XCreateSimpleWindow(screen->x_disp->display, win->window, 
+                               x, y, width, height, bwidth,
+                               screen->black_pixel, screen->white_pixel);
+
+    screen->x_disp->wincount++;
+    xwindow** temp=new xwindow*[screen->x_disp->wincount];
+
+    for(int i=0; i<screen->x_disp->wincount-1; i++)
+        temp[i]=screen->x_disp->wins[i];
+
+    temp[screen->x_disp->wincount-1]=this;
+    delete[] screen->x_disp->wins;
+    screen->x_disp->wins=temp;
+
+    XSelectInput(screen->x_disp->display, window,
+                 ExposureMask|KeyPressMask|ButtonPressMask|StructureNotifyMask);
+}
+
+xwindow::xwindow(const xwindow& xw) {
+    screen=xw.screen;
+
+    window=xw.window;
+    back=xw.back;
+    swapinfo=xw.swapinfo;
+}
+
+xwindow& xwindow::operator=(const xwindow& xw) {
+    screen=xw.screen;
+
+    window=xw.window;
+    back=xw.back;
+    swapinfo=xw.swapinfo;
+
+    return *this;
+}
+
+// Dies sollte nochmal in mehrere kleinere Methoden zum einstellen der
+// diversen Dinge fuer den WM aufgesplittet werden.
+void xwindow::initWM(void) {
+    XSizeHints* size_hints;     // Informationen fuer WM ueber
+                                // minimale Groessen fuer App
+    XWMHints* wm_hints;         // weiter Infos fuer WM z.B. Icon
+                                // Input/Output initialisierung
+    XClassHint* class_hints;    // noch mehr infos fuer WM
+
+    if (!(size_hints = XAllocSizeHints())) {
+        fprintf(stderr, "failure allocating memory\n");
+        exit(1); //throw exception...
+    }
+    if (!(wm_hints = XAllocWMHints())) {
+        fprintf(stderr, "failure allocating memory\n");
+        exit(1); //throw exception...
+    }
+    if (!(class_hints = XAllocClassHint())) {
+        fprintf(stderr, "failure allocating memory\n");
+        exit(1); //throw exception...
+    }
+
+    size_hints->flags = PPosition | PSize | PMinSize;
+    size_hints->min_width = 300;
+    size_hints->min_height = 200;
+
+    wm_hints->initial_state = NormalState;
+    wm_hints->input = True;
+    // wm_hints->icon_pixmap = icon_pixmap;
+    wm_hints->flags = StateHint | IconPixmapHint | InputHint;
+
+    class_hints->res_name = "jokus"; //screen->x_disp->argv[0];
+    class_hints->res_class = "Basicwin";
+
+//    XSetWMProperties(screen->x_disp->display, window, NULL, NULL, /*&iconName*/
+//                     screen->x_disp->argv, screen->x_disp->argc, size_hints, 
+//                     wm_hints, class_hints);
+    XStoreName(screen->x_disp->display, window, "jokus");
+} 

+/**
+ * \file xclass.h
+ *
+ * \brief Drei Klassen für die zentralen XWindows Objekte.
+ *
+ * Verpackt die drei zentralen Elemente für ein XWindows Programm 
+ * in drei Klassen.
+ * <ul type="circle">
+ *    <li>\ref xdisplay f&uuml;r das display</li>
+ *    <li>\ref xscreen f&uuml;r alle screens</li>
+ *    <li>\ref xwindow f&uuml;r alle windows</li>
+ * </ul>
+ * Dabei ist die Struktur so das zu ein display aus 1-n screens bestehen
+ * In denen dann wiederum jeweils 1-n windows existieren. Es existiert
+ * mindestens das rootwindow.
+ * Alle in dieser Datei definierten Klassen arbeiten sehr eng zusammen,
+ * daher ist jede friend der aller anderen.
+ *
+ * \author Georg Steffers <georg@steffers.org>
+ *
+ * \date 04.12.2003
+ *
+ * \version ..2001 (Georg Steffers): erste implementation
+ * \version 2001-2003 (Georg Steffers): diverse Modifikationen
+ * \version 05.12.2003 (Georg Steffers): beginn der Dokumentation via doxygen
+ */
+
+/* 
+ * Copyright (C)2003 Georg Steffers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __xclass_h__
+#define __xclass_h__
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/Xatom.h>
+#include <X11/keysym.h>
+#include <X11/extensions/Xdbe.h>
+
+class xscreen;
+class xwindow;
+
+/**
+ * \brief Das Display ist die Verbindung zum X-Server
+ *
+ * Verbindung zum X-Server, entwerder &uuml;ber TCP/IP oder 
+ * Unix Domain Sockets. Je nach Server und Hardware auf der dieser
+ * l&auml;ft kann dieser 1-n screens zur verf&uuml;gung stellen.
+ * Es existiert zumindest der \ref default_screen.
+ */
+class xdisplay {
+    friend class xscreen; //!< Da ein xscreen sehr eng mit einem xdisplay
+                          //! zusammenarbeitet
+    friend class xwindow; //!< Da ein xwindow sehr eng mit einem xdisplay
+                          //! zusammenarbeitet
+
+    private:
+        // Exceptionklassen
+        class noconnect_exception {};  //!< no connection to display
+        class nofont_exception {};     //!< no font-file to load
+
+        Display* display;    //!< \brief Der Descriptor f&uuml;r die eigentliche
+                             //! Verbindung zum X-Server
+        char* display_name;  //!< \brief Hardwarename des Displays
+                             //!
+                             //! Wenn display_name NULL ist, so wird f&uuml;r
+                             //! den Hardwarenamen der Wert der in der
+                             //! Environmentvariable \$DISPLAY steht genommen.
+
+        int screen_anz;     //<! Anzahl moeglicher screens dieses Displays
+        int default_screen; //<! default screen dieses Displays
+        xscreen** screens;  //<! Liste aller screens dieses Displays
+
+        int wincount;    //<! Anzahle der existierenden Windows
+        xwindow** wins;  //<! Referenz zu allen Windows
+
+        XFontStruct* font_info; //<! Fontinformationen
+
+    public:
+        xdisplay(char* name=NULL); //!< Defaultkonstruktor
+        xdisplay(const xdisplay&); //!< Copyconstruktor
+        ~xdisplay();               //!< Destruktor
+
+        xdisplay& operator=(const xdisplay&); //!< Zuweisungsoperator
+
+        // Queryfunktionen...
+        Display* getdisplay(void)    { return display; }
+        XFontStruct* getfont(void)   { return font_info; }
+        xwindow* getXwinById(Window id);
+        xscreen* defaultscreen(void);
+        int defaultscreenid(void) { return default_screen; }
+        void loadfont(char* name="9x15");
+};
+
+class xscreen {
+    friend class xwindow;
+    friend class xdisplay;
+
+    private:
+        xdisplay* x_disp;
+
+        int screen_num;
+        Screen* screen;
+        xwindow* rootwin;
+
+        unsigned int width;
+        unsigned int height;
+
+        Visual* vis;
+        XVisualInfo vi;
+
+        int depth;
+        int bytespp;
+        int scanline_pad;
+        GC gc;
+
+        Colormap default_cm;
+        unsigned long black_pixel;
+        unsigned long white_pixel;
+
+    public:
+        xscreen(xdisplay* disp=NULL, int screen_num=-1);
+        xscreen(const xscreen&);
+        ~xscreen();
+
+        xscreen& operator=(const xscreen&);
+
+        // queryfunktionen.....
+        Screen* getscreen(void) { return screen; }
+        int getscreennum(void) {return screen_num; }
+        xdisplay* getxdisp(void) { return x_disp; }
+        Visual* getvisual(void) { return vis; }
+        int getdepth(void) { return depth; }
+        int getbytespp(void) { return bytespp; }
+        int getscanlinepad(void) { return scanline_pad; }
+        GC getgc(void) { return gc; }
+        unsigned getwidth(void) { return width; }
+        unsigned getheight(void) { return height; }
+        xwindow* getrootwin(void) { return rootwin; }
+        Colormap getdefaultcm(void)  { return default_cm; }
+        unsigned long blackpixel(void) { return black_pixel; }
+        unsigned long whitepixel(void) { return white_pixel; }
+        unsigned long getcolor(unsigned short, unsigned short, 
+                               unsigned short);
+};
+
+class xwindow {
+   friend class xscreen;
+   friend class xdisplay;
+
+   private:
+       xscreen* screen;
+
+       Window window;
+       XdbeBackBuffer back;
+       XdbeSwapInfo swapinfo;
+
+   public:
+       xwindow(xwindow*, int, int, unsigned int, 
+               unsigned int, unsigned int); 
+       xwindow(xscreen* screen);
+       xwindow(const xwindow&);
+       xwindow() {
+           screen=NULL;
+       }
+       ~xwindow() {
+           XDestroyWindow(screen->x_disp->display, window);
+       }
+
+       xwindow& operator=(const xwindow&);
+
+       xscreen* getxscr(void) { return screen; }
+       Window getwindow(void) { return window; }
+       void initWM(void);
+       void map(void) { XMapWindow(screen->x_disp->display, window); }
+};
+
+#endif // __xclass_h__