api/3.30/qgs3dmapsettings_8cpp_source.html

/***************************************************************************

  qgs3dmapsettings.cpp

  --------------------------------------

  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.                                   *

 *                                                                         *

 ***************************************************************************/


#include "qgs3dmapsettings.h"


#include "qgs3dutils.h"

#include "qgsflatterraingenerator.h"

#include "qgsdemterraingenerator.h"

#include "qgsmeshterraingenerator.h"

#include "qgsonlineterraingenerator.h"

#include "qgsprojectviewsettings.h"

#include "qgsvectorlayer3drenderer.h"

#include "qgsmeshlayer3drenderer.h"

#include "qgspointcloudlayer3drenderer.h"

#include "qgsprojectelevationproperties.h"

#include "qgsterrainprovider.h"

#include "qgslightsource.h"

#include "qgssymbollayerutils.h"

#include "qgsrasterlayer.h"

#include "qgspointlightsettings.h"

#include "qgsdirectionallightsettings.h"


#include <QDomDocument>

#include <QDomElement>


Qgs3DMapSettings::Qgs3DMapSettings()

  : QObject( nullptr )

{

  connect( this, &Qgs3DMapSettings::settingsChanged, [&]()

  {

    QgsProject::instance()->setDirty();

  } );

  connectChangedSignalsToSettingsChanged();

}


Qgs3DMapSettings::Qgs3DMapSettings( const Qgs3DMapSettings &other )

  : QObject( nullptr )

  , QgsTemporalRangeObject( other )

  , mOrigin( other.mOrigin )

  , mCrs( other.mCrs )

  , mBackgroundColor( other.mBackgroundColor )

  , mSelectionColor( other.mSelectionColor )

  , mTerrainVerticalScale( other.mTerrainVerticalScale )

  , mTerrainGenerator( other.mTerrainGenerator ? other.mTerrainGenerator->clone() : nullptr )

  , mMapTileResolution( other.mMapTileResolution )

  , mMaxTerrainScreenError( other.mMaxTerrainScreenError )

  , mMaxTerrainGroundError( other.mMaxTerrainGroundError )

  , mTerrainElevationOffset( other.mTerrainElevationOffset )

  , mTerrainShadingEnabled( other.mTerrainShadingEnabled )

  , mTerrainShadingMaterial( other.mTerrainShadingMaterial )

  , mTerrainMapTheme( other.mTerrainMapTheme )

  , mShowTerrainBoundingBoxes( other.mShowTerrainBoundingBoxes )

  , mShowTerrainTileInfo( other.mShowTerrainTileInfo )

  , mShowCameraViewCenter( other.mShowCameraViewCenter )

  , mShowCameraRotationCenter( other.mShowCameraRotationCenter )

  , mShowLightSources( other.mShowLightSources )

  , mShowLabels( other.mShowLabels )

  , mFieldOfView( other.mFieldOfView )

  , mProjectionType( other.mProjectionType )

  , mCameraNavigationMode( other.mCameraNavigationMode )

  , mCameraMovementSpeed( other.mCameraMovementSpeed )

  , mLayers( other.mLayers )

  , mRenderers() // initialized in body

  , mTransformContext( other.mTransformContext )

  , mPathResolver( other.mPathResolver )

  , mMapThemes( other.mMapThemes )

  , mDpi( other.mDpi )

  , mIsFpsCounterEnabled( other.mIsFpsCounterEnabled )

  , mIsSkyboxEnabled( other.mIsSkyboxEnabled )

  , mSkyboxSettings( other.mSkyboxSettings )

  , mShadowSettings( other.mShadowSettings )

  , mAmbientOcclusionSettings( other.mAmbientOcclusionSettings )

  , mEyeDomeLightingEnabled( other.mEyeDomeLightingEnabled )

  , mEyeDomeLightingStrength( other.mEyeDomeLightingStrength )

  , mEyeDomeLightingDistance( other.mEyeDomeLightingDistance )

  , mViewSyncMode( other.mViewSyncMode )

  , mVisualizeViewFrustum( other.mVisualizeViewFrustum )

  , mDebugShadowMapEnabled( other.mDebugShadowMapEnabled )

  , mDebugShadowMapCorner( other.mDebugShadowMapCorner )

  , mDebugShadowMapSize( other.mDebugShadowMapSize )

  , mDebugDepthMapEnabled( other.mDebugDepthMapEnabled )

  , mDebugDepthMapCorner( other.mDebugDepthMapCorner )

  , mDebugDepthMapSize( other.mDebugDepthMapSize )

  , mTerrainRenderingEnabled( other.mTerrainRenderingEnabled )

  , mRendererUsage( other.mRendererUsage )

  , m3dAxisSettings( other.m3dAxisSettings )

  , mIsDebugOverlayEnabled( other.mIsDebugOverlayEnabled )

  , mExtent( other.mExtent )

{

  for ( QgsAbstract3DRenderer *renderer : std::as_const( other.mRenderers ) )

  {

    mRenderers << renderer->clone();

  }


  for ( QgsLightSource *source : std::as_const( other.mLightSources ) )

  {

    if ( source )

      mLightSources << source->clone();

  }


  connect( this, &Qgs3DMapSettings::settingsChanged, [&]()

  {

    QgsProject::instance()->setDirty();

  } );

  connectChangedSignalsToSettingsChanged();

}


Qgs3DMapSettings::~Qgs3DMapSettings()

{

  qDeleteAll( mRenderers );

  qDeleteAll( mLightSources );

}


void Qgs3DMapSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )

