struct s_Textur {
    const char* Name;
    const double X; //Positionierungen
    const double Y;
    s_Textur(const double x=TexDefaKoor_X, const double y=TexDefaKoor_Y, const char* name=TexDefaNa): X(x), Y(y), Name(name) {};
};

struct s_Material {
    //! const int ID;
    int ID;
    s_Textur *Tex;
    s_Material(const int id): ID(id) { Tex = new s_Textur(); } //Default-Values
    s_Material(const int id, double x, double y, char* Name): ID(id) {
        Tex = new s_Textur(x,y,Name);
    }
};

struct s_Vertex {
    double X;
    double Y;
    double Z;
    //s_Vertex(double x, double y, double z): X(x), Y(y), Z(z) {};
};

struct s_Mesh {
      std::vector<s_Vertex> Points;
      std::vector<s_Material> Mat;
      void createAndAddPoint (double x=-51.25, double y=-51.25, double z=-51.25);
        void Render();
};
void s_Mesh::createAndAddPoint (double x, double y, double z) {
    Points.push_back( ((struct s_Vertex){x,y,z}) );
}

void s_Mesh::Render() { //es folgen OpenGL-Befehle zum Zeichnen
}

class c_MeshLoader {
   private:
      ///std::vector <s_Mesh*> Meshes;//! Kira... Das, was du da machst, ist BÖSE!
      std::vector <s_Mesh> Meshes;
   public:
      inline s_Mesh &get_Mesh(const int ID) {
            Infos << "[c_MeshLoader]Get Mesh with ID '" << ID << "'." << std::endl;
          return Meshes[ID];
      }
      void load_Mesh(const char* Name);
};
void c_MeshLoader::load_Mesh(const char* Name) {
    std::ifstream File;File.open(Name, std::ios::in);
    if(File.good()) {
        Infos << "[c_MeshLoader]Read File '" << Name << "'." << std::endl;
      s_Mesh *currentMesh = new s_Mesh();
      //Hier kommt eine Schleife zum Dateieinleisen.
        File.close();
        Infos << "[c_MeshLoader]Reading completed." << std::endl;

        /*Infos << &currentMesh->Points[0].X << std::endl; //Adresse
        Infos << currentMesh->Points[0].X << std::endl; //Wert

        /Infos << *&currentMesh->Points[0].X << std::endl; //Wert
        */
        Infos << "[c_MeshLoader]Meshes-Size: " << std::endl;

        ///Meshes.push_back(currentMesh);
        if(Meshes.empty()) {
            Infos << "Leer" << std::endl;
            ///Meshes.reserve(1);
        }
        else {
            Infos << "Nicht leer" << std::endl;
            ///Infos << Meshes.size() << std::endl;
        }

        //! Meshes.push_back(*(new s_Mesh()));

        Meshes.reserve(Meshes.size()+1);
        Infos << "[c_MeshLoader]Mesh added." << std::endl;
        s_Mesh temp;
        Meshes[Meshes.size()-1]=*currentMesh;
        //delete currentMesh;
        ///currentMesh = NULL;
    }else
        Infos << "[c_MeshLoader]Cant load '" << Name << "'." << std::endl;
}

// debug.h
#ifndef INCLUDE_GUARD_DEBUG
#define INCLUDE_GUARD_DEBUG

#ifdef DEBUG
   #define DEBUG_OUT std::cout << __FILE__ << ": line " << __LINE__ << ": "
   #define DEBUG_LINE DEBUG_OUT << "\n"; std::cout.flush()
   #define DEBUG_GL_ERROR {unsigned err = glGetError(); if(err != GL_NO_ERROR) DEBUG_OUT << "OpenGL Error: 0x" << std::hex << err << std::dec << "\n"; std::cout.flush(); }
#endif // DEBUG
#ifndef DEBUG
   #define DEBUG_OUT
   #define DEBUG_LINE
   #define DEBUG_GL_ERROR
#endif // DEBUG

