Erster Fersuch

Bildschirm.cpp

@@ -21,6 +21,8 @@
 #include "DXBuffer.h"
 #include "Model3D.h"
 #include "Textur.h"
+#include "TexturModel.h"
+#include "TexturList.h"
 #include <d3d11.h>
 #include <d3d9.h>
 
@@ -507,8 +509,6 @@ Bildschirm3D::Bildschirm3D( WFenster *fenster )
     d3d11Context( 0 ),
     d3d11SpawChain( 0 ),
     frameworkTextur( 0 ),
-    vertexBuffer( 0 ),
-    indexBuffer( 0 ),
     vertexShader( 0 ),
     pixelShader( 0 ),
     sampleState( 0 ),
@@ -521,7 +521,8 @@ Bildschirm3D::Bildschirm3D( WFenster *fenster )
     kameras( new RCArray< Kam3D >() ),
     rend3D( 0 ),
     vp( 0 ),
-    renderObj( new Render3D() )
+    renderObj( new Render3D() ),
+    texturModel( new TexturModel() )
 {}
 
 // Destruktor 
@@ -529,6 +530,7 @@ Bildschirm3D::~Bildschirm3D()
 {
     kameras->release();
     renderObj->release();
+    texturModel->release();
     cleanUpDirectX();
 }
 
@@ -555,16 +557,6 @@ void Bildschirm3D::cleanUpDirectX()
         frameworkTextur->release();
         frameworkTextur = NULL;
     }
-    if( vertexBuffer )
-    {
-        vertexBuffer->release();
-        vertexBuffer = NULL;
-    }
-    if( indexBuffer )
-    {
-        indexBuffer->release();
-        indexBuffer = NULL;
-    }
     if( pixelShader )
     {
         pixelShader->release();
@@ -770,7 +762,7 @@ void Bildschirm3D::update() // aktualisiert directX
     D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
     // Clear the second depth stencil state before setting the parameters.
     ZeroMemory( &depthDisabledStencilDesc, sizeof( depthDisabledStencilDesc ) );
-    
+
     // Now create a second depth stencil state which turns off the Z buffer for 2D rendering.  The only difference is 
     // that DepthEnable is set to false, all other parameters are the same as the other depth stencil state.
     depthDisabledStencilDesc.DepthEnable = false;
@@ -787,7 +779,7 @@ void Bildschirm3D::update() // aktualisiert directX
     depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
     depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
     depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
-    
+
     // Create the state using the device.
     result = d3d11Device->CreateDepthStencilState( &depthDisabledStencilDesc, &depthDisabledStencilState );
 
@@ -804,7 +796,7 @@ void Bildschirm3D::update() // aktualisiert directX
     pixelShader->setShaderCode( &shader );
     pixelShader->compile( d3d11Device, "TexturePixelShader", "5_0" );
 
-    D3D11_INPUT_ELEMENT_DESC polygonLayout[ 2 ];
+    D3D11_INPUT_ELEMENT_DESC polygonLayout[ 3 ];
     // Create the vertex input layout description.
     // This setup needs to match the VertexType stucture in the ModelClass and in the shader.
     polygonLayout[ 0 ].SemanticName = "POSITION";
@@ -823,8 +815,16 @@ void Bildschirm3D::update() // aktualisiert directX
     polygonLayout[ 1 ].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
     polygonLayout[ 1 ].InstanceDataStepRate = 0;
 
-    vertexShader->erstelleInputLayout( d3d11Device, polygonLayout, 2 );
-    vertexShader->erstelleConstBuffer( d3d11Device, sizeof( Mat4< float > ) * 3, 0 );
+    polygonLayout[ 2 ].SemanticName = "KNOCHEN_ID";
+    polygonLayout[ 2 ].SemanticIndex = 0;
+    polygonLayout[ 2 ].Format = DXGI_FORMAT_R32_UINT;
+    polygonLayout[ 2 ].InputSlot = 0;
+    polygonLayout[ 2 ].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
+    polygonLayout[ 2 ].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+    polygonLayout[ 2 ].InstanceDataStepRate = 0;
+
+    vertexShader->erstelleInputLayout( d3d11Device, polygonLayout, 3 );
+    vertexShader->erstelleConstBuffer( d3d11Device, sizeof( Mat4< float > ) * 128, 0 );
 
     // Create a texture sampler state description.
     D3D11_SAMPLER_DESC samplerDesc;
@@ -848,60 +848,12 @@ void Bildschirm3D::update() // aktualisiert directX
     //---------------------------------------------------------------
     // Framework Backbuffer Texture
 
-
-    unsigned long indices[ 6 ];
-    Vertex3D vertices[ 6 ];
-
-    // Load the index array with data.
-    for( int i = 0; i < 6; i++ )
-    {
-        indices[ i ] = i;
-    }
-    vertexBuffer = new DXVertexBuffer( sizeof( Vertex3D ) );
-    vertexBuffer->setLänge( sizeof( vertices ) );
-    vertexBuffer->setData( vertices );
-
-    indexBuffer = new DXIndexBuffer( sizeof( int ) );
-    indexBuffer->setLänge( sizeof( int ) * 6 );
-    indexBuffer->setData( indices );
-
     frameworkTextur = new Textur();
     frameworkTextur->setBildZ( renderB->getThis() );
+    texturRegister->addTextur( frameworkTextur->getThis(), "f_Render_Bild" );
 
-    float left, right, top, bottom;
-    // Calculate the screen coordinates of the left side of the bitmap.
-    left = (float)( ( backBufferGröße.x / 2.0 ) * -1 );
-
-    // Calculate the screen coordinates of the right side of the bitmap.
-    right = left + (float)backBufferGröße.x;
-
-    // Calculate the screen coordinates of the top of the bitmap.
-    top = (float)( backBufferGröße.y / 2.0 );
-
-    // Calculate the screen coordinates of the bottom of the bitmap.
-    bottom = top - (float)backBufferGröße.y;
-
-    // Load the vertex array with data.
-    // First triangle.
-    vertices[ 0 ].pos = Vec3< float >( left, top, 0.0f );  // Top left.
-    vertices[ 0 ].tPos = Vec2< float >( 0.0f, 0.0f );
-
-    vertices[ 1 ].pos = Vec3< float >( right, bottom, 0.0f );  // Bottom right.
-    vertices[ 1 ].tPos = Vec2< float >( 1.0f, 1.0f );
-
-    vertices[ 2 ].pos = Vec3< float >( left, bottom, 0.0f );  // Bottom left.
-    vertices[ 2 ].tPos = Vec2< float >( 0.0f, 1.0f );
-
-    // Second triangle.
-    vertices[ 3 ].pos = Vec3< float >( left, top, 0.0f );  // Top left.
-    vertices[ 3 ].tPos = Vec2< float >( 0.0f, 0.0f );
-
-    vertices[ 4 ].pos = Vec3< float >( right, top, 0.0f );  // Top right.
-    vertices[ 4 ].tPos = Vec2< float >( 1.0f, 0.0f );
-
-    vertices[ 5 ].pos = Vec3< float >( right, bottom, 0.0f );  // Bottom right.
-    vertices[ 5 ].tPos = Vec2< float >( 1.0f, 1.0f );
-
+    texturModel->setGröße( backBufferGröße );
+    texturModel->setTextur( frameworkTextur->getId() );
 
     D3D11_BLEND_DESC blendState;
     ZeroMemory( &blendState, sizeof( D3D11_BLEND_DESC ) );
@@ -932,9 +884,6 @@ void Bildschirm3D::update() // aktualisiert directX
     d3d11Context->PSSetSamplers( 0, 1, &sampleState );
     renderObj->benutzeShader( PIXEL, pixelShader->getThis() );
 
-    vertexBuffer->copieren( renderObj );
-    indexBuffer->copieren( renderObj );
-
     rend = 1;
     unlock();
 }
