ExoEngine.h

Go to the documentation of this file.

#ifndef exoViewer_ExoEngine_h
#define exoViewer_ExoEngine_h

#include <math.h>
#include <ctime>
#include <iostream>
#include <stdio.h>
#include <vector>
#include <vmmlib/vmmlib.hpp>
#include "OpenGL_Includes.h"
#include "Engine.h"
#include "Shader.h"
#include "Common.h"
#include "AstroCoordinateSystem.h"
#include "SceneStateSet.h"
#include "DrawableComponent.h"
#include "System.h"
#include "tinyxml2.h"
#include "Texture.h"
#include "FrameBufferObject.h"
#include "Skybox.h"
#include "ExoComposition.h"
#include "Ring.h"
#include "UnitCircles.h"
#include "ArcBallCamera.h"
#include "OrthographicMapCamera.h"
#include "FlightCamera.h"
//#include "DebugMap.h"
#include "PassiveCamera.h"
#include "DebugLogger.h"
#include "XMLGetter.h"
#include "Universe.h"
#include "OrbitJob.h"
#include "DebugMapProvider.h"
#include "ComparisonGrid.h"
#include "CoordinateSystem.h"
#include "OverviewPointCloud.h"
#include "GaussianBlurComposition.h"
#include "BloomComposition.h"
#include "ComparisonComposition.h"
#include "Comparisoner.h"


namespace geAstro{

    enum PickingEvent{ IDLE, MARKINGEVENT, PICKINGEVENT, LABELPICKINGEVENT };

    enum SceneType{ VISUALIZATION, OVERVIEWMAP, PLANETCOMPARISON};

    class ExoEngine : public ge::Engine
    {
    public:
        ExoEngine();
        ~ExoEngine();

        void clear();
        void destroy();
        void create();
        void initializeScene(std::string path);

        void drawScene();
        void resize(int _w, int _h);
        void update();

        void toggleAnimation();
        void toggleOrbits();
        void toggleHabitableZone();
        void toggleCoordinateAxes();
        void toggleUnitCircles();
        void toggleScaled();
        void toggleSkybox();
        void setDate(double _julianDay);
        void setSpeed(double _daysPerUpdate);
        void setUnitCircles(double _unitSize, int _unit, int _numberOfRings);
        void setIsCoreView(bool _isCoreView);
        void setIsMapView(bool _isMapView);

        //comparison stuff
        void setSceneToDisplay(geAstro::SceneType _sceneToDisplay);
        void repositionDrawables(geAstro::SceneType _sceneToDisplay);

        double getSpeed() const;
    
        void setSelectedHasChanged(bool _selectedHasChanged);
        bool getSelectedHasChanged();
        void setSystemInFocus(int _systemIndex);

        const std::shared_ptr<System> getSystemByName(std::string _name);
        const std::shared_ptr<Universe> getUniverse();

        vmml::Vector3i getDate();
        vmml::Vector2d get2dPoint(vmml::Vector3d _p);
        vmml::Vector2d get2dPoint(vmml::Vector3d _p, vmml::Matrix4d _modelMatrix);

        /*void isUsingPassiveCamera(bool _value);
        bool isUsingPassiveCamera();
        */
        void toggleDebugMap();

        void setPickingEvent(PickingEvent pe);
        void setPickingCoordinates(vmml::Vector2i _coord);

        const std::vector<std::shared_ptr<System>>& getSystems();

        std::shared_ptr<System> getSystemInFocus();

        
        void setMousePosition(int x, int y);
        vmml::Vector2i getMousePosition();

        void navigateToCurrentSelection();
        void navigateToNewSelection(UniverseSelection _sel);
        void navigateToNewSelectionInSystem(UniverseSelection _sel);
        void navigateBack();

        void reloadShaders();

        void sortUIInfoForSystemInFocus();

