GlobeEngine.h

Go to the documentation of this file.

#ifndef GlobeEngine_GlobeEngine_h
#define GlobeEngine_GlobeEngine_h

#include <math.h>
#include <ctime>
#include <iostream>
#include <stdio.h>
#include <vector>
#include "OpenGL_Includes.h"
#include "Engine.h"
#include "FrameBufferObject.h"
#include "Shader.h"
#include "FlightCamera.h"
#include "OrthographicMapCamera.h"
#include "Common.h"
#include "CoordinateSystem.h"
#include "ArcBallCamera.h"
#include "Globe.h"
#include "SceneStateSet.h"
#include "DebugMap.h"
#include "SceneBluePrint.h"
#include "Cube.h"
#include "DrawableComponent.h"
#include "ColorisationTable.h"
#include "GlobeComposition.h"
#include "Skybox.h"
#include "Cube.h"
#include "Plane.h"
#include "DebugLogger.h"
#include "Timer.h"
#include "StyleCollection.h"
#include "AnimationPath.h"
#include "VolumeRenderer.h"

namespace geGIS {
    
    class ModelLayer;
    
    
    struct PickingResult
    {
        int pickCoordinates[2];
        GLint pickResultGroup; // ID of the type of vector data
        GLint pickResultID; // ID of the vector data set
        GLint entityID; // ID of the picked entity of a vector data set
    };

    struct GBufferHandles
    {
        GLuint colorChannel1;
        GLuint colorChannel2; 
        GLuint depthChannel;
    };
    
    class GlobeEngine : public ge::Engine
    {
    public:
        GlobeEngine();
        ~GlobeEngine();
        
        void clear();
        void destroy();
        void create(const std::shared_ptr<geGIS::SceneBlueprint>& _scene);
        void setModelAndBluePrintReference(std::shared_ptr<geGIS::ModelLayer> _modelLayer);
        
        void initializeScene(std::string _pathFile = 0);
        void drawScene();
        void resize(int _w, int _h);
        void update();
        
        void drawUtilities(std::shared_ptr<ge::Camera> _cam);
        void drawDecals(std::shared_ptr<ge::Camera> _cam);
        void selectPixel(int x, int y);
        void showCameraFrustums(bool _in);
        void setEditortable(geData::HeightColorTable _colortable);
        
        void requestOcclusionQuery();
        void setAAWeight(float _in);
        void setAAActive(bool _in) ;
        void setBackgroundColor(vmml::Vector3f _color);
        
        void setPickingColor(vmml::Vector3f _color){
            this->pickingColor = _color;
        }
        
        void setPickingOffset(vmml::Vector2f _offset){
            this->pickingOffset = _offset;
        }

        //void setColortableIndex(int _value);
        //void setStencilInDepth(bool _in);
        void saveScreenshot(std::string _filePath, int _bufferID = 0);
        
        void showSkybox(bool _in);
        //std::vector<std::string> getColortableNames();
        
        // composition property
        void setSceneCompositionHandleForStencilTexture(std::shared_ptr<ge::TextureHandle> _in);
        
        // other rendering effects
        void isShadowMappingEnabled(bool _in);
        bool isShadowMappingEnabled();
        
        void isAmbientOcclusionEnabled(bool _in);
        bool isAmbientOcclusionEnabled();
        
        void setSSAOParameter(SSAOParameter _in);
       /* void setSSAOCompositionTotalStrength(double _in);
        void setSSAOCompositionStrength(double _in);
        void setSSAOCompositionOffset(double _in);
        void setSSAOCompositionFalloff(double _in);
        void setSSAOCompositionRadius(double _in);*/
        void setSuperSamplingMultiplicator(double _in);
        double getSuperSamplingMultiplicator(double _in);

        void updateFramebufferStandardID();

        void moveCameraToPosition(vmml::Vector3d _pos);

        vmml::Vector2d get2dPoint(vmml::Vector3d _p, vmml::Matrix4d _modelMatrix = vmml::Matrix4d::IDENTITY);
        
        void enableEdgeHightlighting(bool _in);
        void setEdgeHightlightingThreshold(float _in);

        GBufferHandles getGBufferHandles() const;

        // GPU Feature drawing
        bool isClusteredShadingEnabled() const;
        bool isMortonOrderShadingEnabled() const;

        void enableGPUFeatures(geGIS::GPUFeatureFlags _in);
        void setGPUBufferHandle(GLuint _in, GLuint _inBound, unsigned int _maxDepth, GLuint _attrHandle=0);
        void setGPUFeatureLineRadius(double _rad, double _maxRad);
        void setGPUMouseLensRadius(float _in);
        void setGPUMouseLensCategory(int _in);
        void setRenderingWithTerrain(bool _terrainVis);
        void setRenderingWithVolume(bool _volumeVis);

        void setGPUStyleBufferHandles(geGIS::StyleCollectionUniformHandles _in);
        void setMouseCoordForGPUFeature(vmml::Vector2f _mouseCoord);
        std::shared_ptr<ge::Shader> getActiveCompositionShader();

