2D Engine hinzugefügt

Animation.h

@@ -90,7 +90,6 @@ namespace Framework
         LRahmen *ram;
         int aps;
         bool sichtbar;
-        bool rend;
         int ref;
 
     public:

Array.h

@@ -72,6 +72,18 @@ namespace Framework
             ref = 1;
         }
 
+        // Kopiert eine Linked list
+        Array( const Array &arr )
+        {
+            entries = new ArrayEintrag< TYP >();
+            entries->set = 0;
+            entries->next = 0;
+            int anz = arr.getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+                add( arr.get( i ) );
+            ref = 1;
+        }
+
         // Leert und löscht die Linked List 
         ~Array()
         {
@@ -346,6 +358,15 @@ namespace Framework
                 delete this;
             return 0;
         }
+
+        Array &operator=( const Array &arr )
+        {
+            leeren();
+            int anz = arr.getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+                add( arr.get( i ) );
+            return *this;
+        }
     };
 
     template< class TYP >
@@ -366,6 +387,18 @@ namespace Framework
             ref = 1;
         }
 
+        // Kopiert eine Linked list
+        RCArray( const RCArray &arr )
+        {
+            entries = new ArrayEintrag< TYP* >();
+            entries->set = 0;
+            entries->next = 0;
+            int anz = arr.getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+                add( arr.get( i ) );
+            ref = 1;
+        }
+
         // Leert und löscht die Linked List 
         ~RCArray()
         {
@@ -631,6 +664,15 @@ namespace Framework
                 delete this;
             return 0;
         }
+
+        RCArray &operator=( const RCArray &arr )
+        {
+            leeren();
+            int anz = arr.getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+                add( arr.get( i ) );
+            return *this;
+        }
     };
 }
 

Framework Linux.vcxproj

@@ -119,6 +119,7 @@
     <ClCompile Include="Fortschritt.cpp" />
     <ClCompile Include="Global.cpp" />
     <ClCompile Include="InitDatei.cpp" />
+    <ClCompile Include="Kamera2D.cpp" />
     <ClCompile Include="Key.cpp" />
     <ClCompile Include="Knopf.cpp" />
     <ClCompile Include="KSGTDatei.cpp" />
@@ -146,6 +147,7 @@
     <ClCompile Include="TexturModel.cpp" />
     <ClCompile Include="Thread.cpp" />
     <ClCompile Include="ToolTip.cpp" />
+    <ClCompile Include="Welt2D.cpp" />
     <ClCompile Include="Welt3D.cpp" />
     <ClCompile Include="Zeichnung.cpp" />
     <ClCompile Include="Zeichnung3D.cpp" />
@@ -174,6 +176,7 @@
     <ClInclude Include="FrameworkMath.h" />
     <ClInclude Include="Globals.h" />
     <ClInclude Include="InitDatei.h" />
+    <ClInclude Include="Kamera2D.h" />
     <ClInclude Include="Key.h" />
     <ClInclude Include="Knopf.h" />
     <ClInclude Include="KSGTDatei.h" />
@@ -208,6 +211,7 @@
     <ClInclude Include="ToolTip.h" />
     <ClInclude Include="Vec2.h" />
     <ClInclude Include="Vec3.h" />
+    <ClInclude Include="Welt2D.h" />
     <ClInclude Include="Welt3D.h" />
     <ClInclude Include="Zeichnung.h" />
     <ClInclude Include="Zeichnung3D.h" />

Framework Linux.vcxproj.filters

@@ -252,6 +252,12 @@
     <ClInclude Include="ReferenceCounting.h">
       <Filter>Headerdateien\Framework</Filter>
     </ClInclude>
+    <ClInclude Include="Welt2D.h">
+      <Filter>Headerdateien\Framework\Grafik\2D</Filter>
+    </ClInclude>
+    <ClInclude Include="Kamera2D.h">
+      <Filter>Headerdateien\Framework\Objekte2D</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Prozess.cpp">
@@ -398,5 +404,11 @@
     <ClCompile Include="Textur2D.cpp">
       <Filter>Quelldateien\Framework\Grafik\2D</Filter>
     </ClCompile>
