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 <Qt3DRender/QCamera>
 
#include "qgscoordinatereferencesystem.h"
#include "qgsmaplayerref.h"
#include "qgsmesh3dsymbol.h"
#include "qgsphongmaterialsettings.h"
#include "qgspointlightsettings.h"
#include "qgsdirectionallightsettings.h"
#include "qgsterraingenerator.h"
#include "qgsvector3d.h"
#include "qgsskyboxsettings.h"
#include "qgsshadowsettings.h"
#include "qgscameracontroller.h"
#include "qgstemporalrangeobject.h"
 
class QgsMapLayer;
class QgsRasterLayer;
 
class QgsAbstract3DRenderer;
 
 
class QgsReadWriteContext;
class QgsProject;
 
class QDomElement;
 
class _3D_EXPORT Qgs3DMapSettings : public QObject, public QgsTemporalRangeObject
{
    Q_OBJECT
  public:
 
    Qgs3DMapSettings() = default;
    Qgs3DMapSettings( const Qgs3DMapSettings &other );
    ~Qgs3DMapSettings() override;
 
    Qgs3DMapSettings &operator=( Qgs3DMapSettings const & ) = delete;
 
    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;
 
    void setLayers( const QList<QgsMapLayer *> &layers );
 
    QList<QgsMapLayer *> layers() const;
 
    //
    // terrain related config
    //
 
    void setTerrainVerticalScale( double zScale );
    double terrainVerticalScale() const;
 
    void setMapTileResolution( int res );
 
    int mapTileResolution() const;
 
    void setMaxTerrainScreenError( float error );
 
    float maxTerrainScreenError() const;
 
    void setMaxTerrainGroundError( float error );
 
    float maxTerrainGroundError() const;
 
    void setTerrainElevationOffset( float offset );
 
    float terrainElevationOffset() const { return mTerrainElevationOffset; }
 
    void setTerrainGenerator( QgsTerrainGenerator *gen SIP_TRANSFER ) SIP_SKIP;
    QgsTerrainGenerator *terrainGenerator() const SIP_SKIP
    {
      if ( mTerrainRenderingEnabled )
        return mTerrainGenerator.get();
      return nullptr;
    }
 
    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 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 setShowLightSourceOrigins( bool enabled );
 
    bool showLightSourceOrigins() const { return mShowLightSources; }
 
    void setShowLabels( bool enabled );
    bool showLabels() const { return mShowLabels; }
 
    void setEyeDomeLightingEnabled( bool enabled );
    bool eyeDomeLightingEnabled() const { return mEyeDomeLightingEnabled; }
 
    void setEyeDomeLightingStrength( double strength );
    double eyeDomeLightingStrength() const { return mEyeDomeLightingStrength; }
 
    void setEyeDomeLightingDistance( int distance );
    int eyeDomeLightingDistance() const { return mEyeDomeLightingDistance; }
 
    void setDebugShadowMapSettings( bool enabled, Qt::Corner corner, double size );
    bool debugShadowMapEnabled() const { return mDebugShadowMapEnabled; }
    Qt::Corner debugShadowMapCorner() const { return mDebugShadowMapCorner; }
    double debugShadowMapSize() const { return mDebugShadowMapSize; }
 
    void setDebugDepthMapSettings( bool enabled, Qt::Corner corner, double size );
    bool debugDepthMapEnabled() const { return mDebugDepthMapEnabled; }
    Qt::Corner debugDepthMapCorner() const { return mDebugDepthMapCorner; }
    double debugDepthMapSize() const { return mDebugDepthMapSize; }
 
    QList<QgsPointLightSettings> pointLights() const { return mPointLights; }
 
    QList<QgsDirectionalLightSettings> directionalLights() const { return mDirectionalLights; }
 
    void setPointLights( const QList<QgsPointLightSettings> &pointLights );
 
    void setDirectionalLights( const QList<QgsDirectionalLightSettings> &directionalLights );
 
    float fieldOfView() const { return mFieldOfView; }
 
    void setFieldOfView( const float fieldOfView );
 
    Qt3DRender::QCameraLens::ProjectionType projectionType() const SIP_SKIP { return mProjectionType; }
 
    void setProjectionType( const Qt3DRender::QCameraLens::ProjectionType projectionType ) SIP_SKIP;
 
#ifndef SIP_RUN
 
    QgsCameraController::NavigationMode cameraNavigationMode() const { return mCameraNavigationMode; }
 
    void setCameraNavigationMode( QgsCameraController::NavigationMode navigationMode );
#endif
 
    double cameraMovementSpeed() const { return mCameraMovementSpeed; }
 
    void setCameraMovementSpeed( double movementSpeed );
 
    void setOutputDpi( const double dpi ) {mDpi = dpi;}
 
 
    double outputDpi() const { return mDpi; }
 