        // other functions
        void recompileShadersAfterNextUpdate();

        // Camera animation
        void startCameraAnimation();

        void setReportActive(bool _in);
        void enableVolumeRenderer(vmml::Vector3d _scale, vmml::Vector3d _position);
        void disableVolumeRenderer();
        
        std::shared_ptr<geFlow::VolumeRenderer> getVolumeRenderer();
        std::shared_ptr<geFlow::VolumeComposition> getVolumeComposition();
        void setTFforVolumeRendering(unsigned char* _transferFunctionData);
        void applyVolumeInfo();
        
    private:
        using ge::Engine::create; // implicitly hidden
        
        void paintAccumulatedLines();
        void drawOcclusionQueryPass();
        void drawScreenshot(bool _ssaoActive);
        void drawAmbientOcclusionPass();
        void drawMainPass();
        void drawShadowMapPass();
        void drawStencilBuffer(std::shared_ptr<ge::Camera> _cam);
        void drawFeatures(std::shared_ptr<ge::Camera> _cam);
        void drawClusteredVectorMaps();
        void setupSceneCameras();
        void pickFromFramebuffer(int _AASizeMultiplicator = 1);
        void drawDebugMaps();

        GLfloat renderModeValue;
        std::shared_ptr<ge::Shader> programForDebug;
        std::shared_ptr<ge::Shader> programForDebugDepth;
        std::shared_ptr<ge::Shader> programForDebugStencil;
        std::shared_ptr<ge::Shader> programForDebugInt;
        std::shared_ptr<ge::Shader> programForUtilities;
        std::shared_ptr<ge::Shader> programForSkybox;
        std::shared_ptr<ge::Shader> programForColoredGeometry;
        std::shared_ptr<ge::Shader> programForCubes;
        std::shared_ptr<ge::Shader> computeProgramForClusteredShading;

        // CoordinateCross
        ge::CoordinateSystem coordinateSystem;
        
        // Scenegraph Scalable objects
        std::shared_ptr<geGIS::ModelLayer> modellayer;
        std::shared_ptr<SceneBlueprint> sceneBlueprint;
        ge::SceneStateSet sceneStates[5];
        
        GlobeComposition sceneComposition;
        ResampleComposition resampleComposition;
        
        Globe globe;
        ge::Skybox* skybox;
        ge::Plane* plane;
        
        std::shared_ptr<geData::AnimationPath> cameraFlight;
        float elapsedTime;
        float maxTime;
        bool animationInProgress;

        ge::FrameBufferObject gBuffer;
        ge::FrameBufferObject occlusionFBO;
        ge::FrameBufferObject stencilFBO;
        ge::FrameBufferObject stencilColorFBO;
        ge::FrameBufferObject shadowMap;
        ge::FrameBufferObject accumulatedLineInfo;
        ge::FrameBufferObject decalpass;
        
        enum ge::DrawableComponent::RENDERSTATE renderstate;
        enum ge::Camera::CAMERATYPE cameratype;
        
        // camera properties
        int cameraIdxOcclusions;
        int cameraIdxShadows;

        // planes for occlusion queries
        ge::Plane scanplanes[3];


        // Picking result
        PickingResult toPick;
        PickingResult previous;
        vmml::Vector3f pickingColor;
        vmml::Vector2f pickingOffset;
        
        // Debug
        ge::Timer timer;
        geUtil::DebugMap debugmaps[9];
        geUtil::DebugLogger openglDebugLogger;
        
        ge::DrawableComponent::RENDERSTATE occlusionState;
        ge::DrawableComponent::RENDERSTATE occlusionRequestState;
        bool inOcclusionQueryProcess;
        
        // Antialiasing
        float antialiasingWeight;
        bool activeAA;
        double superSamplingSizeMultiplicator;
        bool superSamplingActive;
         
        // Stencil colorisation
        //std::vector< std::shared_ptr<geData::ColorisationTable> > colorisationTables;
        //int tableIndex;
        //bool stencilColorInDepth;
        
        // hi res screenshot
        int screenShot;
        std::string screenShotFilePath;
        
        // shadow mapping
        bool shadowMappingEnabled;
        vmml::Matrix4d invViewMatrix;
        vmml::Matrix4d depthTextureMatrix;
        vmml::Matrix4d biasMatrix;  
        
        // Ambient occlusion
        SSAOComposition ssaoComposition;
        
        std::shared_ptr<geGIS::SceneBlueprint> earthscene;

        // GBuffer information
        GBufferHandles gbufferInfo;

        // Clustered Shading on
        bool clusteredShadingActive;
        bool mortonOrderShadingActive;
        bool mouseLensForGPUFeaturesActive;

        // Shader recompiler
        bool recompileShaders;

        // Texture
        std::shared_ptr<ge::Texture2Drgba> computeTexture;

        // Volume Rendering 
        std::shared_ptr<geFlow::VolumeRenderer> volumeRenderer;
        std::string volumeShaderPath;

        bool reportActive;
        bool reportCommandApplied;
    };
}
#endif