#endif // INCLUDE_GUARD_DEBUG

        DEBUG_OUT << "[c_MeshLoader]capacity: "  << Meshes.capacity() << std::endl;
        DEBUG_OUT << "[c_MeshLoader]max_size: "  << Meshes.max_size() << std::endl;

      std::vector<double> X;
      std::vector<double> Y;
      std::vector<double> Z;

#include <string>
#include <vector>
#include <GL/glew.h>

#include <SFML/System.hpp>
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>

#define DEBUG
#include "Debug.hpp"

#define TexDefaNa "[d]"
#define TexDefaKoor_X 0
#define TexDefaKoor_Y 1

class c_Applikation;
c_Applikation *App;

enum orientation {
    N, //North
    S, //South
    E, //East
    W  //West
};

struct s_Textur {
    const char* Name;
    const double X; //Positionierungen
    const double Y;
    s_Textur(const double x=TexDefaKoor_X, const double y=TexDefaKoor_Y, const char* name=TexDefaNa): X(x), Y(y), Name(name) {};
};

struct s_Material {
    //! const int ID;
    int ID;
    s_Textur *Tex;
    s_Material(const int id): ID(id) { Tex = new s_Textur(); } //Default-Values
    s_Material(const int id, double x, double y, char* Name): ID(id) {
        Tex = new s_Textur(x,y,Name);
    }
};

struct s_Vertex {
    double X;
    double Y;
    double Z;
    //s_Vertex(double x, double y, double z): X(x), Y(y), Z(z) {};
};

//! Not in use ...
/**
class c_Polygon {
    private:
        std::vector<s_Vertex> *Vtx;
    public:
        c_Polygon (const int Vertexes) {
            Vtx->reserve(Vertexes);
        }
};**/

struct s_Mesh {
        //Vertexes
      std::vector<s_Vertex> Points;
      std::vector<s_Material> Mat;
      void createAndAddPoint (double x=-51.25, double y=-51.25, double z=-51.25);
        void Render();
        int Render_Infos;
};

void s_Mesh::createAndAddPoint (double x, double y, double z) {
    DEBUG_OUT << "[s_Mesh]Define Vertex at (" << x << ", " << y << ", " << z << ")." << std::endl;
    DEBUG_FOUT << "[s_Mesh]Define Vertex at (" << x << ", " << y << ", " << z << ")." << std::endl;
    //s_Vertex *Vec = new s_Vertex;
    //Vec->X=x; Vec->Y=y; Vec->Z=z;


    Points.push_back( ((struct s_Vertex){x,y,z}) );
    /*
    s_Vertex Vec;
    Vec.X=x; Vec.Y=y; Vec.Z=z;
    DEBUG_OUT << "[s_Mesh]Pointerbody ready." << std::endl;
    DEBUG_FOUT << "[s_Mesh]Pointerbody ready." << std::endl;
    s_Vertex *XyZ;XyZ=&Vec;
    DEBUG_OUT << "[s_Mesh]Pointer has got a value." << std::endl;
    DEBUG_FOUT << "[s_Mesh]Pointer has got a value." << std::endl;

    //&Points->push_back(*XyZ);
    Points.push_back(Vec);
    */
}

