include/Simulation.h

Go to the documentation of this file.

#ifndef SIMULATION_H
#define SIMULATION_H

#include <QString>

#include "ngl/Camera.h"
#include "ngl/Colour.h"
#include "ngl/SpotLight.h"
#include "ngl/TransformStack.h"

#include "ShaderLibrary.h"
#include "Solver.h"
#include "Environment.h"
#include "Cache.h"

#include <QtOpenGL>


class Simulation : public QGLWidget
{
Q_OBJECT

public:
    Simulation(
            QWidget* _parent
        );

    ~Simulation();

    void keyPress(QKeyEvent* _event);

    inline Solver* getSolver() const { return  m_solver; }

    inline Environment* getEnvironment() const { return  m_environment; }

    inline Integration* getIntegration() const { return  m_integration; }

    void setup2DTopView();

    void setup2DFrontView();

    void toggleCache();

    void toggleAutomaticCacheFlush();

    void updateFPSTimer();

    void flushCache();


    inline bool getCacheEnabled() const { return m_cacheEnabled; }

    inline int getCacheSamplingInterval() const { return m_cacheSamplingInterval; }

    inline bool getCacheAutomaticFlushEnabled () const { return m_cacheAutomaticFlushEnabled; }

    inline int getCacheAutomaticFlushInterval() const { return m_cacheAutomaticFlushInterval; }

    inline bool getCacheExportRBDEnabled() const { return m_cacheExportRBDEnabled; }

    inline bool getCacheExportBoundaryEnabled() const { return m_cacheExportBoundaryEnabled; }

    inline std::string getCachePath() const { return m_cachePath; }


    inline void setCacheEnabled(const bool _v) { m_cacheEnabled = _v; }

    inline void setCacheSamplingInterval(const int _v) { m_cacheSamplingInterval = _v; }

    inline void setCacheAutomaticFlushEnabled (const bool _v) { m_cacheAutomaticFlushEnabled = _v; }

    inline void setCacheAutomaticFlushInterval(const int _v) { m_cacheAutomaticFlushInterval = _v; }

    inline void setCacheExportRBDEnabled(const bool _v) { m_cacheExportRBDEnabled = _v; }

    inline void setCacheExportBoundaryEnabled(const bool _v) { m_cacheExportBoundaryEnabled = _v; }


public slots:
    void updateCameraZoom(const int _depth);


protected:
    void initializeGL();

    void resizeGL
                (
                    const int _w,
                    const int _h
                );

    void paintGL();


private :
    int m_spinXFace;

    int m_spinYFace;

    bool m_rotate;

    int m_origX;

    int m_origY;

    int m_moveX;

    int m_moveY;

    bool m_move;

    int m_origMoveX;

    int m_origMoveY;

    bool m_drawHelp;

    float m_aspect;

    int m_mouseMoveSensitivity;

    int m_frameRate;

    ngl::TransformStack m_transformStack;

    ngl::Light m_light;

    ngl::Camera m_camera;

    ShaderLibrary* m_shaderLibrary;

    Solver* m_solver;

    Environment* m_environment;

    Integration* m_integration;

    Cache* m_cache;

    float m_lastCamZ;

    int m_frameCounter;

    int m_mainSimulationTimer;

    QTimer* m_fpsTimer;

    bool m_fpsTimerEnabled;

    QTimer* m_simulationCacheTimer;

    QTimer* m_simulationCacheAutoFlushTimer;

    int m_simulationCacheFrameNumber;

    bool m_cacheEnabled;

    int m_cacheSamplingInterval;

    bool m_cacheAutomaticFlushEnabled;

    int m_cacheAutomaticFlushInterval;

    bool m_cacheExportRBDEnabled;

    bool m_cacheExportBoundaryEnabled;

    std::string m_cachePath;


private :
    void timerEvent(QTimerEvent* _event);

    void createCamera();

    void createLight();

    void displayHelp();

    void mouseMoveEvent(
                            QMouseEvent* _event
                        );

    void mousePressEvent(
                            QMouseEvent* _event
                        );

    void mouseReleaseEvent(
                            QMouseEvent* _event
                            );

    void initialiseSimulation();

    void deleteSimulationObjects();



private slots:
    void processFPS();

    void processSimulationCache();

    void processSimulationCacheAutoFlush();


};
#endif // SIMULATION_H