@@ -945,6 +894,7 @@ void Bildschirm3D::tick( double tickval )
     __super::tick( tickval );
     for( auto i = kameras->getArray(); i.set; i++ )
         rend3D |= i.var->tick( tickval );
+    rend3D |= texturModel->tick( tickval );
     unlock();
 }
 
@@ -1033,11 +983,10 @@ void Bildschirm3D::render() // Zeichnet das Bild
 
         d3d11Context->RSSetViewports( 1, vp );
 
-        Mat4< float > welt = welt.identity();
         float screenAspect = (float)backBufferGröße.x / (float)backBufferGröße.y;
-        renderObj->setKameraMatrix( welt.translation( Vec3< float >( 0.f, 0.f, backBufferGröße.y * 1.2075f ) ), welt.projektion( DirectX::XM_PI / 4.0f, screenAspect, 0.1f, 10000.f ), Vec3< float >( 0.f, 0.f, backBufferGröße.y * 1.2075f ) );
-        renderObj->beginnModel( welt, vertexBuffer, -1 );
-        renderObj->draw( indexBuffer, frameworkTextur );
+        Mat4< float > view = view.translation( Vec3< float >( 0.f, 0.f, backBufferGröße.y * 1.2075f ) );
+        renderObj->setKameraMatrix( view, view.projektion( DirectX::XM_PI / 4.0f, screenAspect, 0.1f, 10000.f ), Vec3< float >( 0.f, 0.f, backBufferGröße.y * 1.2075f ) );
+        texturModel->render( renderObj );
 
         result = d3d11SpawChain->Present( 0, 0 );
         renderZeit->messungEnde();

Bildschirm.h

@@ -46,6 +46,7 @@ namespace Framework
     class DXVertexBuffer; // DXBuffer.h
     class DXIndexBuffer; // DXBuffer.h
     class Textur; // Textur.h