void s_Mesh::Render() {
    if(Render_Infos!=2)
    Render_Infos++;
    /** ///Unnötiger Schleifenbalast!
    DEBUG_OUT << "[s_Mesh]Render the Mesh.\n";
    DEBUG_FOUT << "[s_Mesh]Render the Mesh.\n";
    DEBUG_OUT << "[s_Mesh]Anzahl der Punktevektoren: " << Points.size() << std::endl;
    DEBUG_FOUT << "[s_Mesh]Anzahl der Punktevektoren: " << Points.size() << std::endl;
    **/
    const int Anz=Points.size();
    ///glMatrixMode(GL_MODELVIEW);   // Select The Modelview Matrix
    ///glPushMatrix();             // Store The Modelview Matrix
    ///glLoadIdentity();         // Reset The Modelview Matrix

    ///glTranslatef(0.f, 0.f, -200.f);
    /*if( !(Anz%3) && !(Anz%4) )
        glBegin(GL_LINE_LOOP);
    else {
        if(Anz%3)
            glBegin(GL_TRIANGLE_STRIP);
        else if(Anz%4)
            glBegin(GL_QUAD_STRIP);
    }*/
        glBegin(GL_TRIANGLE_STRIP);
    if(Mat.size() > 0)
        for(int i=0; i<Anz; i++) {
            if(i >= Mat.size() ) {
                glVertex3f(Points[i].X, Points[i].Y, Points[i].Z);
                ///Unnötiger Schleifenbalast!
                if(Render_Infos==1) {
                DEBUG_OUT << "[s_Mesh]Vertex created.[" << i+1 << "/" <<Anz << "]" << std::endl;
                DEBUG_FOUT << "[s_Mesh]Vertex created.[" << i+1 << "/" <<Anz << "]" << std::endl;
                }

                continue;
            } else {
            glVertex3f(Points[i].X, Points[i].Y, Points[i].Z);
            glColor3f(Mat[i].Tex->X, Mat[i].Tex->Y,0); //Eigentlich glTexPos
            if(Render_Infos==1) {
             ///Unnötiger Schleifenbalast!
            DEBUG_OUT << "[s_Mesh]Vertex with Color/Texture created.[" << i+1 << "/" <<Anz << "]" << std::endl;
            DEBUG_FOUT << "[s_Mesh]Vertex with Color/Texture created.[" << i+1 << "/" <<Anz << "]" << std::endl;
            }
            }
        }
    else {
        for(int i=0; i<Anz; i++) {
            glVertex3f(Points[i].X, Points[i].Y, Points[i].Z);
            ///Unnötiger Schleifenbalast!
            if(Render_Infos==1) {
            DEBUG_OUT << "[s_Mesh]Vertex (" << i+1 << "/" <<Anz << ") created at [" << Points[i].X << "," << Points[i].Y << "," << Points[i].Z << "]" << std::endl;
            DEBUG_FOUT << "[s_Mesh]Vertex (" << i+1 << "/" <<Anz << ") created at [" << Points[i].X << "," << Points[i].Y << "," << Points[i].Z << "]" << std::endl;
            }
        }
    }
    glEnd();
};

s_Mesh *NeuesMesh;
class c_MeshLoader {
   private:
      ///std::vector <s_Mesh*> Meshes;//! Sören... Das, was du da machst, ist BÖSE!
      std::vector <s_Mesh> Meshes;
   public:
      //2 Funktionen: Eine zum Laden eines Meshes über den Dateinamen und eine andere zum Auswerten der Mesh-Dateidaten. Bei Erfolgreichem Laden+Auswerten würde ein 'currentMesh' über 'new' erzeugt, mit den ausgewerteten Werten befüllt und in den Vektor geschoben wird. ('delete nicht vergessen')
      inline s_Mesh &get_Mesh(const int ID) {
            DEBUG_OUT << "[c_MeshLoader]Get Mesh with ID '" << ID << "'." << std::endl;
            DEBUG_FOUT << "[c_MeshLoader]Get Mesh with ID '" << ID << "'." << std::endl;
          return Meshes[ID];
      }
      void load_Mesh(const char* Name);
};