        const std::vector<UIBodyInfo>& getSystemsUIInfo() const;
        const std::vector<UIBodyInfo>& getSunsUIInfo() const;
        const std::vector<UIBodyInfo>& getPlanetUIInfo() const;
        const std::vector<UIBodyInfo>& getMoonUIInfo() const;
        const std::vector<UIBodyInfo>& getSmallBodyObjectUIInfo() const;
        const UIBodyInfo& getSelectedUIInfo() const;
        const std::vector<int>& getUIInfoSizes() const;

        UniverseSelection getSelectionForUIInfoID(int _idx) const;

        Comparisoner& getComparisoner();

    private:
        void updateFramebufferStandardID();
        void setUpUpdateJobs();

        void setupCameras();
        void setCamerasForResize();
        vmml::Vector4d calculateOrthoCamCoordinates();

        vmml::Vector2d calculateLightPositionOnScreen();

        void drawVisualizationScene();
        void drawOverviewMapScene();
        void drawPlanetComparisonScene();

        void drawBodies();
        void evaluatePickingEvent();
        void drawOrbits();
        void drawHabitableZone();
        void drawSkybox();
        void drawDebugMap();

        XMLGetter* xmlGetter;

        std::shared_ptr<ge::Shader> programForUnitCircles;
        std::shared_ptr<ge::Shader> programForSkybox;
        std::shared_ptr<ge::Shader> programForUtilities;
        std::shared_ptr<ge::Shader> programForDebug;
        std::shared_ptr<ge::Shader> programForCoordinateSystem;

        // The universe
        std::shared_ptr<Universe> universe;
        // CoordinateCross
        AstroCoordinateSystem coordinateSystem;
        // grid for comparison view
        ComparisonGrid comparisonGrid;
        // unit circles to draw
        std::shared_ptr<UnitCircles> unitCircles;
        // Basic scene state
        ge::SceneStateSet sceneStates[2];

        double initialDate;
        double currentDate;
        double daysPerUpdate;

        std::string shaderPath;
        std::string skyboxPath;

        bool pauseAnimation;
        bool showOrbits;
        bool showSkybox;
        bool smallBodiesAsPointCloud;
        bool isCoreView;
        bool isMapView;

        SceneType sceneToDisplay;

        ge::FrameBufferObject bodiesFbo;
        ge::FrameBufferObject orbitsFbo;
        ge::FrameBufferObject habZoneAndSkyboxFbo;

        //FBOs for sun rendering
        ge::FrameBufferObject sunBuffer;

        bool selectedHasChanged;
        int systemInFocus;

        //composition for sun rendering blur
        geExoViewer::GaussianBlurComposition gaussianBlurPassHorizontal;
        geExoViewer::GaussianBlurComposition gaussianBlurPassVertical;

        //composition for bloom
        geExoViewer::BloomComposition bloomComposition;

        //composition for planet comparison
        geExoViewer::ComparisonComposition comparisonComposition;

        //sun rendering rotation
        float sunRotation;
        float sunOverlayRotation;

        bool usingEQCamera;

        geExoViewer::ExoComposition outlineComposition;
        std::shared_ptr<ge::Skybox> skybox;

        ge::ViewFrustumProperties vfprop;
        ge::ViewFrustumProperties vfpropOrtho;

        vmml::Vector2i screenExtent;
        PickingEvent pickingevent;
        vmml::Vector2i pickCoord;
        vmml::Vector2i mousePosition;

        geUtil::DebugMapProvider* debugMapProvider;
        geUtil::DebugLogger openglDebugLogger;

        std::vector<OrbitJob*> runnables;
        std::vector<UIBodyInfo> systemsUIInfo;
        std::vector<UIBodyInfo> sunsUIInfo;
        std::vector<UIBodyInfo> planetUIInfo;
        std::vector<UIBodyInfo> moonUIInfo;
        std::vector<UIBodyInfo> smallBodyObjectUIInfo;
        UIBodyInfo selectedUIInfo;
        std::vector<int> uiInfoSizeSums;

        //comparison stuff
        Comparisoner comparisoner;
    };

}
#endif