+    class TexturModel; // TexturModel.h
 
     struct Monitor
     {
@@ -146,8 +147,6 @@ namespace Framework
         ID3D11Device *d3d11Device;
         ID3D11DeviceContext *d3d11Context;
         IDXGISwapChain *d3d11SpawChain;
-        DXVertexBuffer *vertexBuffer;
-        DXIndexBuffer *indexBuffer;
         Textur *frameworkTextur;
         ID3D11SamplerState* sampleState;
         ID3D11RenderTargetView *rtview;
@@ -161,6 +160,7 @@ namespace Framework
         VertexShader *vertexShader;
         Render3D *renderObj;
         D3D11_VIEWPORT *vp;
+        TexturModel *texturModel;
         bool rend3D;
 
         void cleanUpDirectX();

Cube.cpp

@@ -14,9 +14,6 @@ using namespace Framework;
 Cube::Cube( float size )
     : Model3D()
 {
-    for( int i = 0; i < 6; i++ )
-        texturUpdate[ i ] = 0;
-
     if( m3dRegister->hatModel( Standart3DTypes::würfel ) )
         model = m3dRegister->getModel( Standart3DTypes::würfel );
     else
@@ -173,11 +170,6 @@ Cube::Cube( float size )
     textur = new Model3DTextur();
 }
 
-// Destruktor
-Cube::~Cube()
-{
-}
-
 // Setzt die Textur des Würfels, so dass sie an allen Seiten gleich ist
 //  textur: Die Textur als Bild
 void Cube::setTextur( Bild *textur )
@@ -190,8 +182,6 @@ void Cube::setTextur( Bild *textur )
     this->textur->setPolygonTextur( UNTEN, t->getThis() );
     this->textur->setPolygonTextur( VORNE, t->getThis() );
     this->textur->setPolygonTextur( HINTEN, t );
-    for( int i = 0; i < 6; i++ )
-        texturUpdate[ i ] = 1;
     rend = 1;
 }
 
@@ -208,8 +198,6 @@ void Cube::setTextur( int id )
     this->textur->setPolygonTextur( UNTEN, t->getThis() );
     this->textur->setPolygonTextur( VORNE, t->getThis() );
     this->textur->setPolygonTextur( HINTEN, t );
-    for( int i = 0; i < 6; i++ )
-        texturUpdate[ i ] = 1;
     rend = 1;
 }
 
@@ -221,7 +209,6 @@ void Cube::setTextur( Bild *textur, CubeSeite s )
     Textur *t = new Textur();
     t->setBildZ( textur );
     this->textur->setPolygonTextur( s, t );
-    texturUpdate[ s ] = 1;
     rend = 1;
 }
 
@@ -234,31 +221,9 @@ void Cube::setTextur( int id, CubeSeite s )
     if( !t )
         return;
     this->textur->setPolygonTextur( s, t );
-    texturUpdate[ s ] = 1;
     rend = 1;
 }
 
-// Zeichnet den Würfel
-//  zRObj: Ein Zeiger auf das Objekt, das zum Zeichnen verwendet werden soll (ohne erhöhten Reference Counter)
-void Cube::render( Render3D *zRObj )
-{
-    Array< Textur* > tmp;
-    for( int i = 0; i < 6; i++ )
-    {
-        if( texturUpdate[ i ] )
-        {
-            Textur *t = textur->zPolygonTextur( i );
-            if( tmp.getWertIndex( t ) < 0 )
-            {
-                //t->updateTextur( zRObj );
-                tmp.add( t );
-            }
-            texturUpdate[ i ] = 0;
-        }
-    }
-    __super::render( zRObj );
-}
-
 // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
 //  return: 0.
 Model3D *Cube::release()

Cube.h

@@ -19,15 +19,10 @@ namespace Framework
     // Ein Model eines Würfels
     class Cube : public Model3D
     {
-    private:
-        bool texturUpdate[ 6 ];
-
     public:
         // Konstruktor
         //  size: Die Größe des Würfels
         __declspec( dllexport ) Cube( float size );
-        // Destruktor
-        __declspec( dllexport ) ~Cube();
         // Setzt die Textur des Würfels, so dass sie an allen Seiten gleich ist
         //  textur: Die Textur als Bild
         __declspec( dllexport ) void setTextur( Bild *textur );
@@ -42,9 +37,6 @@ namespace Framework
         //  id: Die id der Textur. Sie muss im Textur Register des Frameworks registriert sein
         //  s: Die Seite, die gesetzt werden soll
         __declspec( dllexport ) void setTextur( int id, CubeSeite s );
-        // Zeichnet den Würfel
-        //  zRObj: Ein Zeiger auf das Objekt, das zum Zeichnen verwendet werden soll (ohne erhöhten Reference Counter)
-        __declspec( dllexport ) void render( Render3D *zRObj ) override;
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
         __declspec( dllexport ) Model3D *release() override;

DefaultShader.h

@@ -8,21 +8,14 @@ namespace Framework
     void getVertexShader( Text &ret )
     {
         ret = "////////////////////////////////////////////////////////////////////////////////         \n\
-        // Filename: texture.vs                                                                         \n\
-        ////////////////////////////////////////////////////////////////////////////////                \n\
-                                                                                                        \n\
-                                                                                                        \n\
         /////////////                                                                                   \n\
         // GLOBALS //                                                                                   \n\
         /////////////                                                                                   \n\
-        cbuffer MatrixBuffer                                                                            \n\
+        cbuffer MatrixBuffer : register( b0 )                                                           \n\
         {                                                                                               \n\
-            matrix worldMatrix;                                                                         \n\
-            matrix viewMatrix;                                                                          \n\
-            matrix projectionMatrix;                                                                    \n\
+            matrix knochenMatrix[ 128 ];                                                                \n\
         };                                                                                              \n\
                                                                                                         \n\
-                                                                                                        \n\
         //////////////                                                                                  \n\
         // TYPEDEFS //                                                                                  \n\
         //////////////                                                                                  \n\
@@ -30,6 +23,7 @@ namespace Framework
         {                                                                                               \n\
             float4 position : POSITION;                                                                 \n\
             float2 tex : TEXCOORD0;                                                                     \n\
+            int knochen : KNOCHEN_ID;                                                                   \n\
         };                                                                                              \n\
                                                                                                         \n\
         struct PixelInputType                                                                           \n\
@@ -38,7 +32,6 @@ namespace Framework
             float2 tex : TEXCOORD0;                                                                     \n\
         };                                                                                              \n\
                                                                                                         \n\
-                                                                                                        \n\
         ////////////////////////////////////////////////////////////////////////////////                \n\
         // Vertex Shader                                                                                \n\
         ////////////////////////////////////////////////////////////////////////////////                \n\
@@ -54,10 +47,7 @@ namespace Framework
             output.tex = input.tex;                                                                     \n\
                                                                                                         \n\
             // Calculate the position of the vertex against the world, view, and projection matrices.   \n\
-            output.position = input.position;                                                           \n\
-            output.position = mul( input.position, worldMatrix );                                       \n\
-            output.position = mul( output.position, viewMatrix );                                       \n\
-            output.position = mul( output.position, projectionMatrix );                                 \n\
+            output.position = mul( input.position, knochenMatrix[ input.knochen ] );                    \n\
                                                                                                         \n\
             return output;                                                                              \n\
         }";