bool schrott(false);
//Diese Funktion kann noch kein Mesh verarbeiten. (Es wird noch garnicht ausgelesen, die Datei sollte aber vorhanden sein)
void c_MeshLoader::load_Mesh(const char* Name) {
    std::ifstream File;File.open(Name, std::ios::in);
    if(File.good()) {
        DEBUG_OUT << "[c_MeshLoader]Read File '" << Name << "'." << std::endl;
        DEBUG_FOUT << "[c_MeshLoader]Read File '" << Name << "'." << std::endl;
      s_Mesh *currentMesh = new s_Mesh();
      //s_Mesh currentMesh;
        ///File.close();
        ///File.open(Name);
        while(!schrott/*File.eof()*/) {
        DEBUG_OUT << "[c_MeshLoader]..." << std::endl;
        DEBUG_FOUT << "[c_MeshLoader]..." << std::endl;
            if(!schrott) {
            currentMesh->createAndAddPoint(-50.f, -50.f, -50.f);
            currentMesh->createAndAddPoint(-50.f,  50.f, -50.f);
            currentMesh->createAndAddPoint( 50.f,  50.f, -50.f);
            currentMesh->createAndAddPoint( 50.f, -50.f, -50.f);
            schrott=true;
            }
        }
        File.close();
        DEBUG_OUT << "[c_MeshLoader]Reading completed." << std::endl;
        DEBUG_FOUT << "[c_MeshLoader]Reading completed." << std::endl;

        /*DEBUG_FOUT << &currentMesh->Points[0].X << std::endl; //Adresse
        DEBUG_FOUT << currentMesh->Points[0].X << std::endl; //Wert

        /DEBUG_FOUT << *&currentMesh->Points[0].X << std::endl; //Wert

        */

        DEBUG_OUT << "[c_MeshLoader]Prüfe auf Funktionsaufrufe ohne Auswertung: " << std::endl;
        DEBUG_FOUT << "[c_MeshLoader]Pruefe auf Funktionsaufrufe ohne Auswertung: " << std::endl;
        ///Normale Funktionsaufrufe...
        Meshes.empty();
        Meshes.size();
        Meshes.capacity();
        DEBUG_OUT << "[c_MeshLoader]Pruefung OK." << std::endl;
        DEBUG_FOUT << "[c_MeshLoader]Pruefung OK." << std::endl;

        DEBUG_OUT << "[c_MeshLoader]Meshes-Size: ";
        DEBUG_FOUT << "[c_MeshLoader]Meshes-Size: ";

        ///Meshes.push_back(currentMesh);
        if(Meshes.empty()) {
            DEBUG_OUT << "Leer" << std::endl;
            DEBUG_FOUT << "Leer" << std::endl;
            ///Meshes.reserve(1);
        }
        else {
            DEBUG_OUT << "Nicht leer\n";
            DEBUG_FOUT << "Nicht leer\n";
            DEBUG_OUT << "\t\t" << Meshes.size() << std::endl;
            DEBUG_FOUT << "\t\t" << Meshes.size() << std::endl;
            ///DEBUG_FOUT << Meshes.size() << std::endl;
        }

        //! Meshes.push_back(*(new s_Mesh()));

        Meshes.reserve(Meshes.size()+1); //Als Ersatz für push_back
        DEBUG_OUT << "[c_MeshLoader]Mesh added." << std::endl;
        DEBUG_FOUT << "[c_MeshLoader]Mesh added." << std::endl;
        s_Mesh temp;
        Meshes[Meshes.size()-1]=*currentMesh;
        //delete currentMesh;
        ///currentMesh = NULL;
    }else {
        DEBUG_OUT << "[c_MeshLoader]Cant load '" << Name << "'." << std::endl;
        DEBUG_FOUT << "[c_MeshLoader]Cant load '" << Name << "'." << std::endl;
    }
}

c_MeshLoader *MeshMan;



//class LifeformMapObject; //Hier erstmal total unnötig
class DeadMapObject {
   private:
        //Membervariablen wie z.B. einen Funktionszeiger auf die Funktion für die "KI" bzw. "Perception" des Objektes [an ID angepasst]
        double Coordinate_X;
        double Coordinate_Y;
        orientation Orientation;
        //std::vector <double> Coordinates; //STL-Vektoren kann man schlecht/garnicht über Initialisierungslisten mit x [in diesem Fall 2] reservieren.
   public:
        //Getter-Funktionen
        //Setter-Funktionen [für "künstliche" Positionsveränderungen während des Spieles]
        double extract_MeshXPos(); //Übermittelt X-Position auf der Karte
        double extract_MeshYPos();
        orientation extract_MeshOrientation();
        double get_XPosition();
        DeadMapObject(const int ID): Coordinate_X(extract_MeshXPos()),
            Coordinate_Y(extract_MeshYPos()),
            Orientation(extract_MeshOrientation()) {}; //Vielleicht etwas ungeschickt formuliert, aber es "dürfte" inetwa so funktionieren.
        void draw_Object(); //Zeichnet das Objekt und zusätzlich ruft die Funktion noch den Funktionspointer auf für Veränderungen an der Orientierung und der Position des Objektes.
};

