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