qgs3dmapsettings.h

Go to the documentation of this file.

/***************************************************************************
  qgs3dmapsettings.h
  --------------------------------------
  Date                 : July 2017
  Copyright            : (C) 2017 by Martin Dobias
  Email                : wonder dot sk at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QGS3DMAPSETTINGS_H
#define QGS3DMAPSETTINGS_H

#include "qgis_3d.h"

#include <memory>
#include <QColor>
#include <QMatrix4x4>

#include "qgscoordinatereferencesystem.h"
#include "qgsmaplayerref.h"
#include "qgsphongmaterialsettings.h"
#include "qgspointlightsettings.h"
#include "qgsterraingenerator.h"
#include "qgsvector3d.h"

class QgsMapLayer;
class QgsRasterLayer;

class QgsAbstract3DRenderer;


class QgsReadWriteContext;
class QgsProject;

class QDomElement;


class _3D_EXPORT Qgs3DMapSettings : public QObject
{
    Q_OBJECT
  public:

    Qgs3DMapSettings() = default;
    Qgs3DMapSettings( const Qgs3DMapSettings &other );
    ~Qgs3DMapSettings() override;

    void readXml( const QDomElement &elem, const QgsReadWriteContext &context );
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const;
    void resolveReferences( const QgsProject &project );

    void setOrigin( const QgsVector3D &origin ) { mOrigin = origin; }
    QgsVector3D origin() const { return mOrigin; }

    QgsVector3D mapToWorldCoordinates( const QgsVector3D &mapCoords ) const;
    QgsVector3D worldToMapCoordinates( const QgsVector3D &worldCoords ) const;

    void setCrs( const QgsCoordinateReferenceSystem &crs );
    QgsCoordinateReferenceSystem crs() const { return mCrs; }

    QgsCoordinateTransformContext transformContext() const;

    void setTransformContext( const QgsCoordinateTransformContext &context );

    const QgsPathResolver &pathResolver() const { return mPathResolver; }

    void setPathResolver( const QgsPathResolver &resolver ) { mPathResolver = resolver; }

    QgsMapThemeCollection *mapThemeCollection() const { return mMapThemes; }

    void setMapThemeCollection( QgsMapThemeCollection *mapThemes ) { mMapThemes = mapThemes; }

    void setBackgroundColor( const QColor &color );
    QColor backgroundColor() const;

    void setSelectionColor( const QColor &color );
    QColor selectionColor() const;

    //
    // terrain related config
    //

    void setTerrainVerticalScale( double zScale );
    double terrainVerticalScale() const;

    void setLayers( const QList<QgsMapLayer *> &layers );

    QList<QgsMapLayer *> layers() const;

    void setMapTileResolution( int res );

    int mapTileResolution() const;

    void setMaxTerrainScreenError( float error );

    float maxTerrainScreenError() const;

    void setMaxTerrainGroundError( float error );

    float maxTerrainGroundError() const;

    void setTerrainGenerator( QgsTerrainGenerator *gen SIP_TRANSFER );
    QgsTerrainGenerator *terrainGenerator() const { return mTerrainGenerator.get(); }

    void setTerrainShadingEnabled( bool enabled );

    bool isTerrainShadingEnabled() const { return mTerrainShadingEnabled; }

    void setTerrainShadingMaterial( const QgsPhongMaterialSettings &material );

    QgsPhongMaterialSettings terrainShadingMaterial() const { return mTerrainShadingMaterial; }

    void setTerrainMapTheme( const QString &theme );

    QString terrainMapTheme() const { return mTerrainMapTheme; }

    //
    // misc configuration
    //

    void setRenderers( const QList<QgsAbstract3DRenderer *> &renderers SIP_TRANSFER );
    QList<QgsAbstract3DRenderer *> renderers() const { return mRenderers; }

    void setSkybox( bool enabled, const QString &fileBase = QString(), const QString &fileExtension = QString() );
    bool hasSkyboxEnabled() const { return mSkyboxEnabled; }
    QString skyboxFileBase() const { return mSkyboxFileBase; }
    QString skyboxFileExtension() const { return mSkyboxFileExtension; }

    void setShowTerrainBoundingBoxes( bool enabled );
    bool showTerrainBoundingBoxes() const { return mShowTerrainBoundingBoxes; }
    void setShowTerrainTilesInfo( bool enabled );
    bool showTerrainTilesInfo() const { return mShowTerrainTileInfo; }

    void setShowCameraViewCenter( bool enabled );

    bool showCameraViewCenter() const { return mShowCameraViewCenter; }
    void setShowLabels( bool enabled );
    bool showLabels() const { return mShowLabels; }

    QList<QgsPointLightSettings> pointLights() const { return mPointLights; }

    void setPointLights( const QList<QgsPointLightSettings> &pointLights );

    float fieldOfView() const { return mFieldOfView; }

    void setFieldOfView( const float fieldOfView );

  signals:
    void backgroundColorChanged();
    void selectionColorChanged();
    void layersChanged();
    void terrainGeneratorChanged();
    void terrainVerticalScaleChanged();
    void mapTileResolutionChanged();
    void maxTerrainScreenErrorChanged();
    void maxTerrainGroundErrorChanged();

    void terrainShadingChanged();

    void terrainMapThemeChanged();
    void showTerrainBoundingBoxesChanged();
    void showTerrainTilesInfoChanged();

    void showCameraViewCenterChanged();
    void showLabelsChanged();

    void pointLightsChanged();

    void fieldOfViewChanged();

  private:
    QgsVector3D mOrigin;
    QgsCoordinateReferenceSystem mCrs;   
    QColor mBackgroundColor = Qt::black;   
    QColor mSelectionColor; 
    double mTerrainVerticalScale = 1;   
    std::unique_ptr<QgsTerrainGenerator> mTerrainGenerator;  
    int mMapTileResolution = 512;   
    float mMaxTerrainScreenError = 3.f;   
    float mMaxTerrainGroundError = 1.f;  
    bool mTerrainShadingEnabled = false;   
    QgsPhongMaterialSettings mTerrainShadingMaterial;  
    QString mTerrainMapTheme;  
    bool mShowTerrainBoundingBoxes = false;  
    bool mShowTerrainTileInfo = false;  
    bool mShowCameraViewCenter = false;  
    bool mShowLabels = false; 
    QList<QgsPointLightSettings> mPointLights;  
    float mFieldOfView = 45.0f; //<! Camera lens field of view value
    QList<QgsMapLayerRef> mLayers;   
    QList<QgsAbstract3DRenderer *> mRenderers;  
    bool mSkyboxEnabled = false;  
    QString mSkyboxFileBase; 
    QString mSkyboxFileExtension; 
    QgsCoordinateTransformContext mTransformContext;
    QgsPathResolver mPathResolver;
    QgsMapThemeCollection *mMapThemes = nullptr;   
};


#endif // QGS3DMAPSETTINGS_H