double DeadMapObject::extract_MeshXPos() {
    ///MeshMan->get_Mesh(ID);
    //usw. usf.
}
orientation DeadMapObject::extract_MeshOrientation() {
    //orientation *Neue = new orientation::N;
    return ((orientation)0); //0 für N
    //usw. usf.
}

class Map {
};


sf::Clock *Clock;
//Zur Rotation der Szene
void roate_Cube() {
    glRotatef(Clock->GetElapsedTime() * 50, 1.f, 0.f, 0.f);
    glRotatef(Clock->GetElapsedTime() * 30, 0.f, 1.f, 0.f);
    glRotatef(Clock->GetElapsedTime() * 90, 0.f, 0.f, 1.f);
}

//Erzeugt einfach so ein CubeMesh, das auch angezeigt werden kann.
void create_CubeMesh() {
    NeuesMesh = new s_Mesh();
    DEBUG_FOUT << "[Start]" << std::endl;
    NeuesMesh->createAndAddPoint(-50.f, -50.f, -50.f);
    NeuesMesh->createAndAddPoint(-50.f,  50.f, -50.f);
    NeuesMesh->createAndAddPoint( 50.f,  50.f, -50.f);
    NeuesMesh->createAndAddPoint( 50.f, -50.f, -50.f);

    NeuesMesh->createAndAddPoint(-50.f, -50.f, 50.f);
    NeuesMesh->createAndAddPoint(-50.f,  50.f, 50.f);
    NeuesMesh->createAndAddPoint( 50.f,  50.f, 50.f);
    NeuesMesh->createAndAddPoint( 50.f, -50.f, 50.f);

    NeuesMesh->createAndAddPoint(-50.f, -50.f, -50.f);
    NeuesMesh->createAndAddPoint(-50.f,  50.f, -50.f);
    NeuesMesh->createAndAddPoint(-50.f,  50.f,  50.f);
    NeuesMesh->createAndAddPoint(-50.f, -50.f,  50.f);

    NeuesMesh->createAndAddPoint(50.f, -50.f, -50.f);
    NeuesMesh->createAndAddPoint(50.f,  50.f, -50.f);
    NeuesMesh->createAndAddPoint(50.f,  50.f,  50.f);
    NeuesMesh->createAndAddPoint(50.f, -50.f,  50.f);

    NeuesMesh->createAndAddPoint(-50.f, -50.f,  50.f);
    NeuesMesh->createAndAddPoint(-50.f, -50.f, -50.f);
    NeuesMesh->createAndAddPoint( 50.f, -50.f, -50.f);
    NeuesMesh->createAndAddPoint( 50.f, -50.f,  50.f);

    NeuesMesh->createAndAddPoint(-50.f, 50.f,  50.f);
    NeuesMesh->createAndAddPoint(-50.f, 50.f, -50.f);
    NeuesMesh->createAndAddPoint( 50.f, 50.f, -50.f);
    NeuesMesh->createAndAddPoint( 50.f, 50.f,  50.f);
}
//Erstellt aus vorher geladenem Mesh einen Kubus
void draw_CubeMesh() {
    roate_Cube();
    NeuesMesh->Render();
}

