KSG-Framework/Model2D.h

#ifndef Model2D_H
#define Model2D_H

#include "Welt2D.h"
#include "Punkt.h"
#include "Array.h"
#include "DreieckListe.h"
#include "Vec3.h"
#include <functional>
#include "Zeichnung.h"

namespace Framework
{
    class Textur2D;

    //! Eine Polygon Struktur, die von Model2D verwendet wird
    //! Model2D Klasse löscht die Zeiger
    struct Polygon2D
    {
        bool transparent;
        Text *name;
        Array< Vertex > *vertex;
        Array< Vertex > *tKordinaten;
        Vertex *schwerpunkt;
    };

    //! Die Daten für ein 2D Model
    class Model2DData : public virtual ReferenceCounter
    {
    private:
        RCArray< Array< Punkt > > outList;

        //! Überprüft, ob ein Punkt im Model ist
        //! \param p Der Punkt
        //! \param polygonId Die Id des Polygons, das geprüft werden soll
        bool istPunktInnen( Vertex p, int polygonId = -1 ) const;
        //! Überprüft, ob eine Linie innerhalb des Models ist
        //! \param a Der Startpunkt der Linie
        //! \param b Der Endpunkt der Linie
        bool istLinieInnen( Vertex a, Vertex b, int polygonId = -1 ) const;

    public:
        Array< Polygon2D > *polygons;
        RCArray< RCArray< DreieckListe< Vertex > > > *vListen;
        Punkt minP, maxP;