+    <ClCompile Include="Welt2D.cpp">
+      <Filter>Quelldateien\Framework\Grafik\2D</Filter>
+    </ClCompile>
+    <ClCompile Include="Kamera2D.cpp">
+      <Filter>Quelldateien\Framework\Objekte2D</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Framework.vcxproj

@@ -220,6 +220,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClInclude Include="Globals.h" />
     <ClInclude Include="InitDatei.h" />
     <ClInclude Include="Kam3D.h" />
+    <ClInclude Include="Kamera2D.h" />
     <ClInclude Include="Knopf.h" />
     <ClInclude Include="KSGTDatei.h" />
     <ClInclude Include="Liste.h" />
@@ -245,6 +246,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClInclude Include="TexturList.h" />
     <ClInclude Include="TexturModel.h" />
     <ClInclude Include="Ebene3D.h" />
+    <ClInclude Include="Welt2D.h" />
     <ClInclude Include="Welt3D.h" />
     <ClInclude Include="Zeichnung.h" />
     <ClInclude Include="Prozess.h" />
@@ -286,6 +288,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClCompile Include="Global.cpp" />
     <ClCompile Include="InitDatei.cpp" />
     <ClCompile Include="Kam3D.cpp" />
+    <ClCompile Include="Kamera2D.cpp" />
     <ClCompile Include="Knopf.cpp" />
     <ClCompile Include="KSGTDatei.cpp" />
     <ClCompile Include="Liste.cpp" />
@@ -304,6 +307,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClCompile Include="Textur2D.cpp" />
     <ClCompile Include="TexturList.cpp" />
     <ClCompile Include="TexturModel.cpp" />
+    <ClCompile Include="Welt2D.cpp" />
     <ClCompile Include="Welt3D.cpp" />
     <ClCompile Include="Zeichnung3D.cpp" />
     <ClCompile Include="Zeichnung.cpp" />

Framework.vcxproj.filters

@@ -276,6 +276,12 @@
     <ClInclude Include="ReferenceCounting.h">
       <Filter>Headerdateien\Framework</Filter>
     </ClInclude>
+    <ClInclude Include="Kamera2D.h">
+      <Filter>Headerdateien\Framework\Objekte2D</Filter>
+    </ClInclude>
+    <ClInclude Include="Welt2D.h">
+      <Filter>Headerdateien\Framework\Grafik\2D</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Maus.cpp">
@@ -440,5 +446,11 @@
     <ClCompile Include="Textur2D.cpp">
       <Filter>Quelldateien\Framework\Grafik\2D</Filter>
     </ClCompile>
+    <ClCompile Include="Kamera2D.cpp">
+      <Filter>Quelldateien\Framework\Objekte2D</Filter>
+    </ClCompile>
+    <ClCompile Include="Welt2D.cpp">
+      <Filter>Quelldateien\Framework\Grafik\2D</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Kamera2D.cpp

