api/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 "qgs3d.h"

#include "qgs3drendercontext.h"

#include "qgs3dterrainregistry.h"

#include "qgs3dutils.h"

#include "qgsabstract3dmapbackgroundsettings.h"

#include "qgsabstractterrainsettings.h"

#include "qgscolorutils.h"

#include "qgsdirectionallightsettings.h"

#include "qgsfixedgradientbackgroundsettings.h"

#include "qgsflatterrainsettings.h"

#include "qgslightsource.h"

#include "qgsmaplayerlistutils_p.h"

#include "qgspointlightsettings.h"

#include "qgsprojectelevationproperties.h"

#include "qgsprojectviewsettings.h"

#include "qgsrasterlayer.h"

#include "qgsterrainprovider.h"

#include "qgsthreadingutils.h"


#include <QDomDocument>

#include <QDomElement>

#include <QString>


#include "moc_qgs3dmapsettings.cpp"


using namespace Qt::StringLiterals;


Qgs3DMapSettings::Qgs3DMapSettings()

  : QObject( nullptr )

{

  connect( this, &Qgs3DMapSettings::settingsChanged, [&]() { QgsProject::instance()->setDirty(); } );

  connectChangedSignalsToSettingsChanged();

  mTerrainSettings = std::make_unique<QgsFlatTerrainSettings>();

}


Qgs3DMapSettings::Qgs3DMapSettings( const Qgs3DMapSettings &other )

  : QObject( nullptr )

  , QgsTemporalRangeObject( other )

  , mOrigin( other.mOrigin )

  , mCrs( other.mCrs )

  , mBackgroundColor( other.mBackgroundColor )

  , mSelectionColor( other.mSelectionColor )

  , 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 )

  , mStopUpdates( other.mStopUpdates )

  , mShowDebugPanel( other.mShowDebugPanel )

  , mFieldOfView( other.mFieldOfView )

  , mProjectionType( other.mProjectionType )

  , mCameraNavigationMode( other.mCameraNavigationMode )

  , mCameraMovementSpeed( other.mCameraMovementSpeed )

  , mLayers( other.mLayers )

  , mTransformContext( other.mTransformContext )

  , mPathResolver( other.mPathResolver )

  , mMapThemes( other.mMapThemes )

  , mDpi( other.mDpi )

  , mIsFpsCounterEnabled( other.mIsFpsCounterEnabled )

  , mShadowSettings( other.mShadowSettings )

  , mAmbientOcclusionSettings( other.mAmbientOcclusionSettings )

  , mBloomSettings( other.mBloomSettings )

  , mEyeDomeLightingEnabled( other.mEyeDomeLightingEnabled )

  , mEyeDomeLightingStrength( other.mEyeDomeLightingStrength )

  , mEyeDomeLightingDistance( other.mEyeDomeLightingDistance )

  , mMsaaEnabled( other.mMsaaEnabled )

  , mTextureFilterQuality( other.mTextureFilterQuality )

  , mViewSyncMode( other.mViewSyncMode )

  , mVisualizeViewFrustum( other.mVisualizeViewFrustum )

  , mTerrainRenderingEnabled( other.mTerrainRenderingEnabled )

  , mRendererUsage( other.mRendererUsage )

  , m3dAxisSettings( other.m3dAxisSettings )

  , mIsDebugOverlayEnabled( other.mIsDebugOverlayEnabled )

  , mExtent( other.mExtent )

  , mShowExtentIn2DView( other.mShowExtentIn2DView )

  , mShow2DMapOverlay( other.mShow2DMapOverlay )