Framework.vcxproj

@@ -251,6 +251,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClInclude Include="Shader.h" />
     <ClInclude Include="Textur.h" />
     <ClInclude Include="TexturList.h" />
+    <ClInclude Include="TexturModel.h" />
     <ClInclude Include="Vec4.h" />
     <ClInclude Include="Welt3D.h" />
     <ClInclude Include="Zeichnung.h" />
@@ -307,6 +308,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClCompile Include="Shader.cpp" />
     <ClCompile Include="Textur.cpp" />
     <ClCompile Include="TexturList.cpp" />
+    <ClCompile Include="TexturModel.cpp" />
     <ClCompile Include="Welt3D.cpp" />
     <ClCompile Include="Zeichnung3D.cpp" />
     <ClCompile Include="Zeichnung.cpp" />

Framework.vcxproj.filters

@@ -225,9 +225,6 @@
     <ClInclude Include="Mat4.h">
       <Filter>Headerdateien\Framework\Grafik\4D</Filter>
     </ClInclude>
-    <ClInclude Include="Shader.h">
-      <Filter>Headerdateien\Framework\Grafik\DX</Filter>
-    </ClInclude>
     <ClInclude Include="Kam3D.h">
       <Filter>Headerdateien\Framework\Grafik\3D</Filter>
     </ClInclude>
@@ -261,6 +258,12 @@
     <ClInclude Include="Animation3D.h">
       <Filter>Headerdateien\Framework\Grafik\3D</Filter>
     </ClInclude>
+    <ClInclude Include="Shader.h">
+      <Filter>Headerdateien\Framework\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="TexturModel.h">
+      <Filter>Headerdateien\Framework\Objekte3D</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Maus.cpp">
@@ -413,6 +416,9 @@
     <ClCompile Include="TexturList.cpp">
       <Filter>Quelldateien\Framework\Grafik\3D</Filter>
     </ClCompile>
+    <ClCompile Include="TexturModel.cpp">
+      <Filter>Quelldateien\Framework\Objekte3D</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="TestShader.hlsl">

Model3D.cpp

@@ -141,14 +141,19 @@ void Model3DData::removePolygon( int index )
     polygons->lösche( index );
 }
 
