QGIS API Documentation 3.39.0-Master (734b709c2f9)
Loading...
Searching...
No Matches
qgs3dmapsettings.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgs3dmapsettings.cpp
3 --------------------------------------
4 Date : July 2017
5 Copyright : (C) 2017 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgs3dmapsettings.h"
17
18#include "qgs3dutils.h"
19#include "qgsflatterraingenerator.h"
20#include "qgsdemterraingenerator.h"
21#include "qgsmeshterraingenerator.h"
22#include "qgsonlineterraingenerator.h"
23#include "qgsprojectviewsettings.h"
24#include "qgsprojectelevationproperties.h"
25#include "qgsterrainprovider.h"
26#include "qgslightsource.h"
27#include "qgscolorutils.h"
28#include "qgsrasterlayer.h"
29#include "qgspointlightsettings.h"
30#include "qgsdirectionallightsettings.h"
31#include "qgs3drendercontext.h"
32#include "qgsthreadingutils.h"
33
34#include <QDomDocument>
35#include <QDomElement>
36
37
38Qgs3DMapSettings::Qgs3DMapSettings()
39 : QObject( nullptr )
40{
41 connect( this, &Qgs3DMapSettings::settingsChanged, [&]()
42 {
43 QgsProject::instance()->setDirty();
44 } );
45 connectChangedSignalsToSettingsChanged();
46}
47
48Qgs3DMapSettings::Qgs3DMapSettings( const Qgs3DMapSettings &other )
49 : QObject( nullptr )
50 , QgsTemporalRangeObject( other )
51 , mOrigin( other.mOrigin )
52 , mCrs( other.mCrs )
53 , mBackgroundColor( other.mBackgroundColor )
54 , mSelectionColor( other.mSelectionColor )
55 , mTerrainVerticalScale( other.mTerrainVerticalScale )
56 , mTerrainGenerator( other.mTerrainGenerator ? other.mTerrainGenerator->clone() : nullptr )
57 , mMapTileResolution( other.mMapTileResolution )
58 , mMaxTerrainScreenError( other.mMaxTerrainScreenError )
59 , mMaxTerrainGroundError( other.mMaxTerrainGroundError )
60 , mTerrainElevationOffset( other.mTerrainElevationOffset )
61 , mTerrainShadingEnabled( other.mTerrainShadingEnabled )
62 , mTerrainShadingMaterial( other.mTerrainShadingMaterial )
63 , mTerrainMapTheme( other.mTerrainMapTheme )
64 , mShowTerrainBoundingBoxes( other.mShowTerrainBoundingBoxes )
65 , mShowTerrainTileInfo( other.mShowTerrainTileInfo )
66 , mShowCameraViewCenter( other.mShowCameraViewCenter )
67 , mShowCameraRotationCenter( other.mShowCameraRotationCenter )
68 , mShowLightSources( other.mShowLightSources )
69 , mShowLabels( other.mShowLabels )
70 , mFieldOfView( other.mFieldOfView )
71 , mProjectionType( other.mProjectionType )
72 , mCameraNavigationMode( other.mCameraNavigationMode )
73 , mCameraMovementSpeed( other.mCameraMovementSpeed )
74 , mLayers( other.mLayers )
75 , mTransformContext( other.mTransformContext )
76 , mPathResolver( other.mPathResolver )
77 , mMapThemes( other.mMapThemes )
78 , mDpi( other.mDpi )
79 , mIsFpsCounterEnabled( other.mIsFpsCounterEnabled )
80 , mIsSkyboxEnabled( other.mIsSkyboxEnabled )
81 , mSkyboxSettings( other.mSkyboxSettings )
82 , mShadowSettings( other.mShadowSettings )
83 , mAmbientOcclusionSettings( other.mAmbientOcclusionSettings )
84 , mEyeDomeLightingEnabled( other.mEyeDomeLightingEnabled )
85 , mEyeDomeLightingStrength( other.mEyeDomeLightingStrength )
86 , mEyeDomeLightingDistance( other.mEyeDomeLightingDistance )
87 , mViewSyncMode( other.mViewSyncMode )
88 , mVisualizeViewFrustum( other.mVisualizeViewFrustum )
89 , mDebugShadowMapEnabled( other.mDebugShadowMapEnabled )
90 , mDebugShadowMapCorner( other.mDebugShadowMapCorner )
91 , mDebugShadowMapSize( other.mDebugShadowMapSize )
92 , mDebugDepthMapEnabled( other.mDebugDepthMapEnabled )
93 , mDebugDepthMapCorner( other.mDebugDepthMapCorner )
94 , mDebugDepthMapSize( other.mDebugDepthMapSize )
95 , mTerrainRenderingEnabled( other.mTerrainRenderingEnabled )
96 , mRendererUsage( other.mRendererUsage )
97 , m3dAxisSettings( other.m3dAxisSettings )
98 , mIsDebugOverlayEnabled( other.mIsDebugOverlayEnabled )
99 , mExtent( other.mExtent )
100 , mShowExtentIn2DView( other.mShowExtentIn2DView )
101{
102 for ( QgsLightSource *source : std::as_const( other.mLightSources ) )
103 {
104 if ( source )
105 mLightSources << source->clone();
106 }
107
108 connect( this, &Qgs3DMapSettings::settingsChanged, [&]()
109 {
110 QgsProject::instance()->setDirty();
111 } );
112 connectChangedSignalsToSettingsChanged();
113}
114
115Qgs3DMapSettings::~Qgs3DMapSettings()
116{
117 qDeleteAll( mLightSources );
118}
119
120void Qgs3DMapSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
121{
122 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
123
124 QgsProjectDirtyBlocker blocker( QgsProject::instance() );
125 QDomElement elemOrigin = elem.firstChildElement( QStringLiteral( "origin" ) );
126 mOrigin = QgsVector3D(
127 elemOrigin.attribute( QStringLiteral( "x" ) ).toDouble(),
128 elemOrigin.attribute( QStringLiteral( "y" ) ).toDouble(),
129 elemOrigin.attribute( QStringLiteral( "z" ) ).toDouble() );
130
131 QDomElement elemExtent = elem.firstChildElement( QStringLiteral( "extent" ) );
132 if ( !elemExtent.isNull() )
133 {
134 mExtent = QgsRectangle(
135 elemExtent.attribute( QStringLiteral( "xMin" ) ).toDouble(),
136 elemExtent.attribute( QStringLiteral( "yMin" ) ).toDouble(),
137 elemExtent.attribute( QStringLiteral( "xMax" ) ).toDouble(),
138 elemExtent.attribute( QStringLiteral( "yMax" ) ).toDouble() );
139
140 mShowExtentIn2DView = elemExtent.attribute( QStringLiteral( "showIn2dView" ), QStringLiteral( "0" ) ).toInt();
141 }
142 else
143 {
144 mExtent = QgsProject::instance()->viewSettings()->fullExtent();
145 }
146
147 QDomElement elemCamera = elem.firstChildElement( QStringLiteral( "camera" ) );
148 if ( !elemCamera.isNull() )
149 {
150 mFieldOfView = elemCamera.attribute( QStringLiteral( "field-of-view" ), QStringLiteral( "45" ) ).toFloat();
151 mProjectionType = static_cast< Qt3DRender::QCameraLens::ProjectionType >( elemCamera.attribute( QStringLiteral( "projection-type" ), QStringLiteral( "1" ) ).toInt() );
152 QString cameraNavigationMode = elemCamera.attribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "basic-navigation" ) );
153 if ( cameraNavigationMode == QLatin1String( "terrain-based-navigation" ) )
154 mCameraNavigationMode = Qgis::NavigationMode::TerrainBased;
155 else if ( cameraNavigationMode == QLatin1String( "walk-navigation" ) )
156 mCameraNavigationMode = Qgis::NavigationMode::Walk;
157 mCameraMovementSpeed = elemCamera.attribute( QStringLiteral( "camera-movement-speed" ), QStringLiteral( "5.0" ) ).toDouble();
158 }
159
160 QDomElement elemColor = elem.firstChildElement( QStringLiteral( "color" ) );
161 if ( !elemColor.isNull() )
162 {
163 mBackgroundColor = QgsColorUtils::colorFromString( elemColor.attribute( QStringLiteral( "background" ) ) );
164 mSelectionColor = QgsColorUtils::colorFromString( elemColor.attribute( QStringLiteral( "selection" ) ) );
165 }
166
167 QDomElement elemCrs = elem.firstChildElement( QStringLiteral( "crs" ) );
168 mCrs.readXml( elemCrs );
169
170 QDomElement elemTerrain = elem.firstChildElement( QStringLiteral( "terrain" ) );
171 mTerrainRenderingEnabled = elemTerrain.attribute( QStringLiteral( "terrain-rendering-enabled" ), QStringLiteral( "1" ) ).toInt();
172 mTerrainVerticalScale = elemTerrain.attribute( QStringLiteral( "exaggeration" ), QStringLiteral( "1" ) ).toFloat();
173 mMapTileResolution = elemTerrain.attribute( QStringLiteral( "texture-size" ), QStringLiteral( "512" ) ).toInt();
174 mMaxTerrainScreenError = elemTerrain.attribute( QStringLiteral( "max-terrain-error" ), QStringLiteral( "3" ) ).toFloat();
175 mMaxTerrainGroundError = elemTerrain.attribute( QStringLiteral( "max-ground-error" ), QStringLiteral( "1" ) ).toFloat();
176 mTerrainShadingEnabled = elemTerrain.attribute( QStringLiteral( "shading-enabled" ), QStringLiteral( "0" ) ).toInt();
177 mTerrainElevationOffset = elemTerrain.attribute( QStringLiteral( "elevation-offset" ), QStringLiteral( "0.0" ) ).toFloat();
178
179 QDomElement elemTerrainShadingMaterial = elemTerrain.firstChildElement( QStringLiteral( "shading-material" ) );
180 if ( !elemTerrainShadingMaterial.isNull() )
181 mTerrainShadingMaterial.readXml( elemTerrainShadingMaterial, context );
182 mTerrainMapTheme = elemTerrain.attribute( QStringLiteral( "map-theme" ) );
183 mShowLabels = elemTerrain.attribute( QStringLiteral( "show-labels" ), QStringLiteral( "0" ) ).toInt();
184
185 qDeleteAll( mLightSources );
186 mLightSources.clear();
187 const QDomElement lightsElem = elem.firstChildElement( QStringLiteral( "lights" ) );
188 if ( !lightsElem.isNull() )
189 {
190 const QDomNodeList lightNodes = lightsElem.childNodes();
191 for ( int i = 0; i < lightNodes.size(); ++i )
192 {
193 const QDomElement lightElement = lightNodes.at( i ).toElement();
194 if ( QgsLightSource *light = QgsLightSource::createFromXml( lightElement, context ) )
195 mLightSources << light;
196 }
197 }
198 else
199 {
200 // older project format
201 QDomElement elemPointLights = elem.firstChildElement( QStringLiteral( "point-lights" ) );
202 if ( !elemPointLights.isNull() )
203 {
204 QDomElement elemPointLight = elemPointLights.firstChildElement( QStringLiteral( "point-light" ) );
205 while ( !elemPointLight.isNull() )
206 {
207 std::unique_ptr< QgsPointLightSettings > pointLight = std::make_unique< QgsPointLightSettings >();
208 pointLight->readXml( elemPointLight, context );
209 mLightSources << pointLight.release();
210 elemPointLight = elemPointLight.nextSiblingElement( QStringLiteral( "point-light" ) );
211 }
212 }
213 else
214 {
215 // QGIS <= 3.4 did not have light configuration
216 std::unique_ptr< QgsPointLightSettings > defaultLight = std::make_unique< QgsPointLightSettings >();
217 defaultLight->setPosition( QgsVector3D( 0, 1000, 0 ) );
218 mLightSources << defaultLight.release();
219 }
220
221 QDomElement elemDirectionalLights = elem.firstChildElement( QStringLiteral( "directional-lights" ) );
222 if ( !elemDirectionalLights.isNull() )
223 {
224 QDomElement elemDirectionalLight = elemDirectionalLights.firstChildElement( QStringLiteral( "directional-light" ) );
225 while ( !elemDirectionalLight.isNull() )
226 {
227 std::unique_ptr< QgsDirectionalLightSettings > directionalLight = std::make_unique< QgsDirectionalLightSettings >();
228 directionalLight->readXml( elemDirectionalLight, context );
229 mLightSources << directionalLight.release();
230 elemDirectionalLight = elemDirectionalLight.nextSiblingElement( QStringLiteral( "directional-light" ) );
231 }
232 }
233 }
234
235 QDomElement elemMapLayers = elemTerrain.firstChildElement( QStringLiteral( "layers" ) );
236 QDomElement elemMapLayer = elemMapLayers.firstChildElement( QStringLiteral( "layer" ) );
237 QList<QgsMapLayerRef> mapLayers;
238 while ( !elemMapLayer.isNull() )
239 {
240 mapLayers << QgsMapLayerRef( elemMapLayer.attribute( QStringLiteral( "id" ) ) );
241 elemMapLayer = elemMapLayer.nextSiblingElement( QStringLiteral( "layer" ) );
242 }
243 mLayers = mapLayers; // needs to resolve refs afterwards
244
245 QDomElement elemTerrainGenerator = elemTerrain.firstChildElement( QStringLiteral( "generator" ) );
246 QString terrainGenType = elemTerrainGenerator.attribute( QStringLiteral( "type" ) );
247 if ( terrainGenType == QLatin1String( "dem" ) )
248 {
249 QgsDemTerrainGenerator *demTerrainGenerator = new QgsDemTerrainGenerator;
250 demTerrainGenerator->setCrs( mCrs, mTransformContext );
251 setTerrainGenerator( demTerrainGenerator );
252 }
253 else if ( terrainGenType == QLatin1String( "online" ) )
254 {
255 QgsOnlineTerrainGenerator *onlineTerrainGenerator = new QgsOnlineTerrainGenerator;
256 onlineTerrainGenerator->setCrs( mCrs, mTransformContext );
257 setTerrainGenerator( onlineTerrainGenerator );
258 }
259 else if ( terrainGenType == QLatin1String( "mesh" ) )
260 {
261 QgsMeshTerrainGenerator *meshTerrainGenerator = new QgsMeshTerrainGenerator;
262 meshTerrainGenerator->setCrs( mCrs, mTransformContext );
263 setTerrainGenerator( meshTerrainGenerator );
264 }
265 else // "flat"
266 {
267 QgsFlatTerrainGenerator *flatGen = new QgsFlatTerrainGenerator;
268 flatGen->setCrs( mCrs );
269 setTerrainGenerator( flatGen );
270 }
271 mTerrainGenerator->readXml( elemTerrainGenerator );
272
273 QDomElement elemSkybox = elem.firstChildElement( QStringLiteral( "skybox" ) );
274 mIsSkyboxEnabled = elemSkybox.attribute( QStringLiteral( "skybox-enabled" ) ).toInt();
275 mSkyboxSettings.readXml( elemSkybox, context );
276
277 QDomElement elemShadows = elem.firstChildElement( QStringLiteral( "shadow-rendering" ) );
278 mShadowSettings.readXml( elemShadows, context );
279
280 QDomElement elemAmbientOcclusion = elem.firstChildElement( QStringLiteral( "screen-space-ambient-occlusion" ) );
281 mAmbientOcclusionSettings.readXml( elemAmbientOcclusion, context );
282
283 QDomElement elemEyeDomeLighting = elem.firstChildElement( QStringLiteral( "eye-dome-lighting" ) );
284 mEyeDomeLightingEnabled = elemEyeDomeLighting.attribute( "enabled", QStringLiteral( "0" ) ).toInt();
285 mEyeDomeLightingStrength = elemEyeDomeLighting.attribute( "eye-dome-lighting-strength", QStringLiteral( "1000.0" ) ).toDouble();
286 mEyeDomeLightingDistance = elemEyeDomeLighting.attribute( "eye-dome-lighting-distance", QStringLiteral( "1" ) ).toInt();
287
288 QDomElement elemNavigationSync = elem.firstChildElement( QStringLiteral( "navigation-sync" ) );
289 mViewSyncMode = ( Qgis::ViewSyncModeFlags )( elemNavigationSync.attribute( QStringLiteral( "view-sync-mode" ), QStringLiteral( "0" ) ).toInt() );
290 mVisualizeViewFrustum = elemNavigationSync.attribute( QStringLiteral( "view-frustum-visualization-enabled" ), QStringLiteral( "0" ) ).toInt();
291
292 QDomElement elemDebugSettings = elem.firstChildElement( QStringLiteral( "debug-settings" ) );
293 mDebugShadowMapEnabled = elemDebugSettings.attribute( QStringLiteral( "shadowmap-enabled" ), QStringLiteral( "0" ) ).toInt();
294 mDebugShadowMapCorner = static_cast<Qt::Corner>( elemDebugSettings.attribute( QStringLiteral( "shadowmap-corner" ), "0" ).toInt() );
295 mDebugShadowMapSize = elemDebugSettings.attribute( QStringLiteral( "shadowmap-size" ), QStringLiteral( "0.2" ) ).toDouble();
296
297 mDebugDepthMapEnabled = elemDebugSettings.attribute( QStringLiteral( "depthmap-enabled" ), QStringLiteral( "0" ) ).toInt();
298 mDebugDepthMapCorner = static_cast<Qt::Corner>( elemDebugSettings.attribute( QStringLiteral( "depthmap-corner" ), QStringLiteral( "1" ) ).toInt() );
299 mDebugDepthMapSize = elemDebugSettings.attribute( QStringLiteral( "depthmap-size" ), QStringLiteral( "0.2" ) ).toDouble();
300
301 QDomElement elemDebug = elem.firstChildElement( QStringLiteral( "debug" ) );
302 mShowTerrainBoundingBoxes = elemDebug.attribute( QStringLiteral( "bounding-boxes" ), QStringLiteral( "0" ) ).toInt();
303 mShowTerrainTileInfo = elemDebug.attribute( QStringLiteral( "terrain-tile-info" ), QStringLiteral( "0" ) ).toInt();
304 mShowCameraViewCenter = elemDebug.attribute( QStringLiteral( "camera-view-center" ), QStringLiteral( "0" ) ).toInt();
305 mShowCameraRotationCenter = elemDebug.attribute( QStringLiteral( "camera-rotation-center" ), QStringLiteral( "0" ) ).toInt();
306 mShowLightSources = elemDebug.attribute( QStringLiteral( "show-light-sources" ), QStringLiteral( "0" ) ).toInt();
307 mIsFpsCounterEnabled = elemDebug.attribute( QStringLiteral( "show-fps-counter" ), QStringLiteral( "0" ) ).toInt();
308
309 QDomElement elemTemporalRange = elem.firstChildElement( QStringLiteral( "temporal-range" ) );
310 QDateTime start = QDateTime::fromString( elemTemporalRange.attribute( QStringLiteral( "start" ) ), Qt::ISODate );
311 QDateTime end = QDateTime::fromString( elemTemporalRange.attribute( QStringLiteral( "end" ) ), Qt::ISODate );
312 setTemporalRange( QgsDateTimeRange( start, end ) );
313
314 QDomElement elem3dAxis = elem.firstChildElement( QStringLiteral( "axis3d" ) );
315 m3dAxisSettings.readXml( elem3dAxis, context );
316
317}
318
319QDomElement Qgs3DMapSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
320{
321 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
322
323 QDomElement elem = doc.createElement( QStringLiteral( "qgis3d" ) );
324
325 QDomElement elemOrigin = doc.createElement( QStringLiteral( "origin" ) );
326 elemOrigin.setAttribute( QStringLiteral( "x" ), QString::number( mOrigin.x() ) );
327 elemOrigin.setAttribute( QStringLiteral( "y" ), QString::number( mOrigin.y() ) );
328 elemOrigin.setAttribute( QStringLiteral( "z" ), QString::number( mOrigin.z() ) );
329 elem.appendChild( elemOrigin );
330
331 QDomElement elemExtent = doc.createElement( QStringLiteral( "extent" ) );
332 elemExtent.setAttribute( QStringLiteral( "xMin" ), mExtent.xMinimum() );
333 elemExtent.setAttribute( QStringLiteral( "yMin" ), mExtent.yMinimum() );
334 elemExtent.setAttribute( QStringLiteral( "xMax" ), mExtent.xMaximum() );
335 elemExtent.setAttribute( QStringLiteral( "yMax" ), mExtent.yMaximum() );
336 elemExtent.setAttribute( QStringLiteral( "showIn2dView" ), mShowExtentIn2DView );
337 elem.appendChild( elemExtent );
338
339 QDomElement elemCamera = doc.createElement( QStringLiteral( "camera" ) );
340 elemCamera.setAttribute( QStringLiteral( "field-of-view" ), mFieldOfView );
341 elemCamera.setAttribute( QStringLiteral( "projection-type" ), static_cast< int >( mProjectionType ) );
342 switch ( mCameraNavigationMode )
343 {
344 case Qgis::NavigationMode::TerrainBased:
345 elemCamera.setAttribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "terrain-based-navigation" ) );
346 break;
347 case Qgis::NavigationMode::Walk:
348 elemCamera.setAttribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "walk-navigation" ) );
349 break;
350 }
351 elemCamera.setAttribute( QStringLiteral( "camera-movement-speed" ), mCameraMovementSpeed );
352 elem.appendChild( elemCamera );
353
354 QDomElement elemColor = doc.createElement( QStringLiteral( "color" ) );
355 elemColor.setAttribute( QStringLiteral( "background" ), QgsColorUtils::colorToString( mBackgroundColor ) );
356 elemColor.setAttribute( QStringLiteral( "selection" ), QgsColorUtils::colorToString( mSelectionColor ) );
357 elem.appendChild( elemColor );
358
359 QDomElement elemCrs = doc.createElement( QStringLiteral( "crs" ) );
360 mCrs.writeXml( elemCrs, doc );
361 elem.appendChild( elemCrs );
362
363 QDomElement elemTerrain = doc.createElement( QStringLiteral( "terrain" ) );
364 elemTerrain.setAttribute( QStringLiteral( "terrain-rendering-enabled" ), mTerrainRenderingEnabled ? 1 : 0 );
365 elemTerrain.setAttribute( QStringLiteral( "exaggeration" ), QString::number( mTerrainVerticalScale ) );
366 elemTerrain.setAttribute( QStringLiteral( "texture-size" ), mMapTileResolution );
367 elemTerrain.setAttribute( QStringLiteral( "max-terrain-error" ), QString::number( mMaxTerrainScreenError ) );
368 elemTerrain.setAttribute( QStringLiteral( "max-ground-error" ), QString::number( mMaxTerrainGroundError ) );
369 elemTerrain.setAttribute( QStringLiteral( "shading-enabled" ), mTerrainShadingEnabled ? 1 : 0 );
370 elemTerrain.setAttribute( QStringLiteral( "elevation-offset" ), mTerrainElevationOffset );
371
372 QDomElement elemTerrainShadingMaterial = doc.createElement( QStringLiteral( "shading-material" ) );
373 mTerrainShadingMaterial.writeXml( elemTerrainShadingMaterial, context );
374 elemTerrain.appendChild( elemTerrainShadingMaterial );
375 elemTerrain.setAttribute( QStringLiteral( "map-theme" ), mTerrainMapTheme );
376 elemTerrain.setAttribute( QStringLiteral( "show-labels" ), mShowLabels ? 1 : 0 );
377
378 {
379 QDomElement elemLights = doc.createElement( QStringLiteral( "lights" ) );
380 for ( const QgsLightSource *light : mLightSources )
381 {
382 const QDomElement elemLight = light->writeXml( doc, context );
383 elemLights.appendChild( elemLight );
384 }
385 elem.appendChild( elemLights );
386 }
387
388 QDomElement elemMapLayers = doc.createElement( QStringLiteral( "layers" ) );
389 for ( const QgsMapLayerRef &layerRef : mLayers )
390 {
391 QDomElement elemMapLayer = doc.createElement( QStringLiteral( "layer" ) );
392 elemMapLayer.setAttribute( QStringLiteral( "id" ), layerRef.layerId );
393 elemMapLayers.appendChild( elemMapLayer );
394 }
395 elemTerrain.appendChild( elemMapLayers );
396
397 QDomElement elemTerrainGenerator = doc.createElement( QStringLiteral( "generator" ) );
398 elemTerrainGenerator.setAttribute( QStringLiteral( "type" ), QgsTerrainGenerator::typeToString( mTerrainGenerator->type() ) );
399 mTerrainGenerator->writeXml( elemTerrainGenerator );
400 elemTerrain.appendChild( elemTerrainGenerator );
401 elem.appendChild( elemTerrain );
402
403 QDomElement elemSkybox = doc.createElement( QStringLiteral( "skybox" ) );
404 elemSkybox.setAttribute( QStringLiteral( "skybox-enabled" ), mIsSkyboxEnabled );
405 mSkyboxSettings.writeXml( elemSkybox, context );
406 elem.appendChild( elemSkybox );
407
408 QDomElement elemShadows = doc.createElement( QStringLiteral( "shadow-rendering" ) );
409 mShadowSettings.writeXml( elemShadows, context );
410 elem.appendChild( elemShadows );
411
412 QDomElement elemAmbientOcclusion = doc.createElement( QStringLiteral( "screen-space-ambient-occlusion" ) );
413 mAmbientOcclusionSettings.writeXml( elemAmbientOcclusion, context );
414 elem.appendChild( elemAmbientOcclusion );
415
416 QDomElement elemDebug = doc.createElement( QStringLiteral( "debug" ) );
417 elemDebug.setAttribute( QStringLiteral( "bounding-boxes" ), mShowTerrainBoundingBoxes ? 1 : 0 );
418 elemDebug.setAttribute( QStringLiteral( "terrain-tile-info" ), mShowTerrainTileInfo ? 1 : 0 );
419 elemDebug.setAttribute( QStringLiteral( "camera-view-center" ), mShowCameraViewCenter ? 1 : 0 );
420 elemDebug.setAttribute( QStringLiteral( "camera-rotation-center" ), mShowCameraRotationCenter ? 1 : 0 );
421 elemDebug.setAttribute( QStringLiteral( "show-light-sources" ), mShowLightSources ? 1 : 0 );
422 elemDebug.setAttribute( QStringLiteral( "show-fps-counter" ), mIsFpsCounterEnabled ? 1 : 0 );
423 elem.appendChild( elemDebug );
424
425 QDomElement elemEyeDomeLighting = doc.createElement( QStringLiteral( "eye-dome-lighting" ) );
426 elemEyeDomeLighting.setAttribute( QStringLiteral( "enabled" ), mEyeDomeLightingEnabled ? 1 : 0 );
427 elemEyeDomeLighting.setAttribute( QStringLiteral( "eye-dome-lighting-strength" ), mEyeDomeLightingStrength );
428 elemEyeDomeLighting.setAttribute( QStringLiteral( "eye-dome-lighting-distance" ), mEyeDomeLightingDistance );
429 elem.appendChild( elemEyeDomeLighting );
430
431 QDomElement elemNavigationSync = doc.createElement( QStringLiteral( "navigation-sync" ) );
432 elemNavigationSync.setAttribute( QStringLiteral( "view-sync-mode" ), ( int )mViewSyncMode );
433 elemNavigationSync.setAttribute( QStringLiteral( "view-frustum-visualization-enabled" ), mVisualizeViewFrustum ? 1 : 0 );
434 elem.appendChild( elemNavigationSync );
435
436 QDomElement elemDebugSettings = doc.createElement( QStringLiteral( "debug-settings" ) );
437 elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-enabled" ), mDebugShadowMapEnabled );
438 elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-corner" ), mDebugShadowMapCorner );
439 elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-size" ), mDebugShadowMapSize );
440 elemDebugSettings.setAttribute( QStringLiteral( "depthmap-enabled" ), mDebugDepthMapEnabled );
441 elemDebugSettings.setAttribute( QStringLiteral( "depthmap-corner" ), mDebugDepthMapCorner );
442 elemDebugSettings.setAttribute( QStringLiteral( "depthmap-size" ), mDebugDepthMapSize );
443 elem.appendChild( elemDebugSettings );
444
445 QDomElement elemTemporalRange = doc.createElement( QStringLiteral( "temporal-range" ) );
446 elemTemporalRange.setAttribute( QStringLiteral( "start" ), temporalRange().begin().toString( Qt::ISODate ) );
447 elemTemporalRange.setAttribute( QStringLiteral( "end" ), temporalRange().end().toString( Qt::ISODate ) );
448
449 QDomElement elem3dAxis = doc.createElement( QStringLiteral( "axis3d" ) );
450 m3dAxisSettings.writeXml( elem3dAxis, context );
451 elem.appendChild( elem3dAxis );
452
453 return elem;
454}
455
456void Qgs3DMapSettings::resolveReferences( const QgsProject &project )
457{
458 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
459
460 for ( int i = 0; i < mLayers.count(); ++i )
461 {
462 QgsMapLayerRef &layerRef = mLayers[i];
463 layerRef.setLayer( project.mapLayer( layerRef.layerId ) );
464 }
465
466 mTerrainGenerator->resolveReferences( project );
467}
468
475
476void Qgs3DMapSettings::setExtent( const QgsRectangle &extent )
477{
478 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
479
480 if ( extent == mExtent )
481 return;
482
483 mExtent = extent;
484 const QgsPointXY center = mExtent.center();
485 setOrigin( QgsVector3D( center.x(), center.y(), 0 ) );
486 if ( mTerrainGenerator )
487 {
488 QgsRectangle terrainExtent = Qgs3DUtils::tryReprojectExtent2D( mExtent, mCrs, mTerrainGenerator->crs(), mTransformContext );
489 mTerrainGenerator->setExtent( terrainExtent );
490 }
491 emit extentChanged();
492}
493
494void Qgs3DMapSettings::setOrigin( const QgsVector3D &origin )
495{
496 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
497
498 mOrigin = origin;
499}
500
501QgsVector3D Qgs3DMapSettings::origin() const
502{
503 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
504
505 return mOrigin;
506}
507
514
521
528
535
542
543void Qgs3DMapSettings::setTransformContext( const QgsCoordinateTransformContext &context )
544{
545 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
546
547 mTransformContext = context;
548}
549
550const QgsPathResolver &Qgs3DMapSettings::pathResolver() const
551{
552 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
553
554 return mPathResolver;
555}
556
557void Qgs3DMapSettings::setPathResolver( const QgsPathResolver &resolver )
558{
559 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
560
561 mPathResolver = resolver;
562}
563
570
571void Qgs3DMapSettings::setMapThemeCollection( QgsMapThemeCollection *mapThemes )
572{
573 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
574
575 mMapThemes = mapThemes;
576}
577
578void Qgs3DMapSettings::setBackgroundColor( const QColor &color )
579{
580 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
581
582 if ( color == mBackgroundColor )
583 return;
584
585 mBackgroundColor = color;
586 emit backgroundColorChanged();
587}
588
589QColor Qgs3DMapSettings::backgroundColor() const
590{
591 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
592
593 return mBackgroundColor;
594}
595
596void Qgs3DMapSettings::setSelectionColor( const QColor &color )
597{
598 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
599
600 if ( color == mSelectionColor )
601 return;
602
603 mSelectionColor = color;
604 emit selectionColorChanged();
605}
606
607QColor Qgs3DMapSettings::selectionColor() const
608{
609 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
610
611 return mSelectionColor;
612}
613
614void Qgs3DMapSettings::setTerrainVerticalScale( double zScale )
615{
616 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
617
618 if ( zScale == mTerrainVerticalScale )
619 return;
620
621 mTerrainVerticalScale = zScale;
622 emit terrainVerticalScaleChanged();
623}
624
625double Qgs3DMapSettings::terrainVerticalScale() const
626{
627 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
628
629 return mTerrainVerticalScale;
630}
631
632void Qgs3DMapSettings::setLayers( const QList<QgsMapLayer *> &layers )
633{
634 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
635
636 QList<QgsMapLayerRef> lst;
637 lst.reserve( layers.count() );
638 for ( QgsMapLayer *layer : layers )
639 {
640 lst.append( layer );
641 }
642
643 if ( mLayers == lst )
644 return;
645
646 mLayers = lst;
647 emit layersChanged();
648}
649
650QList<QgsMapLayer *> Qgs3DMapSettings::layers() const
651{
652 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
653
654 QList<QgsMapLayer *> lst;
655 lst.reserve( mLayers.count() );
656 for ( const QgsMapLayerRef &layerRef : mLayers )
657 {
658 if ( layerRef.layer )
659 lst.append( layerRef.layer );
660 }
661 return lst;
662}
663
664void Qgs3DMapSettings::configureTerrainFromProject( QgsProjectElevationProperties *properties, const QgsRectangle &fullExtent )
665{
666 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
667
668 setExtent( fullExtent );
669 if ( properties->terrainProvider()->type() == QLatin1String( "flat" ) )
670 {
671 QgsFlatTerrainGenerator *flatTerrain = new QgsFlatTerrainGenerator;
672 flatTerrain->setCrs( crs() );
673 setTerrainGenerator( flatTerrain );
674
675 setTerrainElevationOffset( properties->terrainProvider()->offset() );
676 }
677 else if ( properties->terrainProvider()->type() == QLatin1String( "raster" ) )
678 {
679 QgsRasterDemTerrainProvider *rasterProvider = qgis::down_cast< QgsRasterDemTerrainProvider * >( properties->terrainProvider() );
680
681 QgsDemTerrainGenerator *demTerrainGen = new QgsDemTerrainGenerator;
682 demTerrainGen->setCrs( crs(), QgsProject::instance()->transformContext() );
683 demTerrainGen->setLayer( rasterProvider->layer() );
684 setTerrainGenerator( demTerrainGen );
685
686 setTerrainElevationOffset( properties->terrainProvider()->offset() );
687 setTerrainVerticalScale( properties->terrainProvider()->scale() );
688 }
689 else if ( properties->terrainProvider()->type() == QLatin1String( "mesh" ) )
690 {
691 QgsMeshTerrainProvider *meshProvider = qgis::down_cast< QgsMeshTerrainProvider * >( properties->terrainProvider() );
692
693 QgsMeshTerrainGenerator *newTerrainGenerator = new QgsMeshTerrainGenerator;
694 newTerrainGenerator->setCrs( crs(), QgsProject::instance()->transformContext() );
695 newTerrainGenerator->setLayer( meshProvider->layer() );
696 std::unique_ptr< QgsMesh3DSymbol > symbol( newTerrainGenerator->symbol()->clone() );
697 symbol->setVerticalScale( properties->terrainProvider()->scale() );
698 newTerrainGenerator->setSymbol( symbol.release() );
699 setTerrainGenerator( newTerrainGenerator );
700
701 setTerrainElevationOffset( properties->terrainProvider()->offset() );
702 setTerrainVerticalScale( properties->terrainProvider()->scale() );
703 }
704 else
705 {
706 QgsFlatTerrainGenerator *flatTerrain = new QgsFlatTerrainGenerator;
707 flatTerrain->setCrs( crs() );
708 setTerrainGenerator( flatTerrain );
709 }
710}
711
712void Qgs3DMapSettings::setMapTileResolution( int res )
713{
714 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
715
716 if ( mMapTileResolution == res )
717 return;
718
719 mMapTileResolution = res;
720 emit mapTileResolutionChanged();
721}
722
723int Qgs3DMapSettings::mapTileResolution() const
724{
725 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
726
727 return mMapTileResolution;
728}
729
730void Qgs3DMapSettings::setMaxTerrainScreenError( float error )
731{
732 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
733
734 if ( mMaxTerrainScreenError == error )
735 return;
736
737 mMaxTerrainScreenError = error;
738 emit maxTerrainScreenErrorChanged();
739}
740
741float Qgs3DMapSettings::maxTerrainScreenError() const
742{
743 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
744
745 return mMaxTerrainScreenError;
746}
747
748void Qgs3DMapSettings::setMaxTerrainGroundError( float error )
749{
750 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
751
752 if ( mMaxTerrainGroundError == error )
753 return;
754
755 mMaxTerrainGroundError = error;
756 emit maxTerrainGroundErrorChanged();
757}
758
759void Qgs3DMapSettings::setTerrainElevationOffset( float offset )
760{
761 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
762
763 if ( mTerrainElevationOffset == offset )
764 return;
765 mTerrainElevationOffset = offset;
766 emit terrainElevationOffsetChanged( mTerrainElevationOffset );
767}
768
769float Qgs3DMapSettings::terrainElevationOffset() const
770{
771 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
772
773 return mTerrainElevationOffset;
774}
775
776float Qgs3DMapSettings::maxTerrainGroundError() const
777{
778 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
779
780 return mMaxTerrainGroundError;
781}
782
783void Qgs3DMapSettings::setTerrainGenerator( QgsTerrainGenerator *gen )
784{
785 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
786
787 if ( mTerrainGenerator )
788 {
789 disconnect( mTerrainGenerator.get(), &QgsTerrainGenerator::terrainChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );
790 }
791
792 QgsRectangle terrainExtent = Qgs3DUtils::tryReprojectExtent2D( mExtent, mCrs, gen->crs(), mTransformContext );
793 gen->setExtent( terrainExtent );
794 mTerrainGenerator.reset( gen );
795 connect( mTerrainGenerator.get(), &QgsTerrainGenerator::terrainChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );
796
797 emit terrainGeneratorChanged();
798}
799
800QgsTerrainGenerator *Qgs3DMapSettings::terrainGenerator() const
801{
802 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
803
804 return mTerrainGenerator.get();
805}
806
807void Qgs3DMapSettings::setTerrainShadingEnabled( bool enabled )
808{
809 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
810
811 if ( mTerrainShadingEnabled == enabled )
812 return;
813
814 mTerrainShadingEnabled = enabled;
815 emit terrainShadingChanged();
816}
817
818bool Qgs3DMapSettings::isTerrainShadingEnabled() const
819{
820 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
821
822 return mTerrainShadingEnabled;
823}
824
825void Qgs3DMapSettings::setTerrainShadingMaterial( const QgsPhongMaterialSettings &material )
826{
827 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
828
829 if ( mTerrainShadingMaterial == material )
830 return;
831
832 mTerrainShadingMaterial = material;
833 emit terrainShadingChanged();
834}
835
842
843void Qgs3DMapSettings::setTerrainMapTheme( const QString &theme )
844{
845 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
846
847 if ( mTerrainMapTheme == theme )
848 return;
849
850 mTerrainMapTheme = theme;
851 emit terrainMapThemeChanged();
852}
853
854QString Qgs3DMapSettings::terrainMapTheme() const
855{
856 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
857
858 return mTerrainMapTheme;
859}
860
861void Qgs3DMapSettings::setShowTerrainBoundingBoxes( bool enabled )
862{
863 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
864
865 if ( mShowTerrainBoundingBoxes == enabled )
866 return;
867
868 mShowTerrainBoundingBoxes = enabled;
869 emit showTerrainBoundingBoxesChanged();
870}
871
872bool Qgs3DMapSettings::showTerrainBoundingBoxes() const
873{
874 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
875
876 return mShowTerrainBoundingBoxes;
877}
878
879
880void Qgs3DMapSettings::setShowTerrainTilesInfo( bool enabled )
881{
882 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
883
884 if ( mShowTerrainTileInfo == enabled )
885 return;
886
887 mShowTerrainTileInfo = enabled;
888 emit showTerrainTilesInfoChanged();
889}
890
891bool Qgs3DMapSettings::showTerrainTilesInfo() const
892{
893 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
894
895 return mShowTerrainTileInfo;
896}
897
898void Qgs3DMapSettings::setShowCameraViewCenter( bool enabled )
899{
900 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
901
902 if ( mShowCameraViewCenter == enabled )
903 return;
904
905 mShowCameraViewCenter = enabled;
906 emit showCameraViewCenterChanged();
907}
908
909bool Qgs3DMapSettings::showCameraViewCenter() const
910{
911 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
912
913 return mShowCameraViewCenter;
914}
915
916void Qgs3DMapSettings::setShowCameraRotationCenter( bool enabled )
917{
918 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
919
920 if ( mShowCameraRotationCenter == enabled )
921 return;
922
923 mShowCameraRotationCenter = enabled;
924 emit showCameraRotationCenterChanged();
925}
926
927bool Qgs3DMapSettings::showCameraRotationCenter() const
928{
929 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
930
931 return mShowCameraRotationCenter;
932}
933
934void Qgs3DMapSettings::setShowLightSourceOrigins( bool enabled )
935{
936 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
937
938 if ( mShowLightSources == enabled )
939 return;
940
941 mShowLightSources = enabled;
942 emit showLightSourceOriginsChanged();
943}
944
945bool Qgs3DMapSettings::showLightSourceOrigins() const
946{
947 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
948
949 return mShowLightSources;
950}
951
952void Qgs3DMapSettings::setShowLabels( bool enabled )
953{
954 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
955
956 if ( mShowLabels == enabled )
957 return;
958
959 mShowLabels = enabled;
960 emit showLabelsChanged();
961}
962
963bool Qgs3DMapSettings::showLabels() const
964{
965 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
966
967 return mShowLabels;
968}
969
970void Qgs3DMapSettings::setEyeDomeLightingEnabled( bool enabled )
971{
972 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
973
974 if ( mEyeDomeLightingEnabled == enabled )
975 return;
976 mEyeDomeLightingEnabled = enabled;
977 emit eyeDomeLightingEnabledChanged();
978}
979
980bool Qgs3DMapSettings::eyeDomeLightingEnabled() const
981{
982 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
983
984 return mEyeDomeLightingEnabled;
985}
986
987void Qgs3DMapSettings::setEyeDomeLightingStrength( double strength )
988{
989 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
990
991 if ( mEyeDomeLightingStrength == strength )
992 return;
993 mEyeDomeLightingStrength = strength;
994 emit eyeDomeLightingStrengthChanged();
995}
996
997double Qgs3DMapSettings::eyeDomeLightingStrength() const
998{
999 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1000
1001 return mEyeDomeLightingStrength;
1002}
1003
1004void Qgs3DMapSettings::setEyeDomeLightingDistance( int distance )
1005{
1006 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1007
1008 if ( mEyeDomeLightingDistance == distance )
1009 return;
1010 mEyeDomeLightingDistance = distance;
1011 emit eyeDomeLightingDistanceChanged();
1012}
1013
1014int Qgs3DMapSettings::eyeDomeLightingDistance() const
1015{
1016 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1017
1018 return mEyeDomeLightingDistance;
1019}
1020
1021QList<QgsLightSource *> Qgs3DMapSettings::lightSources() const
1022{
1023 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1024
1025 return mLightSources;
1026}
1027
1028void Qgs3DMapSettings::setLightSources( const QList<QgsLightSource *> &lights )
1029{
1030 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1031
1032 // have lights actually changed?
1033 if ( mLightSources.count() == lights.count() )
1034 {
1035 bool same = true;
1036 for ( int i = 0; i < mLightSources.count(); ++i )
1037 {
1038 if ( mLightSources[i]->type() == lights[i]->type() )
1039 {
1040 switch ( mLightSources[i]->type() )
1041 {
1042 case Qgis::LightSourceType::Point:
1043 if ( *static_cast< QgsPointLightSettings * >( mLightSources[i] ) == *static_cast< QgsPointLightSettings * >( lights[i] ) )
1044 continue;
1045 break;
1046 case Qgis::LightSourceType::Directional:
1047 if ( *static_cast< QgsDirectionalLightSettings * >( mLightSources[i] ) == *static_cast< QgsDirectionalLightSettings * >( lights[i] ) )
1048 continue;
1049 break;
1050 }
1051 }
1052 same = false;
1053 break;
1054 }
1055 if ( same )
1056 {
1057 qDeleteAll( lights );
1058 return;
1059 }
1060 }
1061
1062 qDeleteAll( mLightSources );
1063 mLightSources = lights;
1064
1065 emit directionalLightsChanged();
1066 emit pointLightsChanged();
1067 emit lightSourcesChanged();
1068}
1069
1070float Qgs3DMapSettings::fieldOfView() const
1071{
1072 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1073
1074 return mFieldOfView;
1075}
1076
1077void Qgs3DMapSettings::setFieldOfView( const float fieldOfView )
1078{
1079 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1080
1081 if ( mFieldOfView == fieldOfView )
1082 return;
1083
1084 mFieldOfView = fieldOfView;
1085 emit fieldOfViewChanged();
1086}
1087
1088Qt3DRender::QCameraLens::ProjectionType Qgs3DMapSettings::projectionType() const
1089{
1090 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1091
1092 return mProjectionType;
1093}
1094
1095void Qgs3DMapSettings::setProjectionType( const Qt3DRender::QCameraLens::ProjectionType projectionType )
1096{
1097 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1098
1099 if ( mProjectionType == projectionType )
1100 return;
1101
1102 mProjectionType = projectionType;
1103 emit projectionTypeChanged();
1104}
1105
1106Qgis::NavigationMode Qgs3DMapSettings::cameraNavigationMode() const
1107{
1108 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1109
1110 return mCameraNavigationMode;
1111}
1112
1113void Qgs3DMapSettings::setCameraNavigationMode( Qgis::NavigationMode navigationMode )
1114{
1115 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1116
1117 if ( mCameraNavigationMode == navigationMode )
1118 return;
1119
1120 mCameraNavigationMode = navigationMode;
1121 emit cameraNavigationModeChanged();
1122}
1123
1124double Qgs3DMapSettings::cameraMovementSpeed() const
1125{
1126 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1127
1128 return mCameraMovementSpeed;
1129}
1130
1131void Qgs3DMapSettings::setCameraMovementSpeed( double movementSpeed )
1132{
1133 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1134
1135 if ( mCameraMovementSpeed == movementSpeed )
1136 return;
1137
1138 mCameraMovementSpeed = movementSpeed;
1139 emit cameraMovementSpeedChanged();
1140}
1141
1142void Qgs3DMapSettings::setOutputDpi( const double dpi )
1143{
1144 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1145
1146 mDpi = dpi;
1147}
1148
1149double Qgs3DMapSettings::outputDpi() const
1150{
1151 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1152
1153 return mDpi;
1154}
1155
1156QgsSkyboxSettings Qgs3DMapSettings::skyboxSettings() const
1157{
1158 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1159
1160 return mSkyboxSettings;
1161}
1162
1163QgsShadowSettings Qgs3DMapSettings::shadowSettings() const
1164{
1165 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1166
1167 return mShadowSettings;
1168}
1169
1170QgsAmbientOcclusionSettings Qgs3DMapSettings::ambientOcclusionSettings() const
1171{
1172 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1173
1174 return mAmbientOcclusionSettings;
1175}
1176
1177void Qgs3DMapSettings::setSkyboxSettings( const QgsSkyboxSettings &skyboxSettings )
1178{
1179 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1180
1181 mSkyboxSettings = skyboxSettings;
1182 emit skyboxSettingsChanged();
1183}
1184
1185void Qgs3DMapSettings::setShadowSettings( const QgsShadowSettings &shadowSettings )
1186{
1187 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1188
1189 mShadowSettings = shadowSettings;
1190 emit shadowSettingsChanged();
1191}
1192
1193void Qgs3DMapSettings::setAmbientOcclusionSettings( const QgsAmbientOcclusionSettings &ambientOcclusionSettings )
1194{
1195 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1196
1197 mAmbientOcclusionSettings = ambientOcclusionSettings;
1198 emit ambientOcclusionSettingsChanged();
1199}
1200
1201bool Qgs3DMapSettings::isSkyboxEnabled() const
1202{
1203 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1204
1205 return mIsSkyboxEnabled;
1206}
1207
1208void Qgs3DMapSettings::setIsSkyboxEnabled( bool enabled )
1209{
1210 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1211
1212 mIsSkyboxEnabled = enabled;
1213}
1214
1215bool Qgs3DMapSettings::isFpsCounterEnabled() const
1216{
1217 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1218
1219 return mIsFpsCounterEnabled;
1220}
1221
1222void Qgs3DMapSettings::setDebugShadowMapSettings( bool enabled, Qt::Corner corner, double size )
1223{
1224 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1225
1226 mDebugShadowMapEnabled = enabled;
1227 mDebugShadowMapCorner = corner;
1228 mDebugShadowMapSize = size;
1229 emit debugShadowMapSettingsChanged();
1230}
1231
1232bool Qgs3DMapSettings::debugShadowMapEnabled() const
1233{
1234 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1235
1236 return mDebugShadowMapEnabled;
1237}
1238
1239Qt::Corner Qgs3DMapSettings::debugShadowMapCorner() const
1240{
1241 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1242
1243 return mDebugShadowMapCorner;
1244}
1245
1246double Qgs3DMapSettings::debugShadowMapSize() const
1247{
1248 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1249
1250 return mDebugShadowMapSize;
1251}
1252
1253void Qgs3DMapSettings::setDebugDepthMapSettings( bool enabled, Qt::Corner corner, double size )
1254{
1255 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1256
1257 mDebugDepthMapEnabled = enabled;
1258 mDebugDepthMapCorner = corner;
1259 mDebugDepthMapSize = size;
1260 emit debugDepthMapSettingsChanged();
1261}
1262
1263bool Qgs3DMapSettings::debugDepthMapEnabled() const
1264{
1265 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1266
1267 return mDebugDepthMapEnabled;
1268}
1269
1270Qt::Corner Qgs3DMapSettings::debugDepthMapCorner() const
1271{
1272 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1273
1274 return mDebugDepthMapCorner;
1275}
1276
1277double Qgs3DMapSettings::debugDepthMapSize() const
1278{
1279 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1280
1281 return mDebugDepthMapSize;
1282}
1283
1284void Qgs3DMapSettings::setIsFpsCounterEnabled( bool fpsCounterEnabled )
1285{
1286 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1287
1288 if ( fpsCounterEnabled == mIsFpsCounterEnabled )
1289 return;
1290 mIsFpsCounterEnabled = fpsCounterEnabled;
1291 emit fpsCounterEnabledChanged( mIsFpsCounterEnabled );
1292}
1293
1294bool Qgs3DMapSettings::terrainRenderingEnabled() const
1295{
1296 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1297
1298 return mTerrainRenderingEnabled;
1299}
1300
1301void Qgs3DMapSettings::setTerrainRenderingEnabled( bool terrainRenderingEnabled )
1302{
1303 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1304
1305 if ( terrainRenderingEnabled == mTerrainRenderingEnabled )
1306 return;
1307 mTerrainRenderingEnabled = terrainRenderingEnabled;
1308 emit terrainGeneratorChanged();
1309}
1310
1311Qgis::RendererUsage Qgs3DMapSettings::rendererUsage() const
1312{
1313 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1314
1315 return mRendererUsage;
1316}
1317
1318void Qgs3DMapSettings::setRendererUsage( Qgis::RendererUsage rendererUsage )
1319{
1320 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1321
1322 mRendererUsage = rendererUsage;
1323}
1324
1331
1332void Qgs3DMapSettings::setViewSyncMode( Qgis::ViewSyncModeFlags mode )
1333{
1334 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1335
1336 mViewSyncMode = mode;
1337}
1338
1339bool Qgs3DMapSettings::viewFrustumVisualizationEnabled() const
1340{
1341 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1342
1343 return mVisualizeViewFrustum;
1344}
1345
1346void Qgs3DMapSettings::setViewFrustumVisualizationEnabled( bool enabled )
1347{
1348 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1349
1350 if ( mVisualizeViewFrustum != enabled )
1351 {
1352 mVisualizeViewFrustum = enabled;
1353 emit viewFrustumVisualizationEnabledChanged();
1354 }
1355}
1356
1357Qgs3DAxisSettings Qgs3DMapSettings::get3DAxisSettings() const
1358{
1359 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1360
1361 return m3dAxisSettings;
1362}
1363
1364void Qgs3DMapSettings::setIsDebugOverlayEnabled( bool debugOverlayEnabled )
1365{
1366 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1367
1368 if ( debugOverlayEnabled == mIsDebugOverlayEnabled )
1369 return;
1370
1371 mIsDebugOverlayEnabled = debugOverlayEnabled;
1372 emit debugOverlayEnabledChanged( mIsDebugOverlayEnabled );
1373}
1374
1375bool Qgs3DMapSettings::showExtentIn2DView() const
1376{
1377 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1378
1379 return mShowExtentIn2DView;
1380}
1381
1382void Qgs3DMapSettings::connectChangedSignalsToSettingsChanged()
1383{
1384 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1385
1386 connect( this, &Qgs3DMapSettings::selectionColorChanged, this, &Qgs3DMapSettings::settingsChanged );
1387 connect( this, &Qgs3DMapSettings::layersChanged, this, &Qgs3DMapSettings::settingsChanged );
1388 connect( this, &Qgs3DMapSettings::terrainGeneratorChanged, this, &Qgs3DMapSettings::settingsChanged );
1389 connect( this, &Qgs3DMapSettings::terrainVerticalScaleChanged, this, &Qgs3DMapSettings::settingsChanged );
1390 connect( this, &Qgs3DMapSettings::mapTileResolutionChanged, this, &Qgs3DMapSettings::settingsChanged );
1391 connect( this, &Qgs3DMapSettings::maxTerrainScreenErrorChanged, this, &Qgs3DMapSettings::settingsChanged );
1392 connect( this, &Qgs3DMapSettings::maxTerrainGroundErrorChanged, this, &Qgs3DMapSettings::settingsChanged );
1393 connect( this, &Qgs3DMapSettings::terrainElevationOffsetChanged, this, &Qgs3DMapSettings::settingsChanged );
1394 connect( this, &Qgs3DMapSettings::terrainShadingChanged, this, &Qgs3DMapSettings::settingsChanged );
1395 connect( this, &Qgs3DMapSettings::terrainMapThemeChanged, this, &Qgs3DMapSettings::settingsChanged );
1396 connect( this, &Qgs3DMapSettings::renderersChanged, this, &Qgs3DMapSettings::settingsChanged );
1397 connect( this, &Qgs3DMapSettings::showTerrainBoundingBoxesChanged, this, &Qgs3DMapSettings::settingsChanged );
1398 connect( this, &Qgs3DMapSettings::showTerrainTilesInfoChanged, this, &Qgs3DMapSettings::settingsChanged );
1399 connect( this, &Qgs3DMapSettings::showCameraViewCenterChanged, this, &Qgs3DMapSettings::settingsChanged );
1400 connect( this, &Qgs3DMapSettings::showCameraRotationCenterChanged, this, &Qgs3DMapSettings::settingsChanged );
1401 connect( this, &Qgs3DMapSettings::showLightSourceOriginsChanged, this, &Qgs3DMapSettings::settingsChanged );
1402 connect( this, &Qgs3DMapSettings::eyeDomeLightingEnabledChanged, this, &Qgs3DMapSettings::settingsChanged );
1403 connect( this, &Qgs3DMapSettings::eyeDomeLightingStrengthChanged, this, &Qgs3DMapSettings::settingsChanged );
1404 connect( this, &Qgs3DMapSettings::eyeDomeLightingDistanceChanged, this, &Qgs3DMapSettings::settingsChanged );
1405 connect( this, &Qgs3DMapSettings::debugShadowMapSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1406 connect( this, &Qgs3DMapSettings::debugDepthMapSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1407 connect( this, &Qgs3DMapSettings::lightSourcesChanged, this, &Qgs3DMapSettings::settingsChanged );
1408 connect( this, &Qgs3DMapSettings::fieldOfViewChanged, this, &Qgs3DMapSettings::settingsChanged );
1409 connect( this, &Qgs3DMapSettings::projectionTypeChanged, this, &Qgs3DMapSettings::settingsChanged );
1410 connect( this, &Qgs3DMapSettings::cameraNavigationModeChanged, this, &Qgs3DMapSettings::settingsChanged );
1411 connect( this, &Qgs3DMapSettings::cameraMovementSpeedChanged, this, &Qgs3DMapSettings::settingsChanged );
1412 connect( this, &Qgs3DMapSettings::skyboxSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1413 connect( this, &Qgs3DMapSettings::shadowSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1414 connect( this, &Qgs3DMapSettings::fpsCounterEnabledChanged, this, &Qgs3DMapSettings::settingsChanged );
1415 connect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1416 connect( this, &Qgs3DMapSettings::ambientOcclusionSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1417 connect( this, &Qgs3DMapSettings::extentChanged, this, &Qgs3DMapSettings::settingsChanged );
1418 connect( this, &Qgs3DMapSettings::showExtentIn2DViewChanged, this, &Qgs3DMapSettings::settingsChanged );
1419}
1420
1421
1422void Qgs3DMapSettings::set3DAxisSettings( const Qgs3DAxisSettings &axisSettings, bool force )
1423{
1424 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1425
1426 if ( axisSettings == m3dAxisSettings )
1427 {
1428 if ( force )
1429 {
1430 // ie. refresh. We need to disconnect and to reconnect to avoid 'dirty' project
1431 disconnect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1432 emit axisSettingsChanged();
1433 connect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1434 }
1435 }
1436 else
1437 {
1438 m3dAxisSettings = axisSettings;
1439 emit axisSettingsChanged();
1440 }
1441}
1442
1443bool Qgs3DMapSettings::isDebugOverlayEnabled() const
1444{
1445 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1446
1447 return mIsDebugOverlayEnabled;
1448}
1449
1450void Qgs3DMapSettings::setShowExtentIn2DView( bool show )
1451{
1452 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1453
1454 if ( show == mShowExtentIn2DView )
1455 return;
1456
1457 mShowExtentIn2DView = show;
1458 emit showExtentIn2DViewChanged();
1459}
Qgis::ViewSyncModeFlags
QFlags< ViewSyncModeFlag > ViewSyncModeFlags
Definition qgis.h:3088
Qgis::NavigationMode
NavigationMode
The navigation mode used by 3D cameras.
Definition qgis.h:3726
Qgis::NavigationMode::TerrainBased
@ TerrainBased
The default navigation based on the terrain.
Qgis::NavigationMode::Walk
@ Walk
Uses WASD keys or arrows to navigate in walking (first person) manner.
Qgis::RendererUsage
RendererUsage
Usage of the renderer.
Definition qgis.h:3070
Qgis::LightSourceType::Point
@ Point
Point light source.
Qgis::LightSourceType::Directional
@ Directional
Directional light source.
Qgs3DAxisSettings
Contains the configuration of a 3d axis.
Definition qgs3daxissettings.h:36
Qgs3DAxisSettings::readXml
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
Definition qgs3daxissettings.cpp:38
Qgs3DAxisSettings::writeXml
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
Definition qgs3daxissettings.cpp:77
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:987
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::isDebugOverlayEnabled
bool isDebugOverlayEnabled() const
Returns whether debug overlay is enabled.
Definition qgs3dmapsettings.cpp:1443
Qgs3DMapSettings::debugDepthMapCorner
Qt::Corner debugDepthMapCorner() const
Returns the corner where the shadow map preview is displayed.
Definition qgs3dmapsettings.cpp:1270
Qgs3DMapSettings::setTransformContext
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the coordinate transform context, which stores various information regarding which datum transfo...
Definition qgs3dmapsettings.cpp:543
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:120
Qgs3DMapSettings::terrainShadingChanged
void terrainShadingChanged()
Emitted when terrain shading enabled flag or terrain shading material has changed.
Qgs3DMapSettings::pathResolver
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
Definition qgs3dmapsettings.cpp:550
Qgs3DMapSettings::setAmbientOcclusionSettings
void setAmbientOcclusionSettings(const QgsAmbientOcclusionSettings &ambientOcclusionSettings)
Sets the current configuration of screen space ambient occlusion.
Definition qgs3dmapsettings.cpp:1193
Qgs3DMapSettings::setShowTerrainTilesInfo
void setShowTerrainTilesInfo(bool enabled)
Sets whether to display extra tile info on top of terrain tiles (for debugging)
Definition qgs3dmapsettings.cpp:880
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:508
Qgs3DMapSettings::showExtentIn2DView
bool showExtentIn2DView() const
Returns whether the extent is displayed on the main 2D map canvas.
Definition qgs3dmapsettings.cpp:1375
Qgs3DMapSettings::cameraMovementSpeed
double cameraMovementSpeed() const
Returns the camera movement speed.
Definition qgs3dmapsettings.cpp:1124
Qgs3DMapSettings::projectionType
Qt3DRender::QCameraLens::ProjectionType projectionType() const
Returns the camera lens' projection type.
Definition qgs3dmapsettings.cpp:1088
Qgs3DMapSettings::setEyeDomeLightingEnabled
void setEyeDomeLightingEnabled(bool enabled)
Sets whether eye dome lighting will be used.
Definition qgs3dmapsettings.cpp:970
Qgs3DMapSettings::debugDepthMapEnabled
bool debugDepthMapEnabled() const
Returns whether the shadow map debugging is enabled.
Definition qgs3dmapsettings.cpp:1263
Qgs3DMapSettings::isSkyboxEnabled
bool isSkyboxEnabled() const
Returns whether the skybox is enabled.
Definition qgs3dmapsettings.cpp:1201
Qgs3DMapSettings::setFieldOfView
void setFieldOfView(const float fieldOfView)
Sets the camera lens' field of view.
Definition qgs3dmapsettings.cpp:1077
Qgs3DMapSettings::debugDepthMapSettingsChanged
void debugDepthMapSettingsChanged()
Emitted when depth map debugging has changed.
Qgs3DMapSettings::setLightSources
void setLightSources(const QList< QgsLightSource * > &lights)
Sets the list of light sources defined in the scene.
Definition qgs3dmapsettings.cpp:1028
Qgs3DMapSettings::outputDpi
double outputDpi() const
Returns DPI used for conversion between real world units (e.g.
Definition qgs3dmapsettings.cpp:1149
Qgs3DMapSettings::cameraNavigationMode
Qgis::NavigationMode cameraNavigationMode() const
Returns the navigation mode used by the camera.
Definition qgs3dmapsettings.cpp:1106
Qgs3DMapSettings::eyeDomeLightingStrength
double eyeDomeLightingStrength() const
Returns the eye dome lighting strength value.
Definition qgs3dmapsettings.cpp:997
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::debugShadowMapCorner
Qt::Corner debugShadowMapCorner() const
Returns the corner where the shadow map preview is displayed.
Definition qgs3dmapsettings.cpp:1239
Qgs3DMapSettings::setMapThemeCollection
void setMapThemeCollection(QgsMapThemeCollection *mapThemes)
Sets pointer to the collection of map themes.
Definition qgs3dmapsettings.cpp:571
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:319
Qgs3DMapSettings::setDebugDepthMapSettings
void setDebugDepthMapSettings(bool enabled, Qt::Corner corner, double size)
Sets the debugging settings of the depth map.
Definition qgs3dmapsettings.cpp:1253
Qgs3DMapSettings::showCameraViewCenter
bool showCameraViewCenter() const
Returns whether to show camera's view center as a sphere (for debugging)
Definition qgs3dmapsettings.cpp:909
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:607
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:825
Qgs3DMapSettings::cameraNavigationModeChanged
void cameraNavigationModeChanged()
Emitted when the camera navigation mode was changed.
Qgs3DMapSettings::shadowSettingsChanged
void shadowSettingsChanged()
Emitted when shadow rendering settings are changed.
Qgs3DMapSettings::setViewFrustumVisualizationEnabled
void setViewFrustumVisualizationEnabled(bool enabled)
Sets whether the camera's view frustum is visualized on the 2D map canvas.
Definition qgs3dmapsettings.cpp:1346
Qgs3DMapSettings::setShowCameraRotationCenter
void setShowCameraRotationCenter(bool enabled)
Sets whether to show camera's rotation center as a sphere (for debugging)
Definition qgs3dmapsettings.cpp:916
Qgs3DMapSettings::maxTerrainGroundError
float maxTerrainGroundError() const
Returns maximum ground error of terrain tiles in world units.
Definition qgs3dmapsettings.cpp:776
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:476
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:614
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:1142
Qgs3DMapSettings::setIsSkyboxEnabled
void setIsSkyboxEnabled(bool enabled)
Sets whether the skybox is enabled.
Definition qgs3dmapsettings.cpp:1208
Qgs3DMapSettings::setShowLabels
void setShowLabels(bool enabled)
Sets whether to display labels on terrain tiles.
Definition qgs3dmapsettings.cpp:952
Qgs3DMapSettings::terrainVerticalScale
double terrainVerticalScale() const
Returns vertical scale (exaggeration) of terrain.
Definition qgs3dmapsettings.cpp:625
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:1332
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:494
Qgs3DMapSettings::setMaxTerrainGroundError
void setMaxTerrainGroundError(float error)
Returns maximum ground error of terrain tiles in world units.
Definition qgs3dmapsettings.cpp:748
Qgs3DMapSettings::setSkyboxSettings
void setSkyboxSettings(const QgsSkyboxSettings &skyboxSettings)
Sets the current configuration of the skybox.
Definition qgs3dmapsettings.cpp:1177
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:712
Qgs3DMapSettings::setLayers
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of 3D map layers to be rendered in the scene.
Definition qgs3dmapsettings.cpp:632
Qgs3DMapSettings::shadowSettings
QgsShadowSettings shadowSettings() const
Returns the current configuration of shadows.
Definition qgs3dmapsettings.cpp:1163
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:1185
Qgs3DMapSettings::setIsDebugOverlayEnabled
void setIsDebugOverlayEnabled(bool debugOverlayEnabled)
Sets whether debug overlay is enabled The debug overlay displays some debugging and profiling informa...
Definition qgs3dmapsettings.cpp:1364
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:759
Qgs3DMapSettings::lightSources
QList< QgsLightSource * > lightSources() const
Returns list of directional light sources defined in the scene.
Definition qgs3dmapsettings.cpp:1021
Qgs3DMapSettings::debugDepthMapSize
double debugDepthMapSize() const
Returns the size of the shadow map preview.
Definition qgs3dmapsettings.cpp:1277
Qgs3DMapSettings::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets coordinate reference system used in the 3D scene.
Definition qgs3dmapsettings.cpp:522
Qgs3DMapSettings::get3DAxisSettings
Qgs3DAxisSettings get3DAxisSettings() const
Returns the current configuration of 3d axis.
Definition qgs3dmapsettings.cpp:1357
Qgs3DMapSettings::setEyeDomeLightingDistance
void setEyeDomeLightingDistance(int distance)
Sets the eye dome lighting distance value (contributes to the contrast of the image.
Definition qgs3dmapsettings.cpp:1004
Qgs3DMapSettings::viewFrustumVisualizationEnabled
bool viewFrustumVisualizationEnabled() const
Returns whether the camera's view frustum is visualized on the 2D map canvas.
Definition qgs3dmapsettings.cpp:1339
Qgs3DMapSettings::setShowLightSourceOrigins
void setShowLightSourceOrigins(bool enabled)
Sets whether to show light source origins as a sphere (for debugging)
Definition qgs3dmapsettings.cpp:934
Qgs3DMapSettings::setShowExtentIn2DView
void setShowExtentIn2DView(bool show)
Sets whether the extent is displayed on the main 2D map canvas.
Definition qgs3dmapsettings.cpp:1450
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:1070
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:1170
Qgs3DMapSettings::extent
QgsRectangle extent() const
Returns the 3D scene's 2D extent in the 3D scene's CRS.
Definition qgs3dmapsettings.cpp:469
Qgs3DMapSettings::setTerrainShadingEnabled
void setTerrainShadingEnabled(bool enabled)
Sets whether terrain shading is enabled.
Definition qgs3dmapsettings.cpp:807
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:1325
Qgs3DMapSettings::setDebugShadowMapSettings
void setDebugShadowMapSettings(bool enabled, Qt::Corner corner, double size)
Sets the debugging settings of the shadow map.
Definition qgs3dmapsettings.cpp:1222
Qgs3DMapSettings::terrainElevationOffset
float terrainElevationOffset() const
Returns the elevation offset of the terrain (used to move the terrain up or down)
Definition qgs3dmapsettings.cpp:769
Qgs3DMapSettings::eyeDomeLightingDistance
int eyeDomeLightingDistance() const
Returns the eye dome lighting distance value (contributes to the contrast of the image)
Definition qgs3dmapsettings.cpp:1014
Qgs3DMapSettings::setSelectionColor
void setSelectionColor(const QColor &color)
Sets color used for selected features.
Definition qgs3dmapsettings.cpp:596
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:800
Qgs3DMapSettings::setCameraNavigationMode
void setCameraNavigationMode(Qgis::NavigationMode navigationMode)
Sets the navigation mode for the camera.
Definition qgs3dmapsettings.cpp:1113
Qgs3DMapSettings::backgroundColor
QColor backgroundColor() const
Returns background color of the 3D map view.
Definition qgs3dmapsettings.cpp:589
Qgs3DMapSettings::resolveReferences
void resolveReferences(const QgsProject &project)
Resolves references to other objects (map layers) after the call to readXml()
Definition qgs3dmapsettings.cpp:456
Qgs3DMapSettings::debugShadowMapSize
double debugShadowMapSize() const
Returns the size of the shadow map preview.
Definition qgs3dmapsettings.cpp:1246
Qgs3DMapSettings::setPathResolver
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
Definition qgs3dmapsettings.cpp:557
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:515
Qgs3DMapSettings::showTerrainBoundingBoxes
bool showTerrainBoundingBoxes() const
Returns whether to display bounding boxes of terrain tiles (for debugging)
Definition qgs3dmapsettings.cpp:872
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:898
Qgs3DMapSettings::mapTileResolution
int mapTileResolution() const
Returns resolution (in pixels) of the texture of a terrain tile.
Definition qgs3dmapsettings.cpp:723
Qgs3DMapSettings::showLabels
bool showLabels() const
Returns whether to display labels on terrain tiles.
Definition qgs3dmapsettings.cpp:963
Qgs3DMapSettings::set3DAxisSettings
void set3DAxisSettings(const Qgs3DAxisSettings &axisSettings, bool force=false)
Sets the current configuration of 3d axis.
Definition qgs3dmapsettings.cpp:1422
Qgs3DMapSettings::setCameraMovementSpeed
void setCameraMovementSpeed(double movementSpeed)
Sets the camera movement speed.
Definition qgs3dmapsettings.cpp:1131
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:1301
Qgs3DMapSettings::debugShadowMapEnabled
bool debugShadowMapEnabled() const
Returns whether the shadow map debugging is enabled.
Definition qgs3dmapsettings.cpp:1232
Qgs3DMapSettings::setBackgroundColor
void setBackgroundColor(const QColor &color)
Sets background color of the 3D map view.
Definition qgs3dmapsettings.cpp:578
Qgs3DMapSettings::terrainRenderingEnabled
bool terrainRenderingEnabled() const
Returns whether the 2D terrain surface will be rendered.
Definition qgs3dmapsettings.cpp:1294
Qgs3DMapSettings::fpsCounterEnabledChanged
void fpsCounterEnabledChanged(bool fpsCounterEnabled)
Emitted when the FPS counter is enabled or disabled.
Qgs3DMapSettings::axisSettingsChanged
void axisSettingsChanged()
Emitted when 3d axis rendering settings are changed.
Qgs3DMapSettings::viewFrustumVisualizationEnabledChanged
void viewFrustumVisualizationEnabledChanged()
Emitted when the camera's view frustum visualization on the main 2D map canvas is enabled or disabled...
Qgs3DMapSettings::setProjectionType
void setProjectionType(const Qt3DRender::QCameraLens::ProjectionType projectionType)
Sets the camera lens' projection type.
Definition qgs3dmapsettings.cpp:1095
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:891
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:664
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.cpp:1156
Qgs3DMapSettings::setMaxTerrainScreenError
void setMaxTerrainScreenError(float error)
Sets maximum allowed screen error of terrain tiles in pixels.
Definition qgs3dmapsettings.cpp:730
Qgs3DMapSettings::isTerrainShadingEnabled
bool isTerrainShadingEnabled() const
Returns whether terrain shading is enabled.
Definition qgs3dmapsettings.cpp:818
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:529
Qgs3DMapSettings::eyeDomeLightingEnabled
bool eyeDomeLightingEnabled() const
Returns whether eye dome lighting is used.
Definition qgs3dmapsettings.cpp:980
Qgs3DMapSettings::terrainShadingMaterial
QgsPhongMaterialSettings terrainShadingMaterial() const
Returns terrain shading material.
Definition qgs3dmapsettings.cpp:836
Qgs3DMapSettings::setRendererUsage
void setRendererUsage(Qgis::RendererUsage rendererUsage)
Sets the renderer usage.
Definition qgs3dmapsettings.cpp:1318
Qgs3DMapSettings::isFpsCounterEnabled
bool isFpsCounterEnabled() const
Returns whether FPS counter label is enabled.
Definition qgs3dmapsettings.cpp:1215
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:854
Qgs3DMapSettings::maxTerrainScreenError
float maxTerrainScreenError() const
Returns maximum allowed screen error of terrain tiles in pixels.
Definition qgs3dmapsettings.cpp:741
Qgs3DMapSettings::setShowTerrainBoundingBoxes
void setShowTerrainBoundingBoxes(bool enabled)
Sets whether to display bounding boxes of terrain tiles (for debugging)
Definition qgs3dmapsettings.cpp:861
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:1311
Qgs3DMapSettings::setIsFpsCounterEnabled
void setIsFpsCounterEnabled(bool fpsCounterEnabled)
Sets whether FPS counter label is enabled.
Definition qgs3dmapsettings.cpp:1284
Qgs3DMapSettings::mapThemeCollection
QgsMapThemeCollection * mapThemeCollection() const
Returns pointer to the collection of map themes.
Definition qgs3dmapsettings.cpp:564
Qgs3DMapSettings::layers
QList< QgsMapLayer * > layers() const
Returns the list of 3D map layers to be rendered in the scene.
Definition qgs3dmapsettings.cpp:650
Qgs3DMapSettings::setTerrainMapTheme
void setTerrainMapTheme(const QString &theme)
Sets name of the map theme.
Definition qgs3dmapsettings.cpp:843
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:945
Qgs3DMapSettings::setTerrainGenerator
void setTerrainGenerator(QgsTerrainGenerator *gen)
Sets terrain generator and sets extent() as the generator's extent.
Definition qgs3dmapsettings.cpp:783
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:536
Qgs3DMapSettings::origin
QgsVector3D origin() const
Returns coordinates in map CRS at which 3D scene has origin (0,0,0).
Definition qgs3dmapsettings.cpp:501
Qgs3DMapSettings::showCameraRotationCenter
bool showCameraRotationCenter() const
Returns whether to show camera's rotation center as a sphere (for debugging)
Definition qgs3dmapsettings.cpp:927
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:589
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:582
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:574
QgsAbstractTerrainProvider::type
virtual QString type() const =0
Returns the unique type ID string for the provider.
QgsAbstractTerrainProvider::offset
double offset() const
Returns the vertical offset value, used for adjusting the heights from the terrain provider.
Definition qgsterrainprovider.h:146
QgsAbstractTerrainProvider::scale
double scale() const
Returns the vertical scale factor, which can be used to exaggerate vertical heights.
Definition qgsterrainprovider.h:130
QgsAmbientOcclusionSettings
class containing the configuration of ambient occlusion rendering 3
Definition qgsambientocclusionsettings.h:36
QgsAmbientOcclusionSettings::writeXml
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
Definition qgsambientocclusionsettings.cpp:51
QgsAmbientOcclusionSettings::readXml
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
Definition qgsambientocclusionsettings.cpp:41
QgsColorUtils::colorFromString
static QColor colorFromString(const QString &string)
Decodes a string into a color value.
Definition qgscolorutils.cpp:296
QgsColorUtils::colorToString
static QString colorToString(const QColor &color)
Encodes a color into a string value.
Definition qgscolorutils.cpp:193
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:2026
QgsCoordinateReferenceSystem::writeXml
bool writeXml(QDomNode &node, QDomDocument &doc) const
Stores state to the given Dom node in the given document.
Definition qgscoordinatereferencesystem.cpp:2146
QgsCoordinateTransformContext
Contains information about the context in which a coordinate transform is executed.
Definition qgscoordinatetransformcontext.h:57
QgsDemTerrainGenerator::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets CRS of the terrain.
Definition qgsdemterraingenerator.cpp:40
QgsDemTerrainGenerator::setLayer
void setLayer(QgsRasterLayer *layer)
Sets raster layer with elevation model to be used for terrain generation.
Definition qgsdemterraingenerator.cpp:29
QgsFlatTerrainGenerator::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets CRS of the terrain.
Definition qgsflatterraingenerator.cpp:132
QgsLightSource::createFromXml
static QgsLightSource * createFromXml(const QDomElement &element, const QgsReadWriteContext &context)
Creates a new light source from an XML element.
Definition qgslightsource.cpp:30
QgsMapLayer
Base class for all map layer types.
Definition qgsmaplayer.h:76
QgsMapThemeCollection
Container class that allows storage of map themes consisting of visible map layers and layer styles.
Definition qgsmapthemecollection.h:44
QgsMeshTerrainProvider
A terrain provider that uses the Z values of a mesh layer to build a terrain surface.
Definition qgsterrainprovider.h:268
QgsMeshTerrainProvider::layer
QgsMeshLayer * layer() const
Returns the mesh layer to be used as the terrain source.
Definition qgsterrainprovider.cpp:321
QgsOnlineTerrainGenerator::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets CRS of the terrain.
Definition qgsonlineterraingenerator.cpp:93
QgsPathResolver
Resolves relative paths into absolute paths and vice versa.
Definition qgspathresolver.h:31
QgsPhongMaterialSettings::writeXml
void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const override
Writes settings to a DOM element.
Definition qgsphongmaterialsettings.cpp:91
QgsPhongMaterialSettings::readXml
void readXml(const QDomElement &elem, const QgsReadWriteContext &context) override
Reads settings from a DOM element.
Definition qgsphongmaterialsettings.cpp:77
QgsPointXY
A class to represent a 2D point.
Definition qgspointxy.h:60
QgsPointXY::y
double y
Definition qgspointxy.h:64
QgsPointXY::x
double x
Definition qgspointxy.h:63
QgsProjectDirtyBlocker
Temporarily blocks QgsProject "dirtying" for the lifetime of the object.
Definition qgsproject.h:2508
QgsProjectElevationProperties
Contains elevation properties for a QgsProject.
Definition qgsprojectelevationproperties.h:39
QgsProjectElevationProperties::terrainProvider
QgsAbstractTerrainProvider * terrainProvider()
Returns the project's terrain provider.
Definition qgsprojectelevationproperties.cpp:116
QgsProjectViewSettings::fullExtent
QgsReferencedRectangle fullExtent() const
Returns the full extent of the project, which represents the maximal limits of the project.
Definition qgsprojectviewsettings.cpp:73
QgsProject
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:107
QgsProject::instance
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition qgsproject.cpp:481
QgsProject::mapLayer
Q_INVOKABLE QgsMapLayer * mapLayer(const QString &layerId) const
Retrieve a pointer to a registered layer by layer ID.
Definition qgsproject.cpp:4515
QgsProject::setDirty
void setDirty(bool b=true)
Flag the project as dirty (modified).
Definition qgsproject.cpp:599
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:4262
QgsRasterDemTerrainProvider
A terrain provider where the terrain source is a raster DEM layer.
Definition qgsterrainprovider.h:218
QgsRasterDemTerrainProvider::layer
QgsRasterLayer * layer() const
Returns the raster layer with elevation model to be used as the terrain source.
Definition qgsterrainprovider.cpp:213
QgsReadWriteContext
The class is used as a container of context for various read/write operations on other objects.
Definition qgsreadwritecontext.h:34
QgsRectangle
A rectangle specified with double values.
Definition qgsrectangle.h:42
QgsRectangle::xMinimum
double xMinimum() const
Returns the x minimum value (left side of rectangle).
Definition qgsrectangle.h:200
QgsRectangle::yMinimum
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
Definition qgsrectangle.h:210
QgsRectangle::xMaximum
double xMaximum() const
Returns the x maximum value (right side of rectangle).
Definition qgsrectangle.h:195
QgsRectangle::yMaximum
double yMaximum() const
Returns the y maximum value (top side of rectangle).
Definition qgsrectangle.h:205
QgsRectangle::center
QgsPointXY center() const
Returns the center point of the rectangle.
Definition qgsrectangle.h:261
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
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
QgsTemporalRange::begin
T begin() const
Returns the beginning of the range.
Definition qgsrange.h:444
QgsTemporalRange::end
T end() const
Returns the upper bound of the range.
Definition qgsrange.h:451
QgsTerrainGenerator::terrainChanged
void terrainChanged()
Emitted when the terrain changed (for example, raster DEM or mesh have data changed)
QgsTerrainGenerator::crs
QgsCoordinateReferenceSystem crs() const
Returns CRS of the terrain.
Definition qgsterraingenerator.h:109
QgsTerrainGenerator::setExtent
virtual void setExtent(const QgsRectangle &extent)
sets the extent of the terrain in terrain's CRS
Definition qgsterraingenerator.h:76
QgsTerrainGenerator::typeToString
static QString typeToString(Type type)
Converts terrain generator type enumeration into a string.
Definition qgsterraingenerator.cpp:55
QgsVector3D
Class for storage of 3D vectors similar to QVector3D, with the difference that it uses double precisi...
Definition qgsvector3d.h:31
QgsVector3D::y
double y() const
Returns Y coordinate.
Definition qgsvector3d.h:50
QgsVector3D::z
double z() const
Returns Z coordinate.
Definition qgsvector3d.h:52
QgsVector3D::x
double x() const
Returns X coordinate.
Definition qgsvector3d.h:48
QgsMapLayerRef
_LayerRef< QgsMapLayer > QgsMapLayerRef
Definition qgsmaplayerref.h:328
QgsDateTimeRange
QgsTemporalRange< QDateTime > QgsDateTimeRange
QgsRange which stores a range of date times.
Definition qgsrange.h:742
QGIS_PROTECT_QOBJECT_THREAD_ACCESS
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS
Definition qgsthreadingutils.h:42
crs
const QgsCoordinateReferenceSystem & crs
Definition qgswfsgetfeature.cpp:53
_LayerRef< QgsMapLayer >
_LayerRef::setLayer
void setLayer(TYPE *l)
Sets the reference to point to a specified layer.
Definition qgsmaplayerref.h:79
_LayerRef::layerId
QString layerId
Original layer ID.
Definition qgsmaplayerref.h:118
Generated on Mon Sep 9 2024 12:20:57 for QGIS API Documentation by doxygen 1.9.8