{

  QgsProjectDirtyBlocker blocker( QgsProject::instance() );

  QDomElement elemOrigin = elem.firstChildElement( QStringLiteral( "origin" ) );

  mOrigin = QgsVector3D(

              elemOrigin.attribute( QStringLiteral( "x" ) ).toDouble(),

              elemOrigin.attribute( QStringLiteral( "y" ) ).toDouble(),

              elemOrigin.attribute( QStringLiteral( "z" ) ).toDouble() );


  QDomElement elemExtent = elem.firstChildElement( QStringLiteral( "extent" ) );

  if ( !elemExtent.isNull() )

  {

    mExtent = QgsRectangle(

                elemExtent.attribute( QStringLiteral( "xMin" ) ).toDouble(),

                elemExtent.attribute( QStringLiteral( "yMin" ) ).toDouble(),

                elemExtent.attribute( QStringLiteral( "xMax" ) ).toDouble(),

                elemExtent.attribute( QStringLiteral( "yMax" ) ).toDouble() );

  }

  else

  {

    mExtent = QgsProject::instance()->viewSettings()->fullExtent();

  }


  QDomElement elemCamera = elem.firstChildElement( QStringLiteral( "camera" ) );

  if ( !elemCamera.isNull() )

  {

    mFieldOfView = elemCamera.attribute( QStringLiteral( "field-of-view" ), QStringLiteral( "45" ) ).toFloat();

    mProjectionType = static_cast< Qt3DRender::QCameraLens::ProjectionType >( elemCamera.attribute( QStringLiteral( "projection-type" ), QStringLiteral( "1" ) ).toInt() );

    QString cameraNavigationMode = elemCamera.attribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "basic-navigation" ) );

    if ( cameraNavigationMode == QLatin1String( "terrain-based-navigation" ) )

      mCameraNavigationMode = Qgis::NavigationMode::TerrainBased;

    else if ( cameraNavigationMode == QLatin1String( "walk-navigation" ) )

      mCameraNavigationMode = Qgis::NavigationMode::Walk;

    mCameraMovementSpeed = elemCamera.attribute( QStringLiteral( "camera-movement-speed" ), QStringLiteral( "5.0" ) ).toDouble();

  }


  QDomElement elemColor = elem.firstChildElement( QStringLiteral( "color" ) );

  if ( !elemColor.isNull() )

  {

    mBackgroundColor = QgsSymbolLayerUtils::decodeColor( elemColor.attribute( QStringLiteral( "background" ) ) );

    mSelectionColor = QgsSymbolLayerUtils::decodeColor( elemColor.attribute( QStringLiteral( "selection" ) ) );

  }


  QDomElement elemCrs = elem.firstChildElement( QStringLiteral( "crs" ) );

  mCrs.readXml( elemCrs );


  QDomElement elemTerrain = elem.firstChildElement( QStringLiteral( "terrain" ) );

  mTerrainRenderingEnabled = elemTerrain.attribute( QStringLiteral( "terrain-rendering-enabled" ), QStringLiteral( "1" ) ).toInt();

  mTerrainVerticalScale = elemTerrain.attribute( QStringLiteral( "exaggeration" ), QStringLiteral( "1" ) ).toFloat();

  mMapTileResolution = elemTerrain.attribute( QStringLiteral( "texture-size" ), QStringLiteral( "512" ) ).toInt();

  mMaxTerrainScreenError = elemTerrain.attribute( QStringLiteral( "max-terrain-error" ), QStringLiteral( "3" ) ).toFloat();

  mMaxTerrainGroundError = elemTerrain.attribute( QStringLiteral( "max-ground-error" ), QStringLiteral( "1" ) ).toFloat();

  mTerrainShadingEnabled = elemTerrain.attribute( QStringLiteral( "shading-enabled" ), QStringLiteral( "0" ) ).toInt();

  mTerrainElevationOffset = elemTerrain.attribute( QStringLiteral( "elevation-offset" ), QStringLiteral( "0.0" ) ).toFloat();


  QDomElement elemTerrainShadingMaterial = elemTerrain.firstChildElement( QStringLiteral( "shading-material" ) );

  if ( !elemTerrainShadingMaterial.isNull() )

    mTerrainShadingMaterial.readXml( elemTerrainShadingMaterial, context );

  mTerrainMapTheme = elemTerrain.attribute( QStringLiteral( "map-theme" ) );

  mShowLabels = elemTerrain.attribute( QStringLiteral( "show-labels" ), QStringLiteral( "0" ) ).toInt();


  qDeleteAll( mLightSources );

  mLightSources.clear();

  const QDomElement lightsElem = elem.firstChildElement( QStringLiteral( "lights" ) );

  if ( !lightsElem.isNull() )

  {

    const QDomNodeList lightNodes = lightsElem.childNodes();

    for ( int i = 0; i < lightNodes.size(); ++i )

    {

      const QDomElement lightElement = lightNodes.at( i ).toElement();

      if ( QgsLightSource *light = QgsLightSource::createFromXml( lightElement, context ) )

        mLightSources << light;

    }

  }

  else

  {

    // older project format

    QDomElement elemPointLights = elem.firstChildElement( QStringLiteral( "point-lights" ) );

    if ( !elemPointLights.isNull() )

    {

      QDomElement elemPointLight = elemPointLights.firstChildElement( QStringLiteral( "point-light" ) );

      while ( !elemPointLight.isNull() )

      {

        std::unique_ptr< QgsPointLightSettings > pointLight = std::make_unique< QgsPointLightSettings >();

        pointLight->readXml( elemPointLight, context );

        mLightSources << pointLight.release();

        elemPointLight = elemPointLight.nextSiblingElement( QStringLiteral( "point-light" ) );

      }

    }

    else

    {

      // QGIS <= 3.4 did not have light configuration

      std::unique_ptr< QgsPointLightSettings > defaultLight = std::make_unique< QgsPointLightSettings >();

      defaultLight->setPosition( QgsVector3D( 0, 1000, 0 ) );

      mLightSources << defaultLight.release();

    }


    QDomElement elemDirectionalLights = elem.firstChildElement( QStringLiteral( "directional-lights" ) );

    if ( !elemDirectionalLights.isNull() )

    {

      QDomElement elemDirectionalLight = elemDirectionalLights.firstChildElement( QStringLiteral( "directional-light" ) );

      while ( !elemDirectionalLight.isNull() )

      {

        std::unique_ptr< QgsDirectionalLightSettings > directionalLight = std::make_unique< QgsDirectionalLightSettings >();

        directionalLight->readXml( elemDirectionalLight, context );

        mLightSources << directionalLight.release();

        elemDirectionalLight = elemDirectionalLight.nextSiblingElement( QStringLiteral( "directional-light" ) );

      }

    }

  }


  QDomElement elemMapLayers = elemTerrain.firstChildElement( QStringLiteral( "layers" ) );

  QDomElement elemMapLayer = elemMapLayers.firstChildElement( QStringLiteral( "layer" ) );

  QList<QgsMapLayerRef> mapLayers;

  while ( !elemMapLayer.isNull() )

  {

    mapLayers << QgsMapLayerRef( elemMapLayer.attribute( QStringLiteral( "id" ) ) );

    elemMapLayer = elemMapLayer.nextSiblingElement( QStringLiteral( "layer" ) );

  }

  mLayers = mapLayers;  // needs to resolve refs afterwards


  QDomElement elemTerrainGenerator = elemTerrain.firstChildElement( QStringLiteral( "generator" ) );

  QString terrainGenType = elemTerrainGenerator.attribute( QStringLiteral( "type" ) );

  if ( terrainGenType == QLatin1String( "dem" ) )

  {

    QgsDemTerrainGenerator *demTerrainGenerator = new QgsDemTerrainGenerator;

    demTerrainGenerator->setCrs( mCrs, mTransformContext );

    setTerrainGenerator( demTerrainGenerator );

  }

  else if ( terrainGenType == QLatin1String( "online" ) )

  {

    QgsOnlineTerrainGenerator *onlineTerrainGenerator = new QgsOnlineTerrainGenerator;

    onlineTerrainGenerator->setCrs( mCrs, mTransformContext );

    setTerrainGenerator( onlineTerrainGenerator );

  }

  else if ( terrainGenType == QLatin1String( "mesh" ) )

  {

    QgsMeshTerrainGenerator *meshTerrainGenerator = new QgsMeshTerrainGenerator;

    meshTerrainGenerator->setCrs( mCrs, mTransformContext );

    setTerrainGenerator( meshTerrainGenerator );

  }

  else // "flat"

  {

    QgsFlatTerrainGenerator *flatGen = new QgsFlatTerrainGenerator;

    flatGen->setCrs( mCrs );

    setTerrainGenerator( flatGen );

  }

  mTerrainGenerator->readXml( elemTerrainGenerator );


  qDeleteAll( mRenderers );

  mRenderers.clear();


  QDomElement elemRenderers = elem.firstChildElement( QStringLiteral( "renderers" ) );

  QDomElement elemRenderer = elemRenderers.firstChildElement( QStringLiteral( "renderer" ) );

  while ( !elemRenderer.isNull() )

  {

    QgsAbstract3DRenderer *renderer = nullptr;

    QString type = elemRenderer.attribute( QStringLiteral( "type" ) );

    if ( type == QLatin1String( "vector" ) )

    {

      renderer = new QgsVectorLayer3DRenderer;

    }

    else if ( type == QLatin1String( "mesh" ) )

    {

      renderer = new QgsMeshLayer3DRenderer;

    }

    else if ( type == QLatin1String( "pointcloud" ) )

    {

      renderer = new QgsPointCloudLayer3DRenderer;

    }


    if ( renderer )

    {

      renderer->readXml( elemRenderer, context );

      mRenderers.append( renderer );

    }

    elemRenderer = elemRenderer.nextSiblingElement( QStringLiteral( "renderer" ) );

  }


  QDomElement elemSkybox = elem.firstChildElement( QStringLiteral( "skybox" ) );

  mIsSkyboxEnabled = elemSkybox.attribute( QStringLiteral( "skybox-enabled" ) ).toInt();

  mSkyboxSettings.readXml( elemSkybox, context );


  QDomElement elemShadows = elem.firstChildElement( QStringLiteral( "shadow-rendering" ) );

  mShadowSettings.readXml( elemShadows, context );


  QDomElement elemAmbientOcclusion = elem.firstChildElement( QStringLiteral( "screen-space-ambient-occlusion" ) );

  mAmbientOcclusionSettings.readXml( elemAmbientOcclusion, context );


  QDomElement elemEyeDomeLighting = elem.firstChildElement( QStringLiteral( "eye-dome-lighting" ) );

  mEyeDomeLightingEnabled = elemEyeDomeLighting.attribute( "enabled", QStringLiteral( "0" ) ).toInt();

  mEyeDomeLightingStrength = elemEyeDomeLighting.attribute( "eye-dome-lighting-strength", QStringLiteral( "1000.0" ) ).toDouble();

  mEyeDomeLightingDistance = elemEyeDomeLighting.attribute( "eye-dome-lighting-distance", QStringLiteral( "1" ) ).toInt();


  QDomElement elemNavigationSync = elem.firstChildElement( QStringLiteral( "navigation-sync" ) );

  mViewSyncMode = ( Qgis::ViewSyncModeFlags )( elemNavigationSync.attribute( QStringLiteral( "view-sync-mode" ), QStringLiteral( "0" ) ).toInt() );

  mVisualizeViewFrustum = elemNavigationSync.attribute( QStringLiteral( "view-frustum-visualization-enabled" ), QStringLiteral( "0" ) ).toInt();


  QDomElement elemDebugSettings = elem.firstChildElement( QStringLiteral( "debug-settings" ) );

  mDebugShadowMapEnabled = elemDebugSettings.attribute( QStringLiteral( "shadowmap-enabled" ), QStringLiteral( "0" ) ).toInt();

  mDebugShadowMapCorner = static_cast<Qt::Corner>( elemDebugSettings.attribute( QStringLiteral( "shadowmap-corner" ), "0" ).toInt() );

  mDebugShadowMapSize = elemDebugSettings.attribute( QStringLiteral( "shadowmap-size" ), QStringLiteral( "0.2" ) ).toDouble();


  mDebugDepthMapEnabled = elemDebugSettings.attribute( QStringLiteral( "depthmap-enabled" ), QStringLiteral( "0" ) ).toInt();

  mDebugDepthMapCorner = static_cast<Qt::Corner>( elemDebugSettings.attribute( QStringLiteral( "depthmap-corner" ), QStringLiteral( "1" ) ).toInt() );

  mDebugDepthMapSize = elemDebugSettings.attribute( QStringLiteral( "depthmap-size" ), QStringLiteral( "0.2" ) ).toDouble();


  QDomElement elemDebug = elem.firstChildElement( QStringLiteral( "debug" ) );

  mShowTerrainBoundingBoxes = elemDebug.attribute( QStringLiteral( "bounding-boxes" ), QStringLiteral( "0" ) ).toInt();

  mShowTerrainTileInfo = elemDebug.attribute( QStringLiteral( "terrain-tile-info" ), QStringLiteral( "0" ) ).toInt();

  mShowCameraViewCenter = elemDebug.attribute( QStringLiteral( "camera-view-center" ), QStringLiteral( "0" ) ).toInt();

  mShowCameraRotationCenter = elemDebug.attribute( QStringLiteral( "camera-rotation-center" ), QStringLiteral( "0" ) ).toInt();

  mShowLightSources = elemDebug.attribute( QStringLiteral( "show-light-sources" ), QStringLiteral( "0" ) ).toInt();

  mIsFpsCounterEnabled = elemDebug.attribute( QStringLiteral( "show-fps-counter" ), QStringLiteral( "0" ) ).toInt();


  QDomElement elemTemporalRange = elem.firstChildElement( QStringLiteral( "temporal-range" ) );

  QDateTime start = QDateTime::fromString( elemTemporalRange.attribute( QStringLiteral( "start" ) ), Qt::ISODate );

  QDateTime end = QDateTime::fromString( elemTemporalRange.attribute( QStringLiteral( "end" ) ), Qt::ISODate );

  setTemporalRange( QgsDateTimeRange( start, end ) );


  QDomElement elem3dAxis = elem.firstChildElement( QStringLiteral( "axis3d" ) );

  m3dAxisSettings.readXml( elem3dAxis, context );


}


QDomElement Qgs3DMapSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const