@@ -0,0 +1,112 @@
+#include "Kamera2D.h"
+#include "Welt2D.h"
+#include "Bild.h"
+#include "Globals.h"
+
+using namespace Framework;
+
+
+Kamera2D::Kamera2D()
+    : ZeichnungHintergrund()
+{
+    welt = 0;
+    rotation = 0;
+    matrix = Mat3< float >::identity();
+    zoom = 1;
+    ref = 1;
+}
+
+Kamera2D::~Kamera2D()
+{
+    if( welt )
+        welt->release();
+}
+
+void Kamera2D::setWelt( Welt2D *welt )
+{
+    if( this->welt )
+        this->welt->release();
+    this->welt = welt;
+}
+
+bool Kamera2D::tick( double time )
+{
+    bool ret = rend;
+    rend = 0;
+    if( getTastenStand( 'q' ) )
+    {
+        rotation += (float)( time * 0.5 );
+        ret = 1;
+    }
+    if( getTastenStand( 'e' ) )
+    {
+        rotation -= (float)( time * 0.5 );
+        ret = 1;
+    }
+    Vertex move;
+    if( getTastenStand( 'w' ) )
+        move = Vertex( 0, -100 * (float)time );
+    if( getTastenStand( 'a' ) )
+        move = Vertex( -100 * (float)time, 0 );
+    if( getTastenStand( 'd' ) )
+        move = Vertex( 100 * (float)time, 0 );
+    if( getTastenStand( 's' ) )
+        move = Vertex( 0, +100 * (float)time );
+    if( move != Vertex( 0, 0 ) )
+    {
+        wPos += move.rotation( -rotation ) * ( 1 / zoom );
+        ret = 1;
+    }
+    if( getTastenStand( '+' ) )
+    {
+        zoom += ( zoom ) * (float)time;
+        ret = 1;
+    }
+    if( getTastenStand( '-' ) )
+    {
+        zoom -= ( zoom ) * (float)time;
+        if( zoom <= 0 )
+            zoom = 1;
+        ret = 1;
+    }
+    if( welt )
+        ret |= welt->tick( time );
+    return ret | ZeichnungHintergrund::tick( time );
+}
+
+void Kamera2D::render( Bild &zRObj )
+{
+    if( hatStyleNicht( Style::Sichtbar ) )
+        return;
+    ZeichnungHintergrund::render( zRObj );
+    if( !welt )
+        return;
+    lockZeichnung();
+    if( !zRObj.setDrawOptions( innenPosition, innenSize ) )
+    {
+        unlockZeichnung();
+        return;
+    }
+    matrix = Mat3< float >::translation( (Vertex)gr / 2 ) * Mat3< float >::rotation( rotation ) * Mat3< float >::scaling( zoom ) * Mat3< float >::translation( -wPos );
+    welt->render( matrix, gr, zRObj );
+    zRObj.releaseDrawOptions();
+    unlockZeichnung();
+}
+
+Vertex Kamera2D::getWorldCoordinates( Punkt screenPos )
+{
+    return ( Mat3< float >::translation( wPos ) * Mat3< float >::scaling( 1 / zoom ) * Mat3< float >::rotation( -rotation ) * Mat3< float >::translation( (Vertex)gr / -2 ) ) * (Vertex)screenPos;
+}
+
+Kamera2D *Kamera2D::getThis()
+{
+    ref++;
+    return this;
+}
+
+Kamera2D *Kamera2D::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

Kamera2D.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Zeichnung.h"
+#include "Mat3.h"
+#include "Welt2D.h"
+
+namespace Framework
+{
+    class Welt2D;
+    class Object2D;
+
+    class Kamera2D : public ZeichnungHintergrund
+    {
+    private:
+        Welt2D * welt;
+        Vertex wPos;
+        float rotation;
+        float zoom;
+        Mat3< float > matrix;
+        int ref;
+
+    public:
+        __declspec( dllexport ) Kamera2D();
+        virtual __declspec( dllexport ) ~Kamera2D();
+        __declspec( dllexport ) void setWelt( Welt2D *welt );
+        __declspec( dllexport ) bool tick( double time );
+        __declspec( dllexport ) void render( Bild &zRObj );
+        __declspec( dllexport ) Vertex getWorldCoordinates( Punkt screenPos );
+        __declspec( dllexport ) Kamera2D *getThis();
+        __declspec( dllexport ) Kamera2D *release();
+    };
+}

Model2D.cpp

@@ -179,9 +179,15 @@ bool Model2DData::erstelleModell( Array< Polygon2D > *polygons )
         for( int i = 0; i < vAnz; i++ )
         {
             if( maxP.x < fabs( pg.vertex->get( i ).x ) )
+            {
                 maxP.x = abs( (int)pg.vertex->get( i ).x ) + 1;
+                maxP.y = abs( (int)pg.vertex->get( i ).x ) + 1;
+            }
             if( maxP.y < fabs( pg.vertex->get( i ).y ) )
+            {
+                maxP.x = abs( (int)pg.vertex->get( i ).y ) + 1;
                 maxP.y = abs( (int)pg.vertex->get( i ).y ) + 1;
+            }
         }
         minP = -maxP;
         if( !textur )
@@ -393,7 +399,7 @@ void Model2DData::removeModell() // setzt die Vertex daten zur
     maxP = Punkt( 0, 0 );
 }
 