+// Aktualisiert die Vertecies
+//  zRObj: Das Objekt, mit dem die Grafikkarte verwaltet wird
+void Model3DData::aktualisiereVertecies( Render3D *zRObj )
+{
+    vertexBuffer->copieren( zRObj );
+}
+
 // Zeichnet alle Polygons
 //  world: Die Welt Matrix, die das Model in die Welt transformiert
 //  zTxt: Eine Liste mit Texturen der einzelnen Polygone
 //  zRObj: Das Objekt, mit dem gezeichnet werden soll
 void Model3DData::render( Mat4< float > &welt, const Model3DTextur *zTxt, Render3D *zRObj )
 {
-    vertexBuffer->copieren( zRObj );
-    zRObj->beginnModel( welt, vertexBuffer, id );
     int ind = 0;
     for( auto *i = &polygons->getArray(); i && i->set; i = i->next )
     {
@@ -182,6 +187,18 @@ float Model3DData::getRadius() const
     return radius;
 }
 
+// Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
+int Model3DData::getId() const
+{
+    return id;
+}
+
+// Gibt einen Buffer mit allen Vertecies des Models zurück
+const DXVertexBuffer *Model3DData::zVertexBuffer() const
+{
+    return vertexBuffer;
+}
+
 // Erhöht den Reference Counting Zähler.
 //  return: this.
 Model3DData *Model3DData::getThis()
@@ -302,9 +319,22 @@ void Model3D::render( Render3D *zRObj )
 {
     if( !model )
         return;
+    zRObj->beginnModel( this );
     model->render( welt, textur, zRObj );
 }
 
+// Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
+int Model3D::getDatenId() const
+{
+    return model ? model->getId() : -1;
+}
+
+// Gibt einen Buffer mit allen Vertecies des Models zurück
+const DXVertexBuffer *Model3D::zVertexBuffer() const
+{
+    return model ? model->zVertexBuffer() : 0;
+}
+
 // Erhöht den Reference Counting Zähler.
 //  return: this.
 Model3D *Model3D::getThis()

Model3D.h

@@ -22,6 +22,7 @@ namespace Framework
     {
         Vec3< float > pos;
         Vec2< float > tPos;
+        int knochenId;
     };
 
     class Knochen
@@ -32,10 +33,17 @@ namespace Framework
         int *indexList;
         int indexAnz;
         DXIndexBuffer *indexBuffer;
+        Knochen *geschwister;
+        Knochen *kinder;
+        int id;
+
+        // Fügt dem Knochen ein Geschwister Knochen hinzu
+        //  k: Der Knochen, der hinzugefügt werden soll
+        void addGeschwisterKnochen( Knochen *k );
 
     public:
         // Konstruktor
-        Knochen();
+        Knochen( int id );
         // Destruktor
         ~Knochen();
         // Setzt die Anzahl der mit dem Knochen verbundenen Vertecies
@@ -51,16 +59,44 @@ namespace Framework
         // Setzt die Drehung des Knochens relativ zum Model Ursprung
         //  winkel: Ein Vektor der die Drehung um die verschiedenen Achsen als Komponenten hat
         void setDrehung( Vec3< float > &winkel );
+        // Fügt einem bestimmten Knochen ein Kind Knochen hinzu
+        //  id: Die id des Knochens, wo der Knochen als Kind hinzugefügt werden soll
+        //  k: Der Knochen, der hinzugefügt werden soll
+        void addKind( int id, Knochen *k );
+        // Berechnet die Matrizen des Knochen und die von all seinen Geschwister Knochen und Kind Knochen
+        //  elternMat: Die fertig berechnete Matrix des Elternknochens
+        //  matBuffer: Ein Array, in dem alle berechneten Matrizen gespeichert werden sollen
+        void kalkulateMatrix( Mat4< float > elternMat, Mat4< float > *matBuffer );
         // 
-        void render( Render3D *zRObj, Mat4< float > &mat );
+        void render( Render3D *zRObj );
     };
 
     class Skelett
     {
     private:
+        Knochen *k;
+        int nextId;
+        int ref;
 
     public:
-
+        // Konstruktor
+        Skelett();
+        // Destruktor
+        ~Skelett();
+        // Gibt die Id des nächsten Knochens zurück und berechnet die neue Id für den Knochen danach
+        // Es können maximal 128 Knochen für ein Skelett existieren. Wenn diese Zahl überschritten wird, so wird -1 zurückgegeben
+        int getNextKnochenId();
+        // Fügt dem Skellet einen Knochen hinzu
+        //  k: Der Knochen
+        //  elternId: Die Id des Eltern Knochens. Wenn der Knochen kein Elternknochen besitzt, kannder Parameter weggelassen werden.
+        void addKnochen( Knochen *k, int elternId = -1 );
+        // Berechnet die Matrizen der Knochen
+        //  modelMatrix: Die Matrix, die das Skelett in den Raum der Welt transformiert
+        //  matBuffer: Ein Array von Matrizen, der durch die Knochen Matrizen gefüllt wird
+        void kalkulateMatrix( Mat4< float > &modelMatrix, Mat4< float > *matBuffer );
+        // Zeichnet die Knochen
+        //  zRObj: Das Objekt, mit dem gezeichnet werden soll
+        void render( Render3D *zRObj );
     };
 
     struct Polygon3D
@@ -108,6 +144,8 @@ namespace Framework
         // Entfernt ein Polygon
         //  index: Der Index des Polygons
         __declspec( dllexport ) void removePolygon( int index );
+        // Aktualisiert die Vertecies
+        __declspec( dllexport ) void aktualisiereVertecies( Render3D *zRObj );
         // Zeichnet alle Polygons
         //  world: Die Welt Matrix, die das Model in die Welt transformiert
         //  zTxt: Eine Liste mit Texturen der einzelnen Polygone
@@ -120,6 +158,10 @@ namespace Framework
         __declspec( dllexport ) Polygon3D *getPolygon( int index );
         // Gibt den radius einer Kugel zurück, die das gesammte Model umschließt
         __declspec( dllexport ) float getRadius() const;
+        // Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
+        __declspec( dllexport ) int getId() const;
+        // Gibt einen Buffer mit allen Vertecies des Models zurück
+        __declspec( dllexport ) const DXVertexBuffer *zVertexBuffer() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
         __declspec( dllexport ) Model3DData *getThis();
@@ -182,6 +224,10 @@ namespace Framework
         // Zeichnet das Model
         //  zRObj: Ein Zeiger auf das Objekt, das zum Zeichnen verwendet werden soll (ohne erhöhten Reference Counter)
         __declspec( dllexport ) void render( Render3D *zRObj ) override;
+        // Gibt die Id der Daten zurück, wenn sie in einer Model3DList registriert wurden. (siehe Framework::zM3DRegister())
+        __declspec( dllexport ) int getDatenId() const;
+        // Gibt einen Buffer mit allen Vertecies des Models zurück
+        __declspec( dllexport ) const DXVertexBuffer *zVertexBuffer() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
         __declspec( dllexport ) Model3D *getThis();

Render3D.cpp

