Mauern und boden wird genneriert

3DCreator/Start.cpp

@@ -470,6 +470,976 @@ public:
     }
 };
 
+class Mauer : public Model3D
+{
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > ltf, Vec3< float > rtf, Vec3< float > lbf, Vec3< float > rbf, Vec3< float > ltb, Vec3< float > rtb, Vec3< float > lbb, Vec3< float > rbb )
+    {
+        vertecies[ startIndex ].pos = ltf;
+        vertecies[ startIndex ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 1 ].pos = rtf;
+        vertecies[ startIndex + 1 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 2 ].pos = lbf;
+        vertecies[ startIndex + 2 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 3 ].pos = rbf;
+        vertecies[ startIndex + 3 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 4 ].pos = ltb;
+        vertecies[ startIndex + 4 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 5 ].pos = rtb;
+        vertecies[ startIndex + 5 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 6 ].pos = lbb;
+        vertecies[ startIndex + 6 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 7 ].pos = rbb;
+        vertecies[ startIndex + 7 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 8 ].pos = ltf;
+        vertecies[ startIndex + 8 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 9 ].pos = rtf;
+        vertecies[ startIndex + 9 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 10 ].pos = lbf;
+        vertecies[ startIndex + 10 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 11 ].pos = rbf;
+        vertecies[ startIndex + 11 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 12 ].pos = ltb;
+        vertecies[ startIndex + 12 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 13 ].pos = rtb;
+        vertecies[ startIndex + 13 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 14 ].pos = lbb;
+        vertecies[ startIndex + 14 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 15 ].pos = rbb;
+        vertecies[ startIndex + 15 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 16 ].pos = ltf;
+        vertecies[ startIndex + 16 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 17 ].pos = rtf;
+        vertecies[ startIndex + 17 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 18 ].pos = lbf;
+        vertecies[ startIndex + 18 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 19 ].pos = rbf;
+        vertecies[ startIndex + 19 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 20 ].pos = ltb;
+        vertecies[ startIndex + 20 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 21 ].pos = rtb;
+        vertecies[ startIndex + 21 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 22 ].pos = lbb;
+        vertecies[ startIndex + 22 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 23 ].pos = rbb;
+        vertecies[ startIndex + 23 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        // front side
+        Polygon3D* p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0;
+        p->indexList[ 1 ] = startIndex + 2;
+        p->indexList[ 2 ] = startIndex + 3;
+        p->indexList[ 3 ] = startIndex + 0;
+        p->indexList[ 4 ] = startIndex + 3;
+        p->indexList[ 5 ] = startIndex + 1;
+        model->addPolygon( p );
+        // back side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4;
+        p->indexList[ 1 ] = startIndex + 7;
+        p->indexList[ 2 ] = startIndex + 6;
+        p->indexList[ 3 ] = startIndex + 4;
+        p->indexList[ 4 ] = startIndex + 5;
+        p->indexList[ 5 ] = startIndex + 7;
+        model->addPolygon( p );
+        // right side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 1 + 8;
+        p->indexList[ 1 ] = startIndex + 3 + 8;
+        p->indexList[ 2 ] = startIndex + 7 + 8;
+        p->indexList[ 3 ] = startIndex + 1 + 8;
+        p->indexList[ 4 ] = startIndex + 7 + 8;
+        p->indexList[ 5 ] = startIndex + 5 + 8;
+        model->addPolygon( p );
+        // left side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0 + 8;
+        p->indexList[ 1 ] = startIndex + 6 + 8;
+        p->indexList[ 2 ] = startIndex + 2 + 8;
+        p->indexList[ 3 ] = startIndex + 0 + 8;
+        p->indexList[ 4 ] = startIndex + 4 + 8;
+        p->indexList[ 5 ] = startIndex + 6 + 8;
+        model->addPolygon( p );
+        // top side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4 + 16;
+        p->indexList[ 1 ] = startIndex + 0 + 16;
+        p->indexList[ 2 ] = startIndex + 1 + 16;
+        p->indexList[ 3 ] = startIndex + 4 + 16;
+        p->indexList[ 4 ] = startIndex + 1 + 16;
+        p->indexList[ 5 ] = startIndex + 5 + 16;
+        model->addPolygon( p );
+        // down side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 6 + 16;
+        p->indexList[ 1 ] = startIndex + 3 + 16;
+        p->indexList[ 2 ] = startIndex + 2 + 16;
+        p->indexList[ 3 ] = startIndex + 6 + 16;
+        p->indexList[ 4 ] = startIndex + 7 + 16;
+        p->indexList[ 5 ] = startIndex + 3 + 16;
+        model->addPolygon( p );
+    }
+
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > pos, Vec3< float > size )
+    {
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = pos.x;
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = pos.x + size.x;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = pos.y + size.y;
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = pos.y;
+        float front = pos.z + size.z;
+        float back = pos.z;
+
+        makeQuader( vertecies, startIndex, Vec3< float >( left, top, front ), Vec3< float >( right, top, front ), Vec3< float >( left, bottom, front ), Vec3< float >( right, bottom, front ),
+                    Vec3< float >( left, top, back ), Vec3< float >( right, top, back ), Vec3< float >( left, bottom, back ), Vec3< float >( right, bottom, back ) );
+    }
+public:
+    // Konstruktor
+    //  size: Die Größe des Würfels
+    Mauer()
+    {
+        model = new Model3DData();
+        float stdSize = 100;
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = (float)( ( stdSize / 2.0 ) * -1 );
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = left + (float)stdSize;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = (float)( stdSize / 2.0 );
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = top - (float)stdSize;
+        float front = -stdSize / 2;
+        float back = front + stdSize;
+
+        Vertex3D * vertecies = new Vertex3D[ 48 ];
+        for( int i = 0; i < 48; i++ )
+            vertecies[ i ].knochenId = 0;
+        makeQuader( vertecies, 0, Vec3< float >( -stdSize / 2, -stdSize / 2, -stdSize / 2 ), Vec3< float >( stdSize, 10, stdSize ) );
+        makeQuader( vertecies, 24, Vec3< float >( -stdSize / 2, -stdSize / 2, -5 ), Vec3< float >( stdSize, stdSize + 10, 10 ) );
+        model->setVertecies( vertecies, 48 );
+
+        textur = new Model3DTextur();
+    }
+    // Setzt die Textur des Würfels, so dass sie an allen Seiten gleich ist
+    //  textur: Die Textur als Bild
+    void setTextur( Bild * textur )
+    {
+        Textur* t = new Textur();
+        t->setBildZ( textur );
+        int anz = model->getPolygonAnzahl();
+        for( int i = 0; i < anz; i++ )
+            this->textur->setPolygonTextur( i, t->getThis() );
+        t->release();
+        rend = 1;
+    }
+};
+
+class MauerEcke : public Model3D
+{
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > ltf, Vec3< float > rtf, Vec3< float > lbf, Vec3< float > rbf, Vec3< float > ltb, Vec3< float > rtb, Vec3< float > lbb, Vec3< float > rbb )
+    {
+        vertecies[ startIndex ].pos = ltf;
+        vertecies[ startIndex ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 1 ].pos = rtf;
+        vertecies[ startIndex + 1 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 2 ].pos = lbf;
+        vertecies[ startIndex + 2 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 3 ].pos = rbf;
+        vertecies[ startIndex + 3 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 4 ].pos = ltb;
+        vertecies[ startIndex + 4 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 5 ].pos = rtb;
+        vertecies[ startIndex + 5 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 6 ].pos = lbb;
+        vertecies[ startIndex + 6 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 7 ].pos = rbb;
+        vertecies[ startIndex + 7 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 8 ].pos = ltf;
+        vertecies[ startIndex + 8 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 9 ].pos = rtf;
+        vertecies[ startIndex + 9 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 10 ].pos = lbf;
+        vertecies[ startIndex + 10 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 11 ].pos = rbf;
+        vertecies[ startIndex + 11 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 12 ].pos = ltb;
+        vertecies[ startIndex + 12 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 13 ].pos = rtb;
+        vertecies[ startIndex + 13 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 14 ].pos = lbb;
+        vertecies[ startIndex + 14 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 15 ].pos = rbb;
+        vertecies[ startIndex + 15 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 16 ].pos = ltf;
+        vertecies[ startIndex + 16 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 17 ].pos = rtf;
+        vertecies[ startIndex + 17 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 18 ].pos = lbf;
+        vertecies[ startIndex + 18 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 19 ].pos = rbf;
+        vertecies[ startIndex + 19 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 20 ].pos = ltb;
+        vertecies[ startIndex + 20 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 21 ].pos = rtb;
+        vertecies[ startIndex + 21 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 22 ].pos = lbb;
+        vertecies[ startIndex + 22 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 23 ].pos = rbb;
+        vertecies[ startIndex + 23 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        // front side
+        Polygon3D* p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0;
+        p->indexList[ 1 ] = startIndex + 2;
+        p->indexList[ 2 ] = startIndex + 3;
+        p->indexList[ 3 ] = startIndex + 0;
+        p->indexList[ 4 ] = startIndex + 3;
+        p->indexList[ 5 ] = startIndex + 1;
+        model->addPolygon( p );
+        // back side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4;
+        p->indexList[ 1 ] = startIndex + 7;
+        p->indexList[ 2 ] = startIndex + 6;
+        p->indexList[ 3 ] = startIndex + 4;
+        p->indexList[ 4 ] = startIndex + 5;
+        p->indexList[ 5 ] = startIndex + 7;
+        model->addPolygon( p );
+        // right side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 1 + 8;
+        p->indexList[ 1 ] = startIndex + 3 + 8;
+        p->indexList[ 2 ] = startIndex + 7 + 8;
+        p->indexList[ 3 ] = startIndex + 1 + 8;
+        p->indexList[ 4 ] = startIndex + 7 + 8;
+        p->indexList[ 5 ] = startIndex + 5 + 8;
+        model->addPolygon( p );
+        // left side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0 + 8;
+        p->indexList[ 1 ] = startIndex + 6 + 8;
+        p->indexList[ 2 ] = startIndex + 2 + 8;
+        p->indexList[ 3 ] = startIndex + 0 + 8;
+        p->indexList[ 4 ] = startIndex + 4 + 8;
+        p->indexList[ 5 ] = startIndex + 6 + 8;
+        model->addPolygon( p );
+        // top side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4 + 16;
+        p->indexList[ 1 ] = startIndex + 0 + 16;
+        p->indexList[ 2 ] = startIndex + 1 + 16;
+        p->indexList[ 3 ] = startIndex + 4 + 16;
+        p->indexList[ 4 ] = startIndex + 1 + 16;
+        p->indexList[ 5 ] = startIndex + 5 + 16;
+        model->addPolygon( p );
+        // down side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 6 + 16;
+        p->indexList[ 1 ] = startIndex + 3 + 16;
+        p->indexList[ 2 ] = startIndex + 2 + 16;
+        p->indexList[ 3 ] = startIndex + 6 + 16;
+        p->indexList[ 4 ] = startIndex + 7 + 16;
+        p->indexList[ 5 ] = startIndex + 3 + 16;
+        model->addPolygon( p );
+    }
+
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > pos, Vec3< float > size )
+    {
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = pos.x;
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = pos.x + size.x;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = pos.y + size.y;
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = pos.y;
+        float front = pos.z + size.z;
+        float back = pos.z;
+
+        makeQuader( vertecies, startIndex, Vec3< float >( left, top, front ), Vec3< float >( right, top, front ), Vec3< float >( left, bottom, front ), Vec3< float >( right, bottom, front ),
+                    Vec3< float >( left, top, back ), Vec3< float >( right, top, back ), Vec3< float >( left, bottom, back ), Vec3< float >( right, bottom, back ) );
+    }
+public:
+    // Konstruktor
+    //  size: Die Größe des Würfels
+    MauerEcke()
+    {
+        model = new Model3DData();
+        float stdSize = 100;
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = (float)( ( stdSize / 2.0 ) * -1 );
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = left + (float)stdSize;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = (float)( stdSize / 2.0 );
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = top - (float)stdSize;
+        float front = -stdSize / 2;
+        float back = front + stdSize;
+
+        Vertex3D * vertecies = new Vertex3D[ 72 ];
+        for( int i = 0; i < 72; i++ )
+            vertecies[ i ].knochenId = 0;
+        makeQuader( vertecies, 0, Vec3< float >( -stdSize / 2, -stdSize / 2, -stdSize / 2 ), Vec3< float >( stdSize, 10, stdSize ) );
+        makeQuader( vertecies, 24, Vec3< float >( 0, -stdSize / 2, -5 ), Vec3< float >( stdSize / 2, stdSize + 10, 10 ) );
+        makeQuader( vertecies, 48, Vec3< float >( -5, -stdSize / 2, 0 ), Vec3< float >( 10, stdSize + 10, stdSize / 2 ) );
+        model->setVertecies( vertecies, 72 );
+
+        textur = new Model3DTextur();
+    }
+    // Setzt die Textur des Würfels, so dass sie an allen Seiten gleich ist
+    //  textur: Die Textur als Bild
+    void setTextur( Bild * textur )
+    {
+        Textur* t = new Textur();
+        t->setBildZ( textur );
+        int anz = model->getPolygonAnzahl();
+        for( int i = 0; i < anz; i++ )
+            this->textur->setPolygonTextur( i, t->getThis() );
+        t->release();
+        rend = 1;
+    }
+};
+
+class MauerKreuz : public Model3D
+{
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > ltf, Vec3< float > rtf, Vec3< float > lbf, Vec3< float > rbf, Vec3< float > ltb, Vec3< float > rtb, Vec3< float > lbb, Vec3< float > rbb )
+    {
+        vertecies[ startIndex ].pos = ltf;
+        vertecies[ startIndex ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 1 ].pos = rtf;
+        vertecies[ startIndex + 1 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 2 ].pos = lbf;
+        vertecies[ startIndex + 2 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 3 ].pos = rbf;
+        vertecies[ startIndex + 3 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 4 ].pos = ltb;
+        vertecies[ startIndex + 4 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 5 ].pos = rtb;
+        vertecies[ startIndex + 5 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 6 ].pos = lbb;
+        vertecies[ startIndex + 6 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 7 ].pos = rbb;
+        vertecies[ startIndex + 7 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 8 ].pos = ltf;
+        vertecies[ startIndex + 8 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 9 ].pos = rtf;
+        vertecies[ startIndex + 9 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 10 ].pos = lbf;
+        vertecies[ startIndex + 10 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 11 ].pos = rbf;
+        vertecies[ startIndex + 11 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 12 ].pos = ltb;
+        vertecies[ startIndex + 12 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 13 ].pos = rtb;
+        vertecies[ startIndex + 13 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 14 ].pos = lbb;
+        vertecies[ startIndex + 14 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 15 ].pos = rbb;
+        vertecies[ startIndex + 15 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 16 ].pos = ltf;
+        vertecies[ startIndex + 16 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 17 ].pos = rtf;
+        vertecies[ startIndex + 17 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 18 ].pos = lbf;
+        vertecies[ startIndex + 18 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 19 ].pos = rbf;
+        vertecies[ startIndex + 19 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 20 ].pos = ltb;
+        vertecies[ startIndex + 20 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 21 ].pos = rtb;
+        vertecies[ startIndex + 21 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 22 ].pos = lbb;
+        vertecies[ startIndex + 22 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 23 ].pos = rbb;
+        vertecies[ startIndex + 23 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        // front side
+        Polygon3D* p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0;
+        p->indexList[ 1 ] = startIndex + 2;
+        p->indexList[ 2 ] = startIndex + 3;
+        p->indexList[ 3 ] = startIndex + 0;
+        p->indexList[ 4 ] = startIndex + 3;
+        p->indexList[ 5 ] = startIndex + 1;
+        model->addPolygon( p );
+        // back side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4;
+        p->indexList[ 1 ] = startIndex + 7;
+        p->indexList[ 2 ] = startIndex + 6;
+        p->indexList[ 3 ] = startIndex + 4;
+        p->indexList[ 4 ] = startIndex + 5;
+        p->indexList[ 5 ] = startIndex + 7;
+        model->addPolygon( p );
+        // right side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 1 + 8;
+        p->indexList[ 1 ] = startIndex + 3 + 8;
+        p->indexList[ 2 ] = startIndex + 7 + 8;
+        p->indexList[ 3 ] = startIndex + 1 + 8;
+        p->indexList[ 4 ] = startIndex + 7 + 8;
+        p->indexList[ 5 ] = startIndex + 5 + 8;
+        model->addPolygon( p );
+        // left side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0 + 8;
+        p->indexList[ 1 ] = startIndex + 6 + 8;
+        p->indexList[ 2 ] = startIndex + 2 + 8;
+        p->indexList[ 3 ] = startIndex + 0 + 8;
+        p->indexList[ 4 ] = startIndex + 4 + 8;
+        p->indexList[ 5 ] = startIndex + 6 + 8;
+        model->addPolygon( p );
+        // top side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4 + 16;
+        p->indexList[ 1 ] = startIndex + 0 + 16;
+        p->indexList[ 2 ] = startIndex + 1 + 16;
+        p->indexList[ 3 ] = startIndex + 4 + 16;
+        p->indexList[ 4 ] = startIndex + 1 + 16;
+        p->indexList[ 5 ] = startIndex + 5 + 16;
+        model->addPolygon( p );
+        // down side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 6 + 16;
+        p->indexList[ 1 ] = startIndex + 3 + 16;
+        p->indexList[ 2 ] = startIndex + 2 + 16;
+        p->indexList[ 3 ] = startIndex + 6 + 16;
+        p->indexList[ 4 ] = startIndex + 7 + 16;
+        p->indexList[ 5 ] = startIndex + 3 + 16;
+        model->addPolygon( p );
+    }
+
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > pos, Vec3< float > size )
+    {
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = pos.x;
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = pos.x + size.x;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = pos.y + size.y;
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = pos.y;
+        float front = pos.z + size.z;
+        float back = pos.z;
+
+        makeQuader( vertecies, startIndex, Vec3< float >( left, top, front ), Vec3< float >( right, top, front ), Vec3< float >( left, bottom, front ), Vec3< float >( right, bottom, front ),
+                    Vec3< float >( left, top, back ), Vec3< float >( right, top, back ), Vec3< float >( left, bottom, back ), Vec3< float >( right, bottom, back ) );
+    }
+public:
+    // Konstruktor
+    //  size: Die Größe des Würfels
+    MauerKreuz()
+    {
+        model = new Model3DData();
+        float stdSize = 100;
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = (float)( ( stdSize / 2.0 ) * -1 );
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = left + (float)stdSize;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = (float)( stdSize / 2.0 );
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = top - (float)stdSize;
+        float front = -stdSize / 2;
+        float back = front + stdSize;
+
+        Vertex3D * vertecies = new Vertex3D[ 72 ];
+        for( int i = 0; i < 72; i++ )
+            vertecies[ i ].knochenId = 0;
+        makeQuader( vertecies, 0, Vec3< float >( -stdSize / 2, -stdSize / 2, -stdSize / 2 ), Vec3< float >( stdSize, 10, stdSize ) );
+        makeQuader( vertecies, 24, Vec3< float >( -stdSize / 2, -stdSize / 2, -5 ), Vec3< float >( stdSize, stdSize + 10, 10 ) );
+        makeQuader( vertecies, 48, Vec3< float >( -5, -stdSize / 2, -stdSize / 2 ), Vec3< float >( 10, stdSize + 10, stdSize ) );
+        model->setVertecies( vertecies, 72 );
+
+        textur = new Model3DTextur();
+    }
+    // Setzt die Textur des Würfels, so dass sie an allen Seiten gleich ist
+    //  textur: Die Textur als Bild
+    void setTextur( Bild * textur )
+    {
+        Textur* t = new Textur();
+        t->setBildZ( textur );
+        int anz = model->getPolygonAnzahl();
+        for( int i = 0; i < anz; i++ )
+            this->textur->setPolygonTextur( i, t->getThis() );
+        t->release();
+        rend = 1;
+    }
+};
+
+class Boden : public Model3D
+{
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > ltf, Vec3< float > rtf, Vec3< float > lbf, Vec3< float > rbf, Vec3< float > ltb, Vec3< float > rtb, Vec3< float > lbb, Vec3< float > rbb )
+    {
+        vertecies[ startIndex ].pos = ltf;
+        vertecies[ startIndex ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 1 ].pos = rtf;
+        vertecies[ startIndex + 1 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 2 ].pos = lbf;
+        vertecies[ startIndex + 2 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 3 ].pos = rbf;
+        vertecies[ startIndex + 3 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 4 ].pos = ltb;
+        vertecies[ startIndex + 4 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 5 ].pos = rtb;
+        vertecies[ startIndex + 5 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 6 ].pos = lbb;
+        vertecies[ startIndex + 6 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 7 ].pos = rbb;
+        vertecies[ startIndex + 7 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 8 ].pos = ltf;
+        vertecies[ startIndex + 8 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 9 ].pos = rtf;
+        vertecies[ startIndex + 9 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 10 ].pos = lbf;
+        vertecies[ startIndex + 10 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 11 ].pos = rbf;
+        vertecies[ startIndex + 11 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 12 ].pos = ltb;
+        vertecies[ startIndex + 12 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 13 ].pos = rtb;
+        vertecies[ startIndex + 13 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 14 ].pos = lbb;
+        vertecies[ startIndex + 14 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 15 ].pos = rbb;
+        vertecies[ startIndex + 15 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 16 ].pos = ltf;
+        vertecies[ startIndex + 16 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 17 ].pos = rtf;
+        vertecies[ startIndex + 17 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 18 ].pos = lbf;
+        vertecies[ startIndex + 18 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 19 ].pos = rbf;
+        vertecies[ startIndex + 19 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 20 ].pos = ltb;
+        vertecies[ startIndex + 20 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 21 ].pos = rtb;
+        vertecies[ startIndex + 21 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 22 ].pos = lbb;
+        vertecies[ startIndex + 22 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 23 ].pos = rbb;
+        vertecies[ startIndex + 23 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        // front side
+        Polygon3D* p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0;
+        p->indexList[ 1 ] = startIndex + 2;
+        p->indexList[ 2 ] = startIndex + 3;
+        p->indexList[ 3 ] = startIndex + 0;
+        p->indexList[ 4 ] = startIndex + 3;
+        p->indexList[ 5 ] = startIndex + 1;
+        model->addPolygon( p );
+        // back side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4;
+        p->indexList[ 1 ] = startIndex + 7;
+        p->indexList[ 2 ] = startIndex + 6;
+        p->indexList[ 3 ] = startIndex + 4;
+        p->indexList[ 4 ] = startIndex + 5;
+        p->indexList[ 5 ] = startIndex + 7;
+        model->addPolygon( p );
+        // right side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 1 + 8;
+        p->indexList[ 1 ] = startIndex + 3 + 8;
+        p->indexList[ 2 ] = startIndex + 7 + 8;
+        p->indexList[ 3 ] = startIndex + 1 + 8;
+        p->indexList[ 4 ] = startIndex + 7 + 8;
+        p->indexList[ 5 ] = startIndex + 5 + 8;
+        model->addPolygon( p );
+        // left side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0 + 8;
+        p->indexList[ 1 ] = startIndex + 6 + 8;
+        p->indexList[ 2 ] = startIndex + 2 + 8;
+        p->indexList[ 3 ] = startIndex + 0 + 8;
+        p->indexList[ 4 ] = startIndex + 4 + 8;
+        p->indexList[ 5 ] = startIndex + 6 + 8;
+        model->addPolygon( p );
+        // top side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4 + 16;
+        p->indexList[ 1 ] = startIndex + 0 + 16;
+        p->indexList[ 2 ] = startIndex + 1 + 16;
+        p->indexList[ 3 ] = startIndex + 4 + 16;
+        p->indexList[ 4 ] = startIndex + 1 + 16;
+        p->indexList[ 5 ] = startIndex + 5 + 16;
+        model->addPolygon( p );
+        // down side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 6 + 16;
+        p->indexList[ 1 ] = startIndex + 3 + 16;
+        p->indexList[ 2 ] = startIndex + 2 + 16;
+        p->indexList[ 3 ] = startIndex + 6 + 16;
+        p->indexList[ 4 ] = startIndex + 7 + 16;
+        p->indexList[ 5 ] = startIndex + 3 + 16;
+        model->addPolygon( p );
+    }
+
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > pos, Vec3< float > size )
+    {
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = pos.x;
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = pos.x + size.x;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = pos.y + size.y;
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = pos.y;
+        float front = pos.z + size.z;
+        float back = pos.z;
+
+        makeQuader( vertecies, startIndex, Vec3< float >( left, top, front ), Vec3< float >( right, top, front ), Vec3< float >( left, bottom, front ), Vec3< float >( right, bottom, front ),
+                    Vec3< float >( left, top, back ), Vec3< float >( right, top, back ), Vec3< float >( left, bottom, back ), Vec3< float >( right, bottom, back ) );
+    }
+public:
+    // Konstruktor
+    //  size: Die Größe des Würfels
+    Boden()
+    {
+        model = new Model3DData();
+        float stdSize = 100;
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = (float)( ( stdSize / 2.0 ) * -1 );
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = left + (float)stdSize;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = (float)( stdSize / 2.0 );
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = top - (float)stdSize;
+        float front = -stdSize / 2;
+        float back = front + stdSize;
+
+        Vertex3D * vertecies = new Vertex3D[ 24 ];
+        for( int i = 0; i < 24; i++ )
+            vertecies[ i ].knochenId = 0;
+        makeQuader( vertecies, 0, Vec3< float >( -stdSize / 2, -stdSize / 2, -stdSize / 2 ), Vec3< float >( stdSize, 10, stdSize ) );
+        model->setVertecies( vertecies, 24 );
+
+        textur = new Model3DTextur();
+    }
+    // Setzt die Textur des Würfels, so dass sie an allen Seiten gleich ist
+    //  textur: Die Textur als Bild
+    void setTextur( Bild * textur )
+    {
+        Textur* t = new Textur();
+        t->setBildZ( textur );
+        int anz = model->getPolygonAnzahl();
+        for( int i = 0; i < anz; i++ )
+            this->textur->setPolygonTextur( i, t->getThis() );
+        t->release();
+        rend = 1;
+    }
+};
+
+class Held : public Model3D
+{
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > ltf, Vec3< float > rtf, Vec3< float > lbf, Vec3< float > rbf, Vec3< float > ltb, Vec3< float > rtb, Vec3< float > lbb, Vec3< float > rbb )
+    {
+        vertecies[ startIndex ].pos = ltf;
+        vertecies[ startIndex ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 1 ].pos = rtf;
+        vertecies[ startIndex + 1 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 2 ].pos = lbf;
+        vertecies[ startIndex + 2 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 3 ].pos = rbf;
+        vertecies[ startIndex + 3 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 4 ].pos = ltb;
+        vertecies[ startIndex + 4 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 5 ].pos = rtb;
+        vertecies[ startIndex + 5 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 6 ].pos = lbb;
+        vertecies[ startIndex + 6 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 7 ].pos = rbb;
+        vertecies[ startIndex + 7 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 8 ].pos = ltf;
+        vertecies[ startIndex + 8 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 9 ].pos = rtf;
+        vertecies[ startIndex + 9 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 10 ].pos = lbf;
+        vertecies[ startIndex + 10 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 11 ].pos = rbf;
+        vertecies[ startIndex + 11 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 12 ].pos = ltb;
+        vertecies[ startIndex + 12 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 13 ].pos = rtb;
+        vertecies[ startIndex + 13 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 14 ].pos = lbb;
+        vertecies[ startIndex + 14 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 15 ].pos = rbb;
+        vertecies[ startIndex + 15 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        vertecies[ startIndex + 16 ].pos = ltf;
+        vertecies[ startIndex + 16 ].tPos = Vec2< float >( 0.f, 1.f );
+        vertecies[ startIndex + 17 ].pos = rtf;
+        vertecies[ startIndex + 17 ].tPos = Vec2< float >( 1.f, 1.f );
+        vertecies[ startIndex + 18 ].pos = lbf;
+        vertecies[ startIndex + 18 ].tPos = Vec2< float >( 0.f, 0.f );
+        vertecies[ startIndex + 19 ].pos = rbf;
+        vertecies[ startIndex + 19 ].tPos = Vec2< float >( 1.f, 0.f );
+        vertecies[ startIndex + 20 ].pos = ltb;
+        vertecies[ startIndex + 20 ].tPos = Vec2< float >( 0.0f, 0.0f );
+        vertecies[ startIndex + 21 ].pos = rtb;
+        vertecies[ startIndex + 21 ].tPos = Vec2< float >( 1.0f, 0.0f );
+        vertecies[ startIndex + 22 ].pos = lbb;
+        vertecies[ startIndex + 22 ].tPos = Vec2< float >( 0.0f, 1.0f );
+        vertecies[ startIndex + 23 ].pos = rbb;
+        vertecies[ startIndex + 23 ].tPos = Vec2< float >( 1.0f, 1.0f );
+
+        // front side
+        Polygon3D* p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0;
+        p->indexList[ 1 ] = startIndex + 2;
+        p->indexList[ 2 ] = startIndex + 3;
+        p->indexList[ 3 ] = startIndex + 0;
+        p->indexList[ 4 ] = startIndex + 3;
+        p->indexList[ 5 ] = startIndex + 1;
+        model->addPolygon( p );
+        // back side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4;
+        p->indexList[ 1 ] = startIndex + 7;
+        p->indexList[ 2 ] = startIndex + 6;
+        p->indexList[ 3 ] = startIndex + 4;
+        p->indexList[ 4 ] = startIndex + 5;
+        p->indexList[ 5 ] = startIndex + 7;
+        model->addPolygon( p );
+        // right side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 1 + 8;
+        p->indexList[ 1 ] = startIndex + 3 + 8;
+        p->indexList[ 2 ] = startIndex + 7 + 8;
+        p->indexList[ 3 ] = startIndex + 1 + 8;
+        p->indexList[ 4 ] = startIndex + 7 + 8;
+        p->indexList[ 5 ] = startIndex + 5 + 8;
+        model->addPolygon( p );
+        // left side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 0 + 8;
+        p->indexList[ 1 ] = startIndex + 6 + 8;
+        p->indexList[ 2 ] = startIndex + 2 + 8;
+        p->indexList[ 3 ] = startIndex + 0 + 8;
+        p->indexList[ 4 ] = startIndex + 4 + 8;
+        p->indexList[ 5 ] = startIndex + 6 + 8;
+        model->addPolygon( p );
+        // top side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 4 + 16;
+        p->indexList[ 1 ] = startIndex + 0 + 16;
+        p->indexList[ 2 ] = startIndex + 1 + 16;
+        p->indexList[ 3 ] = startIndex + 4 + 16;
+        p->indexList[ 4 ] = startIndex + 1 + 16;
+        p->indexList[ 5 ] = startIndex + 5 + 16;
+        model->addPolygon( p );
+        // down side
+        p = new Polygon3D();
+        p->indexAnz = 6;
+        p->indexList = new int[ p->indexAnz ];
+        p->indexBuffer->setLength( p->indexAnz * 4 );
+        p->indexBuffer->setData( p->indexList );
+        p->indexList[ 0 ] = startIndex + 6 + 16;
+        p->indexList[ 1 ] = startIndex + 3 + 16;
+        p->indexList[ 2 ] = startIndex + 2 + 16;
+        p->indexList[ 3 ] = startIndex + 6 + 16;
+        p->indexList[ 4 ] = startIndex + 7 + 16;
+        p->indexList[ 5 ] = startIndex + 3 + 16;
+        model->addPolygon( p );
+    }
+
+    void makeQuader( Vertex3D* vertecies, int startIndex, Vec3< float > pos, Vec3< float > size )
+    {
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = pos.x;
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = pos.x + size.x;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = pos.y + size.y;
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = pos.y;
+        float front = pos.z + size.z;
+        float back = pos.z;
+
+        makeQuader( vertecies, startIndex, Vec3< float >( left, top, front ), Vec3< float >( right, top, front ), Vec3< float >( left, bottom, front ), Vec3< float >( right, bottom, front ),
+                    Vec3< float >( left, top, back ), Vec3< float >( right, top, back ), Vec3< float >( left, bottom, back ), Vec3< float >( right, bottom, back ) );
+    }
+public:
+    // Konstruktor
+    //  size: Die Größe des Würfels
+    Held()
+    {
+        model = new Model3DData();
+        float stdSize = 100;
+        float left, right, top, bottom;
+        // Calculate the screen coordinates of the left side of the bitmap.
+        left = (float)( ( stdSize / 2.0 ) * -1 );
+        // Calculate the screen coordinates of the right side of the bitmap.
+        right = left + (float)stdSize;
+        // Calculate the screen coordinates of the top of the bitmap.
+        top = (float)( stdSize / 2.0 );
+        // Calculate the screen coordinates of the bottom of the bitmap.
+        bottom = top - (float)stdSize;
+        float front = -stdSize / 2;
+        float back = front + stdSize;
+
+        Vertex3D * vertecies = new Vertex3D[ 24 ];
+        for( int i = 0; i < 24; i++ )
+            vertecies[ i ].knochenId = 0;
+        makeQuader( vertecies, 0, Vec3< float >( -stdSize / 2, -stdSize / 2, -stdSize / 2 ), Vec3< float >( stdSize, 10, stdSize ) );
+        model->setVertecies( vertecies, 24 );
+
+        textur = new Model3DTextur();
+    }
+    // Setzt die Textur des Würfels, so dass sie an allen Seiten gleich ist
+    //  textur: Die Textur als Bild
+    void setTextur( Bild * textur )
+    {
+        Textur* t = new Textur();
+        t->setBildZ( textur );
+        int anz = model->getPolygonAnzahl();
+        for( int i = 0; i < anz; i++ )
+            this->textur->setPolygonTextur( i, t->getThis() );
+        t->release();
+        rend = 1;
+    }
+};
+
 // Aktion beim schließen des Fensters
 void schließen( void* p, void* f )
 {
@@ -498,7 +1468,6 @@ int __stdcall Framework::Start( Startparam p )
 
     Welt3D* welt = new Welt3D();
     TreppeUnten* test = new TreppeUnten();
-    TreppeOben* test2 = new TreppeOben();
 
     LTDBDatei* assets = new LTDBDatei();
     assets->setDatei( new Text( "assets.ltdb" ) );
@@ -508,9 +1477,28 @@ int __stdcall Framework::Start( Startparam p )
     test->setTextur( b1->getThis() );
     test->setPosition( 0, 0, 0 );
     welt->addZeichnung( test );
-    test2->setTextur( b1 );
+    TreppeOben* test2 = new TreppeOben();
+    test2->setTextur( b1->getThis() );
     test2->setPosition( 150, 0, 0 );
     welt->addZeichnung( test2 );
+    Mauer* test3 = new Mauer();
+    test3->setTextur( b1->getThis() );
+    test3->setPosition( 150, 0, 150 );
+    welt->addZeichnung( test3 );
+    MauerEcke* test4 = new MauerEcke();
+    test4->setTextur( b1->getThis() );
+    test4->setPosition( -150, 0, 0 );
+    welt->addZeichnung( test4 );
+    MauerKreuz* test5 = new MauerKreuz();
+    test5->setTextur( b1->getThis() );
+    test5->setPosition( 0, 0, 150 );
+    welt->addZeichnung( test5 );
+    Boden* test6 = new Boden();
+    test6->setTextur( b1->getThis() );
+    test6->setPosition( -150, 0, 150 );
+    welt->addZeichnung( test6 );
+
+    b1->release();
 
     Kam3D* kamA = new Kam3D();
     kamA->setBildschirmPosition( 10, 10 );