    QgsSkyboxSettings skyboxSettings() const SIP_SKIP { return mSkyboxSettings; }
 
    QgsShadowSettings shadowSettings() const SIP_SKIP { return mShadowSettings; }
 
    void setSkyboxSettings( const QgsSkyboxSettings &skyboxSettings ) SIP_SKIP;
 
    void setShadowSettings( const QgsShadowSettings &shadowSettings ) SIP_SKIP;
 
    bool isSkyboxEnabled() const { return mIsSkyboxEnabled; }
 
    void setIsSkyboxEnabled( bool enabled ) { mIsSkyboxEnabled = enabled; }
 
    bool isFpsCounterEnabled() const { return mIsFpsCounterEnabled; }
 
    void setIsFpsCounterEnabled( bool fpsCounterEnabled );
 
    bool terrainRenderingEnabled() { return mTerrainRenderingEnabled; }
 
    void setTerrainRenderingEnabled( bool terrainRenderingEnabled );
 
  signals:
    void backgroundColorChanged();
    void selectionColorChanged();
 
    void layersChanged();
 
    void terrainGeneratorChanged();
    void terrainVerticalScaleChanged();
    void mapTileResolutionChanged();
    void maxTerrainScreenErrorChanged();
    void maxTerrainGroundErrorChanged();
 
    void terrainElevationOffsetChanged( float newElevation );
 
    void terrainShadingChanged();
 
    void terrainMapThemeChanged();
 
    void renderersChanged();
 
    void showTerrainBoundingBoxesChanged();
    void showTerrainTilesInfoChanged();
 
    void showCameraViewCenterChanged();
 
    void showLightSourceOriginsChanged();
 
    void showLabelsChanged();
 
    void eyeDomeLightingEnabledChanged();
 
    void eyeDomeLightingStrengthChanged();
 
    void eyeDomeLightingDistanceChanged();
 
    void debugShadowMapSettingsChanged();
 
    void debugDepthMapSettingsChanged();
 
    void pointLightsChanged();
 
    void directionalLightsChanged();
 
    void fieldOfViewChanged();
 
    void projectionTypeChanged();
 
    void cameraNavigationModeChanged();
 
    void cameraMovementSpeedChanged();
 
    void skyboxSettingsChanged();
 
    void shadowSettingsChanged();
 
    void fpsCounterEnabledChanged( bool fpsCounterEnabled );
 
  private:
#ifdef SIP_RUN
    Qgs3DMapSettings &operator=( const Qgs3DMapSettings & );
#endif
 
  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;  
    float mTerrainElevationOffset = 0.0f; 
    bool mTerrainShadingEnabled = false;   
    QgsPhongMaterialSettings mTerrainShadingMaterial;  
    QString mTerrainMapTheme;  
    bool mShowTerrainBoundingBoxes = false;  
    bool mShowTerrainTileInfo = false;  
    bool mShowCameraViewCenter = false;  
    bool mShowLightSources = false; 
    bool mShowLabels = false; 
    QList<QgsPointLightSettings> mPointLights;  
    QList<QgsDirectionalLightSettings> mDirectionalLights;  
    float mFieldOfView = 45.0f; //<! Camera lens field of view value
    Qt3DRender::QCameraLens::ProjectionType mProjectionType = Qt3DRender::QCameraLens::PerspectiveProjection;  //<! Camera lens projection type
    QgsCameraController::NavigationMode mCameraNavigationMode = QgsCameraController::NavigationMode::TerrainBasedNavigation;
    double mCameraMovementSpeed = 5.0;
    QList<QgsMapLayerRef> mLayers;   
    QList<QgsAbstract3DRenderer *> mRenderers;  
    QgsCoordinateTransformContext mTransformContext;
    QgsPathResolver mPathResolver;
    QgsMapThemeCollection *mMapThemes = nullptr;   
    double mDpi = 96;  
    bool mIsFpsCounterEnabled = false;
 
    bool mIsSkyboxEnabled = false;  
    QgsSkyboxSettings mSkyboxSettings; 
    QgsShadowSettings mShadowSettings; 
 
    bool mEyeDomeLightingEnabled = false;
    double mEyeDomeLightingStrength = 1000.0;
    int mEyeDomeLightingDistance = 1;
 
    bool mDebugShadowMapEnabled = false;
    Qt::Corner mDebugShadowMapCorner = Qt::Corner::TopLeftCorner;
    double mDebugShadowMapSize = 0.2;
 
    bool mDebugDepthMapEnabled = false;
    Qt::Corner mDebugDepthMapCorner = Qt::Corner::TopRightCorner;
    double mDebugDepthMapSize = 0.2;
 
    bool mTerrainRenderingEnabled = true;
};
 
 
#endif // QGS3DMAPSETTINGS_H