SceneBluePrint.h

Go to the documentation of this file.

#ifndef GlobeEngine_SceneBluePrint_h
#define GlobeEngine_SceneBluePrint_h

#include <string>
#include <vector>
#include <vmmlib/vmmlib.hpp>

#include "BluePrints.h"
#include "Camera.h"
#include "VBOVertex.h"

#include "StyleCollection.h"
#include "FeatureRange.h"
#include "FlowDataBlueprint.h"

// XML Support
#include "tinyxml2.h"
#include "tinyxml2utils.h"

namespace geGIS {

    struct UIBlueprint
    {
        std::string qmlWindowPath;
    };

    struct TileServiceInfoBlueprint
    {
        int minlod;
        int maxlod;
        
        TileServiceInfoBlueprint(){}
        TileServiceInfoBlueprint(int _minlod,int _maxlod):
        minlod(_minlod),maxlod(_maxlod){}
    };
    
    struct FeatureBlueprint
    {
        std::string name;
        bool visibleAtStart;
        vmml::Vector3f pos;
        std::string url;
        geGIS::FeatureRange entityRange;
        geGIS::FeatureRange lineRange;
        geGIS::FeatureRange timeRange;
        double timeIntervall;
        std::shared_ptr<ge::ShaderBlueprint> shader;
        //std::string shaderName;
        std::string driver;
        TileServiceInfoBlueprint tileservice;
        bool drawInDeferredPass;
        bool drawWithClusteredShading;
        std::vector<std::string> namesInfoTables;
        std::shared_ptr<StyleCollection> stylecollection;
        vmml::Vector3f textColor;

        FeatureBlueprint(){}
        FeatureBlueprint(std::string _name, vmml::Vector3f _pos, 
            std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, 
            std::shared_ptr<ge::ShaderBlueprint> _shader, 
            std::string _driver, TileServiceInfoBlueprint _tfinfo, 
            bool _gpufeature, bool _clustered) : name(_name), pos(_pos), url(_url),
            entityRange(_entRange), lineRange(_lineRange), shader(_shader), 
            driver(_driver), tileservice(_tfinfo), drawInDeferredPass(_gpufeature), 
            drawWithClusteredShading(_clustered){}
        
        // copy constructor
        FeatureBlueprint(const std::shared_ptr<FeatureBlueprint> copy){
            name = copy->name;
            pos = copy->pos;
            url = copy->url;
            visibleAtStart = copy->visibleAtStart;
            entityRange = copy->entityRange;
            lineRange = copy->lineRange;
            timeRange = copy->timeRange;
            shader = copy->shader;
            driver = copy->driver;
            tileservice = copy->tileservice;
            drawInDeferredPass = copy->drawInDeferredPass;
            drawWithClusteredShading = copy->drawWithClusteredShading;
            namesInfoTables = copy->namesInfoTables;
            stylecollection = copy->stylecollection;
            textColor = copy->textColor;
        }
    };
    
    struct BaseTextureBlueprint : FeatureBlueprint
    {
        //std::string type;
        std::string url;
        std::string format;
        std::string driver;
    };
    
    struct TMSElevationBlueprint : BaseTextureBlueprint
    {
        unsigned int maxLod;
        float distLod;
        unsigned int kpatchBasisType;
        std::string algorithm;
        float scale;
        std::vector< std::shared_ptr<BaseTextureBlueprint> > imagery;
    };
    
    struct RefenceSystemBlueprint : FeatureBlueprint
    {
        float scaleTo;
        std::string profile;
    };

    struct CommuterBlueprint : FeatureBlueprint
    {
        CommuterBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        CommuterBlueprint(const std::shared_ptr<FeatureBlueprint> _input):FeatureBlueprint(_input){}
        std::string starts;
        std::string ends;
        vmml::Vector3f color;
        std::vector < std::string >  weightFields;
        std::string algorithm;
        int minimumCommuterValue;
    };
    
    struct BundlingBlueprint : FeatureBlueprint
    {
        BundlingBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        BundlingBlueprint(const std::shared_ptr<FeatureBlueprint> _input):FeatureBlueprint(_input){}
        std::string starts;
        std::string ends;
        vmml::Vector3f color;
        std::string algorithm;
        int polynomDegree;
        bool multipleSplineGeometry;
        std::shared_ptr<ge::ShaderBlueprint> splineshader;
        std::shared_ptr<ge::ShaderBlueprint> gpusplineshader;
    };