{

  QDomElement elem = doc.createElement( QStringLiteral( "qgis3d" ) );


  QDomElement elemOrigin = doc.createElement( QStringLiteral( "origin" ) );

  elemOrigin.setAttribute( QStringLiteral( "x" ), QString::number( mOrigin.x() ) );

  elemOrigin.setAttribute( QStringLiteral( "y" ), QString::number( mOrigin.y() ) );

  elemOrigin.setAttribute( QStringLiteral( "z" ), QString::number( mOrigin.z() ) );

  elem.appendChild( elemOrigin );


  QDomElement elemExtent = doc.createElement( QStringLiteral( "extent" ) );

  elemExtent.setAttribute( QStringLiteral( "xMin" ), mExtent.xMinimum() );

  elemExtent.setAttribute( QStringLiteral( "yMin" ), mExtent.yMinimum() );

  elemExtent.setAttribute( QStringLiteral( "xMax" ), mExtent.xMaximum() );

  elemExtent.setAttribute( QStringLiteral( "yMax" ), mExtent.yMaximum() );

  elem.appendChild( elemExtent );


  QDomElement elemCamera = doc.createElement( QStringLiteral( "camera" ) );

  elemCamera.setAttribute( QStringLiteral( "field-of-view" ), mFieldOfView );

  elemCamera.setAttribute( QStringLiteral( "projection-type" ), static_cast< int >( mProjectionType ) );

  switch ( mCameraNavigationMode )

  {

    case Qgis::NavigationMode::TerrainBased:

      elemCamera.setAttribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "terrain-based-navigation" ) );

      break;

    case Qgis::NavigationMode::Walk:

      elemCamera.setAttribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "walk-navigation" ) );

      break;

  }

  elemCamera.setAttribute( QStringLiteral( "camera-movement-speed" ), mCameraMovementSpeed );

  elem.appendChild( elemCamera );


  QDomElement elemColor = doc.createElement( QStringLiteral( "color" ) );

  elemColor.setAttribute( QStringLiteral( "background" ), QgsSymbolLayerUtils::encodeColor( mBackgroundColor ) );

  elemColor.setAttribute( QStringLiteral( "selection" ), QgsSymbolLayerUtils::encodeColor( mSelectionColor ) );

  elem.appendChild( elemColor );


  QDomElement elemCrs = doc.createElement( QStringLiteral( "crs" ) );

  mCrs.writeXml( elemCrs, doc );

  elem.appendChild( elemCrs );


  QDomElement elemTerrain = doc.createElement( QStringLiteral( "terrain" ) );

  elemTerrain.setAttribute( QStringLiteral( "terrain-rendering-enabled" ), mTerrainRenderingEnabled ? 1 : 0 );

  elemTerrain.setAttribute( QStringLiteral( "exaggeration" ), QString::number( mTerrainVerticalScale ) );

  elemTerrain.setAttribute( QStringLiteral( "texture-size" ), mMapTileResolution );

  elemTerrain.setAttribute( QStringLiteral( "max-terrain-error" ), QString::number( mMaxTerrainScreenError ) );

  elemTerrain.setAttribute( QStringLiteral( "max-ground-error" ), QString::number( mMaxTerrainGroundError ) );

  elemTerrain.setAttribute( QStringLiteral( "shading-enabled" ), mTerrainShadingEnabled ? 1 : 0 );

  elemTerrain.setAttribute( QStringLiteral( "elevation-offset" ), mTerrainElevationOffset );


  QDomElement elemTerrainShadingMaterial = doc.createElement( QStringLiteral( "shading-material" ) );

  mTerrainShadingMaterial.writeXml( elemTerrainShadingMaterial, context );

  elemTerrain.appendChild( elemTerrainShadingMaterial );

  elemTerrain.setAttribute( QStringLiteral( "map-theme" ), mTerrainMapTheme );

  elemTerrain.setAttribute( QStringLiteral( "show-labels" ), mShowLabels ? 1 : 0 );


  {

    QDomElement elemLights = doc.createElement( QStringLiteral( "lights" ) );

    for ( const QgsLightSource *light : mLightSources )

    {

      const QDomElement elemLight = light->writeXml( doc, context );

      elemLights.appendChild( elemLight );

    }

    elem.appendChild( elemLights );

  }


  QDomElement elemMapLayers = doc.createElement( QStringLiteral( "layers" ) );

  for ( const QgsMapLayerRef &layerRef : mLayers )

  {

    QDomElement elemMapLayer = doc.createElement( QStringLiteral( "layer" ) );

    elemMapLayer.setAttribute( QStringLiteral( "id" ), layerRef.layerId );

    elemMapLayers.appendChild( elemMapLayer );

  }

  elemTerrain.appendChild( elemMapLayers );


  QDomElement elemTerrainGenerator = doc.createElement( QStringLiteral( "generator" ) );

  elemTerrainGenerator.setAttribute( QStringLiteral( "type" ), QgsTerrainGenerator::typeToString( mTerrainGenerator->type() ) );

  mTerrainGenerator->writeXml( elemTerrainGenerator );

  elemTerrain.appendChild( elemTerrainGenerator );

  elem.appendChild( elemTerrain );


  QDomElement elemRenderers = doc.createElement( QStringLiteral( "renderers" ) );

  for ( const QgsAbstract3DRenderer *renderer : mRenderers )

  {

    QDomElement elemRenderer = doc.createElement( QStringLiteral( "renderer" ) );

    elemRenderer.setAttribute( QStringLiteral( "type" ), renderer->type() );

    renderer->writeXml( elemRenderer, context );

    elemRenderers.appendChild( elemRenderer );

  }

  elem.appendChild( elemRenderers );


  QDomElement elemSkybox = doc.createElement( QStringLiteral( "skybox" ) );

  elemSkybox.setAttribute( QStringLiteral( "skybox-enabled" ), mIsSkyboxEnabled );

  mSkyboxSettings.writeXml( elemSkybox, context );

  elem.appendChild( elemSkybox );


  QDomElement elemShadows = doc.createElement( QStringLiteral( "shadow-rendering" ) );

  mShadowSettings.writeXml( elemShadows, context );

  elem.appendChild( elemShadows );


  QDomElement elemAmbientOcclusion = doc.createElement( QStringLiteral( "screen-space-ambient-occlusion" ) );

  mAmbientOcclusionSettings.writeXml( elemAmbientOcclusion, context );

  elem.appendChild( elemAmbientOcclusion );


  QDomElement elemDebug = doc.createElement( QStringLiteral( "debug" ) );

  elemDebug.setAttribute( QStringLiteral( "bounding-boxes" ), mShowTerrainBoundingBoxes ? 1 : 0 );

  elemDebug.setAttribute( QStringLiteral( "terrain-tile-info" ), mShowTerrainTileInfo ? 1 : 0 );

  elemDebug.setAttribute( QStringLiteral( "camera-view-center" ), mShowCameraViewCenter ? 1 : 0 );

  elemDebug.setAttribute( QStringLiteral( "camera-rotation-center" ), mShowCameraRotationCenter ? 1 : 0 );

  elemDebug.setAttribute( QStringLiteral( "show-light-sources" ), mShowLightSources ? 1 : 0 );

  elemDebug.setAttribute( QStringLiteral( "show-fps-counter" ), mIsFpsCounterEnabled ? 1 : 0 );

  elem.appendChild( elemDebug );


  QDomElement elemEyeDomeLighting = doc.createElement( QStringLiteral( "eye-dome-lighting" ) );

  elemEyeDomeLighting.setAttribute( QStringLiteral( "enabled" ), mEyeDomeLightingEnabled ? 1 : 0 );

  elemEyeDomeLighting.setAttribute( QStringLiteral( "eye-dome-lighting-strength" ), mEyeDomeLightingStrength );

  elemEyeDomeLighting.setAttribute( QStringLiteral( "eye-dome-lighting-distance" ), mEyeDomeLightingDistance );

  elem.appendChild( elemEyeDomeLighting );


  QDomElement elemNavigationSync = doc.createElement( QStringLiteral( "navigation-sync" ) );

  elemNavigationSync.setAttribute( QStringLiteral( "view-sync-mode" ), ( int )mViewSyncMode );

  elemNavigationSync.setAttribute( QStringLiteral( "view-frustum-visualization-enabled" ), mVisualizeViewFrustum ? 1 : 0 );

  elem.appendChild( elemNavigationSync );


  QDomElement elemDebugSettings = doc.createElement( QStringLiteral( "debug-settings" ) );

  elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-enabled" ), mDebugShadowMapEnabled );

  elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-corner" ), mDebugShadowMapCorner );

  elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-size" ), mDebugShadowMapSize );

  elemDebugSettings.setAttribute( QStringLiteral( "depthmap-enabled" ), mDebugDepthMapEnabled );

  elemDebugSettings.setAttribute( QStringLiteral( "depthmap-corner" ), mDebugDepthMapCorner );

  elemDebugSettings.setAttribute( QStringLiteral( "depthmap-size" ), mDebugDepthMapSize );

  elem.appendChild( elemDebugSettings );


  QDomElement elemTemporalRange = doc.createElement( QStringLiteral( "temporal-range" ) );

  elemTemporalRange.setAttribute( QStringLiteral( "start" ), temporalRange().begin().toString( Qt::ISODate ) );

  elemTemporalRange.setAttribute( QStringLiteral( "end" ), temporalRange().end().toString( Qt::ISODate ) );


  QDomElement elem3dAxis = doc.createElement( QStringLiteral( "axis3d" ) );

  m3dAxisSettings.writeXml( elem3dAxis, context );

  elem.appendChild( elem3dAxis );


  return elem;

}


void Qgs3DMapSettings::resolveReferences( const QgsProject &project )

{

  for ( int i = 0; i < mLayers.count(); ++i )

  {

    QgsMapLayerRef &layerRef = mLayers[i];

    layerRef.setLayer( project.mapLayer( layerRef.layerId ) );

  }


  mTerrainGenerator->resolveReferences( project );


  for ( int i = 0; i < mRenderers.count(); ++i )

  {

    QgsAbstract3DRenderer *renderer = mRenderers[i];

    renderer->resolveReferences( project );

  }

}