@@ -145,8 +145,8 @@ void Render3D::releaseShader( int listIndex, int anz )
 //  kamPos: Die Position der Kamera in der Welt
 void Render3D::setKameraMatrix( Mat4< float > &view, Mat4< float > &proj, Vec3< float > &kamPos )
 {
-    matrixBuffer[ 1 ] = view;
-    matrixBuffer[ 2 ] = proj;
+    this->view = view;
+    this->proj = proj;
     this->kamPos = kamPos;
 
     Mat4< float > tmp = proj * view;
@@ -186,19 +186,19 @@ void Render3D::setKameraMatrix( Mat4< float > &view, Mat4< float > &proj, Vec3<
 }
 
 // Beginnt das Zeichnen eines bestimmten objektes
-//  world: Die Matrix, die das Model aus dem Model space in den world space übersetzt
-//  zVertexBuffer: Ein VertexBuffer mit allen Punkten des Models ohne erhöhten Reference Counter
-void Render3D::beginnModel( Mat4< float > &world, DXVertexBuffer *zVertexBuffer, int modelId )
+//  zMdl: Das 3D Modelohne erhöhten Reference Counter
+void Render3D::beginnModel( Model3D *zMdl )
 {
-    matrixBuffer[ 0 ] = world;
+    Mat4< float > trans = proj * view;
+    int anz = zMdl->errechneMatrizen( trans, matrixBuffer );
     if( shader->z( VERTEX ) && shaderId->hat( VERTEX ) )
-        shader->z( VERTEX )->z( shaderId->get( VERTEX ) )->füllConstBuffer( context, (char*)matrixBuffer, 0 );
-    if( lastObjektId == -1 || lastObjektId != modelId )
+        shader->z( VERTEX )->z( shaderId->get( VERTEX ) )->füllConstBuffer( context, (char*)matrixBuffer, 0, sizeof( Mat4< float > ) * anz );
+    if( lastObjektId == -1 || lastObjektId != zMdl->getDatenId() )
     {
-        lastObjektId = modelId;
+        lastObjektId = zMdl->getDatenId();
         unsigned int offset = 0;
-        ID3D11Buffer *b = zVertexBuffer->zBuffer();
-        unsigned int es = (unsigned)zVertexBuffer->getElementLänge();
+        ID3D11Buffer *b = zMdl->zVertexBuffer()->zBuffer();
+        unsigned int es = (unsigned)zMdl->zVertexBuffer()->getElementLänge();
         context->IASetVertexBuffers( 0, 1, &b, &es, &offset );
     }
 }

Render3D.h

@@ -16,11 +16,14 @@ namespace Framework
     class DXVertexBuffer; // DXBuffer.h
     class DXIndexBuffer; // DXBuffer.h
     class Textur; // Textur.h
+    class Model3D; // Model3D.h
 
     class Render3D
     {
     private:
-        Mat4< float > matrixBuffer[ 3 ];
+        Mat4< float > matrixBuffer[ 128 ];
+        Mat4< float > view;
+        Mat4< float > proj;
         Vec4< float > frustrum[ 6 ];
         Vec3< float > kamPos;
         ID3D11Device *device;
@@ -59,9 +62,8 @@ namespace Framework
         //  kamPos: Die Position der Kamera in der Welt
         __declspec( dllexport ) void setKameraMatrix( Mat4< float > &view, Mat4< float > &proj, Vec3< float > &kamPos );
         // Beginnt das Zeichnen eines bestimmten objektes
-        //  world: Die Matrix, die das Model aus dem Model space in den world space übersetzt
-        //  zVertexBuffer: Ein VertexBuffer mit allen Punkten des Models ohne erhöhten Reference Counter
-        __declspec( dllexport ) void beginnModel( Mat4< float > &world, DXVertexBuffer *zVertexBuffer, int modelId );
+        //  zMdl: Das 3D Modelohne erhöhten Reference Counter
+        __declspec( dllexport ) void beginnModel( Model3D *zMdl );
         // Zeichnet eine bestimmte struktur
         //  zIndexBuffer: Ein IndexBuffer, der auf verschiedene Vertices aus dem Vertex Buffer des Models zeigt. Ohne erhöhten Reference Counter
         //  textur: Ein Zeiger auf die Textur, die verwendet werden soll ohne erhöhten Reference Counter

Shader.cpp

@@ -151,17 +151,20 @@ bool Shader::l
 //  zD3d11Context: Das Context Objekt, das zum kopieren verwendt werden soll
 //  data: Einen zeiger auf en byte Array der größe des Buffers
 //  index: Der Index des Buffers
-bool Shader::füllConstBuffer( ID3D11DeviceContext *zD3d11Context, char *data, int index )
+//  län: Die Länge der Daten in Bytes (-1 für die maximale größe des Buffers)
+bool Shader::füllConstBuffer( ID3D11DeviceContext *zD3d11Context, char *data, int index, int län )
 {
     if( index < 0 || index >= 14 )
         return 0;
     if( !constBuffers[ index ] )
         return 0;
+    if( län < 0 )
+        län = buffLän[ index ];
     D3D11_MAPPED_SUBRESOURCE mappedResource;
     HRESULT res = zD3d11Context->Map( constBuffers[ index ], 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource );
     if( res != S_OK )
         return 0;
-    memcpy( mappedResource.pData, data, buffLän[ index ] );
+    memcpy( mappedResource.pData, data, län );
     zD3d11Context->Unmap( constBuffers[ index ], 0 );
     return 1;
 }

Shader.h

@@ -65,7 +65,8 @@ namespace Framework
         //  zD3d11Context: Das Context Objekt, das zum kopieren verwendt werden soll
         //  data: Einen zeiger auf en byte Array der größe des Buffers
         //  index: Der Index des Buffers
-        bool füllConstBuffer( ID3D11DeviceContext *zD3d11Context, char *data, int index );
+        //  län: Die Länge der Daten in Bytes (-1 für die maximale größe des Buffers)
+        bool füllConstBuffer( ID3D11DeviceContext *zD3d11Context, char *data, int index, int län = -1 );
         // Gibt die Länge eines constanten Buffers zurück
         //  index: Der Index des Buffers
         int getConstBufferLänge( int index ) const;

TexturModel.cpp

@@ -0,0 +1,108 @@
+#include "TexturModel.h"
+#include "DXBuffer.h"
+#include "Textur.h"
+#include "Globals.h"
+#include "TexturList.h"
+
+using namespace Framework;
+
+// Inhalt der TexturModel Klasse
+
+// Konstruktor
+TexturModel::TexturModel()
+    : Model3D()
+{
+    Vertex3D *vertecies = new Vertex3D[ 4 ];
+    vertecies[ 0 ].pos = Vec3<float >( -50, 50, 0.f );
+    vertecies[ 0 ].tPos = Vec2< float >( 0.f, 0.f );
+    vertecies[ 1 ].pos = Vec3<float >( 50, 50, 0.f );
+    vertecies[ 1 ].tPos = Vec2< float >( 1.f, 0.f );
+    vertecies[ 2 ].pos = Vec3<float >( -50, -50, 0.f );
+    vertecies[ 2 ].tPos = Vec2< float >( 0.f, 1.f );
+    vertecies[ 3 ].pos = Vec3<float >( 50, -50, 0.f );
+    vertecies[ 3 ].tPos = Vec2< float >( 1.f, 1.f );
+
+    model = new Model3DData();
+    model->setVertecies( vertecies, 4 );
+    Polygon3D *p = new Polygon3D();
+    p->indexAnz = 6;
+    p->indexList = new int[ p->indexAnz ];
+    p->indexBuffer->setLänge( p->indexAnz * 4 );
+    p->indexBuffer->setData( p->indexList );
+    p->indexList[ 0 ] = 0;
+    p->indexList[ 1 ] = 3;
+    p->indexList[ 2 ] = 2;
+    p->indexList[ 3 ] = 0;
+    p->indexList[ 4 ] = 1;
+    p->indexList[ 5 ] = 3;
+    model->addPolygon( p );
+
+    textur = new Model3DTextur();
+}
+
+// Setzt die Textur die angezeigt werden soll
+//  textur: Die Textur als Bild
+void TexturModel::setTextur( Bild *textur )
+{
+    Textur *t = new Textur();
+    t->setBildZ( textur );
+    this->textur->setPolygonTextur( 0, t );
+    rend = 1;
+}
+
+// Setzt die Textur die angezeigt werden soll 
+//  id: Die id der Textur. Sie muss im Textur Register des Frameworks registriert sein
+void TexturModel::setTextur( int id )
+{
+    Textur *t = texturRegister->getTextur( id );
+    if( !t )
+        return;
+    this->textur->setPolygonTextur( 0, t );
+    rend = 1;
+}
+
+// Setzt die Größe, in der Die Textur angezeigt wird
+//  gr: Ein Vektor, der für x und y die breite und höhe beinhaltet
+void TexturModel::setGröße( Vec2< float > gr )
+{
+    gr /= 2;
+    Vertex3D *vertecies = new Vertex3D[ 4 ];
+    vertecies[ 0 ].pos = Vec3<float >( -gr.x, gr.y, 0.f );
+    vertecies[ 0 ].tPos = Vec2< float >( 0.f, 0.f );
+    vertecies[ 1 ].pos = Vec3<float >( gr.x, gr.y, 0.f );
+    vertecies[ 1 ].tPos = Vec2< float >( 1.f, 0.f );
+    vertecies[ 2 ].pos = Vec3<float >( -gr.x, -gr.y, 0.f );
+    vertecies[ 2 ].tPos = Vec2< float >( 0.f, 1.f );
+    vertecies[ 3 ].pos = Vec3<float >( gr.x, -gr.y, 0.f );
+    vertecies[ 3 ].tPos = Vec2< float >( 1.f, 1.f );
+    model->setVertecies( vertecies, 4 );
+}
+
+// Setzt die Größe, in der die Textur angezeigt wird
+//  b: Die Breite, in der die Textur angezeigt wird
+//  h: Die Höhe, in der die Textur angezeigt wird
+void TexturModel::setGröße( float b, float h )
+{
+    b /= 2;
+    h /= 2;
+    Vertex3D *vertecies = new Vertex3D[ 4 ];
+    vertecies[ 0 ].pos = Vec3<float >( -b, h, 0.f );
+    vertecies[ 0 ].tPos = Vec2< float >( 0.f, 0.f );
+    vertecies[ 1 ].pos = Vec3<float >( b, h, 0.f );
+    vertecies[ 1 ].tPos = Vec2< float >( 1.f, 0.f );
+    vertecies[ 2 ].pos = Vec3<float >( -b, -h, 0.f );
+    vertecies[ 2 ].tPos = Vec2< float >( 0.f, 1.f );
+    vertecies[ 3 ].pos = Vec3<float >( b, -h, 0.f );
+    vertecies[ 3 ].tPos = Vec2< float >( 1.f, 1.f );
+    model->setVertecies( vertecies, 4 );
+}
+
+// Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
+//  return: 0.
+Model3D *TexturModel::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}

TexturModel.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "Model3D.h"
+
+namespace Framework
+{
+    class Bild; // Bild.h
+
+    class TexturModel : public Model3D
+    {
+    public:
+        // Konstruktor
+        __declspec( dllexport ) TexturModel();
+        // Setzt die Textur die angezeigt werden soll
+        //  textur: Die Textur als Bild
+        __declspec( dllexport ) void setTextur( Bild *textur );
+        // Setzt die Textur die angezeigt werden soll 
+        //  id: Die id der Textur. Sie muss im Textur Register des Frameworks registriert sein
+        __declspec( dllexport ) void setTextur( int id );
+        // Setzt die Größe, in der Die Textur angezeigt wird
+        //  gr: Ein Vektor, der für x und y die breite und höhe beinhaltet
+        __declspec( dllexport ) void setGröße( Vec2< float > gr );
+        // Setzt die Größe, in der die Textur angezeigt wird
+        //  b: Die Breite, in der die Textur angezeigt wird
+        //  h: Die Höhe, in der die Textur angezeigt wird
+        __declspec( dllexport ) void setGröße( float b, float h );
+        // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
+        //  return: 0.
+        __declspec( dllexport ) Model3D *release() override;
+    };
+}

Zeichnung3D.cpp

@@ -110,6 +110,16 @@ void Zeichnung3D::setAlpha( bool a )
     rend = 1;
 }
 