-bool Model2DData::calcHitPoint( Vertex pos, Vertex dir, char *polygonName, Vertex &hitpoint, Vertex &moveSpeed, float &rotSpeed ) const
+bool Model2DData::calcHitPoint( Vertex pos, Vertex dir, const char *polygonName, Vertex &hitpoint, Vertex &moveSpeed, float &rotSpeed ) const
 {
     bool ret = 0;
     for( auto *polygon = &polygons->getArray(); polygon && polygon->set; polygon = polygon->next )
@@ -653,6 +659,221 @@ Model2DData *Model2DData::release()
 }
 
 
+
+// Inhalt der Model2D Klasse aus Model2D.h
+// Konstruktor
+Model2DObject::Model2DObject()
+    : Object2D()
+{
+    rData = 0;
+    textur = new RCArray< Textur2D >;
+    ref = 1;
+}
+
+// Destruktor
+Model2DObject::~Model2DObject()
+{
+    if( rData )
+        rData->release();
+    textur->release();
+}
+
+// nicht constant
+void Model2DObject::setModel( Model2DData *mdl )
+{
+    if( rData )
+        rData->release();
+    rData = mdl;
+}
+
+void Model2DObject::setTextur( Textur2D *t )
+{
+    int index = 0;
+    if( rData )
+    {
+        for( auto i = rData->polygons->getArray(); i.set; i++ )
+            textur->set( t->getThis(), index++ );
+    }
+    t->release();
+}
+
+void Model2DObject::impuls( Vertex start, Vertex speed )
+{
+    if( rData )
+    {
+        Vertex hp;
+        Vertex mSpeed;
+        float rSpeed;
+        if( rData->calcHitPoint( start, speed, "", hp, mSpeed, rSpeed ) )
+        {
+            this->speed += mSpeed;
+            this->rSpeed += rSpeed;
+        }
+    }
+}
+
+void Model2DObject::setTextur( Textur2D *t, const char *polygonName )
+{
+    int index = 0;
+    for( auto i = rData->polygons->getArray(); i.set; i++, index++ )
+    {
+        if( i.var.name->istGleich( polygonName ) )
+            textur->set( t->getThis(), index );
+    }
+    t->release();
+}
+
+void Model2DObject::render( Mat3< float > &kamMat, Bild &zRObj )
+{
+    if( !rData || !rData->polygons || !textur )
+        return;
+    int num = 0;
+    for( auto *p = &rData->vListen->getArray(); p && p->set; p = p->next, num++ )
+    {
+        Mat3< float > mat = kamMat * getObjectMatrix();
+        if( textur->z( num ) )
+        {
+            Bild *txt = textur->z( num )->zTextur();
+            for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
+            {
+                for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
+                {
+                    Vertex a = mat * *j->var->punkt;
+                    Vertex b = mat * *j->next->var->punkt;
+                    Vertex c = mat * *j->next->next->var->punkt;
+                    Punkt ta = (Punkt)Vertex( j->var->textur->x * (float)txt->getBreite(), j->var->textur->y * (float)txt->getHeight() );
+                    Punkt tb = (Punkt)Vertex( j->next->var->textur->x * (float)txt->getBreite(), j->next->var->textur->y * (float)txt->getHeight() );
+                    Punkt tc = (Punkt)Vertex( j->next->next->var->textur->x * (float)txt->getBreite(), j->next->next->var->textur->y * (float)txt->getHeight() );
+                    zRObj.drawDreieckTexturAlpha( a, b, c, ta, tb, tc, *txt );
+                }
+            }
+        }
+    }
+}
+
+// constant
+bool Model2DObject::istPunktInnen( Vertex p ) const
+{
+    if( !rData )
+        return 0;
+    p -= position;
+    if( p < Mat3< float >::scaling( size ) * rData->minP || p > Mat3< float >::scaling( size ) * rData->maxP || !rData->polygons )
+        return 0;
+    int num = 0;
+    for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
+    {
+        if( polygon->var.transparent )
+            continue;
+        Mat3< float > mat = Mat3< float >::rotation( rotation ) * Mat3< float >::scaling( size );
+        int anz = polygon->var.vertex->getEintragAnzahl();
+        bool c = 0;
+        int j = anz - 1;
+        for( int i = 0; i < anz; i++ )
+        {
+            Vertex a = mat * polygon->var.vertex->get( i );
+            Vertex b = mat * polygon->var.vertex->get( j );
+            if( ( ( a.y >= p.y ) != ( b.y >= p.y ) ) && ( p.x <= ( b.x - a.x ) * ( p.y - a.y ) / (float)( b.y - a.y ) + a.x ) )
+                c = !c;
+            j = i;
+        }
+        if( c )
+            return 1;
+    }
+    return 0;
+}
+
+bool Model2DObject::istLinieInnen( Vertex a, Vertex b ) const
+{
+    if( !rData || !rData->polygons )
+        return 0;
+    int pAnz = rData->polygons->getEintragAnzahl();
+    for( int p = 0; p < pAnz; p++ )
+    {
+        if( rData->polygons->get( p ).transparent )
+            continue;
+        Mat3< float > mat = Mat3< float >::rotation( rotation ) * Mat3< float >::scaling( size );
+        int anz = rData->polygons->get( p ).vertex->getEintragAnzahl();
+        int j = anz - 1;
+        for( int i = 0; i < anz; i++ )
+        {
+            Punkt va = mat * rData->polygons->get( p ).vertex->get( i );
+            Punkt vb = mat * rData->polygons->get( p ).vertex->get( j );
+            if( (Punkt)a == position + va && (Punkt)b == position + vb )
+                return 1;
+            if( (Punkt)a == position + vb && (Punkt)b == position + va )
+                return 1;
+            j = i;
+        }
+        Vertex len = b - a;
+        Vertex speed( len.x > 0 ? 1 : -1.f, len.y > 0 ? 1 : -1.f );
+        int mLen = 0;
+        if( fabs( len.x ) > fabs( len.y ) )
+        {
+            mLen = (int)fabs( len.x );
+            speed.y = len.y / (float)fabs( len.x );
+        }
+        else
+        {
+            mLen = (int)fabs( len.y );
+            speed.x = len.x / (float)fabs( len.y );
+        }
+        int i = 1;
+        bool inside = 1;
+        for( Vertex vp = speed + a; (Punkt)vp != (Punkt)( b - speed ) && inside && i < mLen - 1; vp += speed, i++ )
+            inside &= istPunktInnen( vp );
+        if( inside )
+            return 1;
+    }
+    return 0;
+}
+
+bool Model2DObject::istModelInnen( const Model2DObject *zMdl, bool end ) const
+{
+    if( !end )
+    {
+        Vertex min = (Vertex)rData->minP * size + position;
+        Vertex max = (Vertex)rData->maxP * size + position;
+        Vertex min2 = (Vertex)zMdl->zModel()->minP * zMdl->getSize() + zMdl->getPosition();
+        Vertex max2 = (Vertex)zMdl->zModel()->maxP * zMdl->getSize() + zMdl->getPosition();
+        if( max.x < min2.x || min.x > max2.x || max.y < min2.y || min.y > max2.y )
+            return 0;
+    }
+    Mat3< float > mat = getObjectMatrix();
+    for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next )
+    {
+        if( polygon->var.transparent )
+            continue;
+        int anz = polygon->var.vertex->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( zMdl->istPunktInnen( mat * polygon->var.vertex->get( i ) ) )
+                return 1;
+        }
+    }
+    if( end )
+        return 0;
+    return zMdl->istModelInnen( this, 1 );
+}
+
+Rect< float > Model2DObject::getBoundingBox() const
+{
+    if( rData )
+        return Rect< float >{ (Vertex)rData->minP * size + position, (Vertex)rData->maxP * size + position };
+    return Rect< float >();
+}
+
+Model2DData *Model2DObject::getModel() const
+{
+    return rData ? rData->getThis() : 0;
+}
+
+Model2DData *Model2DObject::zModel() const
+{
+    return rData;
+}
+
+
+
 // Inhalt der Model2D Klasse aus Model2D.h
 // Konstruktor
 Model2D::Model2D()