{

  setTerrainSettings( other.mTerrainSettings ? other.mTerrainSettings->clone() : new QgsFlatTerrainSettings() );


  if ( other.mBackgroundSettings )

    mBackgroundSettings.reset( other.mBackgroundSettings->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( mLightSources );

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  QgsProjectDirtyBlocker blocker( QgsProject::instance() );

  QDomElement elemOrigin = elem.firstChildElement( u"origin"_s );

  // clang-format off

  mOrigin = QgsVector3D(

    elemOrigin.attribute( u"x"_s ).toDouble(),

    elemOrigin.attribute( u"y"_s ).toDouble(),

    elemOrigin.attribute( u"z"_s ).toDouble()

  );

  // clang-format on


  QDomElement elemExtent = elem.firstChildElement( u"extent"_s );

  if ( !elemExtent.isNull() )

  {

    // clang-format off

    mExtent = QgsRectangle(

      elemExtent.attribute( u"xMin"_s ).toDouble(),

      elemExtent.attribute( u"yMin"_s ).toDouble(),

      elemExtent.attribute( u"xMax"_s ).toDouble(),

      elemExtent.attribute( u"yMax"_s ).toDouble()

    );

    // clang-format on


    mShowExtentIn2DView = elemExtent.attribute( u"showIn2dView"_s, u"0"_s ).toInt();

  }

  else

  {

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

  }


  QDomElement elemCamera = elem.firstChildElement( u"camera"_s );

  if ( !elemCamera.isNull() )

  {

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

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

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

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

      mCameraNavigationMode = Qgis::NavigationMode::TerrainBased;

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

      mCameraNavigationMode = Qgis::NavigationMode::Walk;

    else if ( cameraNavigationMode == "globe-terrain-based-navigation"_L1 )

      mCameraNavigationMode = Qgis::NavigationMode::GlobeTerrainBased;

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

  }


  QDomElement elemColor = elem.firstChildElement( u"color"_s );

  if ( !elemColor.isNull() )

  {

    mBackgroundColor = QgsColorUtils::colorFromString( elemColor.attribute( u"background"_s ) );

    mSelectionColor = QgsColorUtils::colorFromString( elemColor.attribute( u"selection"_s ) );

  }


  QDomElement elemCrs = elem.firstChildElement( u"crs"_s );

  mCrs.readXml( elemCrs );


  QDomElement elemTerrain = elem.firstChildElement( u"terrain"_s );

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

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


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

  if ( !elemTerrainShadingMaterial.isNull() )

    mTerrainShadingMaterial.readXml( elemTerrainShadingMaterial, context );

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

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


  qDeleteAll( mLightSources );

  mLightSources.clear();

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

  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( u"point-lights"_s );

    if ( !elemPointLights.isNull() )

    {

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

      while ( !elemPointLight.isNull() )

      {

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

        pointLight->readXml( elemPointLight, context );

        mLightSources << pointLight.release();

        elemPointLight = elemPointLight.nextSiblingElement( u"point-light"_s );

      }

    }

    else

    {

      // QGIS <= 3.4 did not have light configuration

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

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

      mLightSources << defaultLight.release();

    }


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

    if ( !elemDirectionalLights.isNull() )

    {

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

      while ( !elemDirectionalLight.isNull() )

      {

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

        directionalLight->readXml( elemDirectionalLight, context );

        mLightSources << directionalLight.release();

        elemDirectionalLight = elemDirectionalLight.nextSiblingElement( u"directional-light"_s );

      }

    }

  }


  QDomElement elemMapLayers = elemTerrain.firstChildElement( u"layers"_s );

  QDomElement elemMapLayer = elemMapLayers.firstChildElement( u"layer"_s );

  QList<QgsMapLayerRef> mapLayers;

  while ( !elemMapLayer.isNull() )

  {

    mapLayers << QgsMapLayerRef( elemMapLayer.attribute( u"id"_s ) );

    elemMapLayer = elemMapLayer.nextSiblingElement( u"layer"_s );

  }

  mLayers = mapLayers; // needs to resolve refs afterwards


  QDomElement elemTerrainGenerator = elemTerrain.firstChildElement( u"generator"_s );

  const QString terrainGenType = elemTerrainGenerator.attribute( u"type"_s );

  std::unique_ptr<QgsAbstractTerrainSettings> terrainSettings( Qgs3D::terrainRegistry()->createTerrainSettings( terrainGenType ) );

  if ( terrainSettings )

  {

    terrainSettings->readXml( elemTerrain, context );

    setTerrainSettings( terrainSettings.release() );

  }


  mBackgroundSettings.reset();

  QDomElement elemBackground = elem.firstChildElement( u"background"_s );

  if ( !elemBackground.isNull() )

  {

    switch ( qgsEnumKeyToValue( elemBackground.attribute( u"type"_s ), Qgis::Map3DBackgroundType::NoBackground ) )

    {

      case Qgis::Map3DBackgroundType::DistinctTextureSkybox:

      {

        auto skybox = std::make_unique<QgsSkyboxSettings>();

        skybox->readXml( elemBackground, context );

        mBackgroundSettings = std::move( skybox );

        break;

      }

      case Qgis::Map3DBackgroundType::FixedGradientBackground:

      {

        auto gradient = std::make_unique<QgsFixedGradientBackgroundSettings>();

        gradient->readXml( elemBackground, context );

        mBackgroundSettings = std::move( gradient );

        break;

      }

      case Qgis::Map3DBackgroundType::NoBackground:

        break;

    }

  }


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

  mShadowSettings.readXml( elemShadows, context );


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

  mAmbientOcclusionSettings.readXml( elemAmbientOcclusion, context );


  {

    QDomElement elemBloom = elem.firstChildElement( u"bloom"_s );

    mBloomSettings.readXml( elemBloom, context );

  }


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

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

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

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


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

  mViewSyncMode = static_cast<Qgis::ViewSyncModeFlags>( elemNavigationSync.attribute( u"view-sync-mode"_s, u"0"_s ).toInt() );

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


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


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

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

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


  QDomElement elemDebug = elem.firstChildElement( u"debug"_s );

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

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

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

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

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

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

  mStopUpdates = elemDebug.attribute( u"stop-updates"_s, u"0"_s ).toInt();

  mShowDebugPanel = elemDebug.attribute( u"debug-panel"_s, u"0"_s ).toInt();


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

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

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

  setTemporalRange( QgsDateTimeRange( start, end ) );


  QDomElement elem3dAxis = elem.firstChildElement( u"axis3d"_s );

  m3dAxisSettings.readXml( elem3dAxis, context );


  QDomElement elemMapOverlay = elem.firstChildElement( u"map-overlay"_s );

  if ( !elemMapOverlay.isNull() )

  {

    mShow2DMapOverlay = elemMapOverlay.attribute( u"enabled"_s, u"0"_s ).toInt();

  }

  else

  {

    mShow2DMapOverlay = false;

  }

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  QDomElement elem = doc.createElement( u"qgis3d"_s );


  QDomElement elemOrigin = doc.createElement( u"origin"_s );

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

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

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

  elem.appendChild( elemOrigin );


  QDomElement elemExtent = doc.createElement( u"extent"_s );

  elemExtent.setAttribute( u"xMin"_s, mExtent.xMinimum() );

  elemExtent.setAttribute( u"yMin"_s, mExtent.yMinimum() );

  elemExtent.setAttribute( u"xMax"_s, mExtent.xMaximum() );

  elemExtent.setAttribute( u"yMax"_s, mExtent.yMaximum() );

  elemExtent.setAttribute( u"showIn2dView"_s, mShowExtentIn2DView );

  elem.appendChild( elemExtent );


  QDomElement elemCamera = doc.createElement( u"camera"_s );

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

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

  switch ( mCameraNavigationMode )

  {

    case Qgis::NavigationMode::TerrainBased:

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

      break;

    case Qgis::NavigationMode::Walk:

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

      break;

    case Qgis::NavigationMode::GlobeTerrainBased:

      elemCamera.setAttribute( u"camera-navigation-mode"_s, u"globe-terrain-based-navigation"_s );

      break;

  }

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

  elem.appendChild( elemCamera );


  QDomElement elemColor = doc.createElement( u"color"_s );

  elemColor.setAttribute( u"background"_s, QgsColorUtils::colorToString( mBackgroundColor ) );

  elemColor.setAttribute( u"selection"_s, QgsColorUtils::colorToString( mSelectionColor ) );

  elem.appendChild( elemColor );


  QDomElement elemCrs = doc.createElement( u"crs"_s );

  mCrs.writeXml( elemCrs, doc );

  elem.appendChild( elemCrs );


  QDomElement elemTerrain = doc.createElement( u"terrain"_s );

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

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


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

  mTerrainShadingMaterial.writeXml( elemTerrainShadingMaterial, context );

  elemTerrain.appendChild( elemTerrainShadingMaterial );

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

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


  {

    QDomElement elemLights = doc.createElement( u"lights"_s );

    for ( const QgsLightSource *light : mLightSources )

    {

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

      elemLights.appendChild( elemLight );

    }

    elem.appendChild( elemLights );

  }


  QDomElement elemMapLayers = doc.createElement( u"layers"_s );

  for ( const QgsMapLayerRef &layerRef : mLayers )

  {

    QDomElement elemMapLayer = doc.createElement( u"layer"_s );

    elemMapLayer.setAttribute( u"id"_s, layerRef.layerId );

    elemMapLayers.appendChild( elemMapLayer );

  }

  elemTerrain.appendChild( elemMapLayers );


  QDomElement elemTerrainGenerator = doc.createElement( u"generator"_s );

  elemTerrainGenerator.setAttribute( u"type"_s, mTerrainSettings->type() );

  mTerrainSettings->writeXml( elemTerrain, context );

  elemTerrain.appendChild( elemTerrainGenerator );

  elem.appendChild( elemTerrain );


  if ( mBackgroundSettings )

  {

    QDomElement elemBackground = doc.createElement( u"background"_s );

    elemBackground.setAttribute( u"type"_s, qgsEnumValueToKey( mBackgroundSettings->type() ) );

    mBackgroundSettings->writeXml( elemBackground, context );

    elem.appendChild( elemBackground );

  }


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

  mShadowSettings.writeXml( elemShadows, context );

  elem.appendChild( elemShadows );


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

  mAmbientOcclusionSettings.writeXml( elemAmbientOcclusion, context );

  elem.appendChild( elemAmbientOcclusion );


  {

    QDomElement elemBloom = doc.createElement( u"bloom"_s );

    mBloomSettings.writeXml( elemBloom, context );

    elem.appendChild( elemBloom );

  }


  QDomElement elemDebug = doc.createElement( u"debug"_s );

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

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

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

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

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

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

  elemDebug.setAttribute( u"stop-updates"_s, mStopUpdates ? 1 : 0 );

  elemDebug.setAttribute( u"debug-panel"_s, mShowDebugPanel ? 1 : 0 );

  elem.appendChild( elemDebug );


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

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

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

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

  elem.appendChild( elemEyeDomeLighting );


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

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

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

  elem.appendChild( elemNavigationSync );


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

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

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

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

  elem.appendChild( elemDebugSettings );


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

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

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


  QDomElement elem3dAxis = doc.createElement( u"axis3d"_s );

  m3dAxisSettings.writeXml( elem3dAxis, context );

  elem.appendChild( elem3dAxis );


  if ( mShow2DMapOverlay )

  {

    QDomElement elemMapOverlay = doc.createElement( u"map-overlay"_s );

    elemMapOverlay.setAttribute( u"enabled"_s, 1 );

    elem.appendChild( elemMapOverlay );

  }


  return elem;

}