    struct TrafficBlueprint : FeatureBlueprint
    {
        TrafficBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        TrafficBlueprint(const std::shared_ptr<FeatureBlueprint> _input):FeatureBlueprint(_input){}
        vmml::Vector3f color;
    };
    
    struct StructureBlueprint : FeatureBlueprint
    {
        StructureBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        StructureBlueprint(const std::shared_ptr<FeatureBlueprint> _input) :FeatureBlueprint(_input){}
        std::string format;
        vmml::Vector3f color;
    };

    struct BorderBlueprint : FeatureBlueprint
    {
        BorderBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        BorderBlueprint(const std::shared_ptr<FeatureBlueprint> _input):FeatureBlueprint(_input){}
        vmml::Vector3f color;
        std::string categoryField;
    };
    
    struct ClimateBlueprint : FeatureBlueprint
    {
        ClimateBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        ClimateBlueprint(const std::shared_ptr<FeatureBlueprint> _input) :FeatureBlueprint(_input){}
        std::shared_ptr<geFlow::WeatherDataLoadingInfo> weatherLoadingInfo;
    };

    struct GreatCircleBlueprint : FeatureBlueprint
    {
        GreatCircleBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        GreatCircleBlueprint(const std::shared_ptr<FeatureBlueprint> _input):FeatureBlueprint(_input){}
        std::shared_ptr<ge::ShaderBlueprint> iconshader;
        std::string iconurl;
        vmml::Vector3f color;
    };
    
    struct HousingBlueprint : FeatureBlueprint
    {
        HousingBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        HousingBlueprint(const std::shared_ptr<FeatureBlueprint> _input):FeatureBlueprint(_input){}
        vmml::Vector3f color;
        std::vector < std::string >  weightFields;
        std::string type;
    };
    
    struct CoatOfArmsBlueprint : FeatureBlueprint
    {
        CoatOfArmsBlueprint(std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        CoatOfArmsBlueprint(const std::shared_ptr<FeatureBlueprint> _input):FeatureBlueprint(_input){}
        vmml::Vector3f color;
        std::string type;
        std::string refToNamesTable;
        std::string textureRepository;
    };

    struct PointFeatureBlueprint : FeatureBlueprint
    {
        PointFeatureBlueprint(double _pointSize, std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : FeatureBlueprint(_name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered), pointSize(_pointSize) {}
        PointFeatureBlueprint(const std::shared_ptr<FeatureBlueprint> _input):FeatureBlueprint(_input){}
        vmml::Vector3d color;
        std::string heighttable;
        double pointSize;
    };
    
