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