void Qgs3DMapSettings::resolveReferences( const QgsProject &project )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


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

  {

    QgsMapLayerRef &layerRef = mLayers[i];

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

  }


  if ( mTerrainSettings )

  {

    mTerrainSettings->resolveReferences( &project );


    std::unique_ptr<QgsTerrainGenerator> terrainGenerator = mTerrainSettings->createTerrainGenerator( Qgs3DRenderContext::fromMapSettings( this ) );

    if ( terrainGenerator )

    {

      setTerrainGenerator( terrainGenerator.release() );

    }

    emit terrainSettingsChanged();

  }

}


QgsRectangle Qgs3DMapSettings::extent() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( sceneMode() == Qgis::SceneMode::Globe )

  {

    QgsDebugError( u"extent() should not be used with globe!"_s );

  }


  return mExtent;

}


void Qgs3DMapSettings::setExtent( const QgsRectangle &extent )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( extent == mExtent )

    return;


  if ( sceneMode() == Qgis::SceneMode::Globe )

  {

    QgsDebugError( u"setExtent() should not be used with globe!"_s );

  }


  mExtent = extent;

  const QgsPointXY center = mExtent.center();

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

  if ( mTerrainGenerator )

  {

    QgsRectangle terrainExtent = Qgs3DUtils::tryReprojectExtent2D( mExtent, mCrs, mTerrainGenerator->crs(), mTransformContext );

    mTerrainGenerator->setExtent( terrainExtent );

  }

  emit extentChanged();

}


void Qgs3DMapSettings::setOrigin( const QgsVector3D &origin )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( origin == mOrigin )

    return;


  mOrigin = origin;

  emit originChanged();

}


QgsVector3D Qgs3DMapSettings::origin() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mOrigin;

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return Qgs3DUtils::mapToWorldCoordinates( mapCoords, mOrigin );

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return Qgs3DUtils::worldToMapCoordinates( worldCoords, mOrigin );

}


void Qgs3DMapSettings::setCrs( const QgsCoordinateReferenceSystem &crs )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mCrs = crs;


  // for convenience, make sure the navigation mode is consistent with the scene mode

  if ( sceneMode() == Qgis::SceneMode::Globe && mCameraNavigationMode == Qgis::NavigationMode::TerrainBased )

  {

    setCameraNavigationMode( Qgis::NavigationMode::GlobeTerrainBased );

  }

  else if ( sceneMode() == Qgis::SceneMode::Local && mCameraNavigationMode == Qgis::NavigationMode::GlobeTerrainBased )

  {

    setCameraNavigationMode( Qgis::NavigationMode::TerrainBased );

  }

}


QgsCoordinateReferenceSystem Qgs3DMapSettings::crs() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mCrs;

}


Qgis::SceneMode Qgs3DMapSettings::sceneMode() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mCrs.type() == Qgis::CrsType::Geocentric ? Qgis::SceneMode::Globe : Qgis::SceneMode::Local;

}


QgsCoordinateTransformContext Qgs3DMapSettings::transformContext() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTransformContext;

}


void Qgs3DMapSettings::setTransformContext( const QgsCoordinateTransformContext &context )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mTransformContext = context;

}


const QgsPathResolver &Qgs3DMapSettings::pathResolver() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mPathResolver;

}


void Qgs3DMapSettings::setPathResolver( const QgsPathResolver &resolver )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mPathResolver = resolver;

}


QgsMapThemeCollection *Qgs3DMapSettings::mapThemeCollection() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mMapThemes;

}


void Qgs3DMapSettings::setMapThemeCollection( QgsMapThemeCollection *mapThemes )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mMapThemes = mapThemes;

}


void Qgs3DMapSettings::setBackgroundColor( const QColor &color )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( color == mBackgroundColor )

    return;


  mBackgroundColor = color;

  emit backgroundColorChanged();

}


QColor Qgs3DMapSettings::backgroundColor() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mBackgroundColor;

}


const QgsAbstract3DMapBackgroundSettings *Qgs3DMapSettings::backgroundSettings() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mBackgroundSettings.get();

}


void Qgs3DMapSettings::setBackgroundSettings( QgsAbstract3DMapBackgroundSettings *settings )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mBackgroundSettings.reset( settings );

  emit backgroundSettingsChanged();

}


void Qgs3DMapSettings::setSelectionColor( const QColor &color )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( color == mSelectionColor )

    return;


  mSelectionColor = color;

  emit selectionColorChanged();

}


QColor Qgs3DMapSettings::selectionColor() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mSelectionColor;

}


void Qgs3DMapSettings::setTerrainVerticalScale( double zScale )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( zScale == mTerrainSettings->verticalScale() )

    return;


  mTerrainSettings->setVerticalScale( zScale );

  Q_NOWARN_DEPRECATED_PUSH

  emit terrainVerticalScaleChanged();

  Q_NOWARN_DEPRECATED_POP

  emit terrainSettingsChanged();

}


double Qgs3DMapSettings::terrainVerticalScale() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainSettings->verticalScale();

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  const QList<QgsMapLayer *> raw = _qgis_listRefToRaw( mLayers );


  if ( layers == raw )

    return;


  mLayers = _qgis_listRawToRef( layers );

  emit layersChanged();

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  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 )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  setExtent( fullExtent );


  std::unique_ptr<QgsAbstractTerrainSettings> terrainSettings( Qgs3D::terrainRegistry()->configureTerrainFromProject( properties ) );

  if ( terrainSettings )

  {

    setTerrainSettings( terrainSettings.release() );

  }

}


const QgsAbstractTerrainSettings *Qgs3DMapSettings::terrainSettings() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainSettings.get();

}


void Qgs3DMapSettings::setTerrainSettings( QgsAbstractTerrainSettings *settings )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  bool hasChanged = false;

  if ( settings == mTerrainSettings.get() )

  {

    // emit signals anyway. We don't know if the caller changed settings on the pointer before calling this..

    hasChanged = true;

  }

  else

  {

    // ensure to generate the terrain if the settings have changed or if the terrain has never been generated.

    hasChanged = !settings->equals( mTerrainSettings.get() ) || !mTerrainGenerator;

    mTerrainSettings.reset( settings );

  }


  if ( hasChanged )

  {

    std::unique_ptr<QgsTerrainGenerator> terrainGenerator = mTerrainSettings->createTerrainGenerator( Qgs3DRenderContext::fromMapSettings( this ) );

    if ( terrainGenerator )

    {

      setTerrainGenerator( terrainGenerator.release() );

    }


    // emit all the signals, we don't know exactly what's changed

    Q_NOWARN_DEPRECATED_PUSH

    emit mapTileResolutionChanged();

    emit maxTerrainScreenErrorChanged();

    emit maxTerrainGroundErrorChanged();

    emit terrainElevationOffsetChanged( mTerrainSettings->elevationOffset() );

    emit terrainVerticalScaleChanged();

    Q_NOWARN_DEPRECATED_POP


    emit terrainSettingsChanged();

  }

}


