GlobeComposition.h

Go to the documentation of this file.

#ifndef GlobeEngine_GlobeComposition_h
#define GlobeEngine_GlobeComposition_h

#include "Composition.h"
#include "SpotLight.h"
#include "StyleCollection.h"

namespace geGIS {

    struct SSAOParameter {
        double strength;
        double totalStrength;
        double offset;
        double falloff;
        double radius;

        SSAOParameter(){
            this->strength = 0.07;
            this->totalStrength = 1.38;
            this->offset = 18.0;
            this->falloff = 0.000002;
            this->radius = 0.006;
        }

        SSAOParameter(double _strength, double _totalStrengh,
            double _offset, double _falloff, double _radius) :
            strength(_strength), totalStrength(_totalStrengh),
            offset(_offset), falloff(_falloff),
            radius(_radius){}

        SSAOParameter(const std::shared_ptr<SSAOParameter> copy) {
            strength = copy->strength;
            totalStrength = copy->totalStrength;
            offset = copy->offset;
            falloff = copy->falloff;
            radius = copy->radius;
        }
    };


    struct GPUFeatureFlags
    {
        bool gpufeatures;
        bool heatmap;
        bool clustering;
        bool mortonorder;
        bool clusterview;
        bool lineAdjustment;
        int mouseLens;
        int mouseLensCategory;
        float mouseLensRadius;
        
        GPUFeatureFlags(){
            this->gpufeatures = false;
            this->clustering = false;
            this->heatmap = false;
            this->clusterview = false;
            this->mortonorder = false;
            this->lineAdjustment= false;
            this->mouseLens = 0;
            this->mouseLensRadius = 0.01;
            this->mouseLensCategory = 4;
        }

        GPUFeatureFlags(bool _gpuFeaturesEnabled, bool _heatmapEnabled,
            bool _clusteringEnabled, bool _mortonorderEnabled, bool _clusterviewEnabled, bool _lineAdjustmentEnabled) :
            gpufeatures(_gpuFeaturesEnabled), heatmap(_heatmapEnabled),
            clustering(_clusteringEnabled), lineAdjustment(_lineAdjustmentEnabled), mortonorder(_mortonorderEnabled),
            clusterview(_clusterviewEnabled){}

        // copy constructor
        GPUFeatureFlags(const std::shared_ptr<GPUFeatureFlags> copy){
            gpufeatures = copy->gpufeatures;
            clustering = copy->clustering;
            heatmap = copy->heatmap;
            clusterview = copy->clusterview;
            lineAdjustment = copy->lineAdjustment;
            mortonorder = copy->mortonorder;
            mouseLens = copy->mouseLens;
            mouseLensRadius = copy->mouseLensRadius;
            mouseLensCategory = copy->mouseLensCategory;
        }
    };

    class GlobeComposition : public ge::Composition
    {
    public:
        GlobeComposition();
        ~GlobeComposition() {};

        void enableEdgeHightlights(bool _in);
        void setColorForEdgeHightlights(vmml::Vector4f _in);
        void setLaplaceFilterThreshold(float _in);

        
        const ge::DirectionalLight* getSunlight(){
            return &this->directionalLight;
        };

        void setGPUFeatureFlags(GPUFeatureFlags _in);
        const GPUFeatureFlags* getGPUFeatureFlags();

        void setGPUFeatureBufferHandle(GLuint _handle);
        void setGPUFeatureBufferAndBoundsHandle(GLuint _handle, GLuint _boundhandle);
        void setGPUFeatureAttributeBufferHandle(GLuint _handle);
        void setGPUFeatureStyleBufferHandles(geGIS::StyleCollectionUniformHandles _handles);
        void enableDecals(bool _in);
        bool isDecalpassEnabled();

        void setGPUFeatureHierachyMaxDepth(int _input);
        void setGPUFeatureLineRadius(double _rad, double _maxRad);
        void setGPUMouseLensRadius(float _in);
        void setGPUMouseLensCategory(int _in);
        void setGPUClusteredSize(vmml::Vector2d _size);
        void setGPUClusteredObjectBounds(vmml::Vector4d _bound);
        bool isPerspectiveLineAdjustmentEnabled();
        void enablePerspectiveLineAdjustment(bool _in);

        void setMouseCoord(vmml::Vector2f _mouseCoord);

    protected:
        void drawFrame(std::shared_ptr<ge::Camera> _cam);
        
        bool decalsEnabled;
        
        bool edgesHighlighted;
        float laplacefilterThreshold;
        vmml::Vector4f edgeHighlightColor;

        // Licht
        ge::Light light;
        ge::SpotLight spotLight;
        ge::DirectionalLight directionalLight;

        // GPU feature buffer handle
        GPUFeatureFlags featureflags;
        GLuint gpuBufferHandle;
        GLuint gpuBoundBufferHandle;
        GLuint gpuCategoryBufferHandle;
        geGIS::StyleCollectionUniformHandles styleBufferHandles;
        vmml::Vector2d clusterSize;
        vmml::Vector4d objectBounds;

        vmml::Vector2f mouseCoord;

        double lineRadius;
        double maxlineRadius;

        int maxDepth;
        // perspective line adjustment on = 1.0, otherwise 0.0;
        float plaOnOff;
    };
    
    class ResampleComposition : public ge::Composition
    {
    public:
        ResampleComposition(){
            ssaoActive = false;
            fboUIActive = false;
        };
        ~ResampleComposition(){};
        
        void setSSAOEnabled(bool _in) {
            ssaoActive = _in;
        }

        bool isSSAOactive() {
            return ssaoActive;
        }

        void enableUIFbo() {
            fboUIActive = true;
        }

        void disableUIFbo() {
            fboUIActive = false;
        }

        bool isUIFboactive() {
            return fboUIActive;
        }
        
    protected:
        void drawFrame(std::shared_ptr<ge::Camera> _cam);

    private:
        bool ssaoActive;
        bool fboUIActive;
    };
    
    /*
     *  composition for screen space ambient occlusion
     */
    class SSAOComposition : public ge::Composition
    {
    public:
        SSAOComposition();
        ~SSAOComposition();
        
        void generateRandomTexture();
        void setSSAOParamter(SSAOParameter _in);
        const SSAOParameter* getSSAOParamter();
        
    private:
        void drawFrame(std::shared_ptr<ge::Camera> _cam);

        std::shared_ptr<ge::Texture2Drgba> randomTex;
        SSAOParameter ssaoparameter;

    };
}
#endif