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>
#include <QCache>

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(Vec3f cardinalsPointsColor
           READ getColorCardinalPoints
           WRITE setColorCardinalPoints
           NOTIFY cardinalsPointsColorChanged)
    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 flagUseLightPollutionFromDatabase // was databaseUsage
           READ getFlagUseLightPollutionFromDatabase
           WRITE setFlagUseLightPollutionFromDatabase
           NOTIFY flagUseLightPollutionFromDatabaseChanged)
    Q_PROPERTY(bool flagLandscapeAutoSelection
           READ getFlagLandscapeAutoSelection
           WRITE setFlagLandscapeAutoSelection
           NOTIFY flagLandscapeAutoSelectionChanged)
    Q_PROPERTY(bool flagLandscapeSetsLocation
           READ getFlagLandscapeSetsLocation
           WRITE setFlagLandscapeSetsLocation
           NOTIFY flagLandscapeSetsLocationChanged)
    Q_PROPERTY(bool flagLandscapeUseMinimalBrightness
           READ getFlagLandscapeUseMinimalBrightness
           WRITE setFlagLandscapeUseMinimalBrightness
           NOTIFY flagLandscapeUseMinimalBrightnessChanged)
    Q_PROPERTY(bool flagLandscapeSetsMinimalBrightness
           READ getFlagLandscapeSetsMinimalBrightness
           WRITE setFlagLandscapeSetsMinimalBrightness
           NOTIFY flagLandscapeSetsMinimalBrightnessChanged)
    Q_PROPERTY(double defaultMinimalBrightness
           READ getDefaultMinimalBrightness
           WRITE setDefaultMinimalBrightness
           NOTIFY defaultMinimalBrightnessChanged)
    Q_PROPERTY(bool flagAtmosphereAutoEnabling
           READ getFlagAtmosphereAutoEnable
           WRITE setFlagAtmosphereAutoEnable
           NOTIFY setFlagAtmosphereAutoEnableChanged)
    Q_PROPERTY(QString currentLandscapeID
           READ getCurrentLandscapeID
           WRITE setCurrentLandscapeID
           NOTIFY currentLandscapeChanged)
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;

    // Methods specific to the landscape manager

    // Load a landscape based on a hash of parameters mirroring the landscape.ini
    // file and make it the current landscape.
    // GZ: This was declared, but not implemented(?)
    //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 scripts and GUI
    float getLuminance() const;
    float getAtmosphereAverageLuminance() const;

    void setAtmosphereAverageLuminance(const float overrideLuminance);

    QMap<QString,QString> getNameToDirMap() const;

    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);

    float getCurrentLandscapeBrightness(const bool light=false) const {return (light? landscape->getLightscapeBrightness() : landscape->getBrightness());}

    bool precacheLandscape(const QString& id, const bool replace=true);
    bool removeCachedLandscape(const QString& id);
    void setCacheSize(int mb) { landscapeCache.setMaxCost(mb);}
    int getCacheSize() const {return landscapeCache.maxCost();}
    int getCacheFilledSize() const {return landscapeCache.totalCost();}
    int getCacheCount() const {return landscapeCache.count();}

    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) {if(b!=flagLandscapeSetsLocation){ flagLandscapeSetsLocation=b; emit flagLandscapeSetsLocationChanged(b);}}

    bool getFlagLandscapeUseMinimalBrightness() const {return flagLandscapeUseMinimalBrightness; }
    void setFlagLandscapeUseMinimalBrightness(bool b) {if(b!=flagLandscapeUseMinimalBrightness){ flagLandscapeUseMinimalBrightness=b; emit flagLandscapeUseMinimalBrightnessChanged(b);}}
    bool getFlagLandscapeSetsMinimalBrightness() const {return flagLandscapeSetsMinimalBrightness;}
    void setFlagLandscapeSetsMinimalBrightness(bool b) {if(b!=flagLandscapeSetsMinimalBrightness){ flagLandscapeSetsMinimalBrightness=b; emit flagLandscapeSetsMinimalBrightnessChanged(b);}}
    double getDefaultMinimalBrightness() const {return defaultMinimalBrightness;}
    void setDefaultMinimalBrightness(const double b) {if(b!=defaultMinimalBrightness){ defaultMinimalBrightness=b; emit defaultMinimalBrightnessChanged(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);

    /*
    //This method has been removed, use StelSkyDrawer::getBortleScaleIndex instead, or StelMainScriptAPI::getBortleScaleIndex in scripts
    //Also, if required, please use StelSkyDrawer::setBortleScaleIndex or StelMainScriptAPI::setBortleScaleIndex instead of LandscapeMgr::setAtmosphereBortleLightPollution
    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);}
    // This variant is required for scripting!
    float getLandscapeOpacity(Vec3f azalt) const {return landscape->getOpacity(Vec3d(azalt[0], azalt[1], azalt[2]));}
    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 cardinalsPointsColorChanged(const Vec3f & newColor) const;
    void fogDisplayedChanged(const bool displayed);
    void landscapeDisplayedChanged(const bool displayed);
    void illuminationDisplayedChanged(const bool displayed);
    void labelsDisplayedChanged(const bool displayed);
    void flagUseLightPollutionFromDatabaseChanged(const bool usage);
    void flagLandscapeAutoSelectionChanged(const bool value);
    void flagLandscapeSetsLocationChanged(const bool value);
    void flagLandscapeUseMinimalBrightnessChanged(const bool value);
    void flagLandscapeSetsMinimalBrightnessChanged(const bool value);
    void defaultMinimalBrightnessChanged(const double value);
    void setFlagAtmosphereAutoEnableChanged(const bool enabled);

    void defaultLandscapeChanged(const QString& id);

    void landscapesChanged();

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

    void currentLandscapeChanged(QString currentLandscapeID,QString currentLandscapeName);

private slots:
    void setAtmosphereBortleLightPollution(const int bIndex);

    void updateLocationBasedPollution(StelLocation loc);

    void updateI18n();  

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


    QString nameToID(const QString& name) 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;
    double defaultMinimalBrightness;
    bool flagLandscapeSetsMinimalBrightness;
    bool flagAtmosphereAutoEnabling;

    QString currentLandscapeID;

    QString defaultLandscapeID;

    QStringList packagedLandscapeIDs;

    QCache<QString,Landscape> landscapeCache;
};

#endif // _LANDSCAPEMGR_HPP_