void Qgs3DMapSettings::setMapTileResolution( int res )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mTerrainSettings->mapTileResolution() == res )

    return;


  mTerrainSettings->setMapTileResolution( res );

  Q_NOWARN_DEPRECATED_PUSH

  emit mapTileResolutionChanged();

  Q_NOWARN_DEPRECATED_POP

  emit terrainSettingsChanged();

}


int Qgs3DMapSettings::mapTileResolution() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainSettings->mapTileResolution();

}


void Qgs3DMapSettings::setMaxTerrainScreenError( double error )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mTerrainSettings->maximumScreenError() == error )

    return;


  mTerrainSettings->setMaximumScreenError( error );

  Q_NOWARN_DEPRECATED_PUSH

  emit maxTerrainScreenErrorChanged();

  Q_NOWARN_DEPRECATED_POP

  emit terrainSettingsChanged();

}


double Qgs3DMapSettings::maxTerrainScreenError() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainSettings->maximumScreenError();

}


void Qgs3DMapSettings::setMaxTerrainGroundError( double error )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mTerrainSettings->maximumGroundError() == error )

    return;


  mTerrainSettings->setMaximumGroundError( error );

  Q_NOWARN_DEPRECATED_PUSH

  emit maxTerrainGroundErrorChanged();

  Q_NOWARN_DEPRECATED_POP


  emit terrainSettingsChanged();

}


void Qgs3DMapSettings::setTerrainElevationOffset( double offset )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mTerrainSettings->elevationOffset() == offset )

    return;

  mTerrainSettings->setElevationOffset( offset );

  Q_NOWARN_DEPRECATED_PUSH

  emit terrainElevationOffsetChanged( offset );

  Q_NOWARN_DEPRECATED_POP

  emit terrainSettingsChanged();

}


double Qgs3DMapSettings::terrainElevationOffset() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainSettings->elevationOffset();

}


double Qgs3DMapSettings::maxTerrainGroundError() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainSettings->maximumGroundError();

}


void Qgs3DMapSettings::setTerrainGenerator( QgsTerrainGenerator *gen )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mTerrainGenerator )

  {

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

  }


  if ( gen->crs().isValid() ) // Don't bother setting an extent rect in the wrong CRS

  {

    QgsRectangle terrainExtent = Qgs3DUtils::tryReprojectExtent2D( mExtent, mCrs, gen->crs(), mTransformContext );

    gen->setExtent( terrainExtent );

  }

  mTerrainGenerator.reset( gen );

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


  emit terrainGeneratorChanged();

}


QgsTerrainGenerator *Qgs3DMapSettings::terrainGenerator() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainGenerator.get();

}


void Qgs3DMapSettings::setTerrainShadingEnabled( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mTerrainShadingEnabled == enabled )

    return;


  mTerrainShadingEnabled = enabled;

  emit terrainShadingChanged();

}


bool Qgs3DMapSettings::isTerrainShadingEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainShadingEnabled;

}


void Qgs3DMapSettings::setTerrainShadingMaterial( const QgsPhongMaterialSettings &material )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mTerrainShadingMaterial == material )

    return;


  mTerrainShadingMaterial = material;

  emit terrainShadingChanged();

}


QgsPhongMaterialSettings Qgs3DMapSettings::terrainShadingMaterial() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainShadingMaterial;

}


void Qgs3DMapSettings::setTerrainMapTheme( const QString &theme )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mTerrainMapTheme == theme )

    return;


  mTerrainMapTheme = theme;

  emit terrainMapThemeChanged();

}


QString Qgs3DMapSettings::terrainMapTheme() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainMapTheme;

}


void Qgs3DMapSettings::setShowTerrainBoundingBoxes( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mShowTerrainBoundingBoxes == enabled )

    return;


  mShowTerrainBoundingBoxes = enabled;

  emit showTerrainBoundingBoxesChanged();

}


bool Qgs3DMapSettings::showTerrainBoundingBoxes() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShowTerrainBoundingBoxes;

}


void Qgs3DMapSettings::setShowTerrainTilesInfo( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mShowTerrainTileInfo == enabled )

    return;


  mShowTerrainTileInfo = enabled;

  emit showTerrainTilesInfoChanged();

}


bool Qgs3DMapSettings::showTerrainTilesInfo() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShowTerrainTileInfo;

}


void Qgs3DMapSettings::setShowCameraViewCenter( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mShowCameraViewCenter == enabled )

    return;


  mShowCameraViewCenter = enabled;

  emit showCameraViewCenterChanged();

}


bool Qgs3DMapSettings::showCameraViewCenter() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShowCameraViewCenter;

}


void Qgs3DMapSettings::setShowCameraRotationCenter( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mShowCameraRotationCenter == enabled )

    return;


  mShowCameraRotationCenter = enabled;

  emit showCameraRotationCenterChanged();

}


bool Qgs3DMapSettings::showCameraRotationCenter() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShowCameraRotationCenter;

}


void Qgs3DMapSettings::setShowLightSourceOrigins( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mShowLightSources == enabled )

    return;


  mShowLightSources = enabled;

  emit showLightSourceOriginsChanged();

}


bool Qgs3DMapSettings::showLightSourceOrigins() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShowLightSources;

}


void Qgs3DMapSettings::setShowLabels( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mShowLabels == enabled )

    return;


  mShowLabels = enabled;

  emit showLabelsChanged();

}


bool Qgs3DMapSettings::showLabels() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShowLabels;

}


void Qgs3DMapSettings::setStopUpdates( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mStopUpdates == enabled )

    return;


  mStopUpdates = enabled;

  emit stopUpdatesChanged();

}


bool Qgs3DMapSettings::stopUpdates() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mStopUpdates;

}


void Qgs3DMapSettings::setEyeDomeLightingEnabled( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mEyeDomeLightingEnabled == enabled )

    return;

  mEyeDomeLightingEnabled = enabled;

  emit eyeDomeLightingEnabledChanged();

}


bool Qgs3DMapSettings::eyeDomeLightingEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mEyeDomeLightingEnabled;

}


void Qgs3DMapSettings::setEyeDomeLightingStrength( double strength )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mEyeDomeLightingStrength == strength )

    return;

  mEyeDomeLightingStrength = strength;

  emit eyeDomeLightingStrengthChanged();

}


double Qgs3DMapSettings::eyeDomeLightingStrength() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mEyeDomeLightingStrength;

}


void Qgs3DMapSettings::setEyeDomeLightingDistance( int distance )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mEyeDomeLightingDistance == distance )

    return;

  mEyeDomeLightingDistance = distance;

  emit eyeDomeLightingDistanceChanged();

}


int Qgs3DMapSettings::eyeDomeLightingDistance() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mEyeDomeLightingDistance;

}


void Qgs3DMapSettings::setMsaaEnabled( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mMsaaEnabled == enabled )

    return;


  mMsaaEnabled = enabled;

  emit msaaEnabledChanged();

}