+// Errechnet die Matrizen aller Knochen des Skeletts der Zeichnung
+//  viewProj: Die miteinander multiplizierten Kameramatrizen
+//  matBuffer: Ein Array mit Matrizen, der gefüllt werden soll
+//  return: Die Anzahl der Matrizen, die die Zeichnung benötigt
+int Zeichnung3D::errechneMatrizen( Mat4< float > &viewProj, Mat4< float > *matBuffer )
+{
+    matBuffer[ 0 ] = welt * viewProj;
+    return 1;
+}
+
 // Verarbeitet ein Mausereignis
 //  me: Das Mausereignis, das verarbeitet werden soll
 void Zeichnung3D::doMausEreignis( MausEreignis &me )
@@ -197,4 +207,10 @@ float Zeichnung3D::getYDrehung() const
 float Zeichnung3D::getZDrehung() const
 {
     return angle.z;
+}
+
+// Gibt die Matrix zurück, die die Zeichnung in den Welt Raum übersetzt
+const Mat4< float > &Zeichnung3D::getMatrix() const
+{
+    return welt;
 }

Zeichnung3D.h

@@ -59,6 +59,11 @@ namespace Framework
         // Legt fest, ob das Objekt teilweise oder ganz transparente stellen enthält
         //  a: true, wenn teilweise oder ganz transparente stellen vorhanden sind
         __declspec( dllexport ) void setAlpha( bool a );
