LandscapeMgr.hpp

/*
 * Stellarium
 * Copyright (C) 2006 Fabien Chereau
 * Copyright (C) 2010 Bogdan Marinov (add/remove landscapes feature)
 * Copyright (C) 2012 Timothy Reaves
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _LANDSCAPEMGR_HPP_
#define _LANDSCAPEMGR_HPP_

#include "StelModule.hpp"
#include "StelUtils.hpp"
#include "Landscape.hpp"

#include <QMap>
#include <QStringList>

class Atmosphere;
class Cardinals;
class QSettings;

class LandscapeMgr : public StelModule
{
    Q_OBJECT
    Q_PROPERTY(bool atmosphereDisplayed
               READ getFlagAtmosphere
               WRITE setFlagAtmosphere
               NOTIFY atmosphereDisplayedChanged)
    Q_PROPERTY(bool cardinalsPointsDisplayed
               READ getFlagCardinalsPoints
               WRITE setFlagCardinalsPoints
               NOTIFY cardinalsPointsDisplayedChanged)
    Q_PROPERTY(bool fogDisplayed
               READ getFlagFog
               WRITE setFlagFog
               NOTIFY fogDisplayedChanged)
    Q_PROPERTY(bool landscapeDisplayed
               READ getFlagLandscape
               WRITE setFlagLandscape
               NOTIFY landscapeDisplayedChanged)
    Q_PROPERTY(bool illuminationDisplayed
               READ getFlagIllumination
               WRITE setFlagIllumination
               NOTIFY illuminationDisplayedChanged)
    Q_PROPERTY(bool labelsDisplayed
               READ getFlagLabels
               WRITE setFlagLabels
               NOTIFY labelsDisplayedChanged)
    Q_PROPERTY(bool databaseUsage
            READ getFlagUseLightPollutionFromDatabase
            WRITE setFlagUseLightPollutionFromDatabase
            NOTIFY lightPollutionUsageChanged)

public:
    LandscapeMgr();
    virtual ~LandscapeMgr();

    // Methods defined in the StelModule class
    virtual void init();

    virtual void draw(StelCore* core);

    virtual void update(double deltaTime);

    virtual double getCallOrder(StelModuleActionName actionName) const;


    // Method specific to the landscape manager
    float getLuminance() const;
    float getAtmosphereAverageLuminance() const;

    bool loadLandscape(QMap<QString, QString>& param);

    Landscape* createFromFile(const QString& landscapeFile, const QString& landscapeId);

    // GZ: implement StelModule's method. For test purposes only, we implement a manual transparency sampler.
    // TODO: comment this away for final builds. Please leave it in until this feature is finished.
    // virtual void handleMouseClicks(class QMouseEvent*);

public slots:
    // Methods callable from script and GUI
    QStringList getAllLandscapeNames() const;

    QStringList getAllLandscapeIDs() const;

    QStringList getUserLandscapeIDs() const;

    const QString& getCurrentLandscapeID() const {return currentLandscapeID;}
    bool setCurrentLandscapeID(const QString& id, const double changeLocationDuration = 1.0);
    
    QString getCurrentLandscapeName() const;
    bool setCurrentLandscapeName(const QString& name, const double changeLocationDuration = 1.0);

    Landscape* getCurrentLandscape() const { return landscape; }

    const QString& getDefaultLandscapeID() const {return defaultLandscapeID;}
    bool setDefaultLandscapeID(const QString& id);

    QString getCurrentLandscapeHtmlDescription() const;

    QString getDescription() const;

    bool getFlagLandscape() const;
    void setFlagLandscape(const bool displayed);

    bool getIsLandscapeFullyVisible() const;
    float getLandscapeSinMinAltitudeLimit() const;
    
    bool getFlagFog() const;
    void setFlagFog(const bool displayed);
    bool getFlagIllumination() const;
    void setFlagIllumination(const bool on);
    bool getFlagLabels() const;
    void setFlagLabels(const bool on);

    bool getFlagLandscapeSetsLocation() const {return flagLandscapeSetsLocation;}
    void setFlagLandscapeSetsLocation(bool b) {flagLandscapeSetsLocation=b;}

    bool getFlagLandscapeUseMinimalBrightness() const {return flagLandscapeUseMinimalBrightness; }
    void setFlagLandscapeUseMinimalBrightness(bool b) {flagLandscapeUseMinimalBrightness=b; }
    bool getFlagLandscapeSetsMinimalBrightness() const {return flagLandscapeSetsMinimalBrightness;}
    void setFlagLandscapeSetsMinimalBrightness(bool b) {flagLandscapeSetsMinimalBrightness=b;}
    double getDefaultMinimalBrightness() const {return defaultMinimalBrightness;}
    void setDefaultMinimalBrightness(const double b) {defaultMinimalBrightness=b;}
    void setFlagUseLightPollutionFromDatabase(const bool usage);
    bool getFlagUseLightPollutionFromDatabase() const;

    bool getFlagCardinalsPoints() const;
    void setFlagCardinalsPoints(const bool displayed);

    Vec3f getColorCardinalPoints() const;
    void setColorCardinalPoints(const Vec3f& v);

    bool getFlagAtmosphere() const;
    void setFlagAtmosphere(const bool displayed);

    float getAtmosphereFadeDuration() const;
    void setAtmosphereFadeDuration(const float f);

    void setAtmosphereBortleLightPollution(const int bIndex);
    int getAtmosphereBortleLightPollution() const;

    void setZRotation(const float d);

    QString installLandscapeFromArchive(QString pathToSourceArchive, const bool display = false, const bool forAllUsers = false);

    /* GZ: leaving doc without the method confuses Doxygen. Commenting out completely.
    //QString installLandscapeFromDirectory(QString pathToSourceLandscapeIni, bool display = false, bool forAllUsers = false);
    */

    bool removeLandscape(const QString landscapeID);

    QString loadLandscapeName(const QString landscapeID);

    quint64 loadLandscapeSize(const QString landscapeID) const;

    bool getFlagLandscapeAutoSelection() const;
    void setFlagLandscapeAutoSelection(bool enableAutoSelect);

    bool getFlagAtmosphereAutoEnable() const;
    void setFlagAtmosphereAutoEnable(bool b);

    float getLandscapeOpacity(Vec3d azalt) const {return landscape->getOpacity(azalt);}
    float getLandscapeOpacity(float azimuth, float altitude) const {
        Vec3d azalt;
        StelUtils::spheToRect((180.0f-azimuth)*M_PI/180.0, altitude*M_PI/180.0, azalt);
        return landscape->getOpacity(azalt);
    }