Model2D.h

@@ -1,15 +1,16 @@
 #ifndef Model2D_H
 #define Model2D_H
 
-#include "Zeichnung.h"
+#include "Welt2D.h"
 #include "Punkt.h"
 #include "Array.h"
 #include "DreieckListe.h"
 #include "Vec3.h"
+#include <functional>
+#include "Zeichnung.h"
 
 namespace Framework
 {
-    typedef Vec2< float > Vertex;
     class Textur2D;
 
     // Eine Polygon Struktur, die von Model2D verwendet wird
@@ -62,7 +63,7 @@ namespace Framework
         //  moveSpeed: die aus der Krafteinwirkung resultierende bewegungsgeschwindigkeit
         //  rotSpeed: die aus der Krafteinwirkung resultierende drehgeschwindigkeit
         //  return: 1, fals ein Schnittpunkt existiert
-        __declspec( dllexport ) bool calcHitPoint( Vertex pos, Vertex dir, char *polygonName, Vertex &hitpoint, Vertex &moveSpeed, float &rotSpeed ) const;
+        __declspec( dllexport ) bool calcHitPoint( Vertex pos, Vertex dir, const char *polygonName, Vertex &hitpoint, Vertex &moveSpeed, float &rotSpeed ) const;
         // Teil ein bestimmtes polygon in zwei teile
         //  pos: Startposition des risses
         //  dir: Startrichtung des risses
@@ -81,6 +82,50 @@ namespace Framework
         __declspec( dllexport ) Model2DData *release();
     };
 