        //! Konstruktor
        __declspec( dllexport ) Model2DData();
        //! Destruktor
        __declspec( dllexport ) ~Model2DData();
        //! Erstellt die Dreieck Listen anhand aller gegebenen Eckpunkte der Polygons
        //! \param polygons Ein Array von Polygons
        //! \return gibt immer 1 zurück
        __declspec( dllexport ) bool erstelleModell( Array< Polygon2D > *polygons );
        //! Löscht die erstellten Dreiecklisten und die Eckpunkte
        __declspec( dllexport ) void removeModell();
        //! gibt das polygon mit einem bestimmten namen zurück
        //! \param pos Der Stützvektor der Linie
        //! \param dir Der richtungsvektor der Linie
        //! \param polygonName Der Name des polygons mit dem der schnittpunkt berechnet werden soll
        //! \param hitPoint eine referenz auf die variable in dem der schnittpunkt gespeichert werden soll
        //! \param moveSpeed die aus der Krafteinwirkung resultierende bewegungsgeschwindigkeit
        //! \param rotSpeed die aus der Krafteinwirkung resultierende drehgeschwindigkeit
        //! \return 1, fals ein Schnittpunkt existiert
        __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
        //! \param pos Startposition des risses
        //! \param dir Startrichtung des risses
        //! \param polygonName der Name des Polygons
        //! \param partA ein Zeiger auf ein Model2DData objekt, in dem die eine hälfte gespeichert werden soll (ausgabe)
        //! \param partB ein Zeiger auf ein Model2DData objekt, in dem die andere hälfte gespeichert werden soll (ausgabe)
        //! \param posA die Position des einen neuen Polygons (ausgabe)
        //! \param posB die Position des anderen neuen Polygons (ausgabe)
        //! \param random eine funktion die zufällige werte zurückgibt
        __declspec( dllexport ) bool split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &partA, Polygon2D &partB, Punkt &posA, Punkt &posB, std::function< double() > random ) const;
        //! Gibt die Masse des 2D Modells zurück (summe der Flächen der nicht transparenten Polygone)
        __declspec( dllexport ) float getMasse() const;
    };

    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
        //! \param mdl Die Model Daten
        __declspec( dllexport ) void setModel( Model2DData *mdl );
        //! Setzt die Textur
        //! \param t Das Bild, das als Textur verwendet werden soll
        __declspec( dllexport ) void setTextur( Textur2D *t );
        //! Setzt die Textur
        //! \param t Das Bild, das als Textur verwendet werden soll
        //! \param 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, float strength = 1.f ) override;
        //! Zeichnet die Zeihnung in ein bestimmtes Bild
        //! \param zRObj Das Bild, in das gezeichnet werden soll
        __declspec( dllexport ) void render( Mat3< float > &kamMat, Bild &zRObj, const char *kamName ) override;
        //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
        //! \param p Der Punkt
        //! \param ignoreTransparentFlag wenn 1, dann werden auch collisionen mit transparenten polygonen beachtet
        __declspec( dllexport ) bool istPunktInnen( Vertex p, bool ignoreTransparent = 0 ) const override;
        //! Überprüft, ob eine Linie im Model enthalten ist
        //! \param a Der startpunkt der Linie
        //! \param b Der endpunkt der Linie
        //! \param ignoreTransparentFlag wenn 1, dann werden auch collisionen mit transparenten polygonen beachtet
        __declspec( dllexport ) bool istLinieInnen( Vertex a, Vertex b, bool ignoreTransparent = 0 ) const override;
        //! Überprüft, ob sich das Objekt mit einem anderen Überschneidet
        //! \param zObj Ein Zeiger auf das andere Objekt ohne erhöhten Reference Counter
        //! \param sp Ein Zeiger auf einen Punkt, in dem der Schnittpunkt gespeichert wird
        //! \param end 0, falls alle Ecken beider Objekte überprüft werdden sollen. 1, falls nur die Punkte dieses Models im anderen gesucht werden sollen
        //! \param ignoreTransparentFlag wenn 1, dann werden auch collisionen mit transparenten polygonen beachtet
        __declspec( dllexport ) virtual bool istModelInnen( const Object2D *zObj, Vertex *sp = 0, bool end = 0, bool ignoreTransparent = 0 ) const;
        __declspec( dllexport ) Rect2< float > getBoundingBox() const override;
        //! Bestimmt den Aufschlagspunkt eines Strahls, der von pos ausgehend in Richtung dir abgegeben wird.
        //! \param pos Der Stützvektor der Linie
        //! \param dir Der richtungsvektor der Linie
        //! \param hitPoint eine referenz auf die variable in dem der schnittpunkt gespeichert werden soll
        //! \return 1, fals ein Schnittpunkt existiert
        __declspec( dllexport ) bool calcHitPoint( Vertex pos, Vertex dir, Vertex &hitpoint ) const override;
        __declspec( dllexport ) float getLuftWiederstand() const override;
        //! Gibt die Masse des 2D Modells zurück (summe der Flächen der nicht transparenten Polygone)
        __declspec( dllexport ) float getMasse() const override;
        //! Gibt die Textur des ersten Polygons zurück
        __declspec( dllexport ) Textur2D *getTextur() const;
        //! Gibt die Textur eines Polygons zurück
        //! \param polygonName Der Name des Polygons
        __declspec( dllexport ) Textur2D *getTextur( const char *polygonName ) const;
        //! Gibt die Textur des ersten Polygons ohne erhöhten Reference Counter zurück
        __declspec( dllexport ) Textur2D *zTextur() const;
        //! Gibt die Textur eines Polygons ohne erhöhten Reference Counter zurück
        //! \param polygonName Der Name des Polygons
        __declspec( dllexport ) Textur2D *zTextur( const char *polygonName ) const;
        //! 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
    {
    public:
        class Style : public Zeichnung::Style
        {
        public:
            const static __int64 Textur = 0x8; //! Wenn dieser Flag gesetzt ist, wird beim Zeichnen eine Textur verwendet
            const static __int64 Rahmen = 0x10; //! Wenn dieser Flag gesetzt ist, werden die Render der Polygone gezeichnet
            const static __int64 Alpha = 0x40; //! Wenn dieser Fag gesetzt ist, wird beim Zeichnen alphablending verwendet
            const static __int64 Mesh = 0x20; //! Wenn dieser Flag gesetzt ist, werden die Render der Dreiecke gezeichnet
        };
    private:
        Model2DData *rData;
        float drehung;
        float size;
        int farbe;
        RCArray< Textur2D > *textur;

    public:
        //! Konstruktor
        __declspec( dllexport ) Model2D();
        //! Destruktor
        __declspec( dllexport ) virtual ~Model2D();
        //! Setzt die Daten des Models
        //! \param mdl Die Model Daten
        __declspec( dllexport ) void setModel( Model2DData *mdl );
        //! Setzt die Drehung des Models gegen den Uhrzeigersinn
        //! \param drehung Der winkel in Bogenmas
        __declspec( dllexport ) void setDrehung( float drehung );
        //! Fügt zum aktuellen Drehungswinkel etwas hinzu
        //! \param drehung Der Winkel in Bogenmas, der hinzugefügt werden soll
        __declspec( dllexport ) void addDrehung( float drehung );
        //! Setzt die Skallierung des Modells
        //! \param size Der Faktor, mit dem Skalliert wird
        __declspec( dllexport ) void setSize( float size );
        //! Addiert zur Skallierung einen bestimmten Wert hinzu
        //! \param size Der Wert, der zur skallierung hinzugefügt werden soll
        __declspec( dllexport ) void addSize( float size );
        //! Setzt die Textur
        //! \param t Das Bild, das als Textur verwendet werden soll
        __declspec( dllexport ) void setTextur( Textur2D *t );
        //! Setzt die Textur
        //! \param t Das Bild, das als Textur verwendet werden soll
        //! \param polygonName Der name des Polygons, was die Textur bekommen soll
        __declspec( dllexport ) void setTextur( Textur2D *t, const char *polygonName );
        //! Setzt die Farbe
        //! \param f Die Farbe im A8R8G8B8 Format
        __declspec( dllexport ) void setFarbe( int f );
        //! Verarbeitet die Zeit, die seit dem letzten aufruf dieser Funktion vergangen ist
        //! \param tickVal Die vergangene Zeit in Sekunden
        __declspec( dllexport ) bool tick( double tickVal ) override;
        //! Zeichnet die Zeihnung in ein bestimmtes Bild
        //! \param zRObj Das Bild, in das gezeichnet werden soll
        __declspec( dllexport ) void render( Bild &zRObj ) override;
        //! gibt die Drehung des Models zurück
        __declspec( dllexport ) float getDrehung() const;
        //! gibt den Skallierungs Faktor zurück
        __declspec( dllexport ) float getSize() const;
        //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
        //! \param p Der Punkt
        __declspec( dllexport ) bool istPunktInnen( int x, int y ) const override;
        //! Gibt zurück, ob ein Punkt in dem Model enthalten ist
        //! \param p Der Punkt
        __declspec( dllexport ) bool istPunktInnen( Vertex p ) const;
        //! Überprüft, ob eine Linie im Model enthalten ist
        //! \param a Der startpunkt der Linie
        //! \param b Der endpunkt der Linie
        __declspec( dllexport ) bool istLinieInnen( Vertex a, Vertex b ) const;
        //! Überprüft, ob sich das Model mit einem anderen Überschneidet
        //! \param zMdl Ein Zeiger auf das andere Model ohne erhöhten Reference Counter
        //! \param 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 Model2D *zMdl, bool end = 0 ) const;
        //! 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;
    };
}
#endif