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 <QMap>
#include "VecMath.hpp"
#include "StelToneReproducer.hpp"
#include "StelProjector.hpp"

#include "StelFader.hpp"
#include "StelUtils.hpp"
#include "renderer/GenericVertexTypes.hpp"
#include "renderer/StelIndexBuffer.hpp"
#include "renderer/StelVertexBuffer.hpp"
#include "StelLocation.hpp"

class QSettings;
class StelLocation;
class StelCore;

class Landscape
{
public:
    Landscape(float _radius = 2.f);
    virtual ~Landscape();
    virtual void load(const QSettings& landscapeIni, const QString& landscapeId) = 0;

    virtual void draw(StelCore* core, class StelRenderer* renderer) = 0;

    void update(double deltaTime)
    {
        landFader.update((int)(deltaTime*1000));
        fogFader.update((int)(deltaTime*1000));
    }

    void setBrightness(const float b) {skyBrightness = b;}

    void setFlagShow(const bool b) {landFader=b;}
    bool getFlagShow() const {return (bool)landFader;}
    void setFlagShowFog(const bool b) {fogFader=b;}
    bool getFlagShowFog() const {return (bool)fogFader;}
    QString getName() const {return name;}
    QString getAuthorName() const {return author;}
    QString getDescription() const {return description;}

    const StelLocation& getLocation() const {return location;}
    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;}

    void setZRotation(float d) {angleRotateZOffset = d;}

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

    const QString getTexturePath(const QString& basename, const QString& landscapeId);
    const float radius;
    QString name;
    float skyBrightness;
    float nightBrightness;
    bool validLandscape;   // was a landscape loaded properly?
    LinearFader landFader;
    LinearFader fogFader;
    QString author;
    QString description;

    // Currently, rows and cols do not change after initialization.
    // If, in future, these values can be modified, cached vertex/index buffers 
    // will have to be regenerated after the change.
    // GZ patched, these can now be set in landscape.ini:
    int rows; // horizontal rows
    int cols; // vertical columns
    int defaultBortleIndex; // light pollution from landscape.ini, or -1(no change)
    int defaultFogSetting; // fog flag setting from landscape.ini: -1(no change), 0(off), 1(on)
    double defaultExtinctionCoefficient; // atmospheric_extinction_coefficient from landscape.ini or -1
    double defaultTemperature; // atmospheric_temperature from landscape.ini or -1000.0
    double defaultPressure; // atmospheric_pressure from landscape.ini or -1.0
    
    typedef struct
    {
        class StelTextureNew* tex;
        float texCoords[4];
    } landscapeTexCoord;

    StelLocation location;
    float angleRotateZ;
    float angleRotateZOffset;
};


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, class StelRenderer* renderer);
    void create(bool _fullpath, QMap<QString, QString> param);

private:
    void drawFog(StelCore* core, class StelRenderer* renderer);
    
    void drawDecor(StelCore* core, class StelRenderer* renderer);

    void drawGround(StelCore* core, class StelRenderer* renderer);

    void generateGroundFanDisk(class StelRenderer* renderer);

    void lazyInitTextures(class StelRenderer* renderer);

    void generatePrecomputedSides(class StelRenderer* renderer);

    struct SideTexture
    {
        QString path;
        class StelTextureNew* texture;
    };

    SideTexture* sideTexs;
    bool texturesInitialized;
    int nbSideTexs;
    int nbSide;
    landscapeTexCoord* sides;
    class StelTextureNew* fogTex;
    QString fogTexPath;
    landscapeTexCoord fogTexCoord;
    class StelTextureNew* groundTex;
    QString groundTexPath;
    landscapeTexCoord groundTexCoord;
    int nbDecorRepeat;
    float fogAltAngle;
    float fogAngleShift;
    float decorAltAngle;
    float decorAngleShift;
    float groundAngleShift;
    float groundAngleRotateZ;
    int drawGroundFirst;
    bool tanMode;       // Whether the angles should be converted using tan instead of sin
    bool calibrated;    // if true, the documented altitudes are inded correct (the original code is buggy!)
    
    struct LOSSide
    {
        StelVertexBuffer<VertexP3T2>* vertices;
        StelIndexBuffer* indices;
        class StelTextureNew* tex;
    };

    QList<LOSSide> precomputedSides;

    QMap<int, int> texToSide;

    StelVertexBuffer<VertexP3T2>* fogCylinderBuffer;

    float previousFogHeight;

    StelVertexBuffer<VertexP3T2>* groundFanDisk;

    StelIndexBuffer* groundFanDiskIndices;
};

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, class StelRenderer* renderer);
    void create(const QString name, const QString& maptex, float texturefov, float angleRotateZ);
private:

    class StelTextureNew* mapTex;
    QString mapTexPath;
    // Currently, this does not change after initialization.
    // If, in future, this value can be modified, cached vertex/index buffers 
    // will have to be regenerated after the change.
    float texFov;

    class StelGeometrySphere* fisheyeSphere;
};


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, class StelRenderer* renderer);
    void create(const QString name, const QString& maptex, float angleRotateZ);
private:

    class StelTextureNew* mapTex;
    QString mapTexPath;

    class StelGeometrySphere* landscapeSphere;
};

#endif // _LANDSCAPE_HPP_