Comparisoner.h

Go to the documentation of this file.

#ifndef GlobeEngine_Comparisoner_h
#define GlobeEngine_Comparisoner_h

#include <vmmlib/vector.hpp>
#include <vector>
#include <set>
#include <algorithm>
#include <memory>
#include <sstream>

#include "Planet.h"
#include "OrthographicMapCamera.h"
#include "ComparisonGrid.h"

namespace geAstro {

    enum ComparisonProperty {
        NOPROPERTY,
        MASS, RADIUS, ROTATIONPERIOD, AXISTILT, TRANSITTIME, TEMPERATURE, AGE,  //from BodyInfo
        ECCENTRICITY, SEMIMAJORAXIS, INCLINATION, LONGITUDEOFASCENDINGNODE, ARGUMENTOFPERIAPSIS, MEANMOTION //from OrbitInfo
    };

    struct ComparisonLabelInfo
    {
        std::string labelContent;
        vmml::Vector3d labelPosition;

        ComparisonLabelInfo() {
            labelContent = "not set";
            labelPosition = vmml::Vector3d(-1.0, -1.0, -1.0);
        }

        ComparisonLabelInfo(std::string _labelContent, vmml::Vector3d _labelPosition) :
            labelContent(_labelContent), labelPosition(labelPosition)
        {}
    };

    struct ComparisonInfo
    {
        double compareValueX;
        double compareValueY;
        vmml::Vector3d comparisonPosition;

        ComparisonInfo() {
            compareValueX = -1;
            compareValueY = -1;
            comparisonPosition = vmml::Vector3d(-1.0, -1.0, -1.0);
        }

        ComparisonInfo(double _compareValueX, double _compareValueY, vmml::Vector3d _comparisonPosition) :
            compareValueX(_compareValueX), compareValueY(_compareValueY), comparisonPosition(_comparisonPosition)
        {}
    };

    class Comparisoner{
    
        public:
            Comparisoner();
            ~Comparisoner();
            void clear();
            void createComparison();
            void drawComparison();
            void drawComparisonGrid();
            void addPlanet(std::shared_ptr<Planet> _planet);
            void addPlanet(std::vector<std::shared_ptr<Planet> > _planets);
            void removePlanet(std::shared_ptr<Planet> _planet);
            void togglePlanetMarking(std::shared_ptr<Planet> _planet);
            void clearPlanets();
            void setXProperty(ComparisonProperty _xProperty);
            void setYProperty(ComparisonProperty _yProperty);
            ComparisonProperty getXProperty();
            ComparisonProperty getYProperty();
            void setCamera(std::shared_ptr<ge::OrthographicMapCamera> _cam);

            void setupComparisonGrid(std::shared_ptr<ge::Shader> _shader);
            void newNumberOfXLines(int _lines);
            void newNumberOfYLines(int _lines);
            void newXRangeMin(double _newMin);
            void newXRangeMax(double _newMax);
            void newYRangeMin(double _newMin);
            void newYRangeMax(double _newMax);
            const vmml::Vector2d& getPropertyValuesMin();
            const vmml::Vector2d& getPropertyValuesMax();
            const vmml::Vector2i& getInitialNumberOfLines();
            const vmml::Vector2i& getCurrentNumberOfLines();

            void createLabelInfos();
            std::vector<ComparisonLabelInfo>& getAxisLabelInfos();
            std::vector<ComparisonLabelInfo>& getPlanetAxisLabelInfos();
            std::vector<ComparisonLabelInfo>& getPlanetNameLabelInfos();
            std::vector<ComparisonLabelInfo>& getMarkedPlanetAxisLabelInfos();
            std::vector<ComparisonLabelInfo>& getMarkedPlanetNameLabelInfos();

            void resetCamera();

        private:
            std::vector<ComparisonInfo> createComparisonInfos();
            std::vector<ComparisonInfo> calculateComparisonPositions(std::vector<ComparisonInfo>& _infosToCompare);
            void setComparisonPositionForPlanets(std::vector<ComparisonInfo>& _infos);
            
            //set containing pointers to all planets that are currently compared
            std::set<std::shared_ptr<Planet> > planetsToCompare;

            //set containing pointers to all planets that lie in the currently selected comparison range (i.e. planets that get displayed)
            std::set<std::shared_ptr<Planet> > planetsInRange;

            //set containing pointers to all planets that are currently marked
            std::set<std::shared_ptr<Planet> > planetsMarked;

            //range (world coordinates) to which the comparisoner maps planet properties
            //e.g. the smallest x-axis property value gets mapped to mapValuesMin.x(), the largest gets mapped to mapValuesMax.x()
            vmml::Vector2d mapValuesMin;
            vmml::Vector2d mapValuesMax;

            //range of the current comparison values
            //e.g. propertyValuesMin.x() contains the current minimal value for the property selected for the x-axis (i.e. the one which gets mapped
            //to mapValuesMin.x())
            vmml::Vector2d propertyValuesMin;
            vmml::Vector2d propertyValuesMax;

            //axis label values
            std::vector<double> xAxisValues;
            std::vector<double> yAxisValues;

            //holds offsets for axis labels
            //.x() offset in x for y-axis labels, .y() offset in y for x-axis labels
            //.z() offset in y for y-axis labels, .w() offset in x for x-axis labels
            //all in world coordinates
            vmml::Vector4d labelOffsets;

            ComparisonProperty xProperty;
            ComparisonProperty yProperty;

            ComparisonGrid comparisonGrid;

            vmml::Vector2i initialNumberOfLines;

            std::shared_ptr<ge::OrthographicMapCamera> orthoCam;

            void calculateAxisValues();
            std::string getUnitForProperty(ComparisonProperty _property);
            vmml::Vector2d getDefaultRangeForProperty(ComparisonProperty _property);

            //labels infos
            std::vector<ComparisonLabelInfo> axisLabelInfos;
            std::vector<ComparisonLabelInfo> planetAxisLabelInfos;
            std::vector<ComparisonLabelInfo> planetNameLabelInfos;
            std::vector<ComparisonLabelInfo> markedPlanetAxisLabelInfos;
            std::vector<ComparisonLabelInfo> markedPlanetNameLabelInfos;

    };
}
#endif