+        // Errechnet die Matrizen aller Knochen des Skeletts der Zeichnung
+        //  viewProj: Die miteinander multiplizierten Kameramatrizen
+        //  matBuffer: Ein Array mit Matrizen, der gefüllt werden soll
+        //  return: Die Anzahl der Matrizen, die die Zeichnung benötigt
+        __declspec( dllexport ) int errechneMatrizen( Mat4< float > &viewProj, Mat4< float > *matBuffer );
         // Verarbeitet ein Mausereignis
         //  me: Das Mausereignis, das verarbeitet werden soll
         __declspec( dllexport ) virtual void doMausEreignis( MausEreignis &me );
@@ -77,20 +82,22 @@ namespace Framework
         // Gibt den radius einer Kugel zurück, die das gesammte Model umschließt
         __declspec( dllexport ) float getRadius() const;
         // Gibt einen Punkt zurück, der die Position der Zeichnung in der Welt darstellt
-        const Vec3< float > &getPos() const;
+        __declspec( dllexport ) const Vec3< float > &getPos() const;
         // Gibt die X Position der Zeichnung in der Welt zurück
-        float getX() const;
+        __declspec( dllexport ) float getX() const;
         // Gibt die Y Position der Zeichnung in der Welt zurück
-        float getY() const;
+        __declspec( dllexport ) float getY() const;
         // Gibt die Z Position der Zeichnung in der Welt zurück
-        float getZ() const;
+        __declspec( dllexport ) float getZ() const;
         // Gibt einen Vektor zurück, der die drehung der Zeichnung in der Welt darstellt. x ist die Drehung um die X Achse im Bogenmaß usw
-        const Vec3< float > &getDrehung() const;
+        __declspec( dllexport ) const Vec3< float > &getDrehung() const;
         // Gibt die Drehung um die X Achse im Bogenmaß zurück
-        float getXDrehung() const;
+        __declspec( dllexport ) float getXDrehung() const;
         // Gibt die Drehung um die Y Achse im Bogenmaß zurück
-        float getYDrehung() const;
+        __declspec( dllexport ) float getYDrehung() const;
         // Gibt die Drehung um die Z Achse im Bogenmaß zurück
-        float getZDrehung() const;
+        __declspec( dllexport ) float getZDrehung() const;
+        // Gibt die Matrix zurück, die die Zeichnung in den Welt Raum übersetzt
+        __declspec( dllexport ) const Mat4< float > &getMatrix() const;
     };
 }