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

 #include "qgsmeshlayer3drenderer.h"

 #include "qgspointcloudlayer3drenderer.h"


 #include <QDomDocument>

 #include <QDomElement>


 #include "qgssymbollayerutils.h"

 #include "qgsrasterlayer.h"


 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 )

   , mPointLights( other.mPointLights )

   , mDirectionalLights( other.mDirectionalLights )

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

   , mEyeDomeLightingEnabled( other.mEyeDomeLightingEnabled )

   , mEyeDomeLightingStrength( other.mEyeDomeLightingStrength )

   , mEyeDomeLightingDistance( other.mEyeDomeLightingDistance )

   , mDebugShadowMapEnabled( other.mDebugShadowMapEnabled )

   , mDebugShadowMapCorner( other.mDebugShadowMapCorner )

   , mDebugShadowMapSize( other.mDebugShadowMapSize )

   , mDebugDepthMapEnabled( other.mDebugDepthMapEnabled )

   , mDebugDepthMapCorner( other.mDebugDepthMapCorner )

   , mDebugDepthMapSize( other.mDebugDepthMapSize )

   , mTerrainRenderingEnabled( other.mTerrainRenderingEnabled )

   , mRendererUsage( other.mRendererUsage )

 {

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

   {

     mRenderers << renderer->clone();

   }


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

   {

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

   } );

   connectChangedSignalsToSettingsChanged();

 }


 Qgs3DMapSettings::~Qgs3DMapSettings()

 {

   qDeleteAll( mRenderers );

 }


 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 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 = QgsCameraController::NavigationMode::TerrainBasedNavigation;

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

       mCameraNavigationMode = QgsCameraController::NavigationMode::WalkNavigation;

     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();


   mPointLights.clear();

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

   if ( !elemPointLights.isNull() )

   {

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

     while ( !elemPointLight.isNull() )

     {

       QgsPointLightSettings pointLight;

       pointLight.readXml( elemPointLight );

       mPointLights << pointLight;

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

     }

   }

   else

   {

     // QGIS <= 3.4 did not have light configuration

     QgsPointLightSettings defaultLight;

     defaultLight.setPosition( QgsVector3D( 0, 1000, 0 ) );

     mPointLights << defaultLight;

   }


   mDirectionalLights.clear();

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

   if ( !elemDirectionalLights.isNull() )

   {

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

     while ( !elemDirectionalLight.isNull() )

     {

       QgsDirectionalLightSettings directionalLight;

       directionalLight.readXml( elemDirectionalLight );

       mDirectionalLights << directionalLight;

       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 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 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 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 elemCamera = doc.createElement( QStringLiteral( "camera" ) );

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

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

   switch ( mCameraNavigationMode )

   {

     case QgsCameraController::TerrainBasedNavigation:

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

       break;

     case QgsCameraController::WalkNavigation:

       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 elemPointLights = doc.createElement( QStringLiteral( "point-lights" ) );

   for ( const QgsPointLightSettings &pointLight : std::as_const( mPointLights ) )

   {

     QDomElement elemPointLight = pointLight.writeXml( doc );

     elemPointLights.appendChild( elemPointLight );

   }

   elem.appendChild( elemPointLights );


   QDomElement elemDirectionalLights = doc.createElement( QStringLiteral( "directional-lights" ) );

   for ( const QgsDirectionalLightSettings &directionalLight : std::as_const( mDirectionalLights ) )

   {

     QDomElement elemDirectionalLight = directionalLight.writeXml( doc );

     elemDirectionalLights.appendChild( elemDirectionalLight );

   }

   elem.appendChild( elemDirectionalLights );


   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 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( "enabled", mEyeDomeLightingEnabled ? 1 : 0 );

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

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

   elem.appendChild( elemEyeDomeLighting );


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


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

   }

 }


 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::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::extentChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );

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

   }


   mTerrainGenerator.reset( gen );

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

   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();

 }


 void Qgs3DMapSettings::setPointLights( const QList<QgsPointLightSettings> &pointLights )

 {

   if ( mPointLights == pointLights )

     return;


   mPointLights = pointLights;

   emit pointLightsChanged();

 }


 void Qgs3DMapSettings::setDirectionalLights( const QList<QgsDirectionalLightSettings> &directionalLights )

 {

   if ( mDirectionalLights == directionalLights )

     return;


   mDirectionalLights = directionalLights;

   emit directionalLightsChanged();

 }


 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( QgsCameraController::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::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::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::pointLightsChanged, this, &Qgs3DMapSettings::settingsChanged );

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

 }

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

Qgs3DMapSettings
3
Definition: qgs3dmapsettings.h:57

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

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

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::renderers
QList< QgsAbstract3DRenderer * > renderers() const
Returns list of extra 3D renderers.
Definition: qgs3dmapsettings.h:311

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

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

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

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

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

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

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

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

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

Qgs3DMapSettings::directionalLights
QList< QgsDirectionalLightSettings > directionalLights() const
Returns list of directional lights defined in the scene.
Definition: qgs3dmapsettings.h:426

Qgs3DMapSettings::setPointLights
void setPointLights(const QList< QgsPointLightSettings > &pointLights)
Sets list of point lights defined in the scene.
Definition: qgs3dmapsettings.cpp:718

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::setDirectionalLights
void setDirectionalLights(const QList< QgsDirectionalLightSettings > &directionalLights)
Sets list of directional lights defined in the scene.
Definition: qgs3dmapsettings.cpp:727

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Qgs3DMapSettings::pointLights
QList< QgsPointLightSettings > pointLights() const
Returns list of point lights defined in the scene.
Definition: qgs3dmapsettings.h:420

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

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

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

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

Qgs3DMapSettings::setTerrainGenerator
void setTerrainGenerator(QgsTerrainGenerator *gen)
Sets terrain generator.
Definition: qgs3dmapsettings.cpp:588

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

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

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

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

QgsCameraController::NavigationMode
NavigationMode
The navigation mode used by the camera.
Definition: qgscameracontroller.h:70

QgsCameraController::WalkNavigation
@ WalkNavigation
Uses WASD keys or arrows to navigate in walking (first person) manner.
Definition: qgscameracontroller.h:72

QgsCameraController::TerrainBasedNavigation
@ TerrainBasedNavigation
The default navigation based on the terrain.
Definition: qgscameracontroller.h:71

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

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

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

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

QgsDirectionalLightSettings
3
Definition: qgsdirectionallightsettings.h:33

QgsDirectionalLightSettings::readXml
void readXml(const QDomElement &elem)
Reads configuration from a DOM element previously written using writeXml()
Definition: qgsdirectionallightsettings.cpp:34

QgsFlatTerrainGenerator
3
Definition: qgsflatterraingenerator.h:54

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

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

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

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

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

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

QgsPointLightSettings
3
Definition: qgspointlightsettings.h:39

QgsPointLightSettings::setPosition
void setPosition(const QgsVector3D &pos)
Sets position of the light (in 3D world coordinates)
Definition: qgspointlightsettings.h:47

QgsPointLightSettings::readXml
void readXml(const QDomElement &elem)
Reads configuration from a DOM element previously written using writeXml()
Definition: qgspointlightsettings.cpp:37

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

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

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

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

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

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

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

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

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::extentChanged
void extentChanged()
Emitted when the terrain extent has changed.

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

qgsflatterraingenerator.h

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

qgsmeshlayer3drenderer.h

qgsonlineterraingenerator.h

qgspointcloudlayer3drenderer.h

qgsrasterlayer.h

qgssymbollayerutils.h

qgsvectorlayer3drenderer.h

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

_LayerRef< QgsMapLayer >

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

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