QGIS API Documentation 4.1.0-Master (01362494303)
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 "qgs3d.h"
19#include "qgs3drendercontext.h"
20#include "qgs3dterrainregistry.h"
21#include "qgs3dutils.h"
22#include "qgsabstractterrainsettings.h"
23#include "qgscolorutils.h"
24#include "qgsdirectionallightsettings.h"
25#include "qgsflatterrainsettings.h"
26#include "qgslightsource.h"
27#include "qgsmaplayerlistutils_p.h"
28#include "qgspointlightsettings.h"
29#include "qgsprojectelevationproperties.h"
30#include "qgsprojectviewsettings.h"
31#include "qgsrasterlayer.h"
32#include "qgsterrainprovider.h"
33#include "qgsthreadingutils.h"
34
35#include <QDomDocument>
36#include <QDomElement>
37#include <QString>
38
39#include "moc_qgs3dmapsettings.cpp"
40
41using namespace Qt::StringLiterals;
42
43Qgs3DMapSettings::Qgs3DMapSettings()
44 : QObject( nullptr )
45{
46 connect( this, &Qgs3DMapSettings::settingsChanged, [&]() { QgsProject::instance()->setDirty(); } );
47 connectChangedSignalsToSettingsChanged();
48 mTerrainSettings = std::make_unique<QgsFlatTerrainSettings>();
49}
50
51Qgs3DMapSettings::Qgs3DMapSettings( const Qgs3DMapSettings &other )
52 : QObject( nullptr )
53 , QgsTemporalRangeObject( other )
54 , mOrigin( other.mOrigin )
55 , mCrs( other.mCrs )
56 , mBackgroundColor( other.mBackgroundColor )
57 , mSelectionColor( other.mSelectionColor )
58 , mTerrainShadingEnabled( other.mTerrainShadingEnabled )
59 , mTerrainShadingMaterial( other.mTerrainShadingMaterial )
60 , mTerrainMapTheme( other.mTerrainMapTheme )
61 , mShowTerrainBoundingBoxes( other.mShowTerrainBoundingBoxes )
62 , mShowTerrainTileInfo( other.mShowTerrainTileInfo )
63 , mShowCameraViewCenter( other.mShowCameraViewCenter )
64 , mShowCameraRotationCenter( other.mShowCameraRotationCenter )
65 , mShowLightSources( other.mShowLightSources )
66 , mShowLabels( other.mShowLabels )
67 , mStopUpdates( other.mStopUpdates )
68 , mShowDebugPanel( other.mShowDebugPanel )
69 , mFieldOfView( other.mFieldOfView )
70 , mProjectionType( other.mProjectionType )
71 , mCameraNavigationMode( other.mCameraNavigationMode )
72 , mCameraMovementSpeed( other.mCameraMovementSpeed )
73 , mLayers( other.mLayers )
74 , mTransformContext( other.mTransformContext )
75 , mPathResolver( other.mPathResolver )
76 , mMapThemes( other.mMapThemes )
77 , mDpi( other.mDpi )
78 , mIsFpsCounterEnabled( other.mIsFpsCounterEnabled )
79 , mBackgroundType( other.mBackgroundType )
80 , mGradientBackgroundTopColor( other.mGradientBackgroundTopColor )
81 , mGradientBackgroundBottomColor( other.mGradientBackgroundBottomColor )
82 , mSkyboxSettings( other.mSkyboxSettings )
83 , mShadowSettings( other.mShadowSettings )
84 , mAmbientOcclusionSettings( other.mAmbientOcclusionSettings )
85 , mEyeDomeLightingEnabled( other.mEyeDomeLightingEnabled )
86 , mEyeDomeLightingStrength( other.mEyeDomeLightingStrength )
87 , mEyeDomeLightingDistance( other.mEyeDomeLightingDistance )
88 , mMsaaEnabled( other.mMsaaEnabled )
89 , mViewSyncMode( other.mViewSyncMode )
90 , mVisualizeViewFrustum( other.mVisualizeViewFrustum )
91 , mDebugShadowMapEnabled( other.mDebugShadowMapEnabled )
92 , mDebugShadowMapCorner( other.mDebugShadowMapCorner )
93 , mDebugShadowMapSize( other.mDebugShadowMapSize )
94 , mDebugDepthMapEnabled( other.mDebugDepthMapEnabled )
95 , mDebugDepthMapCorner( other.mDebugDepthMapCorner )
96 , mDebugDepthMapSize( other.mDebugDepthMapSize )
97 , mTerrainRenderingEnabled( other.mTerrainRenderingEnabled )
98 , mRendererUsage( other.mRendererUsage )
99 , m3dAxisSettings( other.m3dAxisSettings )
100 , mIsDebugOverlayEnabled( other.mIsDebugOverlayEnabled )
101 , mExtent( other.mExtent )
102 , mShowExtentIn2DView( other.mShowExtentIn2DView )
103 , mShow2DMapOverlay( other.mShow2DMapOverlay )
104{
105 setTerrainSettings( other.mTerrainSettings ? other.mTerrainSettings->clone() : new QgsFlatTerrainSettings() );
106
107 for ( QgsLightSource *source : std::as_const( other.mLightSources ) )
108 {
109 if ( source )
110 mLightSources << source->clone();
111 }
112
113 connect( this, &Qgs3DMapSettings::settingsChanged, [&]() { QgsProject::instance()->setDirty(); } );
114 connectChangedSignalsToSettingsChanged();
115}
116
117Qgs3DMapSettings::~Qgs3DMapSettings()
118{
119 qDeleteAll( mLightSources );
120}
121
122void Qgs3DMapSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
123{
124 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
125
126 QgsProjectDirtyBlocker blocker( QgsProject::instance() );
127 QDomElement elemOrigin = elem.firstChildElement( u"origin"_s );
128 // clang-format off
129 mOrigin = QgsVector3D(
130 elemOrigin.attribute( u"x"_s ).toDouble(),
131 elemOrigin.attribute( u"y"_s ).toDouble(),
132 elemOrigin.attribute( u"z"_s ).toDouble()
133 );
134 // clang-format on
135
136 QDomElement elemExtent = elem.firstChildElement( u"extent"_s );
137 if ( !elemExtent.isNull() )
138 {
139 // clang-format off
140 mExtent = QgsRectangle(
141 elemExtent.attribute( u"xMin"_s ).toDouble(),
142 elemExtent.attribute( u"yMin"_s ).toDouble(),
143 elemExtent.attribute( u"xMax"_s ).toDouble(),
144 elemExtent.attribute( u"yMax"_s ).toDouble()
145 );
146 // clang-format on
147
148 mShowExtentIn2DView = elemExtent.attribute( u"showIn2dView"_s, u"0"_s ).toInt();
149 }
150 else
151 {
152 mExtent = QgsProject::instance()->viewSettings()->fullExtent();
153 }
154
155 QDomElement elemCamera = elem.firstChildElement( u"camera"_s );
156 if ( !elemCamera.isNull() )
157 {
158 mFieldOfView = elemCamera.attribute( u"field-of-view"_s, u"45"_s ).toFloat();
159 mProjectionType = static_cast<Qt3DRender::QCameraLens::ProjectionType>( elemCamera.attribute( u"projection-type"_s, u"1"_s ).toInt() );
160 QString cameraNavigationMode = elemCamera.attribute( u"camera-navigation-mode"_s, u"basic-navigation"_s );
161 if ( cameraNavigationMode == "terrain-based-navigation"_L1 )
162 mCameraNavigationMode = Qgis::NavigationMode::TerrainBased;
163 else if ( cameraNavigationMode == "walk-navigation"_L1 )
164 mCameraNavigationMode = Qgis::NavigationMode::Walk;
165 else if ( cameraNavigationMode == "globe-terrain-based-navigation"_L1 )
166 mCameraNavigationMode = Qgis::NavigationMode::GlobeTerrainBased;
167 mCameraMovementSpeed = elemCamera.attribute( u"camera-movement-speed"_s, u"5.0"_s ).toDouble();
168 }
169
170 QDomElement elemColor = elem.firstChildElement( u"color"_s );
171 if ( !elemColor.isNull() )
172 {
173 mBackgroundColor = QgsColorUtils::colorFromString( elemColor.attribute( u"background"_s ) );
174 mSelectionColor = QgsColorUtils::colorFromString( elemColor.attribute( u"selection"_s ) );
175 }
176
177 QDomElement elemCrs = elem.firstChildElement( u"crs"_s );
178 mCrs.readXml( elemCrs );
179
180 QDomElement elemTerrain = elem.firstChildElement( u"terrain"_s );
181 mTerrainRenderingEnabled = elemTerrain.attribute( u"terrain-rendering-enabled"_s, u"1"_s ).toInt();
182 mTerrainShadingEnabled = elemTerrain.attribute( u"shading-enabled"_s, u"0"_s ).toInt();
183
184 QDomElement elemTerrainShadingMaterial = elemTerrain.firstChildElement( u"shading-material"_s );
185 if ( !elemTerrainShadingMaterial.isNull() )
186 mTerrainShadingMaterial.readXml( elemTerrainShadingMaterial, context );
187 mTerrainMapTheme = elemTerrain.attribute( u"map-theme"_s );
188 mShowLabels = elemTerrain.attribute( u"show-labels"_s, u"0"_s ).toInt();
189
190 qDeleteAll( mLightSources );
191 mLightSources.clear();
192 const QDomElement lightsElem = elem.firstChildElement( u"lights"_s );
193 if ( !lightsElem.isNull() )
194 {
195 const QDomNodeList lightNodes = lightsElem.childNodes();
196 for ( int i = 0; i < lightNodes.size(); ++i )
197 {
198 const QDomElement lightElement = lightNodes.at( i ).toElement();
199 if ( QgsLightSource *light = QgsLightSource::createFromXml( lightElement, context ) )
200 mLightSources << light;
201 }
202 }
203 else
204 {
205 // older project format
206 QDomElement elemPointLights = elem.firstChildElement( u"point-lights"_s );
207 if ( !elemPointLights.isNull() )
208 {
209 QDomElement elemPointLight = elemPointLights.firstChildElement( u"point-light"_s );
210 while ( !elemPointLight.isNull() )
211 {
212 auto pointLight = std::make_unique<QgsPointLightSettings>();
213 pointLight->readXml( elemPointLight, context );
214 mLightSources << pointLight.release();
215 elemPointLight = elemPointLight.nextSiblingElement( u"point-light"_s );
216 }
217 }
218 else
219 {
220 // QGIS <= 3.4 did not have light configuration
221 auto defaultLight = std::make_unique<QgsPointLightSettings>();
222 defaultLight->setPosition( QgsVector3D( 0, 1000, 0 ) );
223 mLightSources << defaultLight.release();
224 }
225
226 QDomElement elemDirectionalLights = elem.firstChildElement( u"directional-lights"_s );
227 if ( !elemDirectionalLights.isNull() )
228 {
229 QDomElement elemDirectionalLight = elemDirectionalLights.firstChildElement( u"directional-light"_s );
230 while ( !elemDirectionalLight.isNull() )
231 {
232 auto directionalLight = std::make_unique<QgsDirectionalLightSettings>();
233 directionalLight->readXml( elemDirectionalLight, context );
234 mLightSources << directionalLight.release();
235 elemDirectionalLight = elemDirectionalLight.nextSiblingElement( u"directional-light"_s );
236 }
237 }
238 }
239
240 QDomElement elemMapLayers = elemTerrain.firstChildElement( u"layers"_s );
241 QDomElement elemMapLayer = elemMapLayers.firstChildElement( u"layer"_s );
242 QList<QgsMapLayerRef> mapLayers;
243 while ( !elemMapLayer.isNull() )
244 {
245 mapLayers << QgsMapLayerRef( elemMapLayer.attribute( u"id"_s ) );
246 elemMapLayer = elemMapLayer.nextSiblingElement( u"layer"_s );
247 }
248 mLayers = mapLayers; // needs to resolve refs afterwards
249
250 QDomElement elemTerrainGenerator = elemTerrain.firstChildElement( u"generator"_s );
251 const QString terrainGenType = elemTerrainGenerator.attribute( u"type"_s );
252 std::unique_ptr<QgsAbstractTerrainSettings> terrainSettings( Qgs3D::terrainRegistry()->createTerrainSettings( terrainGenType ) );
253 if ( terrainSettings )
254 {
255 terrainSettings->readXml( elemTerrain, context );
256 setTerrainSettings( terrainSettings.release() );
257 }
258
259 QDomElement elemSkybox = elem.firstChildElement( u"skybox"_s );
260 mSkyboxSettings.readXml( elemSkybox, context );
261
262 QDomElement elemGradientBackground = elem.firstChildElement( u"gradient-background"_s );
263 if ( !elemGradientBackground.isNull() )
264 {
265 mGradientBackgroundTopColor = QgsColorUtils::colorFromString( elemGradientBackground.attribute( u"top-color"_s ) );
266 mGradientBackgroundBottomColor = QgsColorUtils::colorFromString( elemGradientBackground.attribute( u"bottom-color"_s ) );
267 }
268
269 const QString bgType = elemSkybox.attribute( u"background-type"_s );
270 if ( bgType == "skybox"_L1 )
271 mBackgroundType = BackgroundType::Skybox;
272 else if ( bgType == "gradient"_L1 && !elemGradientBackground.isNull() )
273 mBackgroundType = BackgroundType::Gradient;
274 else
275 mBackgroundType = BackgroundType::NoBackground;
276
277 QDomElement elemShadows = elem.firstChildElement( u"shadow-rendering"_s );
278 mShadowSettings.readXml( elemShadows, context );
279
280 QDomElement elemAmbientOcclusion = elem.firstChildElement( u"screen-space-ambient-occlusion"_s );
281 mAmbientOcclusionSettings.readXml( elemAmbientOcclusion, context );
282
283 QDomElement elemEyeDomeLighting = elem.firstChildElement( u"eye-dome-lighting"_s );
284 mEyeDomeLightingEnabled = elemEyeDomeLighting.attribute( "enabled", u"0"_s ).toInt();
285 mEyeDomeLightingStrength = elemEyeDomeLighting.attribute( "eye-dome-lighting-strength", u"1000.0"_s ).toDouble();
286 mEyeDomeLightingDistance = elemEyeDomeLighting.attribute( "eye-dome-lighting-distance", u"1"_s ).toInt();
287
288 QDomElement elemNavigationSync = elem.firstChildElement( u"navigation-sync"_s );
289 mViewSyncMode = static_cast<Qgis::ViewSyncModeFlags>( elemNavigationSync.attribute( u"view-sync-mode"_s, u"0"_s ).toInt() );
290 mVisualizeViewFrustum = elemNavigationSync.attribute( u"view-frustum-visualization-enabled"_s, u"0"_s ).toInt();
291
292 QDomElement elemDebugSettings = elem.firstChildElement( u"debug-settings"_s );
293 mDebugShadowMapEnabled = elemDebugSettings.attribute( u"shadowmap-enabled"_s, u"0"_s ).toInt();
294 mDebugShadowMapCorner = static_cast<Qt::Corner>( elemDebugSettings.attribute( u"shadowmap-corner"_s, "0" ).toInt() );
295 mDebugShadowMapSize = elemDebugSettings.attribute( u"shadowmap-size"_s, u"0.2"_s ).toDouble();
296
297 mDebugDepthMapEnabled = elemDebugSettings.attribute( u"depthmap-enabled"_s, u"0"_s ).toInt();
298 mDebugDepthMapCorner = static_cast<Qt::Corner>( elemDebugSettings.attribute( u"depthmap-corner"_s, u"1"_s ).toInt() );
299 mDebugDepthMapSize = elemDebugSettings.attribute( u"depthmap-size"_s, u"0.2"_s ).toDouble();
300
301 QDomElement elemDebug = elem.firstChildElement( u"debug"_s );
302 mShowTerrainBoundingBoxes = elemDebug.attribute( u"bounding-boxes"_s, u"0"_s ).toInt();
303 mShowTerrainTileInfo = elemDebug.attribute( u"terrain-tile-info"_s, u"0"_s ).toInt();
304 mShowCameraViewCenter = elemDebug.attribute( u"camera-view-center"_s, u"0"_s ).toInt();
305 mShowCameraRotationCenter = elemDebug.attribute( u"camera-rotation-center"_s, u"0"_s ).toInt();
306 mShowLightSources = elemDebug.attribute( u"show-light-sources"_s, u"0"_s ).toInt();
307 mIsFpsCounterEnabled = elemDebug.attribute( u"show-fps-counter"_s, u"0"_s ).toInt();
308 mStopUpdates = elemDebug.attribute( u"stop-updates"_s, u"0"_s ).toInt();
309 mShowDebugPanel = elemDebug.attribute( u"debug-panel"_s, u"0"_s ).toInt();
310
311 QDomElement elemTemporalRange = elem.firstChildElement( u"temporal-range"_s );
312 QDateTime start = QDateTime::fromString( elemTemporalRange.attribute( u"start"_s ), Qt::ISODate );
313 QDateTime end = QDateTime::fromString( elemTemporalRange.attribute( u"end"_s ), Qt::ISODate );
314 setTemporalRange( QgsDateTimeRange( start, end ) );
315
316 QDomElement elem3dAxis = elem.firstChildElement( u"axis3d"_s );
317 m3dAxisSettings.readXml( elem3dAxis, context );
318
319 QDomElement elemMapOverlay = elem.firstChildElement( u"map-overlay"_s );
320 if ( !elemMapOverlay.isNull() )
321 {
322 mShow2DMapOverlay = elemMapOverlay.attribute( u"enabled"_s, u"0"_s ).toInt();
323 }
324 else
325 {
326 mShow2DMapOverlay = false;
327 }
328}
329
330QDomElement Qgs3DMapSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
331{
332 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
333
334 QDomElement elem = doc.createElement( u"qgis3d"_s );
335
336 QDomElement elemOrigin = doc.createElement( u"origin"_s );
337 elemOrigin.setAttribute( u"x"_s, QString::number( mOrigin.x() ) );
338 elemOrigin.setAttribute( u"y"_s, QString::number( mOrigin.y() ) );
339 elemOrigin.setAttribute( u"z"_s, QString::number( mOrigin.z() ) );
340 elem.appendChild( elemOrigin );
341
342 QDomElement elemExtent = doc.createElement( u"extent"_s );
343 elemExtent.setAttribute( u"xMin"_s, mExtent.xMinimum() );
344 elemExtent.setAttribute( u"yMin"_s, mExtent.yMinimum() );
345 elemExtent.setAttribute( u"xMax"_s, mExtent.xMaximum() );
346 elemExtent.setAttribute( u"yMax"_s, mExtent.yMaximum() );
347 elemExtent.setAttribute( u"showIn2dView"_s, mShowExtentIn2DView );
348 elem.appendChild( elemExtent );
349
350 QDomElement elemCamera = doc.createElement( u"camera"_s );
351 elemCamera.setAttribute( u"field-of-view"_s, mFieldOfView );
352 elemCamera.setAttribute( u"projection-type"_s, static_cast<int>( mProjectionType ) );
353 switch ( mCameraNavigationMode )
354 {
355 case Qgis::NavigationMode::TerrainBased:
356 elemCamera.setAttribute( u"camera-navigation-mode"_s, u"terrain-based-navigation"_s );
357 break;
358 case Qgis::NavigationMode::Walk:
359 elemCamera.setAttribute( u"camera-navigation-mode"_s, u"walk-navigation"_s );
360 break;
361 case Qgis::NavigationMode::GlobeTerrainBased:
362 elemCamera.setAttribute( u"camera-navigation-mode"_s, u"globe-terrain-based-navigation"_s );
363 break;
364 }
365 elemCamera.setAttribute( u"camera-movement-speed"_s, mCameraMovementSpeed );
366 elem.appendChild( elemCamera );
367
368 QDomElement elemColor = doc.createElement( u"color"_s );
369 elemColor.setAttribute( u"background"_s, QgsColorUtils::colorToString( mBackgroundColor ) );
370 elemColor.setAttribute( u"selection"_s, QgsColorUtils::colorToString( mSelectionColor ) );
371 elem.appendChild( elemColor );
372
373 QDomElement elemCrs = doc.createElement( u"crs"_s );
374 mCrs.writeXml( elemCrs, doc );
375 elem.appendChild( elemCrs );
376
377 QDomElement elemTerrain = doc.createElement( u"terrain"_s );
378 elemTerrain.setAttribute( u"terrain-rendering-enabled"_s, mTerrainRenderingEnabled ? 1 : 0 );
379 elemTerrain.setAttribute( u"shading-enabled"_s, mTerrainShadingEnabled ? 1 : 0 );
380
381 QDomElement elemTerrainShadingMaterial = doc.createElement( u"shading-material"_s );
382 mTerrainShadingMaterial.writeXml( elemTerrainShadingMaterial, context );
383 elemTerrain.appendChild( elemTerrainShadingMaterial );
384 elemTerrain.setAttribute( u"map-theme"_s, mTerrainMapTheme );
385 elemTerrain.setAttribute( u"show-labels"_s, mShowLabels ? 1 : 0 );
386
387 {
388 QDomElement elemLights = doc.createElement( u"lights"_s );
389 for ( const QgsLightSource *light : mLightSources )
390 {
391 const QDomElement elemLight = light->writeXml( doc, context );
392 elemLights.appendChild( elemLight );
393 }
394 elem.appendChild( elemLights );
395 }
396
397 QDomElement elemMapLayers = doc.createElement( u"layers"_s );
398 for ( const QgsMapLayerRef &layerRef : mLayers )
399 {
400 QDomElement elemMapLayer = doc.createElement( u"layer"_s );
401 elemMapLayer.setAttribute( u"id"_s, layerRef.layerId );
402 elemMapLayers.appendChild( elemMapLayer );
403 }
404 elemTerrain.appendChild( elemMapLayers );
405
406 QDomElement elemTerrainGenerator = doc.createElement( u"generator"_s );
407 elemTerrainGenerator.setAttribute( u"type"_s, mTerrainSettings->type() );
408 mTerrainSettings->writeXml( elemTerrain, context );
409 elemTerrain.appendChild( elemTerrainGenerator );
410 elem.appendChild( elemTerrain );
411
412 QDomElement elemSkybox = doc.createElement( u"skybox"_s );
413 QString bgTypeStr;
414 switch ( mBackgroundType )
415 {
416 case BackgroundType::Skybox:
417 bgTypeStr = u"skybox"_s;
418 break;
419 case BackgroundType::Gradient:
420 bgTypeStr = u"gradient"_s;
421 break;
422 case BackgroundType::NoBackground:
423 bgTypeStr = u"none"_s;
424 break;
425 }
426 elemSkybox.setAttribute( u"background-type"_s, bgTypeStr );
427 mSkyboxSettings.writeXml( elemSkybox, context );
428 elem.appendChild( elemSkybox );
429
430 QDomElement elemGradientBackground = doc.createElement( u"gradient-background"_s );
431 elemGradientBackground.setAttribute( u"top-color"_s, QgsColorUtils::colorToString( mGradientBackgroundTopColor ) );
432 elemGradientBackground.setAttribute( u"bottom-color"_s, QgsColorUtils::colorToString( mGradientBackgroundBottomColor ) );
433 elem.appendChild( elemGradientBackground );
434
435 QDomElement elemShadows = doc.createElement( u"shadow-rendering"_s );
436 mShadowSettings.writeXml( elemShadows, context );
437 elem.appendChild( elemShadows );
438
439 QDomElement elemAmbientOcclusion = doc.createElement( u"screen-space-ambient-occlusion"_s );
440 mAmbientOcclusionSettings.writeXml( elemAmbientOcclusion, context );
441 elem.appendChild( elemAmbientOcclusion );
442
443 QDomElement elemDebug = doc.createElement( u"debug"_s );
444 elemDebug.setAttribute( u"bounding-boxes"_s, mShowTerrainBoundingBoxes ? 1 : 0 );
445 elemDebug.setAttribute( u"terrain-tile-info"_s, mShowTerrainTileInfo ? 1 : 0 );
446 elemDebug.setAttribute( u"camera-view-center"_s, mShowCameraViewCenter ? 1 : 0 );
447 elemDebug.setAttribute( u"camera-rotation-center"_s, mShowCameraRotationCenter ? 1 : 0 );
448 elemDebug.setAttribute( u"show-light-sources"_s, mShowLightSources ? 1 : 0 );
449 elemDebug.setAttribute( u"show-fps-counter"_s, mIsFpsCounterEnabled ? 1 : 0 );
450 elemDebug.setAttribute( u"stop-updates"_s, mStopUpdates ? 1 : 0 );
451 elemDebug.setAttribute( u"debug-panel"_s, mShowDebugPanel ? 1 : 0 );
452 elem.appendChild( elemDebug );
453
454 QDomElement elemEyeDomeLighting = doc.createElement( u"eye-dome-lighting"_s );
455 elemEyeDomeLighting.setAttribute( u"enabled"_s, mEyeDomeLightingEnabled ? 1 : 0 );
456 elemEyeDomeLighting.setAttribute( u"eye-dome-lighting-strength"_s, mEyeDomeLightingStrength );
457 elemEyeDomeLighting.setAttribute( u"eye-dome-lighting-distance"_s, mEyeDomeLightingDistance );
458 elem.appendChild( elemEyeDomeLighting );
459
460 QDomElement elemNavigationSync = doc.createElement( u"navigation-sync"_s );
461 elemNavigationSync.setAttribute( u"view-sync-mode"_s, ( int ) mViewSyncMode );
462 elemNavigationSync.setAttribute( u"view-frustum-visualization-enabled"_s, mVisualizeViewFrustum ? 1 : 0 );
463 elem.appendChild( elemNavigationSync );
464
465 QDomElement elemDebugSettings = doc.createElement( u"debug-settings"_s );
466 elemDebugSettings.setAttribute( u"shadowmap-enabled"_s, mDebugShadowMapEnabled );
467 elemDebugSettings.setAttribute( u"shadowmap-corner"_s, mDebugShadowMapCorner );
468 elemDebugSettings.setAttribute( u"shadowmap-size"_s, mDebugShadowMapSize );
469 elemDebugSettings.setAttribute( u"depthmap-enabled"_s, mDebugDepthMapEnabled );
470 elemDebugSettings.setAttribute( u"depthmap-corner"_s, mDebugDepthMapCorner );
471 elemDebugSettings.setAttribute( u"depthmap-size"_s, mDebugDepthMapSize );
472 elem.appendChild( elemDebugSettings );
473
474 QDomElement elemTemporalRange = doc.createElement( u"temporal-range"_s );
475 elemTemporalRange.setAttribute( u"start"_s, temporalRange().begin().toString( Qt::ISODate ) );
476 elemTemporalRange.setAttribute( u"end"_s, temporalRange().end().toString( Qt::ISODate ) );
477
478 QDomElement elem3dAxis = doc.createElement( u"axis3d"_s );
479 m3dAxisSettings.writeXml( elem3dAxis, context );
480 elem.appendChild( elem3dAxis );
481
482 if ( mShow2DMapOverlay )
483 {
484 QDomElement elemMapOverlay = doc.createElement( u"map-overlay"_s );
485 elemMapOverlay.setAttribute( u"enabled"_s, 1 );
486 elem.appendChild( elemMapOverlay );
487 }
488
489 return elem;
490}
491
492void Qgs3DMapSettings::resolveReferences( const QgsProject &project )
493{
494 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
495
496 for ( int i = 0; i < mLayers.count(); ++i )
497 {
498 QgsMapLayerRef &layerRef = mLayers[i];
499 layerRef.setLayer( project.mapLayer( layerRef.layerId ) );
500 }
501
502 if ( mTerrainSettings )
503 {
504 mTerrainSettings->resolveReferences( &project );
505
506 std::unique_ptr<QgsTerrainGenerator> terrainGenerator = mTerrainSettings->createTerrainGenerator( Qgs3DRenderContext::fromMapSettings( this ) );
507 if ( terrainGenerator )
508 {
509 setTerrainGenerator( terrainGenerator.release() );
510 }
511 emit terrainSettingsChanged();
512 }
513}
514
515QgsRectangle Qgs3DMapSettings::extent() const
516{
517 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
518
519 if ( sceneMode() == Qgis::SceneMode::Globe )
520 {
521 QgsDebugError( u"extent() should not be used with globe!"_s );
522 }
523
524 return mExtent;
525}
526
527void Qgs3DMapSettings::setExtent( const QgsRectangle &extent )
528{
529 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
530
531 if ( extent == mExtent )
532 return;
533
534 if ( sceneMode() == Qgis::SceneMode::Globe )
535 {
536 QgsDebugError( u"setExtent() should not be used with globe!"_s );
537 }
538
539 mExtent = extent;
540 const QgsPointXY center = mExtent.center();
541 setOrigin( QgsVector3D( center.x(), center.y(), 0 ) );
542 if ( mTerrainGenerator )
543 {
544 QgsRectangle terrainExtent = Qgs3DUtils::tryReprojectExtent2D( mExtent, mCrs, mTerrainGenerator->crs(), mTransformContext );
545 mTerrainGenerator->setExtent( terrainExtent );
546 }
547 emit extentChanged();
548}
549
550void Qgs3DMapSettings::setOrigin( const QgsVector3D &origin )
551{
552 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
553
554 if ( origin == mOrigin )
555 return;
556
557 mOrigin = origin;
558 emit originChanged();
559}
560
561QgsVector3D Qgs3DMapSettings::origin() const
562{
563 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
564
565 return mOrigin;
566}
567
574
581
582void Qgs3DMapSettings::setCrs( const QgsCoordinateReferenceSystem &crs )
583{
584 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
585
586 mCrs = crs;
587
588 // for convenience, make sure the navigation mode is consistent with the scene mode
589 if ( sceneMode() == Qgis::SceneMode::Globe && mCameraNavigationMode == Qgis::NavigationMode::TerrainBased )
590 {
591 setCameraNavigationMode( Qgis::NavigationMode::GlobeTerrainBased );
592 }
593 else if ( sceneMode() == Qgis::SceneMode::Local && mCameraNavigationMode == Qgis::NavigationMode::GlobeTerrainBased )
594 {
595 setCameraNavigationMode( Qgis::NavigationMode::TerrainBased );
596 }
597}
598
605
612
619
620void Qgs3DMapSettings::setTransformContext( const QgsCoordinateTransformContext &context )
621{
622 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
623
624 mTransformContext = context;
625}
626
627const QgsPathResolver &Qgs3DMapSettings::pathResolver() const
628{
629 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
630
631 return mPathResolver;
632}
633
634void Qgs3DMapSettings::setPathResolver( const QgsPathResolver &resolver )
635{
636 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
637
638 mPathResolver = resolver;
639}
640
647
648void Qgs3DMapSettings::setMapThemeCollection( QgsMapThemeCollection *mapThemes )
649{
650 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
651
652 mMapThemes = mapThemes;
653}
654
655void Qgs3DMapSettings::setBackgroundColor( const QColor &color )
656{
657 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
658
659 if ( color == mBackgroundColor )
660 return;
661
662 mBackgroundColor = color;
663 emit backgroundColorChanged();
664}
665
666QColor Qgs3DMapSettings::backgroundColor() const
667{
668 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
669
670 return mBackgroundColor;
671}
672
679
680void Qgs3DMapSettings::setBackgroundType( BackgroundType type )
681{
682 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
683
684 if ( type == mBackgroundType )
685 return;
686
687 mBackgroundType = type;
688 emit backgroundTypeChanged();
689}
690
691QColor Qgs3DMapSettings::gradientBackgroundTopColor() const
692{
693 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
694
695 return mGradientBackgroundTopColor;
696}
697
698void Qgs3DMapSettings::setGradientBackgroundTopColor( const QColor &color )
699{
700 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
701
702 if ( color == mGradientBackgroundTopColor )
703 return;
704
705 mGradientBackgroundTopColor = color;
706 emit backgroundTypeChanged();
707}
708
709QColor Qgs3DMapSettings::gradientBackgroundBottomColor() const
710{
711 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
712
713 return mGradientBackgroundBottomColor;
714}
715
716void Qgs3DMapSettings::setGradientBackgroundBottomColor( const QColor &color )
717{
718 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
719
720 if ( color == mGradientBackgroundBottomColor )
721 return;
722
723 mGradientBackgroundBottomColor = color;
724 emit backgroundTypeChanged();
725}
726
727void Qgs3DMapSettings::setSelectionColor( const QColor &color )
728{
729 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
730
731 if ( color == mSelectionColor )
732 return;
733
734 mSelectionColor = color;
735 emit selectionColorChanged();
736}
737
738QColor Qgs3DMapSettings::selectionColor() const
739{
740 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
741
742 return mSelectionColor;
743}
744
745void Qgs3DMapSettings::setTerrainVerticalScale( double zScale )
746{
747 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
748
749 if ( zScale == mTerrainSettings->verticalScale() )
750 return;
751
752 mTerrainSettings->setVerticalScale( zScale );
753 Q_NOWARN_DEPRECATED_PUSH
754 emit terrainVerticalScaleChanged();
755 Q_NOWARN_DEPRECATED_POP
756 emit terrainSettingsChanged();
757}
758
759double Qgs3DMapSettings::terrainVerticalScale() const
760{
761 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
762
763 return mTerrainSettings->verticalScale();
764}
765
766void Qgs3DMapSettings::setLayers( const QList<QgsMapLayer *> &layers )
767{
768 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
769
770 const QList<QgsMapLayer *> raw = _qgis_listRefToRaw( mLayers );
771
772 if ( layers == raw )
773 return;
774
775 mLayers = _qgis_listRawToRef( layers );
776 emit layersChanged();
777}
778
779QList<QgsMapLayer *> Qgs3DMapSettings::layers() const
780{
781 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
782
783 QList<QgsMapLayer *> lst;
784 lst.reserve( mLayers.count() );
785 for ( const QgsMapLayerRef &layerRef : mLayers )
786 {
787 if ( layerRef.layer )
788 lst.append( layerRef.layer );
789 }
790 return lst;
791}
792
793void Qgs3DMapSettings::configureTerrainFromProject( QgsProjectElevationProperties *properties, const QgsRectangle &fullExtent )
794{
795 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
796
797 setExtent( fullExtent );
798
799 std::unique_ptr<QgsAbstractTerrainSettings> terrainSettings( Qgs3D::terrainRegistry()->configureTerrainFromProject( properties ) );
800 if ( terrainSettings )
801 {
802 setTerrainSettings( terrainSettings.release() );
803 }
804}
805
806const QgsAbstractTerrainSettings *Qgs3DMapSettings::terrainSettings() const
807{
808 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
809
810 return mTerrainSettings.get();
811}
812
813void Qgs3DMapSettings::setTerrainSettings( QgsAbstractTerrainSettings *settings )
814{
815 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
816
817 bool hasChanged = false;
818 if ( settings == mTerrainSettings.get() )
819 {
820 // emit signals anyway. We don't know if the caller changed settings on the pointer before calling this..
821 hasChanged = true;
822 }
823 else
824 {
825 // ensure to generate the terrain if the settings have changed or if the terrain has never been generated.
826 hasChanged = !settings->equals( mTerrainSettings.get() ) || !mTerrainGenerator;
827 mTerrainSettings.reset( settings );
828 }
829
830 if ( hasChanged )
831 {
832 std::unique_ptr<QgsTerrainGenerator> terrainGenerator = mTerrainSettings->createTerrainGenerator( Qgs3DRenderContext::fromMapSettings( this ) );
833 if ( terrainGenerator )
834 {
835 setTerrainGenerator( terrainGenerator.release() );
836 }
837
838 // emit all the signals, we don't know exactly what's changed
839 Q_NOWARN_DEPRECATED_PUSH
840 emit mapTileResolutionChanged();
841 emit maxTerrainScreenErrorChanged();
842 emit maxTerrainGroundErrorChanged();
843 emit terrainElevationOffsetChanged( mTerrainSettings->elevationOffset() );
844 emit terrainVerticalScaleChanged();
845 Q_NOWARN_DEPRECATED_POP
846
847 emit terrainSettingsChanged();
848 }
849}
850
851void Qgs3DMapSettings::setMapTileResolution( int res )
852{
853 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
854
855 if ( mTerrainSettings->mapTileResolution() == res )
856 return;
857
858 mTerrainSettings->setMapTileResolution( res );
859 Q_NOWARN_DEPRECATED_PUSH
860 emit mapTileResolutionChanged();
861 Q_NOWARN_DEPRECATED_POP
862 emit terrainSettingsChanged();
863}
864
865int Qgs3DMapSettings::mapTileResolution() const
866{
867 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
868
869 return mTerrainSettings->mapTileResolution();
870}
871
872void Qgs3DMapSettings::setMaxTerrainScreenError( double error )
873{
874 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
875
876 if ( mTerrainSettings->maximumScreenError() == error )
877 return;
878
879 mTerrainSettings->setMaximumScreenError( error );
880 Q_NOWARN_DEPRECATED_PUSH
881 emit maxTerrainScreenErrorChanged();
882 Q_NOWARN_DEPRECATED_POP
883 emit terrainSettingsChanged();
884}
885
886double Qgs3DMapSettings::maxTerrainScreenError() const
887{
888 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
889
890 return mTerrainSettings->maximumScreenError();
891}
892
893void Qgs3DMapSettings::setMaxTerrainGroundError( double error )
894{
895 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
896
897 if ( mTerrainSettings->maximumGroundError() == error )
898 return;
899
900 mTerrainSettings->setMaximumGroundError( error );
901 Q_NOWARN_DEPRECATED_PUSH
902 emit maxTerrainGroundErrorChanged();
903 Q_NOWARN_DEPRECATED_POP
904
905 emit terrainSettingsChanged();
906}
907
908void Qgs3DMapSettings::setTerrainElevationOffset( double offset )
909{
910 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
911
912 if ( mTerrainSettings->elevationOffset() == offset )
913 return;
914 mTerrainSettings->setElevationOffset( offset );
915 Q_NOWARN_DEPRECATED_PUSH
916 emit terrainElevationOffsetChanged( offset );
917 Q_NOWARN_DEPRECATED_POP
918 emit terrainSettingsChanged();
919}
920
921double Qgs3DMapSettings::terrainElevationOffset() const
922{
923 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
924
925 return mTerrainSettings->elevationOffset();
926}
927
928double Qgs3DMapSettings::maxTerrainGroundError() const
929{
930 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
931
932 return mTerrainSettings->maximumGroundError();
933}
934
935void Qgs3DMapSettings::setTerrainGenerator( QgsTerrainGenerator *gen )
936{
937 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
938
939 if ( mTerrainGenerator )
940 {
941 disconnect( mTerrainGenerator.get(), &QgsTerrainGenerator::terrainChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );
942 }
943
944 if ( gen->crs().isValid() ) // Don't bother setting an extent rect in the wrong CRS
945 {
946 QgsRectangle terrainExtent = Qgs3DUtils::tryReprojectExtent2D( mExtent, mCrs, gen->crs(), mTransformContext );
947 gen->setExtent( terrainExtent );
948 }
949 mTerrainGenerator.reset( gen );
950 connect( mTerrainGenerator.get(), &QgsTerrainGenerator::terrainChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );
951
952 emit terrainGeneratorChanged();
953}
954
955QgsTerrainGenerator *Qgs3DMapSettings::terrainGenerator() const
956{
957 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
958
959 return mTerrainGenerator.get();
960}
961
962void Qgs3DMapSettings::setTerrainShadingEnabled( bool enabled )
963{
964 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
965
966 if ( mTerrainShadingEnabled == enabled )
967 return;
968
969 mTerrainShadingEnabled = enabled;
970 emit terrainShadingChanged();
971}
972
973bool Qgs3DMapSettings::isTerrainShadingEnabled() const
974{
975 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
976
977 return mTerrainShadingEnabled;
978}
979
980void Qgs3DMapSettings::setTerrainShadingMaterial( const QgsPhongMaterialSettings &material )
981{
982 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
983
984 if ( mTerrainShadingMaterial == material )
985 return;
986
987 mTerrainShadingMaterial = material;
988 emit terrainShadingChanged();
989}
990
997
998void Qgs3DMapSettings::setTerrainMapTheme( const QString &theme )
999{
1000 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1001
1002 if ( mTerrainMapTheme == theme )
1003 return;
1004
1005 mTerrainMapTheme = theme;
1006 emit terrainMapThemeChanged();
1007}
1008
1009QString Qgs3DMapSettings::terrainMapTheme() const
1010{
1011 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1012
1013 return mTerrainMapTheme;
1014}
1015
1016void Qgs3DMapSettings::setShowTerrainBoundingBoxes( bool enabled )
1017{
1018 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1019
1020 if ( mShowTerrainBoundingBoxes == enabled )
1021 return;
1022
1023 mShowTerrainBoundingBoxes = enabled;
1024 emit showTerrainBoundingBoxesChanged();
1025}
1026
1027bool Qgs3DMapSettings::showTerrainBoundingBoxes() const
1028{
1029 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1030
1031 return mShowTerrainBoundingBoxes;
1032}
1033
1034
1035void Qgs3DMapSettings::setShowTerrainTilesInfo( bool enabled )
1036{
1037 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1038
1039 if ( mShowTerrainTileInfo == enabled )
1040 return;
1041
1042 mShowTerrainTileInfo = enabled;
1043 emit showTerrainTilesInfoChanged();
1044}
1045
1046bool Qgs3DMapSettings::showTerrainTilesInfo() const
1047{
1048 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1049
1050 return mShowTerrainTileInfo;
1051}
1052
1053void Qgs3DMapSettings::setShowCameraViewCenter( bool enabled )
1054{
1055 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1056
1057 if ( mShowCameraViewCenter == enabled )
1058 return;
1059
1060 mShowCameraViewCenter = enabled;
1061 emit showCameraViewCenterChanged();
1062}
1063
1064bool Qgs3DMapSettings::showCameraViewCenter() const
1065{
1066 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1067
1068 return mShowCameraViewCenter;
1069}
1070
1071void Qgs3DMapSettings::setShowCameraRotationCenter( bool enabled )
1072{
1073 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1074
1075 if ( mShowCameraRotationCenter == enabled )
1076 return;
1077
1078 mShowCameraRotationCenter = enabled;
1079 emit showCameraRotationCenterChanged();
1080}
1081
1082bool Qgs3DMapSettings::showCameraRotationCenter() const
1083{
1084 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1085
1086 return mShowCameraRotationCenter;
1087}
1088
1089void Qgs3DMapSettings::setShowLightSourceOrigins( bool enabled )
1090{
1091 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1092
1093 if ( mShowLightSources == enabled )
1094 return;
1095
1096 mShowLightSources = enabled;
1097 emit showLightSourceOriginsChanged();
1098}
1099
1100bool Qgs3DMapSettings::showLightSourceOrigins() const
1101{
1102 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1103
1104 return mShowLightSources;
1105}
1106
1107void Qgs3DMapSettings::setShowLabels( bool enabled )
1108{
1109 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1110
1111 if ( mShowLabels == enabled )
1112 return;
1113
1114 mShowLabels = enabled;
1115 emit showLabelsChanged();
1116}
1117
1118bool Qgs3DMapSettings::showLabels() const
1119{
1120 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1121
1122 return mShowLabels;
1123}
1124
1125void Qgs3DMapSettings::setStopUpdates( bool enabled )
1126{
1127 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1128
1129 if ( mStopUpdates == enabled )
1130 return;
1131
1132 mStopUpdates = enabled;
1133 emit stopUpdatesChanged();
1134}
1135
1136bool Qgs3DMapSettings::stopUpdates() const
1137{
1138 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1139
1140 return mStopUpdates;
1141}
1142
1143void Qgs3DMapSettings::setEyeDomeLightingEnabled( bool enabled )
1144{
1145 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1146
1147 if ( mEyeDomeLightingEnabled == enabled )
1148 return;
1149 mEyeDomeLightingEnabled = enabled;
1150 emit eyeDomeLightingEnabledChanged();
1151}
1152
1153bool Qgs3DMapSettings::eyeDomeLightingEnabled() const
1154{
1155 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1156
1157 return mEyeDomeLightingEnabled;
1158}
1159
1160void Qgs3DMapSettings::setEyeDomeLightingStrength( double strength )
1161{
1162 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1163
1164 if ( mEyeDomeLightingStrength == strength )
1165 return;
1166 mEyeDomeLightingStrength = strength;
1167 emit eyeDomeLightingStrengthChanged();
1168}
1169
1170double Qgs3DMapSettings::eyeDomeLightingStrength() const
1171{
1172 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1173
1174 return mEyeDomeLightingStrength;
1175}
1176
1177void Qgs3DMapSettings::setEyeDomeLightingDistance( int distance )
1178{
1179 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1180
1181 if ( mEyeDomeLightingDistance == distance )
1182 return;
1183 mEyeDomeLightingDistance = distance;
1184 emit eyeDomeLightingDistanceChanged();
1185}
1186
1187int Qgs3DMapSettings::eyeDomeLightingDistance() const
1188{
1189 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1190
1191 return mEyeDomeLightingDistance;
1192}
1193
1194void Qgs3DMapSettings::setMsaaEnabled( bool enabled )
1195{
1196 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1197
1198 if ( mMsaaEnabled == enabled )
1199 return;
1200
1201 mMsaaEnabled = enabled;
1202 emit msaaEnabledChanged();
1203}
1204
1205bool Qgs3DMapSettings::isMsaaEnabled() const
1206{
1207 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1208
1209 return mMsaaEnabled;
1210}
1211
1212QList<QgsLightSource *> Qgs3DMapSettings::lightSources() const
1213{
1214 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1215
1216 return mLightSources;
1217}
1218
1219void Qgs3DMapSettings::setLightSources( const QList<QgsLightSource *> &lights )
1220{
1221 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1222
1223 // have lights actually changed?
1224 if ( mLightSources.count() == lights.count() )
1225 {
1226 bool same = true;
1227 for ( int i = 0; i < mLightSources.count(); ++i )
1228 {
1229 if ( mLightSources[i]->type() == lights[i]->type() )
1230 {
1231 switch ( mLightSources[i]->type() )
1232 {
1233 case Qgis::LightSourceType::Point:
1234 if ( *static_cast<QgsPointLightSettings *>( mLightSources[i] ) == *static_cast<QgsPointLightSettings *>( lights[i] ) )
1235 continue;
1236 break;
1237 case Qgis::LightSourceType::Directional:
1238 if ( *static_cast<QgsDirectionalLightSettings *>( mLightSources[i] ) == *static_cast<QgsDirectionalLightSettings *>( lights[i] ) )
1239 continue;
1240 break;
1241 }
1242 }
1243 same = false;
1244 break;
1245 }
1246 if ( same )
1247 {
1248 qDeleteAll( lights );
1249 return;
1250 }
1251 }
1252
1253 qDeleteAll( mLightSources );
1254 mLightSources = lights;
1255
1256 emit directionalLightsChanged();
1257 emit pointLightsChanged();
1258 emit lightSourcesChanged();
1259}
1260
1261float Qgs3DMapSettings::fieldOfView() const
1262{
1263 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1264
1265 return mFieldOfView;
1266}
1267
1268void Qgs3DMapSettings::setFieldOfView( const float fieldOfView )
1269{
1270 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1271
1272 if ( mFieldOfView == fieldOfView )
1273 return;
1274
1275 mFieldOfView = fieldOfView;
1276 emit fieldOfViewChanged();
1277}
1278
1279Qt3DRender::QCameraLens::ProjectionType Qgs3DMapSettings::projectionType() const
1280{
1281 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1282
1283 return mProjectionType;
1284}
1285
1286void Qgs3DMapSettings::setProjectionType( const Qt3DRender::QCameraLens::ProjectionType projectionType )
1287{
1288 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1289
1290 if ( mProjectionType == projectionType )
1291 return;
1292
1293 mProjectionType = projectionType;
1294 emit projectionTypeChanged();
1295}
1296
1297Qgis::NavigationMode Qgs3DMapSettings::cameraNavigationMode() const
1298{
1299 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1300
1301 return mCameraNavigationMode;
1302}
1303
1304void Qgs3DMapSettings::setCameraNavigationMode( Qgis::NavigationMode navigationMode )
1305{
1306 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1307
1308 if ( mCameraNavigationMode == navigationMode )
1309 return;
1310
1311 mCameraNavigationMode = navigationMode;
1312 emit cameraNavigationModeChanged();
1313}
1314
1315double Qgs3DMapSettings::cameraMovementSpeed() const
1316{
1317 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1318
1319 return mCameraMovementSpeed;
1320}
1321
1322void Qgs3DMapSettings::setCameraMovementSpeed( double movementSpeed )
1323{
1324 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1325
1326 if ( mCameraMovementSpeed == movementSpeed )
1327 return;
1328
1329 mCameraMovementSpeed = movementSpeed;
1330 emit cameraMovementSpeedChanged();
1331}
1332
1333void Qgs3DMapSettings::setOutputDpi( const double dpi )
1334{
1335 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1336
1337 mDpi = dpi;
1338}
1339
1340double Qgs3DMapSettings::outputDpi() const
1341{
1342 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1343
1344 return mDpi;
1345}
1346
1347QgsSkyboxSettings Qgs3DMapSettings::skyboxSettings() const
1348{
1349 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1350
1351 return mSkyboxSettings;
1352}
1353
1354QgsShadowSettings Qgs3DMapSettings::shadowSettings() const
1355{
1356 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1357
1358 return mShadowSettings;
1359}
1360
1361QgsAmbientOcclusionSettings Qgs3DMapSettings::ambientOcclusionSettings() const
1362{
1363 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1364
1365 return mAmbientOcclusionSettings;
1366}
1367
1375
1383
1391
1392bool Qgs3DMapSettings::isSkyboxEnabled() const
1393{
1394 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1395
1396 return mBackgroundType == BackgroundType::Skybox;
1397}
1398
1405
1406bool Qgs3DMapSettings::isFpsCounterEnabled() const
1407{
1408 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1409
1410 return mIsFpsCounterEnabled;
1411}
1412
1413void Qgs3DMapSettings::setShowDebugPanel( const bool enabled )
1414{
1415 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1416
1417 if ( mShowDebugPanel == enabled )
1418 return;
1419
1420 mShowDebugPanel = enabled;
1421 emit showDebugPanelChanged( enabled );
1422}
1423
1424bool Qgs3DMapSettings::showDebugPanel() const
1425{
1426 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1427
1428 return mShowDebugPanel;
1429}
1430
1431void Qgs3DMapSettings::setDebugShadowMapSettings( bool enabled, Qt::Corner corner, double size )
1432{
1433 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1434
1435 mDebugShadowMapEnabled = enabled;
1436 mDebugShadowMapCorner = corner;
1437 mDebugShadowMapSize = size;
1438 emit debugShadowMapSettingsChanged();
1439}
1440
1441bool Qgs3DMapSettings::debugShadowMapEnabled() const
1442{
1443 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1444
1445 return mDebugShadowMapEnabled;
1446}
1447
1448Qt::Corner Qgs3DMapSettings::debugShadowMapCorner() const
1449{
1450 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1451
1452 return mDebugShadowMapCorner;
1453}
1454
1455double Qgs3DMapSettings::debugShadowMapSize() const
1456{
1457 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1458
1459 return mDebugShadowMapSize;
1460}
1461
1462void Qgs3DMapSettings::setDebugDepthMapSettings( bool enabled, Qt::Corner corner, double size )
1463{
1464 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1465
1466 mDebugDepthMapEnabled = enabled;
1467 mDebugDepthMapCorner = corner;
1468 mDebugDepthMapSize = size;
1469 emit debugDepthMapSettingsChanged();
1470}
1471
1472bool Qgs3DMapSettings::debugDepthMapEnabled() const
1473{
1474 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1475
1476 return mDebugDepthMapEnabled;
1477}
1478
1479Qt::Corner Qgs3DMapSettings::debugDepthMapCorner() const
1480{
1481 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1482
1483 return mDebugDepthMapCorner;
1484}
1485
1486double Qgs3DMapSettings::debugDepthMapSize() const
1487{
1488 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1489
1490 return mDebugDepthMapSize;
1491}
1492
1493void Qgs3DMapSettings::setIsFpsCounterEnabled( bool fpsCounterEnabled )
1494{
1495 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1496
1497 if ( fpsCounterEnabled == mIsFpsCounterEnabled )
1498 return;
1499 mIsFpsCounterEnabled = fpsCounterEnabled;
1500 emit fpsCounterEnabledChanged( mIsFpsCounterEnabled );
1501}
1502
1503bool Qgs3DMapSettings::terrainRenderingEnabled() const
1504{
1505 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1506
1507 return mTerrainRenderingEnabled;
1508}
1509
1510void Qgs3DMapSettings::setTerrainRenderingEnabled( bool terrainRenderingEnabled )
1511{
1512 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1513
1514 if ( terrainRenderingEnabled == mTerrainRenderingEnabled )
1515 return;
1516 mTerrainRenderingEnabled = terrainRenderingEnabled;
1517 emit terrainGeneratorChanged();
1518}
1519
1520Qgis::RendererUsage Qgs3DMapSettings::rendererUsage() const
1521{
1522 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1523
1524 return mRendererUsage;
1525}
1526
1533
1540
1541void Qgs3DMapSettings::setViewSyncMode( Qgis::ViewSyncModeFlags mode )
1542{
1543 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1544
1545 mViewSyncMode = mode;
1546}
1547
1548bool Qgs3DMapSettings::viewFrustumVisualizationEnabled() const
1549{
1550 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1551
1552 return mVisualizeViewFrustum;
1553}
1554
1555void Qgs3DMapSettings::setViewFrustumVisualizationEnabled( bool enabled )
1556{
1557 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1558
1559 if ( mVisualizeViewFrustum != enabled )
1560 {
1561 mVisualizeViewFrustum = enabled;
1562 emit viewFrustumVisualizationEnabledChanged();
1563 }
1564}
1565
1566Qgs3DAxisSettings Qgs3DMapSettings::get3DAxisSettings() const
1567{
1568 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1569
1570 return m3dAxisSettings;
1571}
1572
1573void Qgs3DMapSettings::setIsDebugOverlayEnabled( bool debugOverlayEnabled )
1574{
1575 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1576
1577 if ( debugOverlayEnabled == mIsDebugOverlayEnabled )
1578 return;
1579
1580 mIsDebugOverlayEnabled = debugOverlayEnabled;
1581 emit debugOverlayEnabledChanged( mIsDebugOverlayEnabled );
1582}
1583
1584bool Qgs3DMapSettings::showExtentIn2DView() const
1585{
1586 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1587
1588 return mShowExtentIn2DView;
1589}
1590
1591void Qgs3DMapSettings::connectChangedSignalsToSettingsChanged()
1592{
1593 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1594
1595 connect( this, &Qgs3DMapSettings::selectionColorChanged, this, &Qgs3DMapSettings::settingsChanged );
1596 connect( this, &Qgs3DMapSettings::layersChanged, this, &Qgs3DMapSettings::settingsChanged );
1597 connect( this, &Qgs3DMapSettings::terrainGeneratorChanged, this, &Qgs3DMapSettings::settingsChanged );
1598 connect( this, &Qgs3DMapSettings::terrainSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1599 connect( this, &Qgs3DMapSettings::terrainShadingChanged, this, &Qgs3DMapSettings::settingsChanged );
1600 connect( this, &Qgs3DMapSettings::terrainMapThemeChanged, this, &Qgs3DMapSettings::settingsChanged );
1601 connect( this, &Qgs3DMapSettings::renderersChanged, this, &Qgs3DMapSettings::settingsChanged );
1602 connect( this, &Qgs3DMapSettings::showTerrainBoundingBoxesChanged, this, &Qgs3DMapSettings::settingsChanged );
1603 connect( this, &Qgs3DMapSettings::showTerrainTilesInfoChanged, this, &Qgs3DMapSettings::settingsChanged );
1604 connect( this, &Qgs3DMapSettings::showCameraViewCenterChanged, this, &Qgs3DMapSettings::settingsChanged );
1605 connect( this, &Qgs3DMapSettings::showCameraRotationCenterChanged, this, &Qgs3DMapSettings::settingsChanged );
1606 connect( this, &Qgs3DMapSettings::showLightSourceOriginsChanged, this, &Qgs3DMapSettings::settingsChanged );
1607 connect( this, &Qgs3DMapSettings::eyeDomeLightingEnabledChanged, this, &Qgs3DMapSettings::settingsChanged );
1608 connect( this, &Qgs3DMapSettings::eyeDomeLightingStrengthChanged, this, &Qgs3DMapSettings::settingsChanged );
1609 connect( this, &Qgs3DMapSettings::eyeDomeLightingDistanceChanged, this, &Qgs3DMapSettings::settingsChanged );
1610 connect( this, &Qgs3DMapSettings::debugShadowMapSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1611 connect( this, &Qgs3DMapSettings::debugDepthMapSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1612 connect( this, &Qgs3DMapSettings::lightSourcesChanged, this, &Qgs3DMapSettings::settingsChanged );
1613 connect( this, &Qgs3DMapSettings::fieldOfViewChanged, this, &Qgs3DMapSettings::settingsChanged );
1614 connect( this, &Qgs3DMapSettings::projectionTypeChanged, this, &Qgs3DMapSettings::settingsChanged );
1615 connect( this, &Qgs3DMapSettings::cameraNavigationModeChanged, this, &Qgs3DMapSettings::settingsChanged );
1616 connect( this, &Qgs3DMapSettings::cameraMovementSpeedChanged, this, &Qgs3DMapSettings::settingsChanged );
1617 connect( this, &Qgs3DMapSettings::skyboxSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1618 connect( this, &Qgs3DMapSettings::backgroundTypeChanged, this, &Qgs3DMapSettings::settingsChanged );
1619 connect( this, &Qgs3DMapSettings::shadowSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1620 connect( this, &Qgs3DMapSettings::fpsCounterEnabledChanged, this, &Qgs3DMapSettings::settingsChanged );
1621 connect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1622 connect( this, &Qgs3DMapSettings::ambientOcclusionSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1623 connect( this, &Qgs3DMapSettings::extentChanged, this, &Qgs3DMapSettings::settingsChanged );
1624 connect( this, &Qgs3DMapSettings::showExtentIn2DViewChanged, this, &Qgs3DMapSettings::settingsChanged );
1625 connect( this, &Qgs3DMapSettings::stopUpdatesChanged, this, &Qgs3DMapSettings::settingsChanged );
1626 connect( this, &Qgs3DMapSettings::showDebugPanelChanged, this, &Qgs3DMapSettings::settingsChanged );
1627}
1628
1629
1630void Qgs3DMapSettings::set3DAxisSettings( const Qgs3DAxisSettings &axisSettings, bool force )
1631{
1632 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1633
1634 if ( axisSettings == m3dAxisSettings )
1635 {
1636 if ( force )
1637 {
1638 // ie. refresh. We need to disconnect and to reconnect to avoid 'dirty' project
1639 disconnect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1640 emit axisSettingsChanged();
1641 connect( this, &Qgs3DMapSettings::axisSettingsChanged, this, &Qgs3DMapSettings::settingsChanged );
1642 }
1643 }
1644 else
1645 {
1646 m3dAxisSettings = axisSettings;
1647 emit axisSettingsChanged();
1648 }
1649}
1650
1651bool Qgs3DMapSettings::isDebugOverlayEnabled() const
1652{
1653 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1654
1655 return mIsDebugOverlayEnabled;
1656}
1657
1658void Qgs3DMapSettings::setShowExtentIn2DView( bool show )
1659{
1660 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1661
1662 if ( show == mShowExtentIn2DView )
1663 return;
1664
1665 mShowExtentIn2DView = show;
1666 emit showExtentIn2DViewChanged();
1667}
1668
1669bool Qgs3DMapSettings::is2DMapOverlayEnabled() const
1670{
1671 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1672
1673 return mShow2DMapOverlay;
1674}
1675
1676void Qgs3DMapSettings::setIs2DMapOverlayEnabled( bool enabled )
1677{
1678 QGIS_PROTECT_QOBJECT_THREAD_ACCESS
1679
1680 if ( mShow2DMapOverlay == enabled )
1681 return;
1682
1683 mShow2DMapOverlay = enabled;
1684 emit show2DMapOverlayChanged();
1685}
Qgis::CrsType::Geocentric
@ Geocentric
Geocentric CRS.
Definition qgis.h:2465
Qgis::ViewSyncModeFlags
QFlags< ViewSyncModeFlag > ViewSyncModeFlags
Definition qgis.h:3663
Qgis::NavigationMode
NavigationMode
The navigation mode used by 3D cameras.
Definition qgis.h:4400
Qgis::NavigationMode::TerrainBased
@ TerrainBased
The default navigation based on the terrain.
Definition qgis.h:4401
Qgis::NavigationMode::Walk
@ Walk
Uses WASD keys or arrows to navigate in walking (first person) manner.
Definition qgis.h:4402
Qgis::NavigationMode::GlobeTerrainBased
@ GlobeTerrainBased
Navigation similar to TerrainBased, but for use with globe.
Definition qgis.h:4403
Qgis::RendererUsage
RendererUsage
Usage of the renderer.
Definition qgis.h:3626
Qgis::SceneMode
SceneMode
The 3D scene mode used in 3D map views.
Definition qgis.h:4413
Qgis::SceneMode::Globe
@ Globe
Scene is represented as a globe using a geocentric CRS.
Definition qgis.h:4415
Qgis::SceneMode::Local
@ Local
Local scene based on a projected CRS.
Definition qgis.h:4414
Qgis::LightSourceType::Point
@ Point
Point light source.
Definition qgis.h:4361
Qgis::LightSourceType::Directional
@ Directional
Directional light source.
Definition qgis.h:4362
Qgs3DAxisSettings
Contains the configuration of a 3d axis.
Definition qgs3daxissettings.h:37
Qgs3DMapSettings::extentChanged
void extentChanged()
Emitted when the 3d view's 2d extent has changed.
Qgs3DMapSettings::setEyeDomeLightingStrength
void setEyeDomeLightingStrength(double strength)
Sets the eye dome lighting strength value.
Definition qgs3dmapsettings.cpp:1160
Qgs3DMapSettings::gradientBackgroundBottomColor
QColor gradientBackgroundBottomColor() const
Returns the bottom color of the gradient background of the 3D map view.
Definition qgs3dmapsettings.cpp:709
Qgs3DMapSettings::isDebugOverlayEnabled
bool isDebugOverlayEnabled() const
Returns whether debug overlay is enabled.
Definition qgs3dmapsettings.cpp:1651
Qgs3DMapSettings::debugDepthMapCorner
Qt::Corner debugDepthMapCorner() const
Returns the corner where the shadow map preview is displayed.
Definition qgs3dmapsettings.cpp:1479
Qgs3DMapSettings::originChanged
void originChanged()
Emitted when the world's origin point has been shifted.
Qgs3DMapSettings::setTransformContext
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the coordinate transform context, which stores various information regarding which datum transfo...
Definition qgs3dmapsettings.cpp:620
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:122
Qgs3DMapSettings::terrainShadingChanged
void terrainShadingChanged()
Emitted when terrain shading enabled flag or terrain shading material has changed.
Qgs3DMapSettings::isMsaaEnabled
bool isMsaaEnabled() const
Returns whether multisample anti-aliasing (MSAA) is enabled.
Definition qgs3dmapsettings.cpp:1205
Qgs3DMapSettings::pathResolver
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
Definition qgs3dmapsettings.cpp:627
Qgs3DMapSettings::setAmbientOcclusionSettings
void setAmbientOcclusionSettings(const QgsAmbientOcclusionSettings &ambientOcclusionSettings)
Sets the current configuration of screen space ambient occlusion.
Definition qgs3dmapsettings.cpp:1384
Qgs3DMapSettings::setShowTerrainTilesInfo
void setShowTerrainTilesInfo(bool enabled)
Sets whether to display extra tile info on top of terrain tiles (for debugging).
Definition qgs3dmapsettings.cpp:1035
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:568
Qgs3DMapSettings::showExtentIn2DView
bool showExtentIn2DView() const
Returns whether the extent is displayed on the main 2D map canvas.
Definition qgs3dmapsettings.cpp:1584
Qgs3DMapSettings::cameraMovementSpeed
double cameraMovementSpeed() const
Returns the camera movement speed.
Definition qgs3dmapsettings.cpp:1315
Qgs3DMapSettings::projectionType
Qt3DRender::QCameraLens::ProjectionType projectionType() const
Returns the camera lens' projection type.
Definition qgs3dmapsettings.cpp:1279
Qgs3DMapSettings::setEyeDomeLightingEnabled
void setEyeDomeLightingEnabled(bool enabled)
Sets whether eye dome lighting will be used.
Definition qgs3dmapsettings.cpp:1143
Qgs3DMapSettings::showDebugPanelChanged
void showDebugPanelChanged(bool shown)
Emitted when the Show debug panel checkbox changes value.
Qgs3DMapSettings::debugDepthMapEnabled
bool debugDepthMapEnabled() const
Returns whether the shadow map debugging is enabled.
Definition qgs3dmapsettings.cpp:1472
Qgs3DMapSettings::isSkyboxEnabled
Q_DECL_DEPRECATED bool isSkyboxEnabled() const
Returns whether the skybox is enabled.
Definition qgs3dmapsettings.cpp:1392
Qgs3DMapSettings::setFieldOfView
void setFieldOfView(const float fieldOfView)
Sets the camera lens' field of view.
Definition qgs3dmapsettings.cpp:1268
Qgs3DMapSettings::debugDepthMapSettingsChanged
void debugDepthMapSettingsChanged()
Emitted when depth map debugging has changed.
Qgs3DMapSettings::terrainElevationOffset
Q_DECL_DEPRECATED double terrainElevationOffset() const
Returns the elevation offset of the terrain (used to move the terrain up or down).
Definition qgs3dmapsettings.cpp:921
Qgs3DMapSettings::setLightSources
void setLightSources(const QList< QgsLightSource * > &lights)
Sets the list of light sources defined in the scene.
Definition qgs3dmapsettings.cpp:1219
Qgs3DMapSettings::outputDpi
double outputDpi() const
Returns DPI used for conversion between real world units (e.g.
Definition qgs3dmapsettings.cpp:1340
Qgs3DMapSettings::gradientBackgroundTopColor
QColor gradientBackgroundTopColor() const
Returns the top color of the gradient background of the 3D map view.
Definition qgs3dmapsettings.cpp:691
Qgs3DMapSettings::cameraNavigationMode
Qgis::NavigationMode cameraNavigationMode() const
Returns the navigation mode used by the camera.
Definition qgs3dmapsettings.cpp:1297
Qgs3DMapSettings::eyeDomeLightingStrength
double eyeDomeLightingStrength() const
Returns the eye dome lighting strength value.
Definition qgs3dmapsettings.cpp:1170
Qgs3DMapSettings::backgroundColorChanged
void backgroundColorChanged()
Emitted when the background color has changed.
Qgs3DMapSettings::showTerrainBoundingBoxesChanged
void showTerrainBoundingBoxesChanged()
Emitted when the flag whether terrain's bounding boxes are shown has changed.
Qgs3DMapSettings::setMaxTerrainGroundError
Q_DECL_DEPRECATED void setMaxTerrainGroundError(double error)
Sets the maximum ground error of terrain tiles in world units.
Definition qgs3dmapsettings.cpp:893
Qgs3DMapSettings::backgroundTypeChanged
void backgroundTypeChanged()
Emitted when the background type or gradient colors change.
Qgs3DMapSettings::terrainElevationOffsetChanged
Q_DECL_DEPRECATED void terrainElevationOffsetChanged(double newElevation)
Emitted when the terrain elevation offset is changed.
Qgs3DMapSettings::debugShadowMapCorner
Qt::Corner debugShadowMapCorner() const
Returns the corner where the shadow map preview is displayed.
Definition qgs3dmapsettings.cpp:1448
Qgs3DMapSettings::setMapThemeCollection
void setMapThemeCollection(QgsMapThemeCollection *mapThemes)
Sets pointer to the collection of map themes.
Definition qgs3dmapsettings.cpp:648
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:330
Qgs3DMapSettings::setDebugDepthMapSettings
void setDebugDepthMapSettings(bool enabled, Qt::Corner corner, double size)
Sets the debugging settings of the depth map.
Definition qgs3dmapsettings.cpp:1462
Qgs3DMapSettings::showCameraViewCenter
bool showCameraViewCenter() const
Returns whether to show camera's view center as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1064
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:738
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:980
Qgs3DMapSettings::terrainSettings
const QgsAbstractTerrainSettings * terrainSettings() const
Returns the terrain settings.
Definition qgs3dmapsettings.cpp:806
Qgs3DMapSettings::maxTerrainScreenErrorChanged
Q_DECL_DEPRECATED void maxTerrainScreenErrorChanged()
Emitted when the maximum terrain screen error has changed.
Qgs3DMapSettings::cameraNavigationModeChanged
void cameraNavigationModeChanged()
Emitted when the camera navigation mode was changed.
Qgs3DMapSettings::shadowSettingsChanged
void shadowSettingsChanged()
Emitted when shadow rendering settings are changed.
Qgs3DMapSettings::show2DMapOverlayChanged
void show2DMapOverlayChanged()
Emitted when the 2D map overlay is enabled or disabled.
Qgs3DMapSettings::stopUpdates
bool stopUpdates() const
Returns whether the scene updates on camera movement.
Definition qgs3dmapsettings.cpp:1136
Qgs3DMapSettings::setViewFrustumVisualizationEnabled
void setViewFrustumVisualizationEnabled(bool enabled)
Sets whether the camera's view frustum is visualized on the 2D map canvas.
Definition qgs3dmapsettings.cpp:1555
Qgs3DMapSettings::setShowCameraRotationCenter
void setShowCameraRotationCenter(bool enabled)
Sets whether to show camera's rotation center as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1071
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:527
Qgs3DMapSettings::eyeDomeLightingEnabledChanged
void eyeDomeLightingEnabledChanged()
Emitted when the flag whether eye dome lighting is used has changed.
Qgs3DMapSettings::setTerrainVerticalScale
Q_DECL_DEPRECATED void setTerrainVerticalScale(double zScale)
Sets vertical scale (exaggeration) of terrain (1 = true scale, > 1 = hills get more pronounced).
Definition qgs3dmapsettings.cpp:745
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:1333
Qgs3DMapSettings::setIsSkyboxEnabled
Q_DECL_DEPRECATED void setIsSkyboxEnabled(bool enabled)
Sets whether the skybox is enabled.
Definition qgs3dmapsettings.cpp:1399
Qgs3DMapSettings::sceneMode
Qgis::SceneMode sceneMode() const
Returns mode of the 3D scene - whether it is represented as a globe (when using Geocentric CRS such a...
Definition qgs3dmapsettings.cpp:606
Qgs3DMapSettings::setShowLabels
void setShowLabels(bool enabled)
Sets whether to display labels on terrain tiles.
Definition qgs3dmapsettings.cpp:1107
Qgs3DMapSettings::terrainVerticalScale
Q_DECL_DEPRECATED double terrainVerticalScale() const
Returns vertical scale (exaggeration) of terrain.
Definition qgs3dmapsettings.cpp:759
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:1541
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:550
Qgs3DMapSettings::setSkyboxSettings
void setSkyboxSettings(const QgsSkyboxSettings &skyboxSettings)
Sets the current configuration of the skybox.
Definition qgs3dmapsettings.cpp:1368
Qgs3DMapSettings::skyboxSettingsChanged
void skyboxSettingsChanged()
Emitted when skybox settings are changed.
Qgs3DMapSettings::backgroundType
BackgroundType backgroundType() const
Returns the background type for the 3D map view.
Definition qgs3dmapsettings.cpp:673
Qgs3DMapSettings::setMapTileResolution
Q_DECL_DEPRECATED void setMapTileResolution(int res)
Sets resolution (in pixels) of the texture of a terrain tile.
Definition qgs3dmapsettings.cpp:851
Qgs3DMapSettings::setLayers
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of 3D map layers to be rendered in the scene.
Definition qgs3dmapsettings.cpp:766
Qgs3DMapSettings::setShowDebugPanel
void setShowDebugPanel(bool enabled)
Sets whether the debug side panel is shown.
Definition qgs3dmapsettings.cpp:1413
Qgs3DMapSettings::shadowSettings
QgsShadowSettings shadowSettings() const
Returns the current configuration of shadows.
Definition qgs3dmapsettings.cpp:1354
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:1376
Qgs3DMapSettings::setGradientBackgroundTopColor
void setGradientBackgroundTopColor(const QColor &color)
Sets the top color of the gradient background of the 3D map view.
Definition qgs3dmapsettings.cpp:698
Qgs3DMapSettings::msaaEnabledChanged
void msaaEnabledChanged()
Emitted when the MSAA enabled flag has changed.
Qgs3DMapSettings::setIsDebugOverlayEnabled
void setIsDebugOverlayEnabled(bool debugOverlayEnabled)
Sets whether debug overlay is enabled The debug overlay displays some debugging and profiling informa...
Definition qgs3dmapsettings.cpp:1573
Qgs3DMapSettings::pointLightsChanged
void pointLightsChanged()
Emitted when the list of point lights changes.
Qgs3DMapSettings::lightSources
QList< QgsLightSource * > lightSources() const
Returns list of directional light sources defined in the scene.
Definition qgs3dmapsettings.cpp:1212
Qgs3DMapSettings::debugDepthMapSize
double debugDepthMapSize() const
Returns the size of the shadow map preview.
Definition qgs3dmapsettings.cpp:1486
Qgs3DMapSettings::setCrs
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets coordinate reference system used in the 3D scene.
Definition qgs3dmapsettings.cpp:582
Qgs3DMapSettings::maxTerrainScreenError
Q_DECL_DEPRECATED double maxTerrainScreenError() const
Returns maximum allowed screen error of terrain tiles in pixels.
Definition qgs3dmapsettings.cpp:886
Qgs3DMapSettings::get3DAxisSettings
Qgs3DAxisSettings get3DAxisSettings() const
Returns the current configuration of 3d axis.
Definition qgs3dmapsettings.cpp:1566
Qgs3DMapSettings::setEyeDomeLightingDistance
void setEyeDomeLightingDistance(int distance)
Sets the eye dome lighting distance value (contributes to the contrast of the image.
Definition qgs3dmapsettings.cpp:1177
Qgs3DMapSettings::maxTerrainGroundErrorChanged
Q_DECL_DEPRECATED void maxTerrainGroundErrorChanged()
Emitted when the maximum terrain ground error has changed.
Qgs3DMapSettings::viewFrustumVisualizationEnabled
bool viewFrustumVisualizationEnabled() const
Returns whether the camera's view frustum is visualized on the 2D map canvas.
Definition qgs3dmapsettings.cpp:1548
Qgs3DMapSettings::setShowLightSourceOrigins
void setShowLightSourceOrigins(bool enabled)
Sets whether to show light source origins as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1089
Qgs3DMapSettings::showDebugPanel
bool showDebugPanel() const
Returns whether the debug side panel is shown.
Definition qgs3dmapsettings.cpp:1424
Qgs3DMapSettings::is2DMapOverlayEnabled
bool is2DMapOverlayEnabled() const
Returns whether 2D map overlay is enabled.
Definition qgs3dmapsettings.cpp:1669
Qgs3DMapSettings::setIs2DMapOverlayEnabled
void setIs2DMapOverlayEnabled(bool enabled)
Sets whether 2D map overlay is enabled.
Definition qgs3dmapsettings.cpp:1676
Qgs3DMapSettings::setShowExtentIn2DView
void setShowExtentIn2DView(bool show)
Sets whether the extent is displayed on the main 2D map canvas.
Definition qgs3dmapsettings.cpp:1658
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:1261
Qgs3DMapSettings::BackgroundType
BackgroundType
Background rendering type for the 3D map view.
Definition qgs3dmapsettings.h:61
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:1361
Qgs3DMapSettings::extent
QgsRectangle extent() const
Returns the 3D scene's 2D extent in the 3D scene's CRS.
Definition qgs3dmapsettings.cpp:515
Qgs3DMapSettings::setTerrainShadingEnabled
void setTerrainShadingEnabled(bool enabled)
Sets whether terrain shading is enabled.
Definition qgs3dmapsettings.cpp:962
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:1534
Qgs3DMapSettings::mapTileResolutionChanged
Q_DECL_DEPRECATED void mapTileResolutionChanged()
Emitted when the map tile resoulution has changed.
Qgs3DMapSettings::stopUpdatesChanged
void stopUpdatesChanged()
Emitted when the flag whether to keep updating scene has changed.
Qgs3DMapSettings::setDebugShadowMapSettings
void setDebugShadowMapSettings(bool enabled, Qt::Corner corner, double size)
Sets the debugging settings of the shadow map.
Definition qgs3dmapsettings.cpp:1431
Qgs3DMapSettings::setMsaaEnabled
void setMsaaEnabled(bool enabled)
Sets whether multisample anti-aliasing (MSAA) is enabled.
Definition qgs3dmapsettings.cpp:1194
Qgs3DMapSettings::eyeDomeLightingDistance
int eyeDomeLightingDistance() const
Returns the eye dome lighting distance value (contributes to the contrast of the image).
Definition qgs3dmapsettings.cpp:1187
Qgs3DMapSettings::setBackgroundType
void setBackgroundType(BackgroundType type)
Sets the background type for the 3D map view.
Definition qgs3dmapsettings.cpp:680
Qgs3DMapSettings::setSelectionColor
void setSelectionColor(const QColor &color)
Sets color used for selected features.
Definition qgs3dmapsettings.cpp:727
Qgs3DMapSettings::setGradientBackgroundBottomColor
void setGradientBackgroundBottomColor(const QColor &color)
Sets the bottom color of the gradient background of the 3D map view.
Definition qgs3dmapsettings.cpp:716
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:955
Qgs3DMapSettings::setCameraNavigationMode
void setCameraNavigationMode(Qgis::NavigationMode navigationMode)
Sets the navigation mode for the camera.
Definition qgs3dmapsettings.cpp:1304
Qgs3DMapSettings::backgroundColor
QColor backgroundColor() const
Returns background color of the 3D map view.
Definition qgs3dmapsettings.cpp:666
Qgs3DMapSettings::terrainSettingsChanged
void terrainSettingsChanged()
Emitted when the terrain settings are changed.
Qgs3DMapSettings::resolveReferences
void resolveReferences(const QgsProject &project)
Resolves references to other objects (map layers) after the call to readXml().
Definition qgs3dmapsettings.cpp:492
Qgs3DMapSettings::debugShadowMapSize
double debugShadowMapSize() const
Returns the size of the shadow map preview.
Definition qgs3dmapsettings.cpp:1455
Qgs3DMapSettings::setPathResolver
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
Definition qgs3dmapsettings.cpp:634
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:575
Qgs3DMapSettings::showTerrainBoundingBoxes
bool showTerrainBoundingBoxes() const
Returns whether to display bounding boxes of terrain tiles (for debugging).
Definition qgs3dmapsettings.cpp:1027
Qgs3DMapSettings::showLabelsChanged
void showLabelsChanged()
Emitted when the flag whether labels are displayed on terrain tiles has changed.
Qgs3DMapSettings::setStopUpdates
void setStopUpdates(bool enabled)
Sets whether scene updates on camera movement should be enabled.
Definition qgs3dmapsettings.cpp:1125
Qgs3DMapSettings::setShowCameraViewCenter
void setShowCameraViewCenter(bool enabled)
Sets whether to show camera's view center as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1053
Qgs3DMapSettings::mapTileResolution
Q_DECL_DEPRECATED int mapTileResolution() const
Returns resolution (in pixels) of the texture of a terrain tile.
Definition qgs3dmapsettings.cpp:865
Qgs3DMapSettings::showLabels
bool showLabels() const
Returns whether to display labels on terrain tiles.
Definition qgs3dmapsettings.cpp:1118
Qgs3DMapSettings::setTerrainSettings
void setTerrainSettings(QgsAbstractTerrainSettings *settings)
Sets the terrain settings.
Definition qgs3dmapsettings.cpp:813
Qgs3DMapSettings::set3DAxisSettings
void set3DAxisSettings(const Qgs3DAxisSettings &axisSettings, bool force=false)
Sets the current configuration of 3d axis.
Definition qgs3dmapsettings.cpp:1630
Qgs3DMapSettings::setCameraMovementSpeed
void setCameraMovementSpeed(double movementSpeed)
Sets the camera movement speed.
Definition qgs3dmapsettings.cpp:1322
Qgs3DMapSettings::setTerrainRenderingEnabled
void setTerrainRenderingEnabled(bool terrainRenderingEnabled)
Sets whether the 2D terrain surface will be rendered in.
Definition qgs3dmapsettings.cpp:1510
Qgs3DMapSettings::debugShadowMapEnabled
bool debugShadowMapEnabled() const
Returns whether the shadow map debugging is enabled.
Definition qgs3dmapsettings.cpp:1441
Qgs3DMapSettings::setMaxTerrainScreenError
Q_DECL_DEPRECATED void setMaxTerrainScreenError(double error)
Sets maximum allowed screen error of terrain tiles in pixels.
Definition qgs3dmapsettings.cpp:872
Qgs3DMapSettings::setBackgroundColor
void setBackgroundColor(const QColor &color)
Sets background color of the 3D map view.
Definition qgs3dmapsettings.cpp:655
Qgs3DMapSettings::terrainRenderingEnabled
bool terrainRenderingEnabled() const
Returns whether the 2D terrain surface will be rendered.
Definition qgs3dmapsettings.cpp:1503
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:1286
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:1046
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:793
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:1347
Qgs3DMapSettings::maxTerrainGroundError
Q_DECL_DEPRECATED double maxTerrainGroundError() const
Returns maximum ground error of terrain tiles in world units.
Definition qgs3dmapsettings.cpp:928
Qgs3DMapSettings::isTerrainShadingEnabled
bool isTerrainShadingEnabled() const
Returns whether terrain shading is enabled.
Definition qgs3dmapsettings.cpp:973
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:599
Qgs3DMapSettings::eyeDomeLightingEnabled
bool eyeDomeLightingEnabled() const
Returns whether eye dome lighting is used.
Definition qgs3dmapsettings.cpp:1153
Qgs3DMapSettings::terrainShadingMaterial
QgsPhongMaterialSettings terrainShadingMaterial() const
Returns terrain shading material.
Definition qgs3dmapsettings.cpp:991
Qgs3DMapSettings::setRendererUsage
void setRendererUsage(Qgis::RendererUsage rendererUsage)
Sets the renderer usage.
Definition qgs3dmapsettings.cpp:1527
Qgs3DMapSettings::isFpsCounterEnabled
bool isFpsCounterEnabled() const
Returns whether FPS counter label is enabled.
Definition qgs3dmapsettings.cpp:1406
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:1009
Qgs3DMapSettings::setShowTerrainBoundingBoxes
void setShowTerrainBoundingBoxes(bool enabled)
Sets whether to display bounding boxes of terrain tiles (for debugging).
Definition qgs3dmapsettings.cpp:1016
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:1520
Qgs3DMapSettings::setIsFpsCounterEnabled
void setIsFpsCounterEnabled(bool fpsCounterEnabled)
Sets whether FPS counter label is enabled.
Definition qgs3dmapsettings.cpp:1493
Qgs3DMapSettings::mapThemeCollection
QgsMapThemeCollection * mapThemeCollection() const
Returns pointer to the collection of map themes.
Definition qgs3dmapsettings.cpp:641
Qgs3DMapSettings::layers
QList< QgsMapLayer * > layers() const
Returns the list of 3D map layers to be rendered in the scene.
Definition qgs3dmapsettings.cpp:779
Qgs3DMapSettings::setTerrainMapTheme
void setTerrainMapTheme(const QString &theme)
Sets name of the map theme.
Definition qgs3dmapsettings.cpp:998
Qgs3DMapSettings::setTerrainElevationOffset
Q_DECL_DEPRECATED void setTerrainElevationOffset(double offset)
Sets the terrain elevation offset (used to move the terrain up or down).
Definition qgs3dmapsettings.cpp:908
Qgs3DMapSettings::terrainVerticalScaleChanged
Q_DECL_DEPRECATED void terrainVerticalScaleChanged()
Emitted when the vertical scale of the terrain has changed.
Qgs3DMapSettings::terrainGeneratorChanged
void terrainGeneratorChanged()
Emitted when the terrain generator has changed.
Qgs3DMapSettings::showLightSourceOrigins
bool showLightSourceOrigins() const
Returns whether to show light source origins as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1100
Qgs3DMapSettings::setTerrainGenerator
void setTerrainGenerator(QgsTerrainGenerator *gen)
Sets terrain generator and sets extent() as the generator's extent.
Definition qgs3dmapsettings.cpp:935
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::transformContext
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
Definition qgs3dmapsettings.cpp:613
Qgs3DMapSettings::origin
QgsVector3D origin() const
Returns coordinates in map CRS at which 3D scene has origin (0,0,0).
Definition qgs3dmapsettings.cpp:561
Qgs3DMapSettings::showCameraRotationCenter
bool showCameraRotationCenter() const
Returns whether to show camera's rotation center as a sphere (for debugging).
Definition qgs3dmapsettings.cpp:1082
Qgs3DRenderContext::fromMapSettings
static Qgs3DRenderContext fromMapSettings(const Qgs3DMapSettings *mapSettings)
Creates an initialized Qgs3DRenderContext instance from given Qgs3DMapSettings.
Definition qgs3drendercontext.cpp:59
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:643
Qgs3DUtils::worldToMapCoordinates
static QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords, const QgsVector3D &origin)
Converts 3D world coordinates to map coordinates (applies offset).
Definition qgs3dutils.cpp:638
Qgs3DUtils::mapToWorldCoordinates
static QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords, const QgsVector3D &origin)
Converts map coordinates to 3D world coordinates (applies offset).
Definition qgs3dutils.cpp:633
Qgs3D::terrainRegistry
static Qgs3DTerrainRegistry * terrainRegistry()
Returns the terrain registry, used for managing 3D terrains.
Definition qgs3d.cpp:119
QgsAbstractTerrainSettings
Base class for all terrain settings classes.
Definition qgsabstractterrainsettings.h:45
QgsAbstractTerrainSettings::equals
virtual bool equals(const QgsAbstractTerrainSettings *other) const =0
Returns true if this settings is exactly equal to another other settings.
QgsAmbientOcclusionSettings
Contains the configuration of ambient occlusion rendering.
Definition qgsambientocclusionsettings.h:37
QgsColorUtils::colorFromString
static QColor colorFromString(const QString &string)
Decodes a string into a color value.
Definition qgscolorutils.cpp:239
QgsColorUtils::colorToString
static QString colorToString(const QColor &color)
Encodes a color into a string value.
Definition qgscolorutils.cpp:174
QgsCoordinateReferenceSystem
Represents a coordinate reference system (CRS).
Definition qgscoordinatereferencesystem.h:216
QgsCoordinateReferenceSystem::isValid
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
Definition qgscoordinatereferencesystem.cpp:1023
QgsCoordinateTransformContext
Contains information about the context in which a coordinate transform is executed.
Definition qgscoordinatetransformcontext.h:58
QgsDirectionalLightSettings
Definition of a directional light in a 3D map scene.
Definition qgsdirectionallightsettings.h:34
QgsFlatTerrainSettings
Terrain settings for a simple flat area terrain.
Definition qgsflatterrainsettings.h:38
QgsLightSource
Base class for light sources in 3d scenes.
Definition qgslightsource.h:47
QgsLightSource::createFromXml
static QgsLightSource * createFromXml(const QDomElement &element, const QgsReadWriteContext &context)
Creates a new light source from an XML element.
Definition qgslightsource.cpp:33
QgsMapThemeCollection
Container class that allows storage of map themes consisting of visible map layers and layer styles.
Definition qgsmapthemecollection.h:44
QgsPathResolver
Resolves relative paths into absolute paths and vice versa.
Definition qgspathresolver.h:35
QgsPhongMaterialSettings
Basic shading material used for rendering based on the Phong shading model with three color component...
Definition qgsphongmaterialsettings.h:37
QgsPointLightSettings
Definition of a point light in a 3D map scene.
Definition qgspointlightsettings.h:40
QgsPointXY
Represents a 2D point.
Definition qgspointxy.h:62
QgsPointXY::y
double y
Definition qgspointxy.h:66
QgsPointXY::x
double x
Definition qgspointxy.h:65
QgsProjectDirtyBlocker
Temporarily blocks QgsProject "dirtying" for the lifetime of the object.
Definition qgsproject.h:2675
QgsProjectElevationProperties
Contains elevation properties for a QgsProject.
Definition qgsprojectelevationproperties.h:41
QgsProjectViewSettings::fullExtent
QgsReferencedRectangle fullExtent() const
Returns the full extent of the project, which represents the maximal limits of the project.
Definition qgsprojectviewsettings.cpp:90
QgsProject
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:114
QgsProject::instance
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition qgsproject.cpp:490
QgsProject::mapLayer
Q_INVOKABLE QgsMapLayer * mapLayer(const QString &layerId) const
Retrieve a pointer to a registered layer by layer ID.
Definition qgsproject.cpp:4718
QgsProject::setDirty
void setDirty(bool b=true)
Flag the project as dirty (modified).
Definition qgsproject.cpp:609
QgsProject::viewSettings
const QgsProjectViewSettings * viewSettings() const
Returns the project's view settings, which contains settings and properties relating to how a QgsProj...
Definition qgsproject.cpp:4467
QgsReadWriteContext
A container for the context for various read/write operations on objects.
Definition qgsreadwritecontext.h:38
QgsRectangle
A rectangle specified with double values.
Definition qgsrectangle.h:47
QgsShadowSettings
Contains configuration for rendering shadows.
Definition qgsshadowsettings.h:36
QgsSkyboxSettings
Contains the configuration of a skybox entity.
Definition qgsskyboxsettings.h:40
QgsTemporalRangeObject::temporalRange
const QgsDateTimeRange & temporalRange() const
Returns the datetime range for the object.
Definition qgstemporalrangeobject.cpp:42
QgsTemporalRangeObject::QgsTemporalRangeObject
QgsTemporalRangeObject(bool enabled=false)
Constructor QgsTemporalRangeObject.
Definition qgstemporalrangeobject.cpp:20
QgsTemporalRangeObject::setTemporalRange
void setTemporalRange(const QgsDateTimeRange &range)
Sets the temporal range for the object.
Definition qgstemporalrangeobject.cpp:34
QgsTerrainGenerator
Base class for generators of terrain.
Definition qgsterraingenerator.h:50
QgsTerrainGenerator::terrainChanged
void terrainChanged()
Emitted when the terrain changed (for example, raster DEM or mesh have data changed).
QgsTerrainGenerator::setExtent
virtual void setExtent(const QgsRectangle &extent)
sets the extent of the terrain in terrain's CRS
Definition qgsterraingenerator.h:95
QgsTerrainGenerator::crs
virtual QgsCoordinateReferenceSystem crs() const
Returns CRS of the terrain.
Definition qgsterraingenerator.h:126
QgsVector3D
A 3D vector (similar to QVector3D) with the difference that it uses double precision instead of singl...
Definition qgsvector3d.h:33
Q_NOWARN_DEPRECATED_POP
#define Q_NOWARN_DEPRECATED_POP
Definition qgis.h:7666
Q_NOWARN_DEPRECATED_PUSH
#define Q_NOWARN_DEPRECATED_PUSH
Definition qgis.h:7665
QgsDebugError
#define QgsDebugError(str)
Definition qgslogger.h:59
qgsmaplayerlistutils_p.h
QgsMapLayerRef
_LayerRef< QgsMapLayer > QgsMapLayerRef
Definition qgsmaplayerref.h:325
QgsDateTimeRange
QgsTemporalRange< QDateTime > QgsDateTimeRange
QgsRange which stores a range of date times.
Definition qgsrange.h:705
QGIS_PROTECT_QOBJECT_THREAD_ACCESS
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS
Definition qgsthreadingutils.h:78
_LayerRef::setLayer
void setLayer(TYPE *l)
Sets the reference to point to a specified layer.
Definition qgsmaplayerref.h:82
_LayerRef::layerId
QString layerId
Original layer ID.
Definition qgsmaplayerref.h:117
Generated on for QGIS API Documentation by doxygen 1.15.0