void Qgs3DMapSettings::setExtent( const QgsRectangle &extent )

{

  if ( extent == mExtent )

    return;


  mExtent = extent;

  const QgsPointXY center = mExtent.center();

  setOrigin( QgsVector3D( center.x(), center.y(), 0 ) );

  if ( mTerrainGenerator )

  {

    QgsRectangle terrainExtent = mExtent;

    if ( mCrs != mTerrainGenerator->crs() )

    {

      QgsCoordinateTransform ct = QgsCoordinateTransform( mCrs, mTerrainGenerator->crs(), mTransformContext );

      ct.setBallparkTransformsAreAppropriate( true );

      try

      {

        terrainExtent = ct.transformBoundingBox( mExtent );

      }

      catch ( const QgsCsException & )

      {

        QgsDebugMsg( QStringLiteral( "Transformation of map extent to terrain crs failed." ) );

      }

    }

    mTerrainGenerator->setExtent( terrainExtent );

  }

  emit extentChanged();

}


QgsVector3D Qgs3DMapSettings::mapToWorldCoordinates( const QgsVector3D &mapCoords ) const

{

  return Qgs3DUtils::mapToWorldCoordinates( mapCoords, mOrigin );

}


QgsVector3D Qgs3DMapSettings::worldToMapCoordinates( const QgsVector3D &worldCoords ) const

{

  return Qgs3DUtils::worldToMapCoordinates( worldCoords, mOrigin );

}


void Qgs3DMapSettings::setCrs( const QgsCoordinateReferenceSystem &crs )

{

  mCrs = crs;

}


QgsCoordinateTransformContext Qgs3DMapSettings::transformContext() const

{

  return mTransformContext;

}


void Qgs3DMapSettings::setTransformContext( const QgsCoordinateTransformContext &context )

{

  mTransformContext = context;

}


void Qgs3DMapSettings::setBackgroundColor( const QColor &color )

{

  if ( color == mBackgroundColor )

    return;


  mBackgroundColor = color;

  emit backgroundColorChanged();

}


QColor Qgs3DMapSettings::backgroundColor() const

{

  return mBackgroundColor;

}


void Qgs3DMapSettings::setSelectionColor( const QColor &color )

{

  if ( color == mSelectionColor )

    return;


  mSelectionColor = color;

  emit selectionColorChanged();

}


QColor Qgs3DMapSettings::selectionColor() const

{

  return mSelectionColor;

}


void Qgs3DMapSettings::setTerrainVerticalScale( double zScale )

{

  if ( zScale == mTerrainVerticalScale )

    return;


  mTerrainVerticalScale = zScale;

  emit terrainVerticalScaleChanged();

}


double Qgs3DMapSettings::terrainVerticalScale() const

{

  return mTerrainVerticalScale;

}


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

{

  QList<QgsMapLayerRef> lst;

  lst.reserve( layers.count() );

  for ( QgsMapLayer *layer : layers )

  {

    lst.append( layer );

  }


  if ( mLayers == lst )

    return;


  mLayers = lst;

  emit layersChanged();

}


QList<QgsMapLayer *> Qgs3DMapSettings::layers() const

{

  QList<QgsMapLayer *> lst;

  lst.reserve( mLayers.count() );

  for ( const QgsMapLayerRef &layerRef : mLayers )

  {

    if ( layerRef.layer )

      lst.append( layerRef.layer );

  }

  return lst;

}


void Qgs3DMapSettings::configureTerrainFromProject( QgsProjectElevationProperties *properties, const QgsRectangle &fullExtent )

{

  setExtent( fullExtent );

  if ( properties->terrainProvider()->type() == QLatin1String( "flat" ) )

  {

    QgsFlatTerrainGenerator *flatTerrain = new QgsFlatTerrainGenerator;

    flatTerrain->setCrs( crs() );

    setTerrainGenerator( flatTerrain );


    setTerrainElevationOffset( properties->terrainProvider()->offset() );

  }

  else if ( properties->terrainProvider()->type() == QLatin1String( "raster" ) )

  {

    QgsRasterDemTerrainProvider *rasterProvider = qgis::down_cast< QgsRasterDemTerrainProvider * >( properties->terrainProvider() );


    QgsDemTerrainGenerator *demTerrainGen = new QgsDemTerrainGenerator;

    demTerrainGen->setCrs( crs(), QgsProject::instance()->transformContext() );

    demTerrainGen->setLayer( rasterProvider->layer() );

    setTerrainGenerator( demTerrainGen );


    setTerrainElevationOffset( properties->terrainProvider()->offset() );

    setTerrainVerticalScale( properties->terrainProvider()->scale() );

  }

  else if ( properties->terrainProvider()->type() == QLatin1String( "mesh" ) )

  {

    QgsMeshTerrainProvider *meshProvider = qgis::down_cast< QgsMeshTerrainProvider * >( properties->terrainProvider() );


    QgsMeshTerrainGenerator *newTerrainGenerator = new QgsMeshTerrainGenerator;

    newTerrainGenerator->setCrs( crs(), QgsProject::instance()->transformContext() );

    newTerrainGenerator->setLayer( meshProvider->layer() );

    std::unique_ptr< QgsMesh3DSymbol > symbol( newTerrainGenerator->symbol()->clone() );

    symbol->setVerticalScale( properties->terrainProvider()->scale() );

    newTerrainGenerator->setSymbol( symbol.release() );

    setTerrainGenerator( newTerrainGenerator );


    setTerrainElevationOffset( properties->terrainProvider()->offset() );

    setTerrainVerticalScale( properties->terrainProvider()->scale() );

  }

  else

  {

    QgsFlatTerrainGenerator *flatTerrain = new QgsFlatTerrainGenerator;

    flatTerrain->setCrs( crs() );

    setTerrainGenerator( flatTerrain );

  }

}


void Qgs3DMapSettings::setMapTileResolution( int res )

{

  if ( mMapTileResolution == res )

    return;


  mMapTileResolution = res;

  emit mapTileResolutionChanged();

}


int Qgs3DMapSettings::mapTileResolution() const

{

  return mMapTileResolution;

}


void Qgs3DMapSettings::setMaxTerrainScreenError( float error )

{

  if ( mMaxTerrainScreenError == error )

    return;


  mMaxTerrainScreenError = error;

  emit maxTerrainScreenErrorChanged();

}


float Qgs3DMapSettings::maxTerrainScreenError() const

{

  return mMaxTerrainScreenError;

}


void Qgs3DMapSettings::setMaxTerrainGroundError( float error )

{

  if ( mMaxTerrainGroundError == error )

    return;


  mMaxTerrainGroundError = error;

  emit maxTerrainGroundErrorChanged();

}


void Qgs3DMapSettings::setTerrainElevationOffset( float offset )

{

  if ( mTerrainElevationOffset == offset )

    return;

  mTerrainElevationOffset = offset;

  emit terrainElevationOffsetChanged( mTerrainElevationOffset );

}


float Qgs3DMapSettings::maxTerrainGroundError() const

{

  return mMaxTerrainGroundError;

}


void Qgs3DMapSettings::setTerrainGenerator( QgsTerrainGenerator *gen )

{

  if ( mTerrainGenerator )

  {

    disconnect( mTerrainGenerator.get(), &QgsTerrainGenerator::terrainChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );

  }


  QgsRectangle terrainExtent = mExtent;

  if ( mCrs != gen->crs() )

  {

    QgsCoordinateTransform ct = QgsCoordinateTransform( mCrs, gen->crs(), mTransformContext );

    ct.setBallparkTransformsAreAppropriate( true );

    try

    {

      terrainExtent = ct.transformBoundingBox( mExtent );

    }

    catch ( const QgsCsException & )

    {

      QgsDebugMsg( QStringLiteral( "Transformation of map extent to terrain crs failed." ) );

    }

  }

  gen->setExtent( terrainExtent );

  mTerrainGenerator.reset( gen );

  connect( mTerrainGenerator.get(), &QgsTerrainGenerator::terrainChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );


  emit terrainGeneratorChanged();

}


void Qgs3DMapSettings::setTerrainShadingEnabled( bool enabled )

{

  if ( mTerrainShadingEnabled == enabled )

    return;


  mTerrainShadingEnabled = enabled;

  emit terrainShadingChanged();

}


void Qgs3DMapSettings::setTerrainShadingMaterial( const QgsPhongMaterialSettings &material )

{

  if ( mTerrainShadingMaterial == material )

    return;


  mTerrainShadingMaterial = material;

  emit terrainShadingChanged();

}


void Qgs3DMapSettings::setTerrainMapTheme( const QString &theme )

{

  if ( mTerrainMapTheme == theme )

    return;


  mTerrainMapTheme = theme;

  emit terrainMapThemeChanged();

}


void Qgs3DMapSettings::setRenderers( const QList<QgsAbstract3DRenderer *> &renderers )

{

  qDeleteAll( mRenderers );


  mRenderers = renderers;


  emit renderersChanged();

}


void Qgs3DMapSettings::setShowTerrainBoundingBoxes( bool enabled )

{

  if ( mShowTerrainBoundingBoxes == enabled )

    return;


  mShowTerrainBoundingBoxes = enabled;

  emit showTerrainBoundingBoxesChanged();

}


void Qgs3DMapSettings::setShowTerrainTilesInfo( bool enabled )

{

  if ( mShowTerrainTileInfo == enabled )

    return;


  mShowTerrainTileInfo = enabled;

  emit showTerrainTilesInfoChanged();

}


void Qgs3DMapSettings::setShowCameraViewCenter( bool enabled )

{

  if ( mShowCameraViewCenter == enabled )

    return;


  mShowCameraViewCenter = enabled;

  emit showCameraViewCenterChanged();

}


void Qgs3DMapSettings::setShowCameraRotationCenter( bool enabled )

{

  if ( mShowCameraRotationCenter == enabled )

    return;


  mShowCameraRotationCenter = enabled;

  emit showCameraRotationCenterChanged();

}


void Qgs3DMapSettings::setShowLightSourceOrigins( bool enabled )

