ClimateViewerEngine.h

Go to the documentation of this file.

#ifndef GlobeEngine_ClimateViewerEngine_h
#define GlobeEngine_ClimateViewerEngine_h

#include <math.h>
#include <ctime>
#include <iostream>
#include <stdio.h>
#include <vector>
#include "OpenGL_Includes.h"
#include "Engine.h"
#include "Shader.h"
#include "FlightCamera.h"
#include "Common.h"
#include "CoordinateSystem.h"
#include "SceneStateSet.h"
#include "DrawableComponent.h"
#include "Cube.h"
#include "Sphere.h"
#include "DebugLogger.h"
#include "Timer.h"
#include "MemoryState.h"
#include "DebugMap.h"
#include "ClimateViewerComposition.h"
#include "Plane.h"
#include "ArrowField.h"
#include "Streamlines.h"
#include "MultiLineWithBoundaries.h"
#include "Jzon.h"
#include "WeatherData.h"

namespace geClimateViewer {
    struct StreamlineProperties{
        int seeds;
        int lineLength;
        float dt;
        float minDistance;
        bool checkMinDistance;
    };

    struct UISettings{
        int lineLength;
        int seedsNumber;
        float dt;
        float minDistance;
        bool showvector;
        bool checkMinDistance;
        bool drawRandom;
        bool drawTopo;
        int lineSteps;
        int activePoint=-1;
        int activeRegion=0;
        int activeStreamline=0;
        bool showperp=true;
        int x=0;
        int y=0;
        int sizeX=0;
        int sizeY=0;
        int sizeZ=1;
        float arrowsLength;
        float topologyDt;
        float topologyPerpDt;
        float simpEpsilon;
        int colormap;
        float sphereSize;
        float bgr,bgg,bgb;
        int currTimestep=0;
        int timeStepFrom=0,timeStepTo=0;
    };

    class ClimateViewerUI;

    class ClimateViewerEngine : public ge::Engine
    {
    public:
        ClimateViewerEngine(std::string _sceneFilePath);
        ~ClimateViewerEngine();
        
        void clear();
        void destroy();
        void create();
        
        // overrides from ge::Engine
        void initializeScene(std::string _projectsrcPath=0);
        void drawScene();
        void resize(int _w, int _h);
        void update();
        
        void createArrowsFromClimateData(std::shared_ptr<VectorField> _data);

        void updateFramebufferStandardID();
        void createStreamlines();
        void createStreamlinesRandom();
        void loadData();
        void calculateTopology();
        void calculatePerpLines();
        
        UISettings uiSettings;
        
        void updateUiSettings(UISettings _newSettings);
        void highlightStreamline();
        
        void saveCurrentStateToSHP(std::string _path);
        void saveStreamlinesToSHP(std::string _path);
        void saveTopologyToSHP(std::string _path);
        void setUi(ClimateViewerUI *_ui);//{ui=_ui;};
        void play();
        void progress(int _p);
        void direct(std::string _path);

    private:
        std::shared_ptr<ge::Shader> programForUtilities;
        std::shared_ptr<ge::Shader> programForArrows;
        std::shared_ptr<ge::Shader> programForStreamlines;
        std::shared_ptr<ge::Shader> programForStreamlinesRandom;
        std::shared_ptr<ge::Shader> programForSpheres;
        std::shared_ptr<ge::Shader> programForDebug;
        std::shared_ptr<ge::Shader> programForCube;
        std::shared_ptr<ge::Shader> programForPlanes;
        std::shared_ptr<ge::Shader> programForMultiline;
        ge::SceneStateSet sceneStates[1];
        
        //std::shared_ptr<ge::Cube> cube;
        ge::CoordinateSystem coordinateSystem;

        std::shared_ptr<ge::Plane> plane;
        std::shared_ptr<ge::Sphere> sphere;
        std::shared_ptr<ge::Texture2Drgba> spheretex;
        std::shared_ptr<ge::Cube> testCube;
        std::vector<std::shared_ptr<geFlow::ArrowField>> arrowFields;
        std::shared_ptr<geFlow::ArrowField> arrowFieldDeriv;
        std::vector<std::shared_ptr<Streamlines>> streamlinesRandom;

        float rot;
        
        // Debugger functionality
        geUtil::DebugLogger openglDebugLogger;
        ge::Timer openglTimer;
        geUtil::MemoryState openglMemory;
        geUtil::DebugMap debugmaps[2];
        
        ClimateViewerComposition uiComposition;

        ge::FrameBufferObject climateGBuffer;
        
        int screenWidth;
        int screenHeight;

        // path to xml command line argument
        std::string sceneFilePath;
        
        std::vector<std::shared_ptr<VectorField> > climateData;
        std::vector<std::shared_ptr< ge::Sphere> > criticalPointsSpheres;
        std::vector<vmml::Vector3f> seedPoints;
        PolyLineExt highlight;
        // std::vector<std::shared_ptr<ClimateData>> data;
        std::shared_ptr<geFlow::WeatherData> data;
        vmml::Vector3f pos;
        std::string shaderpath;
        
       // ge::Timer openglTimer;
        ClimateViewerUI *ui;
        float progressed;
        
    };
}
#endif