//Standartfunktion zum Zeichnen eines Kubus
void draw_Cube() {
    roate_Cube();
    // Draw a cube
    glBegin(GL_QUADS);

        glVertex3f(-50.f, -50.f, -50.f);
        glVertex3f(-50.f,  50.f, -50.f);
        glVertex3f( 50.f,  50.f, -50.f);
        glVertex3f( 50.f, -50.f, -50.f);

        glVertex3f(-50.f, -50.f, 50.f);
        glVertex3f(-50.f,  50.f, 50.f);
        glVertex3f( 50.f,  50.f, 50.f);
        glVertex3f( 50.f, -50.f, 50.f);

        glVertex3f(-50.f, -50.f, -50.f);
        glVertex3f(-50.f,  50.f, -50.f);
        glVertex3f(-50.f,  50.f,  50.f);
        glVertex3f(-50.f, -50.f,  50.f);

        glVertex3f(50.f, -50.f, -50.f);
        glVertex3f(50.f,  50.f, -50.f);
        glVertex3f(50.f,  50.f,  50.f);
        glVertex3f(50.f, -50.f,  50.f);

        glVertex3f(-50.f, -50.f,  50.f);
        glVertex3f(-50.f, -50.f, -50.f);
        glVertex3f( 50.f, -50.f, -50.f);
        glVertex3f( 50.f, -50.f,  50.f);

        glVertex3f(-50.f, 50.f,  50.f);
        glVertex3f(-50.f, 50.f, -50.f);
        glVertex3f( 50.f, 50.f, -50.f);
        glVertex3f( 50.f, 50.f,  50.f);

    glEnd();
}

int main() {

    // Create the main window
    sf::Window App(sf::VideoMode(800, 600, 32), "Testumgebung");

    // Create a clock for measuring time elapsed
    Clock= new sf::Clock;

    // Set color and depth clear value
    glClearDepth(1.f);
    glClearColor(0.f, 0.f, 0.f, 0.f);

    // Enable Z-buffer read and write
    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_TRUE);

    // Setup a perspective projection
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(90.f, 1.f, 1.f, 500.f);

    create_CubeMesh();
    ///MeshMan->load_Mesh("Cubetest.HQ2[lvl]");
    MeshMan->load_Mesh("Test.HQ2[lvl]");

    // Start game loop
    while (App.IsOpened())
    {
        // Process events
        sf::Event Event;
        while (App.GetEvent(Event))
        {
            // Close window : exit
            if (Event.Type == sf::Event::Closed)
                App.Close();

            // Escape key : exit
            if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::Escape))
                App.Close();

            // Resize event : adjust viewport
            if (Event.Type == sf::Event::Resized)
                glViewport(0, 0, Event.Size.Width, Event.Size.Height);
        }

        // Set the active window before using OpenGL commands
        // It's useless here because active window is always the same,
        // but don't forget it if you use multiple windows or controls
        App.SetActive();


        // Clear color and depth buffer
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // Apply some transformations
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glTranslatef(0.f, 0.f, -200.f);

        ///draw_Cube();
        draw_CubeMesh();
        // Finally, display rendered frame on screen
        App.Display();
    }

    return EXIT_SUCCESS;
}

// ==== MySingleton.h ========================================
#ifndef MYSINGLETON_H
#define MYSINGLETON_H

class MySingleton
{
public:
   static inline MySingleton* instance() {
      if (!m_instance) {
         m_instance = new MySingleton();
      }
      return m_instance;
   }   
private:
   MySingleton();
   ~MySingleton();
   
   static MySingleton* m_instance;
};

#endif

// ==== MySingleton.cpp ========================================
MySingleton* MySingleton::m_instance = NULL;

MySingleton::MySingleton() {
   // Singleton sauber initialisieren
}

MySingleton::~MySingleton() {
   /* Achtung: Wird niemals aufgerufen!
      Speicher wird beim beenden des Programms aber sowieso komplett freigegeben.
      Aufpassen aber bei externen Dingen wie Dateien oder Datenbankverbindungen. */
}

MySingleton::instance()->methode(a,b,c);

MySingleton* mys = MySingleton::instance();
mys->methode(a,b,c);
mys->methode2(a,b,c);
mys->methode3(a,b,c);
mys->methode4(a,b,c);