bool Qgs3DMapSettings::isMsaaEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mMsaaEnabled;

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mLightSources;

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  // have lights actually changed?

  if ( mLightSources.count() == lights.count() )

  {

    bool same = true;

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

    {

      if ( mLightSources[i]->type() == lights[i]->type() )

      {

        switch ( mLightSources[i]->type() )

        {

          case Qgis::LightSourceType::Point:

            if ( *static_cast<QgsPointLightSettings *>( mLightSources[i] ) == *static_cast<QgsPointLightSettings *>( lights[i] ) )

              continue;

            break;

          case Qgis::LightSourceType::Directional:

            if ( *static_cast<QgsDirectionalLightSettings *>( mLightSources[i] ) == *static_cast<QgsDirectionalLightSettings *>( lights[i] ) )

              continue;

            break;

        }

      }

      same = false;

      break;

    }

    if ( same )

    {

      qDeleteAll( lights );

      return;

    }

  }


  qDeleteAll( mLightSources );

  mLightSources = lights;


  emit directionalLightsChanged();

  emit pointLightsChanged();

  emit lightSourcesChanged();

}


float Qgs3DMapSettings::fieldOfView() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mFieldOfView;

}


void Qgs3DMapSettings::setFieldOfView( const float fieldOfView )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mFieldOfView == fieldOfView )

    return;


  mFieldOfView = fieldOfView;

  emit fieldOfViewChanged();

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mProjectionType;

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mProjectionType == projectionType )

    return;


  mProjectionType = projectionType;

  emit projectionTypeChanged();

}


Qgis::NavigationMode Qgs3DMapSettings::cameraNavigationMode() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mCameraNavigationMode;

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mCameraNavigationMode == navigationMode )

    return;


  mCameraNavigationMode = navigationMode;

  emit cameraNavigationModeChanged();

}


double Qgs3DMapSettings::cameraMovementSpeed() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mCameraMovementSpeed;

}


void Qgs3DMapSettings::setCameraMovementSpeed( double movementSpeed )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mCameraMovementSpeed == movementSpeed )

    return;


  mCameraMovementSpeed = movementSpeed;

  emit cameraMovementSpeedChanged();

}


void Qgs3DMapSettings::setOutputDpi( const double dpi )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mDpi = dpi;

}


double Qgs3DMapSettings::outputDpi() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mDpi;

}


QgsSkyboxSettings Qgs3DMapSettings::skyboxSettings() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mBackgroundSettings && mBackgroundSettings->type() == Qgis::Map3DBackgroundType::DistinctTextureSkybox )

    return *dynamic_cast<const QgsSkyboxSettings *>( mBackgroundSettings.get() );

  return QgsSkyboxSettings();

}


QgsShadowSettings Qgs3DMapSettings::shadowSettings() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShadowSettings;

}


QgsAmbientOcclusionSettings Qgs3DMapSettings::ambientOcclusionSettings() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mAmbientOcclusionSettings;

}


QgsBloomSettings Qgs3DMapSettings::bloomSettings() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mBloomSettings;

}


void Qgs3DMapSettings::setSkyboxSettings( const QgsSkyboxSettings &skyboxSettings )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  setBackgroundSettings( skyboxSettings.clone() );

}


void Qgs3DMapSettings::setShadowSettings( const QgsShadowSettings &shadowSettings )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mShadowSettings = shadowSettings;

  emit shadowSettingsChanged();

}


void Qgs3DMapSettings::setAmbientOcclusionSettings( const QgsAmbientOcclusionSettings &ambientOcclusionSettings )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mAmbientOcclusionSettings = ambientOcclusionSettings;

  emit ambientOcclusionSettingsChanged();

}


void Qgs3DMapSettings::setBloomSettings( const QgsBloomSettings &settings )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mBloomSettings = settings;

  emit bloomSettingsChanged();

}


bool Qgs3DMapSettings::isSkyboxEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mBackgroundSettings && mBackgroundSettings->type() == Qgis::Map3DBackgroundType::DistinctTextureSkybox;

}


void Qgs3DMapSettings::setIsSkyboxEnabled( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( enabled )

    setBackgroundSettings( ( mBackgroundSettings && mBackgroundSettings->type() == Qgis::Map3DBackgroundType::DistinctTextureSkybox ) ? mBackgroundSettings->clone() : new QgsSkyboxSettings() );

  else

    setBackgroundSettings( nullptr );

}


bool Qgs3DMapSettings::isFpsCounterEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mIsFpsCounterEnabled;

}


void Qgs3DMapSettings::setShowDebugPanel( const bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mShowDebugPanel == enabled )

    return;


  mShowDebugPanel = enabled;

  emit showDebugPanelChanged( enabled );

}


bool Qgs3DMapSettings::showDebugPanel() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShowDebugPanel;

}


void Qgs3DMapSettings::setDebugShadowMapSettings( bool, Qt::Corner, double )

{}


bool Qgs3DMapSettings::debugShadowMapEnabled() const

{

  return false;

}


Qt::Corner Qgs3DMapSettings::debugShadowMapCorner() const

{

  return Qt::Corner::TopLeftCorner;

}


double Qgs3DMapSettings::debugShadowMapSize() const

{

  return 0;

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mDebugDepthMapEnabled = enabled;

  mDebugDepthMapCorner = corner;

  mDebugDepthMapSize = size;

  emit debugDepthMapSettingsChanged();

}


bool Qgs3DMapSettings::debugDepthMapEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mDebugDepthMapEnabled;

}


Qt::Corner Qgs3DMapSettings::debugDepthMapCorner() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mDebugDepthMapCorner;

}


double Qgs3DMapSettings::debugDepthMapSize() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mDebugDepthMapSize;

}


void Qgs3DMapSettings::setIsFpsCounterEnabled( bool fpsCounterEnabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( fpsCounterEnabled == mIsFpsCounterEnabled )

    return;

  mIsFpsCounterEnabled = fpsCounterEnabled;

  emit fpsCounterEnabledChanged( mIsFpsCounterEnabled );

}


bool Qgs3DMapSettings::terrainRenderingEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mTerrainRenderingEnabled;

}


void Qgs3DMapSettings::setTerrainRenderingEnabled( bool terrainRenderingEnabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( terrainRenderingEnabled == mTerrainRenderingEnabled )

    return;

  mTerrainRenderingEnabled = terrainRenderingEnabled;

  emit terrainGeneratorChanged();

}


Qgis::RendererUsage Qgs3DMapSettings::rendererUsage() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mRendererUsage;

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mRendererUsage = rendererUsage;

}


Qgis::ViewSyncModeFlags Qgs3DMapSettings::viewSyncMode() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mViewSyncMode;

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  mViewSyncMode = mode;

}


bool Qgs3DMapSettings::viewFrustumVisualizationEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mVisualizeViewFrustum;

}


void Qgs3DMapSettings::setViewFrustumVisualizationEnabled( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mVisualizeViewFrustum != enabled )

  {

    mVisualizeViewFrustum = enabled;

    emit viewFrustumVisualizationEnabledChanged();

  }

}


Qgs3DAxisSettings Qgs3DMapSettings::get3DAxisSettings() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return m3dAxisSettings;

}