signals:
    void atmosphereDisplayedChanged(const bool displayed);
    void cardinalsPointsDisplayedChanged(const bool displayed);
    void fogDisplayedChanged(const bool displayed);
    void landscapeDisplayedChanged(const bool displayed);
    void illuminationDisplayedChanged(const bool displayed);
    void labelsDisplayedChanged(const bool displayed);
    void lightPollutionUsageChanged(const bool usage);

    void landscapesChanged();

    void lightPollutionChanged();

    void errorUnableToOpen(QString path);
    void errorNotArchive();
    void errorNotUnique(QString nameOrID);
    void errorRemoveManually(QString path);

private slots:
    void setStelStyle(const QString& section);

    void updateI18n();  

private:
    float getAtmosphereLightPollutionLuminance() const;
    void setAtmosphereLightPollutionLuminance(const float f);


    QString nameToID(const QString& name) const;

    QMap<QString,QString> getNameToDirMap() const;

    QString getLandscapePath(const QString landscapeID) const;

    Atmosphere* atmosphere;         // Atmosphere
    Cardinals* cardinalsPoints;     // Cardinals points
    Landscape* landscape;           // The landscape i.e. the fog, the ground and "decor"
    Landscape* oldLandscape;        // Used only during transitions to newly loaded landscape.

    // Define whether the observer location is to be updated when the landscape is updated.
    bool flagLandscapeSetsLocation;

    bool flagLandscapeAutoSelection;

    bool flagLightPollutionFromDatabase;

    bool flagLandscapeUseMinimalBrightness;
    float defaultMinimalBrightness;
    bool flagLandscapeSetsMinimalBrightness;
    bool flagAtmosphereAutoEnabling;

    // The ID of the currently loaded landscape
    QString currentLandscapeID;

    // The ID of the default landscape
    QString defaultLandscapeID;

    QStringList packagedLandscapeIDs;

};

#endif // _LANDSCAPEMGR_HPP_