    struct ChartBlueprint : PointFeatureBlueprint
    {
        ChartBlueprint(double _pointSize, std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : PointFeatureBlueprint(_pointSize, _name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        ChartBlueprint(const std::shared_ptr<FeatureBlueprint> _input):PointFeatureBlueprint(_input){}
        std::string entryNamesTable;
        std::string charttype;
        std::string type;
    };
    
    struct TrafficInfoBlueprint : PointFeatureBlueprint
    {
        TrafficInfoBlueprint(double _pointSize, std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : PointFeatureBlueprint(_pointSize, _name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        TrafficInfoBlueprint(const std::shared_ptr<FeatureBlueprint> _input):PointFeatureBlueprint(_input){}
        std::string rbltable;
        //std::vector<std::string> iconLineNames;
        //std::vector<std::string> iconURLs;
        
    };
    
    struct NamesBlueprint : PointFeatureBlueprint
    {
        NamesBlueprint(double _pointSize, std::string _name, vmml::Vector3f _pos, std::string _url, geGIS::FeatureRange _entRange, geGIS::FeatureRange _lineRange, std::shared_ptr<ge::ShaderBlueprint> _shader, std::string _driver, TileServiceInfoBlueprint _tfinfo, bool _gpufeature, bool _clustered) : PointFeatureBlueprint(_pointSize, _name, _pos, _url, _entRange, _lineRange, _shader, _driver, _tfinfo, _gpufeature, _clustered){}
        NamesBlueprint(const std::shared_ptr<FeatureBlueprint> _input):PointFeatureBlueprint(_input){}
        std::string namestable;
    };

    
    class SceneBlueprint : public ge::Blueprint
    {
    public:
        SceneBlueprint() {clear(); }
        ~SceneBlueprint() {}
        
        void clear();
        void create(std::string _configFile);
        
    public:
        std::shared_ptr<UIBlueprint> uiBlueprint;

        std::vector< std::shared_ptr<ge::ColorBlueprint> > colorblueprints;
        std::vector< std::shared_ptr<ge::PositionBlueprint> > poiblueprints;

        void addBorderFromJSONElement(const Jzon::Node& _config);

        // Feature Blueprints
        std::shared_ptr<RefenceSystemBlueprint> refenceSystemblueprint;
        std::vector< std::shared_ptr<TMSElevationBlueprint> > elevationblueprints;
        std::vector< std::shared_ptr<StructureBlueprint> > structureblueprints;
        std::vector< std::shared_ptr<CommuterBlueprint> > commuterblueprints;
        std::vector< std::shared_ptr<TrafficBlueprint> > trafficblueprints;
        std::vector< std::shared_ptr<BorderBlueprint> > borderblueprints;
        std::vector< std::shared_ptr<GreatCircleBlueprint> > greatcircleblueprints;
        std::vector< std::shared_ptr<BundlingBlueprint> > bundlingblueprints;
        std::vector< std::shared_ptr<HousingBlueprint> > housingblueprints;
        std::vector< std::shared_ptr<CoatOfArmsBlueprint> > coatofarmsblueprints;
        std::vector< std::shared_ptr<NamesBlueprint> > namesblueprints;
        std::vector< std::shared_ptr<TrafficInfoBlueprint> > trafficInfoblueprints;
        std::vector< std::shared_ptr<ChartBlueprint> > chartblueprints;
        std::vector< std::shared_ptr<ClimateBlueprint> > climateblueprints;
        
    private:
        void readExtendedEngineFromJSON(const Jzon::Node& _config);
        void readFeaturesFromJSON(const Jzon::Node& _config);
        void createFromXML(std::string _configFile);
        GLenum getGLenumFromAttribute(const tinyxml2::XMLAttribute* _attribute);

        // new json loaders functions
        std::shared_ptr<UIBlueprint> readUIFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<TMSElevationBlueprint> getTerrainFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<ge::PositionBlueprint> getPointOfInterestFromJSONElement(const Jzon::Node& _config);
        geGIS::FeatureRange getEntityRangeFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<RefenceSystemBlueprint> getSRSFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<BorderBlueprint> getBorderFromJSONElement(const Jzon::Node& _config, int _timestep);
        std::shared_ptr<NamesBlueprint> getNamesFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<FeatureBlueprint> getFeatureInfoFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<StyleCollection> getStyleCollectionFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<Style> getStyleFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<StylePiece> getStrokeFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<ge::ColorBlueprint> getColorBundleFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<CommuterBlueprint> getCommuterFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<TrafficBlueprint> getTrafficFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<HousingBlueprint> getHousingFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<CoatOfArmsBlueprint> getCoatOfArmsFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<GreatCircleBlueprint> getGreatCirclesFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<BundlingBlueprint> getBundlingObjectFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<ChartBlueprint> getChartFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<TrafficInfoBlueprint> getTrafficInfoFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<StructureBlueprint> getStructureFromJSONElement(const Jzon::Node& _config);
        std::shared_ptr<ClimateBlueprint> getClimatefromJSONElement(const Jzon::Node& _config);
        
        // xml load functions which are not adpated yet
    //  std::shared_ptr<ge::ColorBlueprint> getColorBundleFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<FeatureBlueprint> getFeatureInfoFromElement(const tinyxml2::XMLElement* _element);
 //       std::shared_ptr<TrafficInfoBlueprint> getTrafficInfoFromElement(std::shared_ptr<FeatureBlueprint> _featureInfo, const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<ChartBlueprint> getChartInfoFromElement(std::shared_ptr<FeatureBlueprint> _featureInfo,const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<StyleCollection> getStyleCollectionFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<Style> getStyleFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<StylePiece> getStrokeFromElement(const tinyxml2::XMLElement* _element);
    //  
    //  // old xml loader which are already adapted or do not need to be adapted
    //  std::shared_ptr<BaseTextureBlueprint> getBaseTextureFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<TMSElevationBlueprint> getElevationTMSFromElement(const tinyxml2::XMLElement* _element);
    //  TileServiceInfoBlueprint getTileServiceInfoElement(const tinyxml2::XMLElement* _element);
    //  geGIS::FeatureRange getEntityRangeFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<ge::PipelineElementBlueprint> getCompositionFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<ge::CameraBlueprint> getCameraFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<ge::SkyboxBlueprint> getSkyboxFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<ge::PositionBlueprint> getPointOfInterestFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<ge::ShaderBlueprint> getShaderFromElement(const tinyxml2::XMLElement* _element);
    //  std::shared_ptr<ge::AnimationPathBlueprint> getAnimationPathFromElement(const tinyxml2::XMLElement* _element);

    };
}
#endif