Gennerierung von Treppen hinzugefügt

3DCreator/3DCreator.vcxproj

@@ -161,6 +161,9 @@
   <ItemGroup>
     <ClCompile Include="Start.cpp" />
   </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="EditableObject.h" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

3DCreator/3DCreator.vcxproj.filters

@@ -19,4 +19,9 @@
       <Filter>Quelldateien</Filter>
     </ClCompile>
   </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="EditableObject.h">
+      <Filter>Quelldateien</Filter>
+    </ClInclude>
+  </ItemGroup>
 </Project>

3DCreator/EditableObject.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <Model3D.h>
+
+using namespace Framework;
+
+class EditableObject : public Model3D
+{
+
+};

3DCreator/Start.cpp

@@ -7,11 +7,471 @@
 #include <Kam3D.h>
 #include <Bild.h>
 #include <Rahmen.h>
+#include <Textur.h>
+#include <Model3D.h>
+#include <Model3DList.h>
+#include <DXBuffer.h>
+#include <DateiSystem.h>
+#include <M3Datei.h>
 
 using namespace Framework;
 
+class TreppeOben : 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
+    TreppeOben()
+    {
+        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 + 11 * 24 ];
+        for( int i = 0; i < 48 + 11 * 24; 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 >( -5, -stdSize / 2, -5 ), Vec3< float >( 10, stdSize + 20, 10 ) );
+        float last = -5;
+        for( int i = 0; i < 11; i++ )
+        {
+            float fullRad = PI;
+            float curr = ( fullRad / 10 ) * i;
+            Mat4< float > rotation = Mat4< float >::rotationY( curr );
+            Mat4< float > rotation2 = Mat4< float >::rotationY( fullRad / 10 );
+            Vec3< float > test( stdSize / 2, -stdSize / 2 + i * 10 + 10, 0 );
+            Vec3< float > diff = rotation2 * test;
+            float length = diff.z;
+            Vec3< float > rtf( stdSize / 2, -stdSize / 2 + i * 10 + 20, -diff.z / 2 );
+            Vec3< float > rtb( stdSize / 2, -stdSize / 2 + i * 10 + 20, diff.z / 2 );
+            Vec3< float > rbf( stdSize / 2, -stdSize / 2 + i * 10 + 10, -diff.z / 2 );
+            Vec3< float > rbb( stdSize / 2, -stdSize / 2 + i * 10 + 10, diff.z / 2 );
+            Vec3< float > ltf( 0, -stdSize / 2 + i * 10 + 20, 5 );
+            Vec3< float > ltb( 0, -stdSize / 2 + i * 10 + 20, -5 );
+            Vec3< float > lbf( 0, -stdSize / 2 + i * 10 + 10, 5 );
+            Vec3< float > lbb( 0, -stdSize / 2 + i * 10 + 10, -5 );
+            rtf = rotation * rtf;
+            rtb = rotation * rtb;
+            rbf = rotation * rbf;
+            rbb = rotation * rbb;
+            ltf = rotation * ltf;
+            ltb = rotation * ltb;
+            lbf = rotation * lbf;
+            lbb = rotation * lbb;
+            makeQuader( vertecies, 48 + i * 24, ltf, rtf, lbf, rbf, ltb, rtb, lbb, rbb );
+        }
+        model->setVertecies( vertecies, 48 + 11 * 24 );
+
+        M3Datei dat;
+        dat.setPfad( "3d.m3" );
+        dat.leseDaten();
+        dat.saveModel( model, "treppe" );
+
+        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 TreppeUnten : 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
+    TreppeUnten()
+    {
+        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 + 11 * 24 ];
+        for( int i = 0; i < 48 + 11 * 24; i++ )
+            vertecies[ i ].knochenId = 0;
+        makeQuader( vertecies, 0, Vec3< float >( -stdSize / 2, stdSize / 2 + 10, 0 ), Vec3< float >( stdSize, 10, stdSize / 2 ) );
+        makeQuader( vertecies, 24, Vec3< float >( -5, -stdSize / 2, -5 ), Vec3< float >( 10, stdSize + 20, 10 ) );
+        float last = -5;
+        for( int i = 0; i < 11; i++ )
+        {
+            float fullRad = PI;
+            float curr = ( fullRad / 10 ) * i;
+            Mat4< float > rotation = Mat4< float >::rotationY( curr );
+            Mat4< float > rotation2 = Mat4< float >::rotationY( fullRad / 10 );
+            Vec3< float > test( stdSize / 2, -stdSize / 2 + i * 10 + 10, 0 );
+            Vec3< float > diff = rotation2 * test;
+            float length = diff.z;
+            Vec3< float > rtf( stdSize / 2, -stdSize / 2 + i * 10 + 20, -diff.z / 2 );
+            Vec3< float > rtb( stdSize / 2, -stdSize / 2 + i * 10 + 20, diff.z / 2 );
+            Vec3< float > rbf( stdSize / 2, -stdSize / 2 + i * 10 + 10, -diff.z / 2 );
+            Vec3< float > rbb( stdSize / 2, -stdSize / 2 + i * 10 + 10, diff.z / 2 );
+            Vec3< float > ltf( 0, -stdSize / 2 + i * 10 + 20, 5 );
+            Vec3< float > ltb( 0, -stdSize / 2 + i * 10 + 20, -5 );
+            Vec3< float > lbf( 0, -stdSize / 2 + i * 10 + 10, 5 );
+            Vec3< float > lbb( 0, -stdSize / 2 + i * 10 + 10, -5 );
+            rtf = rotation * rtf;
+            rtb = rotation * rtb;
+            rbf = rotation * rbf;
+            rbb = rotation * rbb;
+            ltf = rotation * ltf;
+            ltb = rotation * ltb;
+            lbf = rotation * lbf;
+            lbb = rotation * lbb;
+            makeQuader( vertecies, 48 + i * 24, ltf, rtf, lbf, rbf, ltb, rtb, lbb, rbb );
+        }
+        model->setVertecies( vertecies, 48 + 11 * 24 );
+
+        M3Datei dat;
+        dat.setPfad( "3d.m3" );
+        dat.leseDaten();
+        dat.saveModel( model, "treppe" );
+
+        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 )
+void schließen( void* p, void* f )
 {
     // Stoppe Nachrichten Loop
     StopNachrichtenSchleife( ( (WFenster*)f )->getFensterHandle() );
@@ -23,7 +483,7 @@ int __stdcall Framework::Start( Startparam p )
     WNDCLASS wc = F_Normal( p.hinst );
     wc.lpszClassName = "3D Creator";
 
-    WFenster *f = new WFenster();
+    WFenster* f = new WFenster();
     f->erstellen( WS_OVERLAPPEDWINDOW, wc );
     f->setVSchließAktion( schließen );
     f->setAnzeigeModus( SW_SHOWNORMAL );
@@ -31,20 +491,28 @@ int __stdcall Framework::Start( Startparam p )
     f->setPosition( Punkt( 100, 100 ) );
 
     // 3D Umgebung erstellen
-    Bildschirm3D *b = new Bildschirm3D( f->getThis() );
+    Bildschirm3D* b = new Bildschirm3D( f->getThis() );
     f->setBildschirm( b->getThis() );
     b->setFillFarbe( 0 );
     b->setTestRend( 0 );
 
-    Welt3D *welt = new Welt3D();
-    Cube *test = new Cube( 10 );
-    Bild b1;
-    b1.neuBild( 100, 100, 0xFF00FF00 );
-    //test->setTextur( b1.getThis() );
+    Welt3D* welt = new Welt3D();
+    TreppeUnten* test = new TreppeUnten();
+    TreppeOben* test2 = new TreppeOben();
+
+    LTDBDatei* assets = new LTDBDatei();
+    assets->setDatei( new Text( "assets.ltdb" ) );
+    assets->leseDaten( 0 );
+    Bild* b1 = assets->laden( 0, new Text( "ground.png" ) );
+    assets->release();
+    test->setTextur( b1->getThis() );
     test->setPosition( 0, 0, 0 );
     welt->addZeichnung( test );
+    test2->setTextur( b1 );
+    test2->setPosition( 150, 0, 0 );
+    welt->addZeichnung( test2 );
 
-    Kam3D *kamA = new Kam3D();
+    Kam3D* kamA = new Kam3D();
     kamA->setBildschirmPosition( 10, 10 );
     kamA->setBildschirmSize( 385, 385 );
     kamA->setPosition( Vec3<float>( -1000, 0, 0 ) );
@@ -52,7 +520,7 @@ int __stdcall Framework::Start( Startparam p )
     kamA->setWelt( welt->getThis() );
     b->addKamera( kamA );
 
-    Kam3D *kamB = new Kam3D();
+    Kam3D* kamB = new Kam3D();
     kamB->setBildschirmPosition( 10, 405 );
     kamB->setBildschirmSize( 385, 385 );
     kamB->setPosition( Vec3<float>( 0, -1000, 0 ) );
@@ -60,7 +528,7 @@ int __stdcall Framework::Start( Startparam p )
     kamB->setWelt( welt->getThis() );
     b->addKamera( kamB );
 
-    Kam3D *kamC = new Kam3D();
+    Kam3D* kamC = new Kam3D();
     kamC->setBildschirmPosition( 405, 10 );
     kamC->setBildschirmSize( 385, 385 );
     kamC->setPosition( Vec3<float>( 0, 0, -1000 ) );
@@ -68,7 +536,7 @@ int __stdcall Framework::Start( Startparam p )
     kamC->setWelt( welt->getThis() );
     b->addKamera( kamC );
 
-    Kam3D *kamD = new Kam3D();
+    Kam3D * kamD = new Kam3D();
     kamD->setStyle( Kam3D::Style::Movable | Kam3D::Style::Rotatable | Kam3D::Style::Tick );
     kamD->setBildschirmPosition( 405, 405 );
     kamD->setBildschirmSize( 385, 385 );
@@ -77,25 +545,25 @@ int __stdcall Framework::Start( Startparam p )
     kamD->setWelt( welt->getThis() );
     b->addKamera( kamD );
 
-    LRahmen *kamAR = new LRahmen();
+    LRahmen * kamAR = new LRahmen();
     kamAR->setPosition( 10, 10 );
     kamAR->setFarbe( 0xFFFFFFFF );
     kamAR->setRamenBreite( 1 );
     kamAR->setSize( 385, 385 );
     b->addMember( kamAR );
-    LRahmen *kamBR = new LRahmen();
+    LRahmen * kamBR = new LRahmen();
     kamBR->setPosition( 404, 10 );
     kamBR->setFarbe( 0xFFFFFFFF );
     kamBR->setRamenBreite( 1 );
     kamBR->setSize( 385, 385 );
     b->addMember( kamBR );
-    LRahmen *kamCR = new LRahmen();
+    LRahmen * kamCR = new LRahmen();
     kamCR->setPosition( 10, 405 );
     kamCR->setFarbe( 0xFFFFFFFF );
     kamCR->setRamenBreite( 1 );
     kamCR->setSize( 385, 385 );
     b->addMember( kamCR );
-    LRahmen *kamDR = new LRahmen();
+    LRahmen * kamDR = new LRahmen();
     kamDR->setPosition( 405, 405 );
     kamDR->setFarbe( 0xFFFFFFFF );
     kamDR->setRamenBreite( 1 );
@@ -103,11 +571,15 @@ int __stdcall Framework::Start( Startparam p )
     b->addMember( kamDR );
 
     // Render Loop starten
-    RenderTh *r = new RenderTh();
+    RenderTh * r = new RenderTh();
     r->setBildschirm( b->getThis() );
-    r->setTickFunktion( [ test, b ]( void *, void *, double t )
+    r->setTickFunktion( [ test, b, kamD ]( void*, void*, double t )
     {
-        test->setDrehung( test->getDrehung() + Vec3<double>( t, t, t ) );
+        //test->setDrehung( test->getDrehung() + Vec3<double>( t, t, t ) );
+        if( Framework::getTastenStand( T_Enter ) )
+        {
+            kamD->setAusrichtung( Vec3<float>( 0, 0, 0 ) );
+        }
     } );
     r->beginn();