void Qgs3DMapSettings::setIsDebugOverlayEnabled( bool debugOverlayEnabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( debugOverlayEnabled == mIsDebugOverlayEnabled )

    return;


  mIsDebugOverlayEnabled = debugOverlayEnabled;

  emit debugOverlayEnabledChanged( mIsDebugOverlayEnabled );

}


bool Qgs3DMapSettings::showExtentIn2DView() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShowExtentIn2DView;

}


void Qgs3DMapSettings::connectChangedSignalsToSettingsChanged()

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


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

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

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

  connect( this, &Qgs3DMapSettings::terrainSettingsChanged, 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::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::backgroundSettingsChanged, 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 );

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

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

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

}


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

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( axisSettings == m3dAxisSettings )

  {

    if ( force )

    {

      // ie. refresh. We need 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();

  }

}


bool Qgs3DMapSettings::isDebugOverlayEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mIsDebugOverlayEnabled;

}


void Qgs3DMapSettings::setShowExtentIn2DView( bool show )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( show == mShowExtentIn2DView )

    return;


  mShowExtentIn2DView = show;

  emit showExtentIn2DViewChanged();

}


bool Qgs3DMapSettings::is2DMapOverlayEnabled() const

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  return mShow2DMapOverlay;

}


void Qgs3DMapSettings::setIs2DMapOverlayEnabled( bool enabled )

{

  QGIS_PROTECT_QOBJECT_THREAD_ACCESS


  if ( mShow2DMapOverlay == enabled )

    return;


  mShow2DMapOverlay = enabled;

  emit show2DMapOverlayChanged();

}


Qgis::Map3DBackgroundType::DistinctTextureSkybox
@ DistinctTextureSkybox
Skybox with 6 distinct textures for different faces.
Definition qgis.h:4418

Qgis::Map3DBackgroundType::NoBackground
@ NoBackground
No background.
Definition qgis.h:4416

Qgis::Map3DBackgroundType::FixedGradientBackground
@ FixedGradientBackground
Two color gradient, fixed in place.
Definition qgis.h:4417

Qgis::CrsType::Geocentric
@ Geocentric
Geocentric CRS.
Definition qgis.h:2465

Qgis::ViewSyncModeFlags
QFlags< ViewSyncModeFlag > ViewSyncModeFlags
Definition qgis.h:3663

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

Qgis::NavigationMode::TerrainBased
@ TerrainBased
The default navigation based on the terrain.
Definition qgis.h:4444

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

Qgis::NavigationMode::GlobeTerrainBased
@ GlobeTerrainBased
Navigation similar to TerrainBased, but for use with globe.
Definition qgis.h:4446

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

Qgis::SceneMode
SceneMode
The 3D scene mode used in 3D map views.
Definition qgis.h:4456

Qgis::SceneMode::Globe
@ Globe
Scene is represented as a globe using a geocentric CRS.
Definition qgis.h:4458

Qgis::SceneMode::Local
@ Local
Local scene based on a projected CRS.
Definition qgis.h:4457

Qgis::LightSourceType::Point
@ Point
Point light source.
Definition qgis.h:4405

Qgis::LightSourceType::Directional
@ Directional
Directional light source.
Definition qgis.h:4406

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

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:1115

Qgs3DMapSettings::isDebugOverlayEnabled
bool isDebugOverlayEnabled() const
Returns whether debug overlay is enabled.
Definition qgs3dmapsettings.cpp:1610

Qgs3DMapSettings::debugDepthMapCorner
Qt::Corner debugDepthMapCorner() const
Returns the corner where the shadow map preview is displayed.
Definition qgs3dmapsettings.cpp:1440

Qgs3DMapSettings::originChanged
void originChanged()
Emitted when the world's origin point has been shifted.

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

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:119

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

Qgs3DMapSettings::isMsaaEnabled
bool isMsaaEnabled() const
Returns whether multisample anti-aliasing (MSAA) is enabled.
Definition qgs3dmapsettings.cpp:1160

Qgs3DMapSettings::pathResolver
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
Definition qgs3dmapsettings.cpp:621

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

Qgs3DMapSettings::bloomSettingsChanged
void bloomSettingsChanged()
Emitted when the bloom lighting effect settings are changed.

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

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:562

Qgs3DMapSettings::showExtentIn2DView
bool showExtentIn2DView() const
Returns whether the extent is displayed on the main 2D map canvas.
Definition qgs3dmapsettings.cpp:1545

Qgs3DMapSettings::cameraMovementSpeed
double cameraMovementSpeed() const
Returns the camera movement speed.
Definition qgs3dmapsettings.cpp:1270

Qgs3DMapSettings::bloomSettings
QgsBloomSettings bloomSettings() const
Returns the current configuration of the bloom lighting effect.
Definition qgs3dmapsettings.cpp:1325

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

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

Qgs3DMapSettings::showDebugPanelChanged
void showDebugPanelChanged(bool shown)
Emitted when the Show debug panel checkbox changes value.

Qgs3DMapSettings::debugDepthMapEnabled
bool debugDepthMapEnabled() const
Returns whether the shadow map debugging is enabled.
Definition qgs3dmapsettings.cpp:1433

Qgs3DMapSettings::isSkyboxEnabled
Q_DECL_DEPRECATED bool isSkyboxEnabled() const
Returns whether the skybox is enabled.
Definition qgs3dmapsettings.cpp:1363

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

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

Qgs3DMapSettings::terrainElevationOffset
Q_DECL_DEPRECATED double terrainElevationOffset() const
Returns the elevation offset of the terrain (used to move the terrain up or down).
Definition qgs3dmapsettings.cpp:876

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

Qgs3DMapSettings::backgroundSettingsChanged
void backgroundSettingsChanged()
Emitted when background settings are changed.

