Landscape.hpp

/*
 * Stellarium
 * Copyright (C) 2003 Fabien Chereau
 *
 * 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 _LANDSCAPE_HPP_
#define _LANDSCAPE_HPP_

#include "VecMath.hpp"
#include "StelToneReproducer.hpp"
#include "StelProjector.hpp"

#include "StelFader.hpp"
#include "StelUtils.hpp"
#include "StelTextureTypes.hpp"
#include "StelLocation.hpp"

#include <QMap>
#include <QImage>
#include <QList>
#include <QFont>

class QSettings;
class StelLocation;
class StelCore;
class StelPainter;

class Landscape
{
public:
    typedef struct
    {
        QString name;
        Vec3d featurePoint; // start of the line: mountain peak, building, ...
        Vec3d labelPoint;   // end of the line, where the centered label best fits.
    } LandscapeLabel;

    Landscape(float _radius = 2.f);
    virtual ~Landscape();
    virtual void load(const QSettings& landscapeIni, const QString& landscapeId) = 0;
    virtual void draw(StelCore* core) = 0;
    void update(double deltaTime)
    {
        landFader.update((int)(deltaTime*1000));
        fogFader.update((int)(deltaTime*1000));
        illumFader.update((int)(deltaTime*1000));
        labelFader.update((int)(deltaTime*1000));
    }

    void setBrightness(const float b, const float pollutionBrightness=0.0f) {landscapeBrightness = b; lightScapeBrightness=pollutionBrightness; }

    float getBrightness() const { return landscapeBrightness; }
    float getLightscapeBrightness() const { return lightScapeBrightness; }
    float getTargetLightscapeBrightness() const { return lightScapeBrightness * illumFader; }
    float getEffectiveLightscapeBrightness() const { return lightScapeBrightness * illumFader.getInterstate(); }

    void setFlagShow(const bool b) {landFader=b;}
    bool getFlagShow() const {return (bool)landFader;}
    float getEffectiveLandFadeValue() { return landFader.getInterstate(); }
    void setFlagShowFog(const bool b) {fogFader=b;}
    bool getFlagShowFog() const {return (bool)fogFader;}
    void setFlagShowIllumination(const bool b) {illumFader=b;}
    bool getFlagShowIllumination() const {return (bool)illumFader;}
    void setFlagShowLabels(const bool b) {labelFader=b;}
    bool getFlagShowLabels() const {return (bool)labelFader;}
    void setLabelFontSize(const int size){fontSize=size;}

    QString getName() const {return name;}
    QString getAuthorName() const {return author;}
    QString getDescription() const {return description;}

    const StelLocation& getLocation() const {return location;}
    bool hasLocation() const {return (!(location.planetName.isEmpty()));}
    int getDefaultBortleIndex() const {return defaultBortleIndex;}
    int getDefaultFogSetting() const {return defaultFogSetting;}
    float getDefaultAtmosphericExtinction() const {return defaultExtinctionCoefficient;}
    float getDefaultAtmosphericTemperature() const {return defaultTemperature;}
    float getDefaultAtmosphericPressure() const {return defaultPressure;}
    float getLandscapeMinimalBrightness() const {return minBrightness;}

    void setZRotation(float d) {angleRotateZOffset = d * M_PI/180.0f;}

    bool getIsFullyVisible() const {return landFader.getInterstate() >= 0.999f;}
    float getSinMinAltitudeLimit() const {return sinMinAltitudeLimit;}

    // TBD: Maybe change this to azalt[2]<sinMinAltitudeLimit ? (But never called in practice, reimplemented by the subclasses...)
    virtual float getOpacity(Vec3d azalt) const { Q_ASSERT(0); return (azalt[2]<0 ? 1.0f : 0.0f); }
    enum horizonListMode {
        azDeg_altDeg   = 0, 
        azDeg_zdDeg    = 1, 
        azRad_altRad   = 2, 
        azRad_zdRad    = 3, 
        azGrad_altGrad = 4, 
        azGrad_zdGrad  = 5  
    };
    
    void loadLabels(const QString& landscapeId);

protected:
    void loadCommon(const QSettings& landscapeIni, const QString& landscapeId);

    void drawLabels(StelCore *core, StelPainter *painter);


    void createPolygonalHorizon(const QString& lineFileName, const float polyAngleRotateZ=0.0f, const QString &listMode="azDeg_altDeg");

    const QString getTexturePath(const QString& basename, const QString& landscapeId) const;
    float radius;
    QString name;          
    QString author;        
    QString description;   

    float minBrightness;   
    float landscapeBrightness;  
    float lightScapeBrightness; 
    bool validLandscape;   
    LinearFader landFader; 
    LinearFader fogFader;  
    LinearFader illumFader;
    LinearFader labelFader;
    int rows; 
    int cols; 
    float angleRotateZ;    
    float angleRotateZOffset; 

    float sinMinAltitudeLimit; 

    StelLocation location; 
    int defaultBortleIndex; 
    int defaultFogSetting;  
    float defaultExtinctionCoefficient; 
    float defaultTemperature; 
    float defaultPressure;    

    // Optional elements which, if present, describe a horizon polygon. They can be used to render a line or a filled region, esp. in LandscapePolygonal
    SphericalRegionP horizonPolygon;   
    Vec3f horizonPolygonLineColor;     
    // Optional element: labels for landscape features.
    QList<LandscapeLabel> landscapeLabels;
    int fontSize;     
    Vec3f labelColor; 
};

class LandscapeOldStyle : public Landscape
{
public:
    LandscapeOldStyle(float radius = 2.f);
    virtual ~LandscapeOldStyle();
    virtual void load(const QSettings& landscapeIni, const QString& landscapeId);
    virtual void draw(StelCore* core);
    //void create(bool _fullpath, QMap<QString, QString> param); // still not implemented
    virtual float getOpacity(Vec3d azalt) const;
protected:
    typedef struct
    {
        StelTextureSP tex;
        StelTextureSP tex_illum; // optional light texture.
        float texCoords[4];
    } landscapeTexCoord;

private:
    void drawFog(StelCore* core, StelPainter&) const;
    // drawLight==true for illumination layer, it then selects only the self-illuminating panels.
    void drawDecor(StelCore* core, StelPainter&, const bool drawLight=false) const;
    void drawGround(StelCore* core, StelPainter&) const;
    QVector<double> groundVertexArr;
    QVector<float> groundTexCoordArr;
    StelTextureSP* sideTexs;
    int nbSideTexs;
    int nbSide;
    landscapeTexCoord* sides;
    StelTextureSP fogTex;
    StelTextureSP groundTex;
    QVector<QImage*> sidesImages; // Required for opacity lookup
    int nbDecorRepeat;
    float fogAltAngle;
    float fogAngleShift;
    float decorAltAngle; // vertical extent of the side panels
    float decorAngleShift;
    float groundAngleShift; 
    float groundAngleRotateZ; 
    int drawGroundFirst;
    bool tanMode;       // Whether the angles should be converted using tan instead of sin, i.e., for a cylindrical pano
    bool calibrated;    // if true, the documented altitudes are indeed correct (the original code is buggy!)
    struct LOSSide
    {
        StelVertexArray arr;
        StelTextureSP tex;
        bool light; // GZ NEW: true if texture is self-lighting.
    };

    QList<LOSSide> precomputedSides;
};

class LandscapePolygonal : public Landscape
{
public:
    LandscapePolygonal(float radius = 1.f);
    virtual ~LandscapePolygonal();
    virtual void load(const QSettings& landscapeIni, const QString& landscapeId);
    virtual void draw(StelCore* core);
    virtual float getOpacity(Vec3d azalt) const;
private:
    // we have inherited: horizonFileName, horizonPolygon, horizonPolygonLineColor
    Vec3f groundColor; 
};

class LandscapeFisheye : public Landscape
{
public:
    LandscapeFisheye(float radius = 1.f);
    virtual ~LandscapeFisheye();
    virtual void load(const QSettings& landscapeIni, const QString& landscapeId);
    virtual void draw(StelCore* core);
    virtual float getOpacity(Vec3d azalt) const;
    void create(const QString name, const QString& maptex, float texturefov, float angleRotateZ);
    void create(const QString name, float texturefov, const QString& maptex, const QString &_maptexFog="", const QString& _maptexIllum="", const float angleRotateZ=0.0f);
private:

    StelTextureSP mapTex;      
    StelTextureSP mapTexFog;   
    StelTextureSP mapTexIllum; 
    QImage *mapImage;          

    float texFov;
};

class LandscapeSpherical : public Landscape
{
public:
    LandscapeSpherical(float radius = 1.f);
    virtual ~LandscapeSpherical();
    virtual void load(const QSettings& landscapeIni, const QString& landscapeId);
    virtual void draw(StelCore* core);
    virtual float getOpacity(Vec3d azalt) const;
    void create(const QString name, const QString& maptex, const QString &_maptexFog="", const QString& _maptexIllum="", const float _angleRotateZ=0.0f,
                const float _mapTexTop=90.0f, const float _mapTexBottom=-90.0f,
                const float _fogTexTop=90.0f, const float _fogTexBottom=-90.0f,
                const float _illumTexTop=90.0f, const float _illumTexBottom=-90.0f);
private:

    StelTextureSP mapTex;      
    StelTextureSP mapTexFog;   
    StelTextureSP mapTexIllum; 
    // These vars are here to conserve texture memory. They must be allowed to be different: a landscape may have its highest elevations at 15°, fog may reach from -25 to +15°,
    // light pollution may cover -5° (street lamps slightly below) plus parts of or even the whole sky. All have default values to simplify life.
    float mapTexTop;           
    float mapTexBottom;    
    float fogTexTop;       
    float fogTexBottom;    
    float illumTexTop;     
    float illumTexBottom;      
    QImage *mapImage;          
};

#endif // _LANDSCAPE_HPP_