+    class Model2DObject : public Object2D
+    {
+    private:
+        Model2DData * rData;
+        RCArray< Textur2D > *textur;
+
+    public:
+        // Konstruktor
+        __declspec( dllexport ) Model2DObject();
+        // Destruktor
+        __declspec( dllexport ) virtual ~Model2DObject();
+        // Setzt die Daten des Models
+        //  mdl: Die Model Daten
+        __declspec( dllexport ) void setModel( Model2DData *mdl );
+        // Setzt die Textur
+        //  t: Das Bild, das als Textur verwendet werden soll
+        __declspec( dllexport ) void setTextur( Textur2D *t );
+        // Setzt die Textur
+        //  t: Das Bild, das als Textur verwendet werden soll
+        //  polygonName: Der name des Polygons, was die Textur bekommen soll
+        __declspec( dllexport ) void setTextur( Textur2D *t, const char *polygonName );
+        __declspec( dllexport ) void impuls( Vertex start, Vertex speed ) override;
+        // Zeichnet die Zeihnung in ein bestimmtes Bild
+        //  zRObj: Das Bild, in das gezeichnet werden soll
+        __declspec( dllexport ) void render( Mat3< float > &kamMat, Bild &zRObj ) override;
+        // Gibt zurück, ob ein Punkt in dem Model enthalten ist
+        //  p: Der Punkt
+        __declspec( dllexport ) bool istPunktInnen( Vertex p ) const;
+        // Überprüft, ob eine Linie im Model enthalten ist
+        //  a: Der startpunkt der Linie
+        //  b: Der endpunkt der Linie
+        __declspec( dllexport ) bool istLinieInnen( Vertex a, Vertex b ) const;
+        // Überprüft, ob sich das Model mit einem anderen Überschneidet
+        //  zMdl: Ein Zeiger auf das andere Model ohne erhöhten Reference Counter
+        //  end: 0, falls alle Ecken beider Modele überprüft werdden sollen. 1, falls nur die Punkte dieses Models im anderen gesucht werden sollen
+        __declspec( dllexport ) bool istModelInnen( const Model2DObject *zMdl, bool end = 0 ) const;
+
+        __declspec( dllexport ) Rect< float > getBoundingBox() const override;
+        // Gibt die Model Daten zurück
+        __declspec( dllexport ) Model2DData *getModel() const;
+        // Gibt die Model Daten ohne erhöhten Reference Counter zurück
+        __declspec( dllexport ) Model2DData *zModel() const;
+    };
+
     // Eine Zeichnung von einem Model
     class Model2D : public Zeichnung
     {

Welt2D.cpp

@@ -0,0 +1,176 @@
+#include "Welt2D.h"
+#include "Bild.h"
+
+using namespace Framework;
+
+Object2D::Object2D()
+{
+    rSpeed = 0;
+    rotation = 0;
+    size = 1;
+    ref = 1;
+}
+
+Object2D::~Object2D()
+{}
+
+void Object2D::explosion( Vertex worldPos, float intensity )
+{
+    intensity /= ( position - worldPos ).getLengthSq();
+    speed += ( position - worldPos ) * intensity;
+}
+
+void Object2D::impuls( Vertex start, Vertex speed )
+{}
+
+void Object2D::setPosition( Vertex pos )
+{
+    position = pos;
+}
+
+void Object2D::setPosition( float x, float y )
+{
+    position = Vertex( x, y );
+}
+
+void Object2D::setDrehung( float drehung )
+{
+    rotation = drehung;
+    while( rotation > PI * 2 )
+        rotation -= (float)PI * 2;
+    while( rotation < 0 )
+        rotation += (float)PI * 2;
+}
+
+void Object2D::addDrehung( float drehung )
+{
+    rotation += drehung;
+    while( rotation > PI * 2 )
+        rotation -= (float)PI * 2;
+    while( rotation < 0 )
+        rotation += (float)PI * 2;
+}
+
+void Object2D::setSize( float size )
+{
+    this->size = size;
+}
+
+void Object2D::addSize( float size )
+{
+    this->size += size;
+}
+
+bool Object2D::tick( double zeit )
+{
+    rotation += rSpeed * (float)zeit;
+    position += speed * (float)zeit;
+    return rSpeed != 0 || speed != Vertex( 0, 0 );
+}
+
+Mat3< float > Object2D::getObjectMatrix() const
+{
+    return Mat3<float>::translation( position ) * Mat3<float>::rotation( rotation ) * Mat3<float>::scaling( size );
+}
+
+Vertex Object2D::getPosition() const
+{
+    return position;
+}
+
+float Object2D::getDrehung() const
+{
+    return rotation;
+}
+
+float Object2D::getSize() const
+{
+    return size;
+}
+
+Object2D *Object2D::getThis()
+{
+    ref++;
+    return this;
+}
+
+Object2D *Object2D::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
+Welt2D::Welt2D()
+{
+    objects = new RCArray< Object2D >();
+    ref = 1;
+}
+
+Welt2D::~Welt2D()
+{
+    objects->release();
+}
+
+void Welt2D::addObject( Object2D *obj )
+{
+    objects->add( obj );
+}
+
+void Welt2D::explosion( Vertex worldPos, float intensity, float maxRad )
+{
+    maxRad = maxRad * maxRad;
+    for( auto obj = objects->getArray(); obj.set; obj++ )
+    {
+        if( ( obj.var->getPosition() - worldPos ).getLengthSq() < maxRad )
+            obj.var->explosion( worldPos, intensity );
+    }
+}
+
+void impuls( Vertex start, Vertex speed )
+{}
+
+bool Welt2D::tick( double zeit )
+{
+    bool ret = 0;
+    for( auto obj = objects->getArray(); obj.set; obj++ )
+        ret |= obj.var->tick( zeit );
+    return ret;
+}
+
+void Welt2D::render( Mat3< float > &kamMat, Punkt size, Bild &zRObj )
+{
+    for( auto obj = objects->getArray(); obj.set; obj++ )
+    {
+        Rect< float > bnd = obj.var->getBoundingBox();
+        Vertex topRight = Vertex( bnd.topLeft.y, bnd.bottomRight.x );
+        Vertex bottomLeft = Vertex( bnd.topLeft.x, bnd.bottomRight.y );
+        bnd.bottomRight = kamMat * bnd.bottomRight;
+        bnd.topLeft = kamMat * bnd.topLeft;
+        topRight = kamMat * topRight;
+        bottomLeft = kamMat * bottomLeft;
+        if( ( bnd.bottomRight.x >= 0 && bnd.bottomRight.x < size.x ) ||
+            ( bnd.bottomRight.y >= 0 && bnd.bottomRight.y < size.y ) ||
+            ( bnd.topLeft.x >= 0 && bnd.topLeft.x < size.x ) ||
+            ( bnd.topLeft.y >= 0 && bnd.topLeft.y < size.y ) ||
+            ( topRight.x >= 0 && topRight.x < size.x ) ||
+            ( topRight.y >= 0 && topRight.y < size.y ) ||
+            ( bottomLeft.x >= 0 && bottomLeft.x < size.x ) ||
+            ( bottomLeft.y >= 0 && bottomLeft.y < size.y ) )
+            obj.var->render( kamMat, zRObj );
+    }
+}
+
+Welt2D *Welt2D::getThis()
+{
+    ref++;
+    return this;
+}
+
+Welt2D *Welt2D::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

Welt2D.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "Array.h"
+#include "Mat3.h"
+#include "Punkt.h"
+
+namespace Framework
+{
+    typedef Vec2< float > Vertex;
+    class Bild;
+
+    template<typename T>
+    struct Rect
+    {
+        Vec2< T > topLeft;
+        Vec2< T > bottomRight;
+    };
+
+    class Object2D
+    {
+    protected:
+        Vertex position;
+        Vertex speed;
+        float rSpeed;
+        float rotation;
+        float size;
+        int ref;
+
+    public:
+        __declspec( dllexport ) Object2D();
+        virtual __declspec( dllexport ) ~Object2D();
+        __declspec( dllexport ) void explosion( Vertex worldPos, float intensity );
+        __declspec( dllexport ) virtual void impuls( Vertex start, Vertex speed );
+        __declspec( dllexport ) void setPosition( Vertex pos );
+        __declspec( dllexport ) void setPosition( float x, float y );
+        // Setzt die Drehung des Models gegen den Uhrzeigersinn
+        //  drehung: Der winkel in Bogenmas
+        __declspec( dllexport ) void setDrehung( float drehung );
+        // Fügt zum aktuellen Drehungswinkel etwas hinzu
+        //  drehung: Der Winkel in Bogenmas, der hinzugefügt werden soll
+        __declspec( dllexport ) void addDrehung( float drehung );
+        // Setzt die Skallierung des Modells
+        //  size: Der Faktor, mit dem Skalliert wird
+        __declspec( dllexport ) void setSize( float size );
+        // Addiert zur Skallierung einen bestimmten Wert hinzu
+        //  size: Der Wert, der zur skallierung hinzugefügt werden soll
+        __declspec( dllexport ) void addSize( float size );
+        __declspec( dllexport ) virtual bool tick( double zeit );
+        virtual void render( Mat3< float > &kamMat, Bild &zRObj ) = 0;
+        __declspec( dllexport ) Mat3< float > getObjectMatrix() const;
+        // gibt die Position des Models zurück
+        __declspec( dllexport ) Vertex getPosition() const;
+        // gibt die Drehung des Models zurück
+        __declspec( dllexport ) float getDrehung() const;
+        // gibt den Skallierungs Faktor zurück
+        __declspec( dllexport ) float getSize() const;
+        __declspec( dllexport ) virtual Rect< float > getBoundingBox() const = 0;
+        __declspec( dllexport ) Object2D *getThis();
+        __declspec( dllexport ) Object2D *release();
+    };
+
+    class Welt2D
+    {
+    private:
+        RCArray< Object2D > *objects;
+        Punkt topLeft;
+        Punkt rightBottom;
+        int ref;
+
+    public:
+        __declspec( dllexport ) Welt2D();
+        __declspec( dllexport ) ~Welt2D();
+        __declspec( dllexport ) void addObject( Object2D *obj );
+        __declspec( dllexport ) void explosion( Vertex worldPos, float intensity, float maxRad );
+        __declspec( dllexport ) bool tick( double zeit );
+        __declspec( dllexport ) void render( Mat3< float > &kamMat, Punkt size, Bild &zRObj );
+        __declspec( dllexport ) Welt2D *getThis();
+        __declspec( dllexport ) Welt2D *release();
+    };
+}