{

  if ( mShowLightSources == enabled )

    return;


  mShowLightSources = enabled;

  emit showLightSourceOriginsChanged();

}


void Qgs3DMapSettings::setShowLabels( bool enabled )

{

  if ( mShowLabels == enabled )

    return;


  mShowLabels = enabled;

  emit showLabelsChanged();

}


void Qgs3DMapSettings::setEyeDomeLightingEnabled( bool enabled )

{

  if ( mEyeDomeLightingEnabled == enabled )

    return;

  mEyeDomeLightingEnabled = enabled;

  emit eyeDomeLightingEnabledChanged();

}


void Qgs3DMapSettings::setEyeDomeLightingStrength( double strength )

{

  if ( mEyeDomeLightingStrength == strength )

    return;

  mEyeDomeLightingStrength = strength;

  emit eyeDomeLightingStrengthChanged();

}


void Qgs3DMapSettings::setEyeDomeLightingDistance( int distance )

{

  if ( mEyeDomeLightingDistance == distance )

    return;

  mEyeDomeLightingDistance = distance;

  emit eyeDomeLightingDistanceChanged();

}


QList<QgsLightSource *> Qgs3DMapSettings::lightSources() const

{

  return mLightSources;

}


void Qgs3DMapSettings::setLightSources( const QList<QgsLightSource *> &lights )

{

  qDeleteAll( mLightSources );

  mLightSources = lights;


  emit directionalLightsChanged();

  emit pointLightsChanged();

  emit lightSourcesChanged();

}


void Qgs3DMapSettings::setFieldOfView( const float fieldOfView )

{

  if ( mFieldOfView == fieldOfView )

    return;


  mFieldOfView = fieldOfView;

  emit fieldOfViewChanged();

}


void Qgs3DMapSettings::setProjectionType( const Qt3DRender::QCameraLens::ProjectionType projectionType )

{

  if ( mProjectionType == projectionType )

    return;


  mProjectionType = projectionType;

  emit projectionTypeChanged();

}


void Qgs3DMapSettings::setCameraNavigationMode( Qgis::NavigationMode navigationMode )

{

  if ( mCameraNavigationMode == navigationMode )

    return;


  mCameraNavigationMode = navigationMode;

  emit cameraNavigationModeChanged();

}


void Qgs3DMapSettings::setCameraMovementSpeed( double movementSpeed )

{

  if ( mCameraMovementSpeed == movementSpeed )

    return;


  mCameraMovementSpeed = movementSpeed;

  emit cameraMovementSpeedChanged();

}


void Qgs3DMapSettings::setSkyboxSettings( const QgsSkyboxSettings &skyboxSettings )

{

  mSkyboxSettings = skyboxSettings;

  emit skyboxSettingsChanged();

}


void Qgs3DMapSettings::setShadowSettings( const QgsShadowSettings &shadowSettings )

{

  mShadowSettings = shadowSettings;

  emit shadowSettingsChanged();

}


void Qgs3DMapSettings::setAmbientOcclusionSettings( const QgsAmbientOcclusionSettings &ambientOcclusionSettings )

{

  mAmbientOcclusionSettings = ambientOcclusionSettings;

  emit ambientOcclusionSettingsChanged();

}


void Qgs3DMapSettings::setDebugShadowMapSettings( bool enabled, Qt::Corner corner, double size )

{

  mDebugShadowMapEnabled = enabled;

  mDebugShadowMapCorner = corner;

  mDebugShadowMapSize = size;

  emit debugShadowMapSettingsChanged();

}


void Qgs3DMapSettings::setDebugDepthMapSettings( bool enabled, Qt::Corner corner, double size )

{

  mDebugDepthMapEnabled = enabled;

  mDebugDepthMapCorner = corner;

  mDebugDepthMapSize = size;

  emit debugDepthMapSettingsChanged();

}


void Qgs3DMapSettings::setIsFpsCounterEnabled( bool fpsCounterEnabled )

{

  if ( fpsCounterEnabled == mIsFpsCounterEnabled )

    return;

  mIsFpsCounterEnabled = fpsCounterEnabled;

  emit fpsCounterEnabledChanged( mIsFpsCounterEnabled );

}


void Qgs3DMapSettings::setTerrainRenderingEnabled( bool terrainRenderingEnabled )

{

  if ( terrainRenderingEnabled == mTerrainRenderingEnabled )

    return;

  mTerrainRenderingEnabled = terrainRenderingEnabled;

  emit terrainGeneratorChanged();

}


Qgis::RendererUsage Qgs3DMapSettings::rendererUsage() const

{

  return mRendererUsage;

}


void Qgs3DMapSettings::setRendererUsage( Qgis::RendererUsage rendererUsage )

{

  mRendererUsage = rendererUsage;

}


void Qgs3DMapSettings::setViewSyncMode( Qgis::ViewSyncModeFlags mode )

{

  mViewSyncMode = mode;

}


void Qgs3DMapSettings::setViewFrustumVisualizationEnabled( bool enabled )

{

  if ( mVisualizeViewFrustum != enabled )

  {

    mVisualizeViewFrustum = enabled;

    emit viewFrustumVisualizationEnabledChanged();

  }

}


void Qgs3DMapSettings::setIsDebugOverlayEnabled( bool debugOverlayEnabled )

{

  if ( debugOverlayEnabled == mIsDebugOverlayEnabled )

    return;


  mIsDebugOverlayEnabled = debugOverlayEnabled;

  emit debugOverlayEnabledChanged( mIsDebugOverlayEnabled );

}


void Qgs3DMapSettings::connectChangedSignalsToSettingsChanged()

{

  connect( this, &Qgs3DMapSettings::selectionColorChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::layersChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::terrainGeneratorChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::terrainVerticalScaleChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::mapTileResolutionChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::maxTerrainScreenErrorChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::maxTerrainGroundErrorChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::terrainElevationOffsetChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::terrainShadingChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::terrainMapThemeChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::renderersChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::showTerrainBoundingBoxesChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::showTerrainTilesInfoChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::showCameraViewCenterChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::showCameraRotationCenterChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::showLightSourceOriginsChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::eyeDomeLightingEnabledChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::eyeDomeLightingStrengthChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::eyeDomeLightingDistanceChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::debugShadowMapSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::debugDepthMapSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::lightSourcesChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::fieldOfViewChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::projectionTypeChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::cameraNavigationModeChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::cameraMovementSpeedChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::skyboxSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::shadowSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::fpsCounterEnabledChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::ambientOcclusionSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );

  connect( this, &Qgs3DMapSettings::extentChanged, this, &Qgs3DMapSettings::settingsChanged );

}


void Qgs3DMapSettings::set3DAxisSettings( const Qgs3DAxisSettings &axisSettings, bool force )

{

  if ( axisSettings == m3dAxisSettings )

  {

    if ( force )

    {

      // ie. refresh. We nned to disconnect and to reconnect to avoid 'dirty' project

      disconnect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );

      emit axisSettingsChanged();

      connect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );

    }

  }

  else

  {

    m3dAxisSettings = axisSettings;

    emit axisSettingsChanged();

  }

}

Qgis::NavigationMode
NavigationMode
The navigation mode used by 3D cameras.
Definition: qgis.h:2421

Qgis::NavigationMode::TerrainBased
@ TerrainBased
The default navigation based on the terrain.

Qgis::NavigationMode::Walk
@ Walk
Uses WASD keys or arrows to navigate in walking (first person) manner.

Qgis::RendererUsage
RendererUsage
Usage of the renderer.
Definition: qgis.h:2205

Qgs3DAxisSettings
Contains the configuration of a 3d axis.
Definition: qgs3daxissettings.h:36

Qgs3DAxisSettings::readXml
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
Definition: qgs3daxissettings.cpp:53

Qgs3DAxisSettings::writeXml
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
Definition: qgs3daxissettings.cpp:92

Qgs3DMapSettings
3
Definition: qgs3dmapsettings.h:53

Qgs3DMapSettings::extentChanged
void extentChanged()
Emitted when the 3d view's 2d extent has changed.

Qgs3DMapSettings::setEyeDomeLightingStrength
void setEyeDomeLightingStrength(double strength)
Sets the eye dome lighting strength value.
Definition: qgs3dmapsettings.cpp:860

Qgs3DMapSettings::mapTileResolutionChanged
void mapTileResolutionChanged()
Emitted when the map tile resoulution has changed.

Qgs3DMapSettings::terrainVerticalScaleChanged
void terrainVerticalScaleChanged()
Emitted when the vertical scale of the terrain has changed.

Qgs3DMapSettings::setTransformContext
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the coordinate transform context, which stores various information regarding which datum transfo...
Definition: qgs3dmapsettings.cpp:562

Qgs3DMapSettings::settingsChanged
void settingsChanged()
Emitted when one of the configuration settings has changed.

Qgs3DMapSettings::renderersChanged
void renderersChanged()
Emitted when the list of map's extra renderers have been modified.

Qgs3DMapSettings::eyeDomeLightingDistanceChanged
void eyeDomeLightingDistanceChanged()
Emitted when the eye dome lighting distance has changed.

Qgs3DMapSettings::readXml
void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Reads configuration from a DOM element previously written by writeXml()
Definition: qgs3dmapsettings.cpp:127

Qgs3DMapSettings::terrainShadingChanged
void terrainShadingChanged()
Emitted when terrain shading enabled flag or terrain shading material has changed.

Qgs3DMapSettings::setAmbientOcclusionSettings
void setAmbientOcclusionSettings(const QgsAmbientOcclusionSettings &ambientOcclusionSettings)
Sets the current configuration of screen space ambient occlusion.
Definition: qgs3dmapsettings.cpp:939

Qgs3DMapSettings::setShowTerrainTilesInfo
void setShowTerrainTilesInfo(bool enabled)
Sets whether to display extra tile info on top of terrain tiles (for debugging)
Definition: qgs3dmapsettings.cpp:806

