KSG-Framework/RenderThread.h

#ifndef RenderThread_H
#define RenderThread_H

#include "Thread.h"
#include "Critical.h"
#include <functional>

namespace Framework
{
    class Bildschirm; //! Bildschirm.h
    class ZeitMesser; //! ZeitMesser.h
    class Bild; //! Bild.h

    //! Ein Thread, der ein Bildschirm verwaltet. Er ruft die render() und tick() funktionen automatisch auf
    class RenderTh : public Thread
    {
    private:
        bool stoppen;
        Bildschirm *bildschirm;
        ZeitMesser *zeit;
        double renderTickZeit;
        void *renderParameter;
        void *tickParameter;
        std::function< void( void*, void*, Bild* ) > renderFunktion;
        std::function< void( void*, void*, double ) > tickFunktion;
        bool pause;
        Critical cs;
        int maxFps;
        bool quiet;

    public:
        //! Konstruktor 
        DLLEXPORT RenderTh();
        //! Destruktor 
        DLLEXPORT ~RenderTh();
        //! Dies ist notwendig, falls mehrere Threads gleichzeitig das Objekt benutzen.
        //! Wenn lock() von zwei threads aufgerufen wird, wartet der letzte so lange, bis der erste unlock() aufgerufen hat.
        DLLEXPORT void lock();
        //! Dies ist notwendig, falls mehrere Threads gleichzeitig das Objekt benutzen.
        //! Wenn lock() von zwei threads aufgerufen wird, wartet der letzte so lange, bis der erste unlock() aufgerufen hat.
        DLLEXPORT void unlock();
        //! Setzt das Bildschirm Objekt, das verwaltet werden soll
        //! \param bildschirm Der Bildschirm
        DLLEXPORT void setBildschirm( Bildschirm *bildschirm );
        //! Die Funktion, die automatisch in einem neuen Thread ausgeführt wird
        DLLEXPORT void thread() override;
        //! Beginnt den Render Thread
        DLLEXPORT void beginn();
        //! Beendet den Render Thread
        DLLEXPORT void beenden();
		//! if true, then nothing will be printent to std::cout
        DLLEXPORT void setQuiet(bool quiet);
        //! Setzt die maximalen Bilder pro Sekunde
        //! \param fps maximale Bilder pro Sekunde
        DLLEXPORT void setMaxFps( int fps );
        //! Pausiert den Render Thread
        //! \param p 1, wenn der Thread pausiert werden soll
        DLLEXPORT void setPause( bool p );
        //! Setzt die Rückruffunktion, die immer vor dem Zeichnen aufgerufen wird
        //! \param rF Die Rückruffunktion
        DLLEXPORT void setRenderFunktion( std::function< void( void*, void*, Bild* ) > rF );
        //! Setzt die Rückruffunktion, die immer vor dem Aktualisieren aller Objekte aufgerufen wird
        //! \param tF Die Rückruffunktion
        DLLEXPORT void setTickFunktion( std::function< void( void*, void*, double ) > tF );
        //! Setzt den Parameter der Rückruffunktion, die immer vor dem Zeichnen aufgerufen wird
        //! \param p Der Parameter
        DLLEXPORT void setRenderFunktionParameter( void *p );
        //! Setzt den Parameter der Rückruffunktion, die immer vor dem Aktualisieren aller Objekte aufgerufen wird
        DLLEXPORT void setTickFunktionParameter( void *p );
        //! Gibt den Bildschirm zurück, der von dem Thread verwaltet wird
        DLLEXPORT Bildschirm *getBildschirm() const;
        //! Gibt den Bildschirm ohne erhöhten Reference Counter zurück, der von dem Thread verwaltet wird
        DLLEXPORT Bildschirm *zBildschirm() const;
        //! Gibt die Zeit zurück, mit der die tick() Funktion des Bildschirms als letztes aufgerufen wurde
        DLLEXPORT double getRenderTickZeit() const;
    };
}

#endif