Qgs3DMapSettings::outputDpi
double outputDpi() const
Returns DPI used for conversion between real world units (e.g.
Definition qgs3dmapsettings.cpp:1295

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

Qgs3DMapSettings::eyeDomeLightingStrength
double eyeDomeLightingStrength() const
Returns the eye dome lighting strength value.
Definition qgs3dmapsettings.cpp:1125

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::setMaxTerrainGroundError
Q_DECL_DEPRECATED void setMaxTerrainGroundError(double error)
Sets the maximum ground error of terrain tiles in world units.
Definition qgs3dmapsettings.cpp:848

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

Qgs3DMapSettings::debugShadowMapCorner
Q_DECL_DEPRECATED Qt::Corner debugShadowMapCorner() const
Returns the corner where the shadow map preview is displayed.
Definition qgs3dmapsettings.cpp:1413

Qgs3DMapSettings::setMapThemeCollection
void setMapThemeCollection(QgsMapThemeCollection *mapThemes)
Sets pointer to the collection of map themes.
Definition qgs3dmapsettings.cpp:642

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:336

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

Qgs3DMapSettings::showCameraViewCenter
bool showCameraViewCenter() const
Returns whether to show camera's view center as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1019

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:693

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:935

Qgs3DMapSettings::terrainSettings
const QgsAbstractTerrainSettings * terrainSettings() const
Returns the terrain settings.
Definition qgs3dmapsettings.cpp:761

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

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

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

Qgs3DMapSettings::show2DMapOverlayChanged
void show2DMapOverlayChanged()
Emitted when the 2D map overlay is enabled or disabled.

Qgs3DMapSettings::stopUpdates
bool stopUpdates() const
Returns whether the scene updates on camera movement.
Definition qgs3dmapsettings.cpp:1091

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

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

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

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

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

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

Qgs3DMapSettings::setOutputDpi
void setOutputDpi(const double dpi)
Sets DPI used for conversion between real world units (e.g.
Definition qgs3dmapsettings.cpp:1288

Qgs3DMapSettings::setIsSkyboxEnabled
Q_DECL_DEPRECATED void setIsSkyboxEnabled(bool enabled)
Sets whether the skybox is enabled.
Definition qgs3dmapsettings.cpp:1370

Qgs3DMapSettings::sceneMode
Qgis::SceneMode sceneMode() const
Returns mode of the 3D scene - whether it is represented as a globe (when using Geocentric CRS such a...
Definition qgs3dmapsettings.cpp:600

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

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

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:1502

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

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

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

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

Qgs3DMapSettings::setShowDebugPanel
void setShowDebugPanel(bool enabled)
Sets whether the debug side panel is shown.
Definition qgs3dmapsettings.cpp:1387

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

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:1339

Qgs3DMapSettings::msaaEnabledChanged
void msaaEnabledChanged()
Emitted when the MSAA enabled flag has changed.

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

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

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

Qgs3DMapSettings::debugDepthMapSize
double debugDepthMapSize() const
Returns the size of the shadow map preview.
Definition qgs3dmapsettings.cpp:1447

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

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

Qgs3DMapSettings::setBackgroundSettings
void setBackgroundSettings(QgsAbstract3DMapBackgroundSettings *settings)
Sets the background settings for the 3D scene.
Definition qgs3dmapsettings.cpp:674

Qgs3DMapSettings::get3DAxisSettings
Qgs3DAxisSettings get3DAxisSettings() const
Returns the current configuration of 3d axis.
Definition qgs3dmapsettings.cpp:1527

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

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

Qgs3DMapSettings::viewFrustumVisualizationEnabled
bool viewFrustumVisualizationEnabled() const
Returns whether the camera's view frustum is visualized on the 2D map canvas.
Definition qgs3dmapsettings.cpp:1509

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

Qgs3DMapSettings::showDebugPanel
bool showDebugPanel() const
Returns whether the debug side panel is shown.
Definition qgs3dmapsettings.cpp:1398

Qgs3DMapSettings::is2DMapOverlayEnabled
bool is2DMapOverlayEnabled() const
Returns whether 2D map overlay is enabled.
Definition qgs3dmapsettings.cpp:1628

Qgs3DMapSettings::setIs2DMapOverlayEnabled
void setIs2DMapOverlayEnabled(bool enabled)
Sets whether 2D map overlay is enabled.
Definition qgs3dmapsettings.cpp:1635

Qgs3DMapSettings::setShowExtentIn2DView
void setShowExtentIn2DView(bool show)
Sets whether the extent is displayed on the main 2D map canvas.
Definition qgs3dmapsettings.cpp:1617

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.cpp:1216

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.cpp:1318

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

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

Qgs3DMapSettings::viewSyncMode
Qgis::ViewSyncModeFlags viewSyncMode() const
Returns the view sync mode (used to synchronize the 2D main map canvas and the 3D camera navigation).
Definition qgs3dmapsettings.cpp:1495

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

Qgs3DMapSettings::stopUpdatesChanged
void stopUpdatesChanged()
Emitted when the flag whether to keep updating scene has changed.

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

Qgs3DMapSettings::setMsaaEnabled
void setMsaaEnabled(bool enabled)
Sets whether multisample anti-aliasing (MSAA) is enabled.
Definition qgs3dmapsettings.cpp:1149

Qgs3DMapSettings::eyeDomeLightingDistance
int eyeDomeLightingDistance() const
Returns the eye dome lighting distance value (contributes to the contrast of the image).
Definition qgs3dmapsettings.cpp:1142

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

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::terrainGenerator
QgsTerrainGenerator * terrainGenerator() const
Returns the terrain generator.
Definition qgs3dmapsettings.cpp:910

Qgs3DMapSettings::backgroundSettings
const QgsAbstract3DMapBackgroundSettings * backgroundSettings() const
Returns the background settings for the 3D scene, or null if no background is set.
Definition qgs3dmapsettings.cpp:667

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

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

Qgs3DMapSettings::terrainSettingsChanged
void terrainSettingsChanged()
Emitted when the terrain settings are changed.

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

Qgs3DMapSettings::debugShadowMapSize
Q_DECL_DEPRECATED double debugShadowMapSize() const
Returns the size of the shadow map preview.
Definition qgs3dmapsettings.cpp:1418

Qgs3DMapSettings::setPathResolver
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
Definition qgs3dmapsettings.cpp:628

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:569

Qgs3DMapSettings::showTerrainBoundingBoxes
bool showTerrainBoundingBoxes() const
Returns whether to display bounding boxes of terrain tiles (for debugging).
Definition qgs3dmapsettings.cpp:982

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

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

Qgs3DMapSettings::setStopUpdates
void setStopUpdates(bool enabled)
Sets whether scene updates on camera movement should be enabled.
Definition qgs3dmapsettings.cpp:1080

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

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

Qgs3DMapSettings::showLabels
bool showLabels() const
Returns whether to display labels on terrain tiles.
Definition qgs3dmapsettings.cpp:1073

Qgs3DMapSettings::setTerrainSettings
void setTerrainSettings(QgsAbstractTerrainSettings *settings)
Sets the terrain settings.
Definition qgs3dmapsettings.cpp:768

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

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

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

Qgs3DMapSettings::debugShadowMapEnabled
Q_DECL_DEPRECATED bool debugShadowMapEnabled() const
Returns whether the shadow map debugging is enabled.
Definition qgs3dmapsettings.cpp:1408

Qgs3DMapSettings::Qgs3DMapSettings
Qgs3DMapSettings()
Definition qgs3dmapsettings.cpp:45

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

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

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

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

Qgs3DMapSettings::setBloomSettings
void setBloomSettings(const QgsBloomSettings &settings)
Sets the current configuration of bloom lighting effect.
Definition qgs3dmapsettings.cpp:1355

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:1241

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

Qgs3DMapSettings::showTerrainTilesInfo
bool showTerrainTilesInfo() const
Returns whether to display extra tile info on top of terrain tiles (for debugging).
Definition qgs3dmapsettings.cpp:1001

Qgs3DMapSettings::showExtentIn2DViewChanged
void showExtentIn2DViewChanged()
Emitted when the parameter to display 3d view's extent in the 2D canvas has 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:748

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
Q_DECL_DEPRECATED QgsSkyboxSettings skyboxSettings() const
Returns the current configuration of the skybox.
Definition qgs3dmapsettings.cpp:1302

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

Qgs3DMapSettings::isTerrainShadingEnabled
bool isTerrainShadingEnabled() const
Returns whether terrain shading is enabled.
Definition qgs3dmapsettings.cpp:928

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.cpp:593

Qgs3DMapSettings::eyeDomeLightingEnabled
bool eyeDomeLightingEnabled() const
Returns whether eye dome lighting is used.
Definition qgs3dmapsettings.cpp:1108

Qgs3DMapSettings::terrainShadingMaterial
QgsPhongMaterialSettings terrainShadingMaterial() const
Returns terrain shading material.
Definition qgs3dmapsettings.cpp:946

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

Qgs3DMapSettings::isFpsCounterEnabled
bool isFpsCounterEnabled() const
Returns whether FPS counter label is enabled.
Definition qgs3dmapsettings.cpp:1380

Qgs3DMapSettings::terrainMapTheme
QString terrainMapTheme() const
Returns name of the map theme (from the active project) that will be used for terrain's texture.
Definition qgs3dmapsettings.cpp:964

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

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:1481

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

Qgs3DMapSettings::mapThemeCollection
QgsMapThemeCollection * mapThemeCollection() const
Returns pointer to the collection of map themes.
Definition qgs3dmapsettings.cpp:635

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

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

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

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

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

Qgs3DMapSettings::showLightSourceOrigins
bool showLightSourceOrigins() const
Returns whether to show light source origins as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1055

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

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

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

Qgs3DMapSettings::origin
QgsVector3D origin() const
Returns coordinates in map CRS at which 3D scene has origin (0,0,0).
Definition qgs3dmapsettings.cpp:555

Qgs3DMapSettings::showCameraRotationCenter
bool showCameraRotationCenter() const
Returns whether to show camera's rotation center as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1037

Qgs3DRenderContext::fromMapSettings
static Qgs3DRenderContext fromMapSettings(const Qgs3DMapSettings *mapSettings)
Creates an initialized Qgs3DRenderContext instance from given Qgs3DMapSettings.
Definition qgs3drendercontext.cpp:61

Qgs3DUtils::tryReprojectExtent2D
static QgsRectangle tryReprojectExtent2D(const QgsRectangle &extent, const QgsCoordinateReferenceSystem &crs1, const QgsCoordinateReferenceSystem &crs2, const QgsCoordinateTransformContext &context)
Reprojects extent from crs1 to crs2 coordinate reference system with context context.
Definition qgs3dutils.cpp:645

Qgs3DUtils::worldToMapCoordinates
static QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords, const QgsVector3D &origin)
Converts 3D world coordinates to map coordinates (applies offset).
Definition qgs3dutils.cpp:640

Qgs3DUtils::mapToWorldCoordinates
static QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords, const QgsVector3D &origin)
Converts map coordinates to 3D world coordinates (applies offset).
Definition qgs3dutils.cpp:635

Qgs3D::terrainRegistry
static Qgs3DTerrainRegistry * terrainRegistry()
Returns the terrain registry, used for managing 3D terrains.
Definition qgs3d.cpp:130

QgsAbstract3DMapBackgroundSettings
Base class for all background settings classes used in a 3D map view.
Definition qgsabstract3dmapbackgroundsettings.h:35

QgsAbstractTerrainSettings
Base class for all terrain settings classes.
Definition qgsabstractterrainsettings.h:45

QgsAbstractTerrainSettings::equals
virtual bool equals(const QgsAbstractTerrainSettings *other) const =0
Returns true if this settings is exactly equal to another other settings.

QgsAmbientOcclusionSettings
Contains the configuration of ambient occlusion rendering.
Definition qgsambientocclusionsettings.h:37

QgsBloomSettings
Contains the configuration of the lighting "bloom" effect.
Definition qgsbloomsettings.h:37

QgsColorUtils::colorFromString
static QColor colorFromString(const QString &string)
Decodes a string into a color value.
Definition qgscolorutils.cpp:239

QgsColorUtils::colorToString
static QString colorToString(const QColor &color)
Encodes a color into a string value.
Definition qgscolorutils.cpp:174

QgsCoordinateReferenceSystem
Represents a coordinate reference system (CRS).
Definition qgscoordinatereferencesystem.h:216

QgsCoordinateReferenceSystem::isValid
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
Definition qgscoordinatereferencesystem.cpp:1023

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

QgsDirectionalLightSettings
Definition of a directional light in a 3D map scene.
Definition qgsdirectionallightsettings.h:34

QgsFlatTerrainSettings
Terrain settings for a simple flat area terrain.
Definition qgsflatterrainsettings.h:38

QgsLightSource
Base class for light sources in 3d scenes.
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:33

QgsMapThemeCollection
Container class that allows storage of map themes consisting of visible map layers and layer styles.
Definition qgsmapthemecollection.h:44

QgsPathResolver
Resolves relative paths into absolute paths and vice versa.
Definition qgspathresolver.h:35

QgsPhongMaterialSettings
Basic shading material used for rendering based on the Phong shading model with three color component...
Definition qgsphongmaterialsettings.h:37

QgsPointLightSettings
Definition of a point light in a 3D map scene.
Definition qgspointlightsettings.h:40

QgsPointXY
Represents a 2D point.
Definition qgspointxy.h:62

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

QgsPointXY::x
double x
Definition qgspointxy.h:65

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

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

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

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

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

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

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

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:4467

QgsReadWriteContext
A container for the context for various read/write operations on objects.
Definition qgsreadwritecontext.h:38

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

QgsShadowSettings
Contains configuration for rendering shadows.
Definition qgsshadowsettings.h:37

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

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

QgsTemporalRangeObject::QgsTemporalRangeObject
QgsTemporalRangeObject(bool enabled=false)
Constructor QgsTemporalRangeObject.
Definition qgstemporalrangeobject.cpp:20

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

QgsTerrainGenerator
Base class for generators of terrain.
Definition qgsterraingenerator.h:50

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

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

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

QgsVector3D
A 3D vector (similar to QVector3D) with the difference that it uses double precision instead of singl...
Definition qgsvector3d.h:33

qgsEnumKeyToValue
T qgsEnumKeyToValue(const QString &key, const T &defaultValue, bool tryValueAsKey=true, bool *returnOk=nullptr)
Returns the value corresponding to the given key of an enum.
Definition qgis.h:7423

Q_NOWARN_DEPRECATED_POP
#define Q_NOWARN_DEPRECATED_POP
Definition qgis.h:7766

qgsEnumValueToKey
QString qgsEnumValueToKey(const T &value, bool *returnOk=nullptr)
Returns the value for the given key of an enum.
Definition qgis.h:7404

Q_NOWARN_DEPRECATED_PUSH
#define Q_NOWARN_DEPRECATED_PUSH
Definition qgis.h:7765

qgs3d.h

qgs3dmapsettings.h

qgs3drendercontext.h

qgs3dterrainregistry.h

qgs3dutils.h

qgsabstract3dmapbackgroundsettings.h

qgsabstractterrainsettings.h

qgscolorutils.h

qgsdirectionallightsettings.h

qgsfixedgradientbackgroundsettings.h

qgsflatterrainsettings.h

qgslightsource.h

QgsDebugError
#define QgsDebugError(str)
Definition qgslogger.h:59

qgsmaplayerlistutils_p.h

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

qgspointlightsettings.h

qgsprojectelevationproperties.h

qgsprojectviewsettings.h

QgsDateTimeRange
QgsTemporalRange< QDateTime > QgsDateTimeRange
QgsRange which stores a range of date times.
Definition qgsrange.h:705

qgsrasterlayer.h

qgsterrainprovider.h

qgsthreadingutils.h

QGIS_PROTECT_QOBJECT_THREAD_ACCESS
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS
Definition qgsthreadingutils.h:78

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

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