Qgs3DMapSettings::mapToWorldCoordinates
QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords) const
Converts map coordinates to 3D world coordinates (applies offset and turns (x,y,z) into (x,...
Definition: qgs3dmapsettings.cpp:542

Qgs3DMapSettings::setRenderers
void setRenderers(const QList< QgsAbstract3DRenderer * > &renderers)
Sets list of extra 3D renderers to use in the scene. Takes ownership of the objects.
Definition: qgs3dmapsettings.cpp:788

Qgs3DMapSettings::projectionType
Qt3DRender::QCameraLens::ProjectionType projectionType() const
Returns the camera lens' projection type.
Definition: qgs3dmapsettings.h:483

Qgs3DMapSettings::setEyeDomeLightingEnabled
void setEyeDomeLightingEnabled(bool enabled)
Sets whether eye dome lighting will be used.
Definition: qgs3dmapsettings.cpp:852

Qgs3DMapSettings::setFieldOfView
void setFieldOfView(const float fieldOfView)
Sets the camera lens' field of view.
Definition: qgs3dmapsettings.cpp:891

Qgs3DMapSettings::debugDepthMapSettingsChanged
void debugDepthMapSettingsChanged()
Emitted when depth map debugging has changed.

Qgs3DMapSettings::setLightSources
void setLightSources(const QList< QgsLightSource * > &lights)
Sets the list of light sources defined in the scene.
Definition: qgs3dmapsettings.cpp:881

Qgs3DMapSettings::cameraNavigationMode
Qgis::NavigationMode cameraNavigationMode() const
Returns the navigation mode used by the camera.
Definition: qgs3dmapsettings.h:497

Qgs3DMapSettings::backgroundColorChanged
void backgroundColorChanged()
Emitted when the background color has changed.

Qgs3DMapSettings::showTerrainBoundingBoxesChanged
void showTerrainBoundingBoxesChanged()
Emitted when the flag whether terrain's bounding boxes are shown has changed.

Qgs3DMapSettings::writeXml
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context) const
Writes configuration to a DOM element, to be used later with readXml()
Definition: qgs3dmapsettings.cpp:352

Qgs3DMapSettings::setDebugDepthMapSettings
void setDebugDepthMapSettings(bool enabled, Qt::Corner corner, double size)
Sets the debugging settings of the depth map.
Definition: qgs3dmapsettings.cpp:953

Qgs3DMapSettings::showCameraRotationCenterChanged
void showCameraRotationCenterChanged()
Emitted when the flag whether camera's rotation center is shown has changed.

Qgs3DMapSettings::selectionColor
QColor selectionColor() const
Returns color used for selected features.
Definition: qgs3dmapsettings.cpp:590

Qgs3DMapSettings::directionalLightsChanged
void directionalLightsChanged()
Emitted when the list of directional lights changes.

Qgs3DMapSettings::setTerrainShadingMaterial
void setTerrainShadingMaterial(const QgsPhongMaterialSettings &material)
Sets terrain shading material.
Definition: qgs3dmapsettings.cpp:770

Qgs3DMapSettings::cameraNavigationModeChanged
void cameraNavigationModeChanged()
Emitted when the camera navigation mode was changed.

Qgs3DMapSettings::shadowSettingsChanged
void shadowSettingsChanged()
Emitted when shadow rendering settings are changed.

Qgs3DMapSettings::setViewFrustumVisualizationEnabled
void setViewFrustumVisualizationEnabled(bool enabled)
Sets whether the camera's view frustum is visualized on the 2D map canvas.
Definition: qgs3dmapsettings.cpp:992

Qgs3DMapSettings::setShowCameraRotationCenter
void setShowCameraRotationCenter(bool enabled)
Sets whether to show camera's rotation center as a sphere (for debugging)
Definition: qgs3dmapsettings.cpp:824

Qgs3DMapSettings::maxTerrainGroundError
float maxTerrainGroundError() const
Returns maximum ground error of terrain tiles in world units.
Definition: qgs3dmapsettings.cpp:728

Qgs3DMapSettings::setExtent
void setExtent(const QgsRectangle &extent)
Sets the 3D scene's 2D extent in project's CRS, while also setting the scene's origin to the extent's...
Definition: qgs3dmapsettings.cpp:513

Qgs3DMapSettings::eyeDomeLightingEnabledChanged
void eyeDomeLightingEnabledChanged()
Emitted when the flag whether eye dome lighting is used has changed.

Qgs3DMapSettings::setTerrainVerticalScale
void setTerrainVerticalScale(double zScale)
Sets vertical scale (exaggeration) of terrain (1 = true scale, > 1 = hills get more pronounced)
Definition: qgs3dmapsettings.cpp:595

Qgs3DMapSettings::debugOverlayEnabledChanged
void debugOverlayEnabledChanged(bool debugOverlayEnabled)
Emitted when the debug overaly is enabled or disabled.

Qgs3DMapSettings::setShowLabels
void setShowLabels(bool enabled)
Sets whether to display labels on terrain tiles.
Definition: qgs3dmapsettings.cpp:843

Qgs3DMapSettings::terrainVerticalScale
double terrainVerticalScale() const
Returns vertical scale (exaggeration) of terrain.
Definition: qgs3dmapsettings.cpp:604

Qgs3DMapSettings::setViewSyncMode
void setViewSyncMode(Qgis::ViewSyncModeFlags mode)
Sets the view sync mode (used to synchronize the 2D main map canvas and the 3D camera navigation)
Definition: qgs3dmapsettings.cpp:987

Qgs3DMapSettings::setOrigin
void setOrigin(const QgsVector3D &origin)
Sets coordinates in map CRS at which our 3D world has origin (0,0,0)
Definition: qgs3dmapsettings.h:98

Qgs3DMapSettings::setMaxTerrainGroundError
void setMaxTerrainGroundError(float error)
Returns maximum ground error of terrain tiles in world units.
Definition: qgs3dmapsettings.cpp:711

Qgs3DMapSettings::setSkyboxSettings
void setSkyboxSettings(const QgsSkyboxSettings &skyboxSettings)
Sets the current configuration of the skybox.
Definition: qgs3dmapsettings.cpp:927

Qgs3DMapSettings::skyboxSettingsChanged
void skyboxSettingsChanged()
Emitted when skybox settings are changed.

Qgs3DMapSettings::setMapTileResolution
void setMapTileResolution(int res)
Sets resolution (in pixels) of the texture of a terrain tile.
Definition: qgs3dmapsettings.cpp:683

Qgs3DMapSettings::setLayers
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of 3D map layers to be rendered in the scene.
Definition: qgs3dmapsettings.cpp:609

Qgs3DMapSettings::shadowSettings
QgsShadowSettings shadowSettings() const
Returns the current configuration of shadows.
Definition: qgs3dmapsettings.h:543

Qgs3DMapSettings::terrainMapThemeChanged
void terrainMapThemeChanged()
Emitted when terrain's map theme has changed.

Qgs3DMapSettings::setShadowSettings
void setShadowSettings(const QgsShadowSettings &shadowSettings)
Sets the current configuration of shadow rendering.
Definition: qgs3dmapsettings.cpp:933

Qgs3DMapSettings::setIsDebugOverlayEnabled
void setIsDebugOverlayEnabled(bool debugOverlayEnabled)
Sets whether debug overlay is enabled The debug overlay displays some debugging and profiling informa...
Definition: qgs3dmapsettings.cpp:1001

Qgs3DMapSettings::pointLightsChanged
void pointLightsChanged()
Emitted when the list of point lights changes.

Qgs3DMapSettings::setTerrainElevationOffset
void setTerrainElevationOffset(float offset)
Sets the terrain elevation offset (used to move the terrain up or down)
Definition: qgs3dmapsettings.cpp:720

Qgs3DMapSettings::lightSources
QList< QgsLightSource * > lightSources() const
Returns list of directional light sources defined in the scene.
Definition: qgs3dmapsettings.cpp:876

Qgs3DMapSettings::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets coordinate reference system used in the 3D scene.
Definition: qgs3dmapsettings.cpp:552

Qgs3DMapSettings::setEyeDomeLightingDistance
void setEyeDomeLightingDistance(int distance)
Sets the eye dome lighting distance value (contributes to the contrast of the image.
Definition: qgs3dmapsettings.cpp:868

Qgs3DMapSettings::setShowLightSourceOrigins
void setShowLightSourceOrigins(bool enabled)
Sets whether to show light source origins as a sphere (for debugging)
Definition: qgs3dmapsettings.cpp:834

Qgs3DMapSettings::renderers
QList< QgsAbstract3DRenderer * > renderers() const
Returns list of extra 3D renderers.
Definition: qgs3dmapsettings.h:345

Qgs3DMapSettings::projectionTypeChanged
void projectionTypeChanged()
Emitted when the camera lens projection type changes.

Qgs3DMapSettings::fieldOfView
float fieldOfView() const
Returns the camera lens' field of view.
Definition: qgs3dmapsettings.h:471

Qgs3DMapSettings::selectionColorChanged
void selectionColorChanged()
Emitted when the selection color has changed.

Qgs3DMapSettings::ambientOcclusionSettings
QgsAmbientOcclusionSettings ambientOcclusionSettings() const
Returns the current configuration of screen space ambient occlusion.
Definition: qgs3dmapsettings.h:549

Qgs3DMapSettings::extent
QgsRectangle extent() const
Returns the 3D scene's 2D extent in project's CRS.
Definition: qgs3dmapsettings.h:75

Qgs3DMapSettings::setTerrainShadingEnabled
void setTerrainShadingEnabled(bool enabled)
Sets whether terrain shading is enabled.
Definition: qgs3dmapsettings.cpp:761

Qgs3DMapSettings::setDebugShadowMapSettings
void setDebugShadowMapSettings(bool enabled, Qt::Corner corner, double size)
Sets the debugging settings of the shadow map.
Definition: qgs3dmapsettings.cpp:945

Qgs3DMapSettings::setSelectionColor
void setSelectionColor(const QColor &color)
Sets color used for selected features.
Definition: qgs3dmapsettings.cpp:581

Qgs3DMapSettings::lightSourcesChanged
void lightSourcesChanged()
Emitted when any of the light source settings in the map changes.

Qgs3DMapSettings::showLightSourceOriginsChanged
void showLightSourceOriginsChanged()
Emitted when the flag whether light source origins are shown has changed.

Qgs3DMapSettings::setCameraNavigationMode
void setCameraNavigationMode(Qgis::NavigationMode navigationMode)
Sets the navigation mode for the camera.
Definition: qgs3dmapsettings.cpp:909

Qgs3DMapSettings::backgroundColor
QColor backgroundColor() const
Returns background color of the 3D map view.
Definition: qgs3dmapsettings.cpp:576

Qgs3DMapSettings::resolveReferences
void resolveReferences(const QgsProject &project)
Resolves references to other objects (map layers) after the call to readXml()
Definition: qgs3dmapsettings.cpp:496

Qgs3DMapSettings::worldToMapCoordinates
QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords) const
Converts 3D world coordinates to map coordinates (applies offset and turns (x,y,z) into (x,...
Definition: qgs3dmapsettings.cpp:547

Qgs3DMapSettings::~Qgs3DMapSettings
~Qgs3DMapSettings() override
Definition: qgs3dmapsettings.cpp:121

Qgs3DMapSettings::showLabelsChanged
void showLabelsChanged()
Emitted when the flag whether labels are displayed on terrain tiles has changed.

Qgs3DMapSettings::maxTerrainScreenErrorChanged
void maxTerrainScreenErrorChanged()
Emitted when the maximum terrain screen error has changed.

Qgs3DMapSettings::setShowCameraViewCenter
void setShowCameraViewCenter(bool enabled)
Sets whether to show camera's view center as a sphere (for debugging)
Definition: qgs3dmapsettings.cpp:815

Qgs3DMapSettings::mapTileResolution
int mapTileResolution() const
Returns resolution (in pixels) of the texture of a terrain tile.
Definition: qgs3dmapsettings.cpp:692

Qgs3DMapSettings::set3DAxisSettings
void set3DAxisSettings(const Qgs3DAxisSettings &axisSettings, bool force=false)
Sets the current configuration of 3d axis.
Definition: qgs3dmapsettings.cpp:1048

Qgs3DMapSettings::setCameraMovementSpeed
void setCameraMovementSpeed(double movementSpeed)
Sets the camera movement speed.
Definition: qgs3dmapsettings.cpp:918

Qgs3DMapSettings::terrainElevationOffsetChanged
void terrainElevationOffsetChanged(float newElevation)
Emitted when the terrain elevation offset is changed.

Qgs3DMapSettings::setTerrainRenderingEnabled
void setTerrainRenderingEnabled(bool terrainRenderingEnabled)
Sets whether the 2D terrain surface will be rendered in.
Definition: qgs3dmapsettings.cpp:969

Qgs3DMapSettings::Qgs3DMapSettings
Qgs3DMapSettings()
Constructor for Qgs3DMapSettings.
Definition: qgs3dmapsettings.cpp:39

Qgs3DMapSettings::setBackgroundColor
void setBackgroundColor(const QColor &color)
Sets background color of the 3D map view.
Definition: qgs3dmapsettings.cpp:567

Qgs3DMapSettings::terrainRenderingEnabled
bool terrainRenderingEnabled() const
Returns whether the 2D terrain surface will be rendered.
Definition: qgs3dmapsettings.h:602

Qgs3DMapSettings::fpsCounterEnabledChanged
void fpsCounterEnabledChanged(bool fpsCounterEnabled)
Emitted when the FPS counter is enabled or disabled.

Qgs3DMapSettings::axisSettingsChanged
void axisSettingsChanged()
Emitted when 3d axis rendering settings are changed.

Qgs3DMapSettings::viewFrustumVisualizationEnabledChanged
void viewFrustumVisualizationEnabledChanged()
Emitted when the camera's view frustum visualization on the main 2D map canvas is enabled or disabled...

Qgs3DMapSettings::setProjectionType
void setProjectionType(const Qt3DRender::QCameraLens::ProjectionType projectionType)
Sets the camera lens' projection type.
Definition: qgs3dmapsettings.cpp:900

Qgs3DMapSettings::ambientOcclusionSettingsChanged
void ambientOcclusionSettingsChanged()
Emitted when ambient occlusion rendering settings are changed.

Qgs3DMapSettings::configureTerrainFromProject
void configureTerrainFromProject(QgsProjectElevationProperties *properties, const QgsRectangle &fullExtent)
Configures the map's terrain settings directly from a project's elevation properties.
Definition: qgs3dmapsettings.cpp:637

Qgs3DMapSettings::layersChanged
void layersChanged()
Emitted when the list of map layers for 3d rendering has changed.

Qgs3DMapSettings::showTerrainTilesInfoChanged
void showTerrainTilesInfoChanged()
Emitted when the flag whether terrain's tile info is shown has changed.

Qgs3DMapSettings::eyeDomeLightingStrengthChanged
void eyeDomeLightingStrengthChanged()
Emitted when the eye dome lighting strength has changed.

Qgs3DMapSettings::skyboxSettings
QgsSkyboxSettings skyboxSettings() const
Returns the current configuration of the skybox.
Definition: qgs3dmapsettings.h:537

Qgs3DMapSettings::setMaxTerrainScreenError
void setMaxTerrainScreenError(float error)
Sets maximum allowed screen error of terrain tiles in pixels.
Definition: qgs3dmapsettings.cpp:697

Qgs3DMapSettings::cameraMovementSpeedChanged
void cameraMovementSpeedChanged()
Emitted when the camera movement speed was changed.

Qgs3DMapSettings::crs
QgsCoordinateReferenceSystem crs() const
Returns coordinate reference system used in the 3D scene.
Definition: qgs3dmapsettings.h:110

Qgs3DMapSettings::setRendererUsage
void setRendererUsage(Qgis::RendererUsage rendererUsage)
Sets the renderer usage.
Definition: qgs3dmapsettings.cpp:982

Qgs3DMapSettings::maxTerrainScreenError
float maxTerrainScreenError() const
Returns maximum allowed screen error of terrain tiles in pixels.
Definition: qgs3dmapsettings.cpp:706

Qgs3DMapSettings::setShowTerrainBoundingBoxes
void setShowTerrainBoundingBoxes(bool enabled)
Sets whether to display bounding boxes of terrain tiles (for debugging)
Definition: qgs3dmapsettings.cpp:797

Qgs3DMapSettings::fieldOfViewChanged
void fieldOfViewChanged()
Emitted when the camera lens field of view changes.

Qgs3DMapSettings::rendererUsage
Qgis::RendererUsage rendererUsage() const
Returns the renderer usage.
Definition: qgs3dmapsettings.cpp:977

Qgs3DMapSettings::setIsFpsCounterEnabled
void setIsFpsCounterEnabled(bool fpsCounterEnabled)
Sets whether FPS counter label is enabled.
Definition: qgs3dmapsettings.cpp:961

Qgs3DMapSettings::layers
QList< QgsMapLayer * > layers() const
Returns the list of 3D map layers to be rendered in the scene.
Definition: qgs3dmapsettings.cpp:625

Qgs3DMapSettings::setTerrainMapTheme
void setTerrainMapTheme(const QString &theme)
Sets name of the map theme.
Definition: qgs3dmapsettings.cpp:779

Qgs3DMapSettings::terrainGeneratorChanged
void terrainGeneratorChanged()
Emitted when the terrain generator has changed.

Qgs3DMapSettings::setTerrainGenerator
void setTerrainGenerator(QgsTerrainGenerator *gen)
Sets terrain generator and sets extent() as the generator's extent.
Definition: qgs3dmapsettings.cpp:733

Qgs3DMapSettings::debugShadowMapSettingsChanged
void debugShadowMapSettingsChanged()
Emitted when shadow map debugging has changed.

Qgs3DMapSettings::showCameraViewCenterChanged
void showCameraViewCenterChanged()
Emitted when the flag whether camera's view center is shown has changed.

Qgs3DMapSettings::maxTerrainGroundErrorChanged
void maxTerrainGroundErrorChanged()
Emitted when the maximum terrain ground error has changed.

Qgs3DMapSettings::transformContext
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
Definition: qgs3dmapsettings.cpp:557

Qgs3DUtils::worldToMapCoordinates
static QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords, const QgsVector3D &origin)
Converts 3D world coordinates to map coordinates (applies offset and turns (x,y,z) into (x,...
Definition: qgs3dutils.cpp:551

Qgs3DUtils::mapToWorldCoordinates
static QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords, const QgsVector3D &origin)
Converts map coordinates to 3D world coordinates (applies offset and turns (x,y,z) into (x,...
Definition: qgs3dutils.cpp:543

QgsAbstract3DRenderer
Base class for all renderers that may to participate in 3D view.
Definition: qgsabstract3drenderer.h:49

QgsAbstract3DRenderer::readXml
virtual void readXml(const QDomElement &elem, const QgsReadWriteContext &context)=0
Reads renderer's properties from given XML element.

QgsAbstract3DRenderer::resolveReferences
virtual void resolveReferences(const QgsProject &project)
Resolves references to other objects - second phase of loading - after readXml()
Definition: qgsabstract3drenderer.cpp:19

QgsAbstractTerrainProvider::type
virtual QString type() const =0
Returns the unique type ID string for the provider.

QgsAbstractTerrainProvider::offset
double offset() const
Returns the vertical offset value, used for adjusting the heights from the terrain provider.
Definition: qgsterrainprovider.h:149

QgsAbstractTerrainProvider::scale
double scale() const
Returns the vertical scale factor, which can be used to exaggerate vertical heights.
Definition: qgsterrainprovider.h:133

QgsAmbientOcclusionSettings
class containing the configuration of ambient occlusion rendering 3
Definition: qgsambientocclusionsettings.h:36

QgsAmbientOcclusionSettings::writeXml
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
Definition: qgsambientocclusionsettings.cpp:51

QgsAmbientOcclusionSettings::readXml
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
Definition: qgsambientocclusionsettings.cpp:41

QgsCoordinateReferenceSystem
This class represents a coordinate reference system (CRS).
Definition: qgscoordinatereferencesystem.h:212

QgsCoordinateReferenceSystem::readXml
bool readXml(const QDomNode &node)
Restores state from the given DOM node.
Definition: qgscoordinatereferencesystem.cpp:1883

QgsCoordinateReferenceSystem::writeXml
bool writeXml(QDomNode &node, QDomDocument &doc) const
Stores state to the given Dom node in the given document.
Definition: qgscoordinatereferencesystem.cpp:2003

QgsCoordinateTransformContext
Contains information about the context in which a coordinate transform is executed.
Definition: qgscoordinatetransformcontext.h:58

QgsCoordinateTransform
Class for doing transforms between two map coordinate systems.
Definition: qgscoordinatetransform.h:58

QgsCoordinateTransform::setBallparkTransformsAreAppropriate
void setBallparkTransformsAreAppropriate(bool appropriate)
Sets whether approximate "ballpark" results are appropriate for this coordinate transform.
Definition: qgscoordinatetransform.cpp:932

QgsCoordinateTransform::transformBoundingBox
QgsRectangle transformBoundingBox(const QgsRectangle &rectangle, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool handle180Crossover=false) const SIP_THROW(QgsCsException)
Transforms a rectangle from the source CRS to the destination CRS.
Definition: qgscoordinatetransform.cpp:560

QgsCsException
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66

QgsDemTerrainGenerator
3
Definition: qgsdemterraingenerator.h:42

QgsDemTerrainGenerator::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets CRS of the terrain.
Definition: qgsdemterraingenerator.cpp:39

QgsDemTerrainGenerator::setLayer
void setLayer(QgsRasterLayer *layer)
Sets raster layer with elevation model to be used for terrain generation.
Definition: qgsdemterraingenerator.cpp:28

QgsFlatTerrainGenerator
3
Definition: qgsflatterraingenerator.h:53

QgsFlatTerrainGenerator::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets CRS of the terrain.
Definition: qgsflatterraingenerator.cpp:132

QgsLightSource
3
Definition: qgslightsource.h:47

QgsLightSource::createFromXml
static QgsLightSource * createFromXml(const QDomElement &element, const QgsReadWriteContext &context)
Creates a new light source from an XML element.
Definition: qgslightsource.cpp:30

QgsMapLayer
Base class for all map layer types.
Definition: qgsmaplayer.h:73

QgsMeshLayer3DRenderer
3D renderer that renders all mesh triangles of a mesh layer.
Definition: qgsmeshlayer3drenderer.h:60

QgsMeshTerrainProvider
A terrain provider that uses the Z values of a mesh layer to build a terrain surface.
Definition: qgsterrainprovider.h:285

QgsMeshTerrainProvider::layer
QgsMeshLayer * layer() const
Returns the mesh layer to be used as the terrain source.
Definition: qgsterrainprovider.cpp:320

QgsOnlineTerrainGenerator
3
Definition: qgsonlineterraingenerator.h:38

QgsOnlineTerrainGenerator::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets CRS of the terrain.
Definition: qgsonlineterraingenerator.cpp:93

QgsPhongMaterialSettings
3
Definition: qgsphongmaterialsettings.h:37

QgsPhongMaterialSettings::writeXml
void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const override
Writes settings to a DOM element.
Definition: qgsphongmaterialsettings.cpp:88

QgsPhongMaterialSettings::readXml
void readXml(const QDomElement &elem, const QgsReadWriteContext &context) override
Reads settings from a DOM element.
Definition: qgsphongmaterialsettings.cpp:77

QgsPointCloudLayer3DRenderer
3D renderer that renders all points from a point cloud layer
Definition: qgspointcloudlayer3drenderer.h:241

QgsPointXY
A class to represent a 2D point.
Definition: qgspointxy.h:59

QgsPointXY::y
double y
Definition: qgspointxy.h:63

QgsPointXY::x
Q_GADGET double x
Definition: qgspointxy.h:62

QgsProjectDirtyBlocker
Temporarily blocks QgsProject "dirtying" for the lifetime of the object.
Definition: qgsproject.h:2396

QgsProjectElevationProperties
Contains elevation properties for a QgsProject.
Definition: qgsprojectelevationproperties.h:39

QgsProjectElevationProperties::terrainProvider
QgsAbstractTerrainProvider * terrainProvider()
Returns the project's terrain provider.
Definition: qgsprojectelevationproperties.cpp:84

QgsProjectViewSettings::fullExtent
QgsReferencedRectangle fullExtent() const
Returns the full extent of the project, which represents the maximal limits of the project.
Definition: qgsprojectviewsettings.cpp:73

QgsProject
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition: qgsproject.h:105

QgsProject::instance
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:477

QgsProject::mapLayer
Q_INVOKABLE QgsMapLayer * mapLayer(const QString &layerId) const
Retrieve a pointer to a registered layer by layer ID.
Definition: qgsproject.cpp:4002

QgsProject::setDirty
void setDirty(bool b=true)
Flag the project as dirty (modified).
Definition: qgsproject.cpp:596

QgsProject::viewSettings
const QgsProjectViewSettings * viewSettings() const
Returns the project's view settings, which contains settings and properties relating to how a QgsProj...
Definition: qgsproject.cpp:3750

QgsRasterDemTerrainProvider
A terrain provider where the terrain source is a raster DEM layer.
Definition: qgsterrainprovider.h:231

QgsRasterDemTerrainProvider::layer
QgsRasterLayer * layer() const
Returns the raster layer with elevation model to be used as the terrain source.
Definition: qgsterrainprovider.cpp:212

QgsReadWriteContext
The class is used as a container of context for various read/write operations on other objects.
Definition: qgsreadwritecontext.h:35

QgsRectangle
A rectangle specified with double values.
Definition: qgsrectangle.h:42

QgsRectangle::yMaximum
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:193

QgsRectangle::xMaximum
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183

QgsRectangle::xMinimum
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188

QgsRectangle::yMinimum
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198

QgsRectangle::center
QgsPointXY center() const SIP_HOLDGIL
Returns the center point of the rectangle.
Definition: qgsrectangle.h:251

QgsShadowSettings
class containing the configuration of shadows rendering 3
Definition: qgsshadowsettings.h:35

QgsShadowSettings::writeXml
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
Definition: qgsshadowsettings.cpp:53

QgsShadowSettings::readXml
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
Definition: qgsshadowsettings.cpp:43

QgsSkyboxSettings
Contains the configuration of a skybox entity.
Definition: qgsskyboxsettings.h:37

QgsSkyboxSettings::readXml
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
Definition: qgsskyboxsettings.cpp:39

QgsSkyboxSettings::writeXml
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
Definition: qgsskyboxsettings.cpp:57

QgsSymbolLayerUtils::decodeColor
static QColor decodeColor(const QString &str)
Definition: qgssymbollayerutils.cpp:70

QgsSymbolLayerUtils::encodeColor
static QString encodeColor(const QColor &color)
Definition: qgssymbollayerutils.cpp:65

QgsTemporalRangeObject
Base class for objects with an associated (optional) temporal range.
Definition: qgstemporalrangeobject.h:34

QgsTemporalRangeObject::temporalRange
const QgsDateTimeRange & temporalRange() const
Returns the datetime range for the object.
Definition: qgstemporalrangeobject.cpp:43

QgsTemporalRangeObject::setTemporalRange
void setTemporalRange(const QgsDateTimeRange &range)
Sets the temporal range for the object.
Definition: qgstemporalrangeobject.cpp:35

QgsTerrainGenerator
3
Definition: qgsterraingenerator.h:50

QgsTerrainGenerator::terrainChanged
void terrainChanged()
Emitted when the terrain changed (for example, raster DEM or mesh have data changed)

QgsTerrainGenerator::crs
QgsCoordinateReferenceSystem crs() const
Returns CRS of the terrain.
Definition: qgsterraingenerator.h:109

QgsTerrainGenerator::setExtent
virtual void setExtent(const QgsRectangle &extent)
sets the extent of the terrain in terrain's CRS
Definition: qgsterraingenerator.h:76

QgsTerrainGenerator::typeToString
static QString typeToString(Type type)
Converts terrain generator type enumeration into a string.
Definition: qgsterraingenerator.cpp:61

QgsVector3D
3
Definition: qgsvector3d.h:32

QgsVector3D::y
double y() const
Returns Y coordinate.
Definition: qgsvector3d.h:51

QgsVector3D::z
double z() const
Returns Z coordinate.
Definition: qgsvector3d.h:53

QgsVector3D::x
double x() const
Returns X coordinate.
Definition: qgsvector3d.h:49

QgsVectorLayer3DRenderer
3D renderer that renders all features of a vector layer with the same 3D symbol.
Definition: qgsvectorlayer3drenderer.h:60

qgs3dmapsettings.h

qgs3dutils.h

qgsdemterraingenerator.h

qgsdirectionallightsettings.h

qgsflatterraingenerator.h

qgslightsource.h

QgsDebugMsg
#define QgsDebugMsg(str)
Definition: qgslogger.h:38

QgsMapLayerRef
_LayerRef< QgsMapLayer > QgsMapLayerRef
Definition: qgsmaplayerref.h:328

qgsmeshlayer3drenderer.h

qgsonlineterraingenerator.h

qgspointcloudlayer3drenderer.h

qgspointlightsettings.h

qgsprojectelevationproperties.h

qgsprojectviewsettings.h

qgsrasterlayer.h

qgssymbollayerutils.h

qgsterrainprovider.h

qgsvectorlayer3drenderer.h

crs
const QgsCoordinateReferenceSystem & crs
Definition: qgswfsgetfeature.cpp:53

_LayerRef< QgsMapLayer >

_LayerRef::setLayer
void setLayer(TYPE *l)
Sets the reference to point to a specified layer.
Definition: qgsmaplayerref.h:79

_LayerRef::layerId
QString layerId
Original layer ID.
Definition: qgsmaplayerref.h:118