QGIS API Documentation 3.27.0-Master (f261cc1f8b)
qgs3dmapsettings.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgs3dmapsettings.cpp
3 --------------------------------------
4 Date : July 2017
5 Copyright : (C) 2017 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgs3dmapsettings.h"
17
18#include "qgs3dutils.h"
21#include "qgsmeshterraingenerator.h"
27#include "qgsterrainprovider.h"
28
29#include <QDomDocument>
30#include <QDomElement>
31
32#include "qgssymbollayerutils.h"
33#include "qgsrasterlayer.h"
34
36 : QObject( nullptr )
37{
38 connect( this, &Qgs3DMapSettings::settingsChanged, [&]()
39 {
41 } );
42 connectChangedSignalsToSettingsChanged();
43}
44
46 : QObject( nullptr )
47 , QgsTemporalRangeObject( other )
48 , mOrigin( other.mOrigin )
49 , mCrs( other.mCrs )
50 , mBackgroundColor( other.mBackgroundColor )
51 , mSelectionColor( other.mSelectionColor )
52 , mTerrainVerticalScale( other.mTerrainVerticalScale )
53 , mTerrainGenerator( other.mTerrainGenerator ? other.mTerrainGenerator->clone() : nullptr )
54 , mMapTileResolution( other.mMapTileResolution )
55 , mMaxTerrainScreenError( other.mMaxTerrainScreenError )
56 , mMaxTerrainGroundError( other.mMaxTerrainGroundError )
57 , mTerrainElevationOffset( other.mTerrainElevationOffset )
58 , mTerrainShadingEnabled( other.mTerrainShadingEnabled )
59 , mTerrainShadingMaterial( other.mTerrainShadingMaterial )
60 , mTerrainMapTheme( other.mTerrainMapTheme )
61 , mShowTerrainBoundingBoxes( other.mShowTerrainBoundingBoxes )
62 , mShowTerrainTileInfo( other.mShowTerrainTileInfo )
63 , mShowCameraViewCenter( other.mShowCameraViewCenter )
64 , mShowCameraRotationCenter( other.mShowCameraRotationCenter )
65 , mShowLightSources( other.mShowLightSources )
66 , mShowLabels( other.mShowLabels )
67 , mFieldOfView( other.mFieldOfView )
68 , mProjectionType( other.mProjectionType )
69 , mCameraNavigationMode( other.mCameraNavigationMode )
70 , mCameraMovementSpeed( other.mCameraMovementSpeed )
71 , mLayers( other.mLayers )
72 , mRenderers() // initialized in body
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 , mEyeDomeLightingEnabled( other.mEyeDomeLightingEnabled )
82 , mEyeDomeLightingStrength( other.mEyeDomeLightingStrength )
83 , mEyeDomeLightingDistance( other.mEyeDomeLightingDistance )
84 , mViewSyncMode( other.mViewSyncMode )
85 , mVisualizeViewFrustum( other.mVisualizeViewFrustum )
86 , mDebugShadowMapEnabled( other.mDebugShadowMapEnabled )
87 , mDebugShadowMapCorner( other.mDebugShadowMapCorner )
88 , mDebugShadowMapSize( other.mDebugShadowMapSize )
89 , mDebugDepthMapEnabled( other.mDebugDepthMapEnabled )
90 , mDebugDepthMapCorner( other.mDebugDepthMapCorner )
91 , mDebugDepthMapSize( other.mDebugDepthMapSize )
92 , mTerrainRenderingEnabled( other.mTerrainRenderingEnabled )
93 , mRendererUsage( other.mRendererUsage )
94 , m3dAxisSettings( other.m3dAxisSettings )
95 , mIsDebugOverlayEnabled( other.mIsDebugOverlayEnabled )
96{
97 for ( QgsAbstract3DRenderer *renderer : std::as_const( other.mRenderers ) )
98 {
99 mRenderers << renderer->clone();
100 }
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 {
111 } );
112 connectChangedSignalsToSettingsChanged();
113}
114
116{
117 qDeleteAll( mRenderers );
118 qDeleteAll( mLightSources );
119}
120
121void Qgs3DMapSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
122{
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 QDomElement elemCamera = elem.firstChildElement( QStringLiteral( "camera" ) );
131 if ( !elemCamera.isNull() )
132 {
133 mFieldOfView = elemCamera.attribute( QStringLiteral( "field-of-view" ), QStringLiteral( "45" ) ).toFloat();
134 mProjectionType = static_cast< Qt3DRender::QCameraLens::ProjectionType >( elemCamera.attribute( QStringLiteral( "projection-type" ), QStringLiteral( "1" ) ).toInt() );
135 QString cameraNavigationMode = elemCamera.attribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "basic-navigation" ) );
136 if ( cameraNavigationMode == QLatin1String( "terrain-based-navigation" ) )
137 mCameraNavigationMode = QgsCameraController::NavigationMode::TerrainBasedNavigation;
138 else if ( cameraNavigationMode == QLatin1String( "walk-navigation" ) )
139 mCameraNavigationMode = QgsCameraController::NavigationMode::WalkNavigation;
140 mCameraMovementSpeed = elemCamera.attribute( QStringLiteral( "camera-movement-speed" ), QStringLiteral( "5.0" ) ).toDouble();
141 }
142
143 QDomElement elemColor = elem.firstChildElement( QStringLiteral( "color" ) );
144 if ( !elemColor.isNull() )
145 {
146 mBackgroundColor = QgsSymbolLayerUtils::decodeColor( elemColor.attribute( QStringLiteral( "background" ) ) );
147 mSelectionColor = QgsSymbolLayerUtils::decodeColor( elemColor.attribute( QStringLiteral( "selection" ) ) );
148 }
149
150 QDomElement elemCrs = elem.firstChildElement( QStringLiteral( "crs" ) );
151 mCrs.readXml( elemCrs );
152
153 QDomElement elemTerrain = elem.firstChildElement( QStringLiteral( "terrain" ) );
154 mTerrainRenderingEnabled = elemTerrain.attribute( QStringLiteral( "terrain-rendering-enabled" ), QStringLiteral( "1" ) ).toInt();
155 mTerrainVerticalScale = elemTerrain.attribute( QStringLiteral( "exaggeration" ), QStringLiteral( "1" ) ).toFloat();
156 mMapTileResolution = elemTerrain.attribute( QStringLiteral( "texture-size" ), QStringLiteral( "512" ) ).toInt();
157 mMaxTerrainScreenError = elemTerrain.attribute( QStringLiteral( "max-terrain-error" ), QStringLiteral( "3" ) ).toFloat();
158 mMaxTerrainGroundError = elemTerrain.attribute( QStringLiteral( "max-ground-error" ), QStringLiteral( "1" ) ).toFloat();
159 mTerrainShadingEnabled = elemTerrain.attribute( QStringLiteral( "shading-enabled" ), QStringLiteral( "0" ) ).toInt();
160 mTerrainElevationOffset = elemTerrain.attribute( QStringLiteral( "elevation-offset" ), QStringLiteral( "0.0" ) ).toFloat();
161
162 QDomElement elemTerrainShadingMaterial = elemTerrain.firstChildElement( QStringLiteral( "shading-material" ) );
163 if ( !elemTerrainShadingMaterial.isNull() )
164 mTerrainShadingMaterial.readXml( elemTerrainShadingMaterial, context );
165 mTerrainMapTheme = elemTerrain.attribute( QStringLiteral( "map-theme" ) );
166 mShowLabels = elemTerrain.attribute( QStringLiteral( "show-labels" ), QStringLiteral( "0" ) ).toInt();
167
168 qDeleteAll( mLightSources );
169 mLightSources.clear();
170 const QDomElement lightsElem = elem.firstChildElement( QStringLiteral( "lights" ) );
171 if ( !lightsElem.isNull() )
172 {
173 const QDomNodeList lightNodes = lightsElem.childNodes();
174 for ( int i = 0; i < lightNodes.size(); ++i )
175 {
176 const QDomElement lightElement = lightNodes.at( i ).toElement();
177 if ( QgsLightSource *light = QgsLightSource::createFromXml( lightElement, context ) )
178 mLightSources << light;
179 }
180 }
181 else
182 {
183 // older project format
184 QDomElement elemPointLights = elem.firstChildElement( QStringLiteral( "point-lights" ) );
185 if ( !elemPointLights.isNull() )
186 {
187 QDomElement elemPointLight = elemPointLights.firstChildElement( QStringLiteral( "point-light" ) );
188 while ( !elemPointLight.isNull() )
189 {
190 std::unique_ptr< QgsPointLightSettings > pointLight = std::make_unique< QgsPointLightSettings >();
191 pointLight->readXml( elemPointLight, context );
192 mLightSources << pointLight.release();
193 elemPointLight = elemPointLight.nextSiblingElement( QStringLiteral( "point-light" ) );
194 }
195 }
196 else
197 {
198 // QGIS <= 3.4 did not have light configuration
199 std::unique_ptr< QgsPointLightSettings > defaultLight = std::make_unique< QgsPointLightSettings >();
200 defaultLight->setPosition( QgsVector3D( 0, 1000, 0 ) );
201 mLightSources << defaultLight.release();
202 }
203
204 QDomElement elemDirectionalLights = elem.firstChildElement( QStringLiteral( "directional-lights" ) );
205 if ( !elemDirectionalLights.isNull() )
206 {
207 QDomElement elemDirectionalLight = elemDirectionalLights.firstChildElement( QStringLiteral( "directional-light" ) );
208 while ( !elemDirectionalLight.isNull() )
209 {
210 std::unique_ptr< QgsDirectionalLightSettings > directionalLight = std::make_unique< QgsDirectionalLightSettings >();
211 directionalLight->readXml( elemDirectionalLight, context );
212 mLightSources << directionalLight.release();
213 elemDirectionalLight = elemDirectionalLight.nextSiblingElement( QStringLiteral( "directional-light" ) );
214 }
215 }
216 }
217
218 QDomElement elemMapLayers = elemTerrain.firstChildElement( QStringLiteral( "layers" ) );
219 QDomElement elemMapLayer = elemMapLayers.firstChildElement( QStringLiteral( "layer" ) );
220 QList<QgsMapLayerRef> mapLayers;
221 while ( !elemMapLayer.isNull() )
222 {
223 mapLayers << QgsMapLayerRef( elemMapLayer.attribute( QStringLiteral( "id" ) ) );
224 elemMapLayer = elemMapLayer.nextSiblingElement( QStringLiteral( "layer" ) );
225 }
226 mLayers = mapLayers; // needs to resolve refs afterwards
227
228 QDomElement elemTerrainGenerator = elemTerrain.firstChildElement( QStringLiteral( "generator" ) );
229 QString terrainGenType = elemTerrainGenerator.attribute( QStringLiteral( "type" ) );
230 if ( terrainGenType == QLatin1String( "dem" ) )
231 {
232 QgsDemTerrainGenerator *demTerrainGenerator = new QgsDemTerrainGenerator;
233 demTerrainGenerator->setCrs( mCrs, mTransformContext );
234 setTerrainGenerator( demTerrainGenerator );
235 }
236 else if ( terrainGenType == QLatin1String( "online" ) )
237 {
238 QgsOnlineTerrainGenerator *onlineTerrainGenerator = new QgsOnlineTerrainGenerator;
239 onlineTerrainGenerator->setCrs( mCrs, mTransformContext );
240 setTerrainGenerator( onlineTerrainGenerator );
241 }
242 else if ( terrainGenType == QLatin1String( "mesh" ) )
243 {
244 QgsMeshTerrainGenerator *meshTerrainGenerator = new QgsMeshTerrainGenerator;
245 meshTerrainGenerator->setCrs( mCrs, mTransformContext );
246 setTerrainGenerator( meshTerrainGenerator );
247 }
248 else // "flat"
249 {
251 flatGen->setCrs( mCrs );
252 setTerrainGenerator( flatGen );
253 }
254 mTerrainGenerator->readXml( elemTerrainGenerator );
255
256 qDeleteAll( mRenderers );
257 mRenderers.clear();
258
259 QDomElement elemRenderers = elem.firstChildElement( QStringLiteral( "renderers" ) );
260 QDomElement elemRenderer = elemRenderers.firstChildElement( QStringLiteral( "renderer" ) );
261 while ( !elemRenderer.isNull() )
262 {
263 QgsAbstract3DRenderer *renderer = nullptr;
264 QString type = elemRenderer.attribute( QStringLiteral( "type" ) );
265 if ( type == QLatin1String( "vector" ) )
266 {
267 renderer = new QgsVectorLayer3DRenderer;
268 }
269 else if ( type == QLatin1String( "mesh" ) )
270 {
271 renderer = new QgsMeshLayer3DRenderer;
272 }
273 else if ( type == QLatin1String( "pointcloud" ) )
274 {
275 renderer = new QgsPointCloudLayer3DRenderer;
276 }
277
278 if ( renderer )
279 {
280 renderer->readXml( elemRenderer, context );
281 mRenderers.append( renderer );
282 }
283 elemRenderer = elemRenderer.nextSiblingElement( QStringLiteral( "renderer" ) );
284 }
285
286 QDomElement elemSkybox = elem.firstChildElement( QStringLiteral( "skybox" ) );
287 mIsSkyboxEnabled = elemSkybox.attribute( QStringLiteral( "skybox-enabled" ) ).toInt();
288 mSkyboxSettings.readXml( elemSkybox, context );
289
290 QDomElement elemShadows = elem.firstChildElement( QStringLiteral( "shadow-rendering" ) );
291 mShadowSettings.readXml( elemShadows, context );
292
293 QDomElement elemEyeDomeLighting = elem.firstChildElement( QStringLiteral( "eye-dome-lighting" ) );
294 mEyeDomeLightingEnabled = elemEyeDomeLighting.attribute( "enabled", QStringLiteral( "0" ) ).toInt();
295 mEyeDomeLightingStrength = elemEyeDomeLighting.attribute( "eye-dome-lighting-strength", QStringLiteral( "1000.0" ) ).toDouble();
296 mEyeDomeLightingDistance = elemEyeDomeLighting.attribute( "eye-dome-lighting-distance", QStringLiteral( "1" ) ).toInt();
297
298 QDomElement elemNavigationSync = elem.firstChildElement( QStringLiteral( "navigation-sync" ) );
299 mViewSyncMode = ( Qgis::ViewSyncModeFlags )( elemNavigationSync.attribute( QStringLiteral( "view-sync-mode" ), QStringLiteral( "0" ) ).toInt() );
300 mVisualizeViewFrustum = elemNavigationSync.attribute( QStringLiteral( "view-frustum-visualization-enabled" ), QStringLiteral( "0" ) ).toInt();
301
302 QDomElement elemDebugSettings = elem.firstChildElement( QStringLiteral( "debug-settings" ) );
303 mDebugShadowMapEnabled = elemDebugSettings.attribute( QStringLiteral( "shadowmap-enabled" ), QStringLiteral( "0" ) ).toInt();
304 mDebugShadowMapCorner = static_cast<Qt::Corner>( elemDebugSettings.attribute( QStringLiteral( "shadowmap-corner" ), "0" ).toInt() );
305 mDebugShadowMapSize = elemDebugSettings.attribute( QStringLiteral( "shadowmap-size" ), QStringLiteral( "0.2" ) ).toDouble();
306
307 mDebugDepthMapEnabled = elemDebugSettings.attribute( QStringLiteral( "depthmap-enabled" ), QStringLiteral( "0" ) ).toInt();
308 mDebugDepthMapCorner = static_cast<Qt::Corner>( elemDebugSettings.attribute( QStringLiteral( "depthmap-corner" ), QStringLiteral( "1" ) ).toInt() );
309 mDebugDepthMapSize = elemDebugSettings.attribute( QStringLiteral( "depthmap-size" ), QStringLiteral( "0.2" ) ).toDouble();
310
311 QDomElement elemDebug = elem.firstChildElement( QStringLiteral( "debug" ) );
312 mShowTerrainBoundingBoxes = elemDebug.attribute( QStringLiteral( "bounding-boxes" ), QStringLiteral( "0" ) ).toInt();
313 mShowTerrainTileInfo = elemDebug.attribute( QStringLiteral( "terrain-tile-info" ), QStringLiteral( "0" ) ).toInt();
314 mShowCameraViewCenter = elemDebug.attribute( QStringLiteral( "camera-view-center" ), QStringLiteral( "0" ) ).toInt();
315 mShowCameraRotationCenter = elemDebug.attribute( QStringLiteral( "camera-rotation-center" ), QStringLiteral( "0" ) ).toInt();
316 mShowLightSources = elemDebug.attribute( QStringLiteral( "show-light-sources" ), QStringLiteral( "0" ) ).toInt();
317 mIsFpsCounterEnabled = elemDebug.attribute( QStringLiteral( "show-fps-counter" ), QStringLiteral( "0" ) ).toInt();
318
319 QDomElement elemTemporalRange = elem.firstChildElement( QStringLiteral( "temporal-range" ) );
320 QDateTime start = QDateTime::fromString( elemTemporalRange.attribute( QStringLiteral( "start" ) ), Qt::ISODate );
321 QDateTime end = QDateTime::fromString( elemTemporalRange.attribute( QStringLiteral( "end" ) ), Qt::ISODate );
322 setTemporalRange( QgsDateTimeRange( start, end ) );
323
324 QDomElement elem3dAxis = elem.firstChildElement( QStringLiteral( "axis3d" ) );
325 m3dAxisSettings.readXml( elem3dAxis, context );
326
327}
328
329QDomElement Qgs3DMapSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
330{
331 QDomElement elem = doc.createElement( QStringLiteral( "qgis3d" ) );
332
333 QDomElement elemOrigin = doc.createElement( QStringLiteral( "origin" ) );
334 elemOrigin.setAttribute( QStringLiteral( "x" ), QString::number( mOrigin.x() ) );
335 elemOrigin.setAttribute( QStringLiteral( "y" ), QString::number( mOrigin.y() ) );
336 elemOrigin.setAttribute( QStringLiteral( "z" ), QString::number( mOrigin.z() ) );
337 elem.appendChild( elemOrigin );
338
339 QDomElement elemCamera = doc.createElement( QStringLiteral( "camera" ) );
340 elemCamera.setAttribute( QStringLiteral( "field-of-view" ), mFieldOfView );
341 elemCamera.setAttribute( QStringLiteral( "projection-type" ), static_cast< int >( mProjectionType ) );
342 switch ( mCameraNavigationMode )
343 {
345 elemCamera.setAttribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "terrain-based-navigation" ) );
346 break;
348 elemCamera.setAttribute( QStringLiteral( "camera-navigation-mode" ), QStringLiteral( "walk-navigation" ) );
349 break;
350 }
351 elemCamera.setAttribute( QStringLiteral( "camera-movement-speed" ), mCameraMovementSpeed );
352 elem.appendChild( elemCamera );
353
354 QDomElement elemColor = doc.createElement( QStringLiteral( "color" ) );
355 elemColor.setAttribute( QStringLiteral( "background" ), QgsSymbolLayerUtils::encodeColor( mBackgroundColor ) );
356 elemColor.setAttribute( QStringLiteral( "selection" ), QgsSymbolLayerUtils::encodeColor( mSelectionColor ) );
357 elem.appendChild( elemColor );
358
359 QDomElement elemCrs = doc.createElement( QStringLiteral( "crs" ) );
360 mCrs.writeXml( elemCrs, doc );
361 elem.appendChild( elemCrs );
362
363 QDomElement elemTerrain = doc.createElement( QStringLiteral( "terrain" ) );
364 elemTerrain.setAttribute( QStringLiteral( "terrain-rendering-enabled" ), mTerrainRenderingEnabled ? 1 : 0 );
365 elemTerrain.setAttribute( QStringLiteral( "exaggeration" ), QString::number( mTerrainVerticalScale ) );
366 elemTerrain.setAttribute( QStringLiteral( "texture-size" ), mMapTileResolution );
367 elemTerrain.setAttribute( QStringLiteral( "max-terrain-error" ), QString::number( mMaxTerrainScreenError ) );
368 elemTerrain.setAttribute( QStringLiteral( "max-ground-error" ), QString::number( mMaxTerrainGroundError ) );
369 elemTerrain.setAttribute( QStringLiteral( "shading-enabled" ), mTerrainShadingEnabled ? 1 : 0 );
370 elemTerrain.setAttribute( QStringLiteral( "elevation-offset" ), mTerrainElevationOffset );
371
372 QDomElement elemTerrainShadingMaterial = doc.createElement( QStringLiteral( "shading-material" ) );
373 mTerrainShadingMaterial.writeXml( elemTerrainShadingMaterial, context );
374 elemTerrain.appendChild( elemTerrainShadingMaterial );
375 elemTerrain.setAttribute( QStringLiteral( "map-theme" ), mTerrainMapTheme );
376 elemTerrain.setAttribute( QStringLiteral( "show-labels" ), mShowLabels ? 1 : 0 );
377
378 {
379 QDomElement elemLights = doc.createElement( QStringLiteral( "lights" ) );
380 for ( const QgsLightSource *light : mLightSources )
381 {
382 const QDomElement elemLight = light->writeXml( doc, context );
383 elemLights.appendChild( elemLight );
384 }
385 elem.appendChild( elemLights );
386 }
387
388 QDomElement elemMapLayers = doc.createElement( QStringLiteral( "layers" ) );
389 for ( const QgsMapLayerRef &layerRef : mLayers )
390 {
391 QDomElement elemMapLayer = doc.createElement( QStringLiteral( "layer" ) );
392 elemMapLayer.setAttribute( QStringLiteral( "id" ), layerRef.layerId );
393 elemMapLayers.appendChild( elemMapLayer );
394 }
395 elemTerrain.appendChild( elemMapLayers );
396
397 QDomElement elemTerrainGenerator = doc.createElement( QStringLiteral( "generator" ) );
398 elemTerrainGenerator.setAttribute( QStringLiteral( "type" ), QgsTerrainGenerator::typeToString( mTerrainGenerator->type() ) );
399 mTerrainGenerator->writeXml( elemTerrainGenerator );
400 elemTerrain.appendChild( elemTerrainGenerator );
401 elem.appendChild( elemTerrain );
402
403 QDomElement elemRenderers = doc.createElement( QStringLiteral( "renderers" ) );
404 for ( const QgsAbstract3DRenderer *renderer : mRenderers )
405 {
406 QDomElement elemRenderer = doc.createElement( QStringLiteral( "renderer" ) );
407 elemRenderer.setAttribute( QStringLiteral( "type" ), renderer->type() );
408 renderer->writeXml( elemRenderer, context );
409 elemRenderers.appendChild( elemRenderer );
410 }
411 elem.appendChild( elemRenderers );
412
413 QDomElement elemSkybox = doc.createElement( QStringLiteral( "skybox" ) );
414 elemSkybox.setAttribute( QStringLiteral( "skybox-enabled" ), mIsSkyboxEnabled );
415 mSkyboxSettings.writeXml( elemSkybox, context );
416 elem.appendChild( elemSkybox );
417
418 QDomElement elemShadows = doc.createElement( QStringLiteral( "shadow-rendering" ) );
419 mShadowSettings.writeXml( elemShadows, context );
420 elem.appendChild( elemShadows );
421
422 QDomElement elemDebug = doc.createElement( QStringLiteral( "debug" ) );
423 elemDebug.setAttribute( QStringLiteral( "bounding-boxes" ), mShowTerrainBoundingBoxes ? 1 : 0 );
424 elemDebug.setAttribute( QStringLiteral( "terrain-tile-info" ), mShowTerrainTileInfo ? 1 : 0 );
425 elemDebug.setAttribute( QStringLiteral( "camera-view-center" ), mShowCameraViewCenter ? 1 : 0 );
426 elemDebug.setAttribute( QStringLiteral( "camera-rotation-center" ), mShowCameraRotationCenter ? 1 : 0 );
427 elemDebug.setAttribute( QStringLiteral( "show-light-sources" ), mShowLightSources ? 1 : 0 );
428 elemDebug.setAttribute( QStringLiteral( "show-fps-counter" ), mIsFpsCounterEnabled ? 1 : 0 );
429 elem.appendChild( elemDebug );
430
431 QDomElement elemEyeDomeLighting = doc.createElement( QStringLiteral( "eye-dome-lighting" ) );
432 elemEyeDomeLighting.setAttribute( QStringLiteral( "enabled" ), mEyeDomeLightingEnabled ? 1 : 0 );
433 elemEyeDomeLighting.setAttribute( QStringLiteral( "eye-dome-lighting-strength" ), mEyeDomeLightingStrength );
434 elemEyeDomeLighting.setAttribute( QStringLiteral( "eye-dome-lighting-distance" ), mEyeDomeLightingDistance );
435 elem.appendChild( elemEyeDomeLighting );
436
437 QDomElement elemNavigationSync = doc.createElement( QStringLiteral( "navigation-sync" ) );
438 elemNavigationSync.setAttribute( QStringLiteral( "view-sync-mode" ), ( int )mViewSyncMode );
439 elemNavigationSync.setAttribute( QStringLiteral( "view-frustum-visualization-enabled" ), mVisualizeViewFrustum ? 1 : 0 );
440 elem.appendChild( elemNavigationSync );
441
442 QDomElement elemDebugSettings = doc.createElement( QStringLiteral( "debug-settings" ) );
443 elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-enabled" ), mDebugShadowMapEnabled );
444 elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-corner" ), mDebugShadowMapCorner );
445 elemDebugSettings.setAttribute( QStringLiteral( "shadowmap-size" ), mDebugShadowMapSize );
446 elemDebugSettings.setAttribute( QStringLiteral( "depthmap-enabled" ), mDebugDepthMapEnabled );
447 elemDebugSettings.setAttribute( QStringLiteral( "depthmap-corner" ), mDebugDepthMapCorner );
448 elemDebugSettings.setAttribute( QStringLiteral( "depthmap-size" ), mDebugDepthMapSize );
449 elem.appendChild( elemDebugSettings );
450
451 QDomElement elemTemporalRange = doc.createElement( QStringLiteral( "temporal-range" ) );
452 elemTemporalRange.setAttribute( QStringLiteral( "start" ), temporalRange().begin().toString( Qt::ISODate ) );
453 elemTemporalRange.setAttribute( QStringLiteral( "end" ), temporalRange().end().toString( Qt::ISODate ) );
454
455 QDomElement elem3dAxis = doc.createElement( QStringLiteral( "axis3d" ) );
456 m3dAxisSettings.writeXml( elem3dAxis, context );
457 elem.appendChild( elem3dAxis );
458
459 return elem;
460}
461
463{
464 for ( int i = 0; i < mLayers.count(); ++i )
465 {
466 QgsMapLayerRef &layerRef = mLayers[i];
467 layerRef.setLayer( project.mapLayer( layerRef.layerId ) );
468 }
469
470 mTerrainGenerator->resolveReferences( project );
471
472 for ( int i = 0; i < mRenderers.count(); ++i )
473 {
474 QgsAbstract3DRenderer *renderer = mRenderers[i];
475 renderer->resolveReferences( project );
476 }
477}
478
480{
481 return Qgs3DUtils::mapToWorldCoordinates( mapCoords, mOrigin );
482}
483
485{
486 return Qgs3DUtils::worldToMapCoordinates( worldCoords, mOrigin );
487}
488
490{
491 mCrs = crs;
492}
493
495{
496 return mTransformContext;
497}
498
500{
501 mTransformContext = context;
502}
503
504void Qgs3DMapSettings::setBackgroundColor( const QColor &color )
505{
506 if ( color == mBackgroundColor )
507 return;
508
509 mBackgroundColor = color;
511}
512
514{
515 return mBackgroundColor;
516}
517
518void Qgs3DMapSettings::setSelectionColor( const QColor &color )
519{
520 if ( color == mSelectionColor )
521 return;
522
523 mSelectionColor = color;
525}
526
528{
529 return mSelectionColor;
530}
531
533{
534 if ( zScale == mTerrainVerticalScale )
535 return;
536
537 mTerrainVerticalScale = zScale;
539}
540
542{
543 return mTerrainVerticalScale;
544}
545
546void Qgs3DMapSettings::setLayers( const QList<QgsMapLayer *> &layers )
547{
548 QList<QgsMapLayerRef> lst;
549 lst.reserve( layers.count() );
550 for ( QgsMapLayer *layer : layers )
551 {
552 lst.append( layer );
553 }
554
555 if ( mLayers == lst )
556 return;
557
558 mLayers = lst;
559 emit layersChanged();
560}
561
562QList<QgsMapLayer *> Qgs3DMapSettings::layers() const
563{
564 QList<QgsMapLayer *> lst;
565 lst.reserve( mLayers.count() );
566 for ( const QgsMapLayerRef &layerRef : mLayers )
567 {
568 if ( layerRef.layer )
569 lst.append( layerRef.layer );
570 }
571 return lst;
572}
573
575{
576 if ( properties->terrainProvider()->type() == QLatin1String( "flat" ) )
577 {
579 flatTerrain->setCrs( crs() );
580 flatTerrain->setExtent( fullExtent );
581 setTerrainGenerator( flatTerrain );
582
584 }
585 else if ( properties->terrainProvider()->type() == QLatin1String( "raster" ) )
586 {
587 QgsRasterDemTerrainProvider *rasterProvider = qgis::down_cast< QgsRasterDemTerrainProvider * >( properties->terrainProvider() );
588
590 demTerrainGen->setCrs( crs(), QgsProject::instance()->transformContext() );
591 demTerrainGen->setLayer( rasterProvider->layer() );
592 setTerrainGenerator( demTerrainGen );
593
596 }
597 else if ( properties->terrainProvider()->type() == QLatin1String( "mesh" ) )
598 {
599 QgsMeshTerrainProvider *meshProvider = qgis::down_cast< QgsMeshTerrainProvider * >( properties->terrainProvider() );
600
601 QgsMeshTerrainGenerator *newTerrainGenerator = new QgsMeshTerrainGenerator;
602 newTerrainGenerator->setCrs( crs(), QgsProject::instance()->transformContext() );
603 newTerrainGenerator->setLayer( meshProvider->layer() );
604 std::unique_ptr< QgsMesh3DSymbol > symbol( newTerrainGenerator->symbol()->clone() );
605 symbol->setVerticalScale( properties->terrainProvider()->scale() );
606 newTerrainGenerator->setSymbol( symbol.release() );
607 setTerrainGenerator( newTerrainGenerator );
608
611 }
612 else
613 {
615 flatTerrain->setCrs( crs() );
616 flatTerrain->setExtent( fullExtent );
617 setTerrainGenerator( flatTerrain );
618 }
619}
620
622{
623 if ( mMapTileResolution == res )
624 return;
625
626 mMapTileResolution = res;
628}
629
631{
632 return mMapTileResolution;
633}
634
636{
637 if ( mMaxTerrainScreenError == error )
638 return;
639
640 mMaxTerrainScreenError = error;
642}
643
645{
646 return mMaxTerrainScreenError;
647}
648
650{
651 if ( mMaxTerrainGroundError == error )
652 return;
653
654 mMaxTerrainGroundError = error;
656}
657
659{
660 if ( mTerrainElevationOffset == offset )
661 return;
662 mTerrainElevationOffset = offset;
663 emit terrainElevationOffsetChanged( mTerrainElevationOffset );
664}
665
667{
668 return mMaxTerrainGroundError;
669}
670
672{
673 if ( mTerrainGenerator )
674 {
675 disconnect( mTerrainGenerator.get(), &QgsTerrainGenerator::extentChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );
676 disconnect( mTerrainGenerator.get(), &QgsTerrainGenerator::terrainChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );
677 }
678
679 mTerrainGenerator.reset( gen );
680 connect( mTerrainGenerator.get(), &QgsTerrainGenerator::extentChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );
681 connect( mTerrainGenerator.get(), &QgsTerrainGenerator::terrainChanged, this, &Qgs3DMapSettings::terrainGeneratorChanged );
682
684}
685
687{
688 if ( mTerrainShadingEnabled == enabled )
689 return;
690
691 mTerrainShadingEnabled = enabled;
693}
694
696{
697 if ( mTerrainShadingMaterial == material )
698 return;
699
700 mTerrainShadingMaterial = material;
702}
703
704void Qgs3DMapSettings::setTerrainMapTheme( const QString &theme )
705{
706 if ( mTerrainMapTheme == theme )
707 return;
708
709 mTerrainMapTheme = theme;
711}
712
713void Qgs3DMapSettings::setRenderers( const QList<QgsAbstract3DRenderer *> &renderers )
714{
715 qDeleteAll( mRenderers );
716
717 mRenderers = renderers;
718
719 emit renderersChanged();
720}
721
723{
724 if ( mShowTerrainBoundingBoxes == enabled )
725 return;
726
727 mShowTerrainBoundingBoxes = enabled;
729}
730
732{
733 if ( mShowTerrainTileInfo == enabled )
734 return;
735
736 mShowTerrainTileInfo = enabled;
738}
739
741{
742 if ( mShowCameraViewCenter == enabled )
743 return;
744
745 mShowCameraViewCenter = enabled;
747}
748
750{
751 if ( mShowCameraRotationCenter == enabled )
752 return;
753
754 mShowCameraRotationCenter = enabled;
756}
757
758
760{
761 if ( mShowLightSources == enabled )
762 return;
763
764 mShowLightSources = enabled;
766}
767
769{
770 if ( mShowLabels == enabled )
771 return;
772
773 mShowLabels = enabled;
774 emit showLabelsChanged();
775}
776
778{
779 if ( mEyeDomeLightingEnabled == enabled )
780 return;
781 mEyeDomeLightingEnabled = enabled;
783}
784
786{
787 if ( mEyeDomeLightingStrength == strength )
788 return;
789 mEyeDomeLightingStrength = strength;
791}
792
794{
795 if ( mEyeDomeLightingDistance == distance )
796 return;
797 mEyeDomeLightingDistance = distance;
799}
800
801QList<QgsLightSource *> Qgs3DMapSettings::lightSources() const
802{
803 return mLightSources;
804}
805
806void Qgs3DMapSettings::setLightSources( const QList<QgsLightSource *> &lights )
807{
808 qDeleteAll( mLightSources );
809 mLightSources = lights;
810
812 emit pointLightsChanged();
813 emit lightSourcesChanged();
814}
815
816void Qgs3DMapSettings::setFieldOfView( const float fieldOfView )
817{
818 if ( mFieldOfView == fieldOfView )
819 return;
820
821 mFieldOfView = fieldOfView;
822 emit fieldOfViewChanged();
823}
824
825void Qgs3DMapSettings::setProjectionType( const Qt3DRender::QCameraLens::ProjectionType projectionType )
826{
827 if ( mProjectionType == projectionType )
828 return;
829
830 mProjectionType = projectionType;
832}
833
835{
836 if ( mCameraNavigationMode == navigationMode )
837 return;
838
839 mCameraNavigationMode = navigationMode;
841}
842
844{
845 if ( mCameraMovementSpeed == movementSpeed )
846 return;
847
848 mCameraMovementSpeed = movementSpeed;
850}
851
853{
854 mSkyboxSettings = skyboxSettings;
856}
857
859{
860 mShadowSettings = shadowSettings;
862}
863
864void Qgs3DMapSettings::setDebugShadowMapSettings( bool enabled, Qt::Corner corner, double size )
865{
866 mDebugShadowMapEnabled = enabled;
867 mDebugShadowMapCorner = corner;
868 mDebugShadowMapSize = size;
870}
871
872void Qgs3DMapSettings::setDebugDepthMapSettings( bool enabled, Qt::Corner corner, double size )
873{
874 mDebugDepthMapEnabled = enabled;
875 mDebugDepthMapCorner = corner;
876 mDebugDepthMapSize = size;
878}
879
880void Qgs3DMapSettings::setIsFpsCounterEnabled( bool fpsCounterEnabled )
881{
882 if ( fpsCounterEnabled == mIsFpsCounterEnabled )
883 return;
884 mIsFpsCounterEnabled = fpsCounterEnabled;
885 emit fpsCounterEnabledChanged( mIsFpsCounterEnabled );
886}
887
888void Qgs3DMapSettings::setTerrainRenderingEnabled( bool terrainRenderingEnabled )
889{
890 if ( terrainRenderingEnabled == mTerrainRenderingEnabled )
891 return;
892 mTerrainRenderingEnabled = terrainRenderingEnabled;
894}
895
897{
898 return mRendererUsage;
899}
900
902{
903 mRendererUsage = rendererUsage;
904}
905
906void Qgs3DMapSettings::setViewSyncMode( Qgis::ViewSyncModeFlags mode )
907{
908 mViewSyncMode = mode;
909}
910
912{
913 if ( mVisualizeViewFrustum != enabled )
914 {
915 mVisualizeViewFrustum = enabled;
917 }
918}
919
920void Qgs3DMapSettings::setIsDebugOverlayEnabled( bool debugOverlayEnabled )
921{
922 if ( debugOverlayEnabled == mIsDebugOverlayEnabled )
923 return;
924
925 mIsDebugOverlayEnabled = debugOverlayEnabled;
926 emit debugOverlayEnabledChanged( mIsDebugOverlayEnabled );
927}
928
929
930void Qgs3DMapSettings::connectChangedSignalsToSettingsChanged()
931{
962}
963
964
965void Qgs3DMapSettings::set3DAxisSettings( const Qgs3DAxisSettings &axisSettings, bool force )
966{
967 if ( axisSettings == m3dAxisSettings )
968 {
969 if ( force )
970 {
971 // ie. refresh. We nned to disconnect and to reconnect to avoid 'dirty' project
973 emit axisSettingsChanged();
975 }
976 }
977 else
978 {
979 m3dAxisSettings = axisSettings;
980 emit axisSettingsChanged();
981 }
982}
RendererUsage
Usage of the renderer.
Definition: qgis.h:1700
Contains the configuration of a 3d axis.
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
void setEyeDomeLightingStrength(double strength)
Sets the eye dome lighting strength value.
void mapTileResolutionChanged()
Emitted when the map tile resoulution has changed.
void terrainVerticalScaleChanged()
Emitted when the vertical scale of the terrain has changed.
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the coordinate transform context, which stores various information regarding which datum transfo...
void settingsChanged()
Emitted when one of the configuration settings has changed.
void renderersChanged()
Emitted when the list of map's extra renderers have been modified.
void eyeDomeLightingDistanceChanged()
Emitted when the eye dome lighting distance has changed.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Reads configuration from a DOM element previously written by writeXml()
void terrainShadingChanged()
Emitted when terrain shading enabled flag or terrain shading material has changed.
void setShowTerrainTilesInfo(bool enabled)
Sets whether to display extra tile info on top of terrain tiles (for debugging)
QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords) const
Converts map coordinates to 3D world coordinates (applies offset and turns (x,y,z) into (x,...
void setRenderers(const QList< QgsAbstract3DRenderer * > &renderers)
Sets list of extra 3D renderers to use in the scene. Takes ownership of the objects.
Qt3DRender::QCameraLens::ProjectionType projectionType() const
Returns the camera lens' projection type.
void setEyeDomeLightingEnabled(bool enabled)
Sets whether eye dome lighting will be used.
void setFieldOfView(const float fieldOfView)
Sets the camera lens' field of view.
void debugDepthMapSettingsChanged()
Emitted when depth map debugging has changed.
void setLightSources(const QList< QgsLightSource * > &lights)
Sets the list of light sources defined in the scene.
void backgroundColorChanged()
Emitted when the background color has changed.
void showTerrainBoundingBoxesChanged()
Emitted when the flag whether terrain's bounding boxes are shown has changed.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context) const
Writes configuration to a DOM element, to be used later with readXml()
void setDebugDepthMapSettings(bool enabled, Qt::Corner corner, double size)
Sets the debugging settings of the depth map.
void showCameraRotationCenterChanged()
Emitted when the flag whether camera's rotation center is shown has changed.
QColor selectionColor() const
Returns color used for selected features.
void directionalLightsChanged()
Emitted when the list of directional lights changes.
void setTerrainShadingMaterial(const QgsPhongMaterialSettings &material)
Sets terrain shading material.
void cameraNavigationModeChanged()
Emitted when the camera navigation mode was changed.
void shadowSettingsChanged()
Emitted when shadow rendering settings are changed.
void setViewFrustumVisualizationEnabled(bool enabled)
Sets whether the camera's view frustum is visualized on the 2D map canvas.
void setShowCameraRotationCenter(bool enabled)
Sets whether to show camera's rotation center as a sphere (for debugging)
float maxTerrainGroundError() const
Returns maximum ground error of terrain tiles in world units.
void eyeDomeLightingEnabledChanged()
Emitted when the flag whether eye dome lighting is used has changed.
void setTerrainVerticalScale(double zScale)
Sets vertical scale (exaggeration) of terrain (1 = true scale, > 1 = hills get more pronounced)
void debugOverlayEnabledChanged(bool debugOverlayEnabled)
Emitted when the debug overaly is enabled or disabled.
void setShowLabels(bool enabled)
Sets whether to display labels on terrain tiles.
double terrainVerticalScale() const
Returns vertical scale (exaggeration) of terrain.
void setViewSyncMode(Qgis::ViewSyncModeFlags mode)
Sets the view sync mode (used to synchronize the 2D main map canvas and the 3D camera navigation)
void setMaxTerrainGroundError(float error)
Returns maximum ground error of terrain tiles in world units.
void setSkyboxSettings(const QgsSkyboxSettings &skyboxSettings)
Sets the current configuration of the skybox.
void skyboxSettingsChanged()
Emitted when skybox settings are changed.
void setMapTileResolution(int res)
Sets resolution (in pixels) of the texture of a terrain tile.
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of 3D map layers to be rendered in the scene.
QgsShadowSettings shadowSettings() const
Returns the current configuration of shadows.
void terrainMapThemeChanged()
Emitted when terrain's map theme has changed.
void setShadowSettings(const QgsShadowSettings &shadowSettings)
Sets the current configuration of shadow rendering.
void setIsDebugOverlayEnabled(bool debugOverlayEnabled)
Sets whether debug overlay is enabled The debug overlay displays some debugging and profiling informa...
void pointLightsChanged()
Emitted when the list of point lights changes.
void setTerrainElevationOffset(float offset)
Sets the terrain elevation offset (used to move the terrain up or down)
QList< QgsLightSource * > lightSources() const
Returns list of directional light sources defined in the scene.
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets coordinate reference system used in the 3D scene.
void setEyeDomeLightingDistance(int distance)
Sets the eye dome lighting distance value (contributes to the contrast of the image.
void setShowLightSourceOrigins(bool enabled)
Sets whether to show light source origins as a sphere (for debugging)
QList< QgsAbstract3DRenderer * > renderers() const
Returns list of extra 3D renderers.
void projectionTypeChanged()
Emitted when the camera lens projection type changes.
float fieldOfView() const
Returns the camera lens' field of view.
void selectionColorChanged()
Emitted when the selection color has changed.
void setTerrainShadingEnabled(bool enabled)
Sets whether terrain shading is enabled.
void setDebugShadowMapSettings(bool enabled, Qt::Corner corner, double size)
Sets the debugging settings of the shadow map.
void setSelectionColor(const QColor &color)
Sets color used for selected features.
void lightSourcesChanged()
Emitted when any of the light source settings in the map changes.
void showLightSourceOriginsChanged()
Emitted when the flag whether light source origins are shown has changed.
QColor backgroundColor() const
Returns background color of the 3D map view.
void resolveReferences(const QgsProject &project)
Resolves references to other objects (map layers) after the call to readXml()
QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords) const
Converts 3D world coordinates to map coordinates (applies offset and turns (x,y,z) into (x,...
~Qgs3DMapSettings() override
void showLabelsChanged()
Emitted when the flag whether labels are displayed on terrain tiles has changed.
void maxTerrainScreenErrorChanged()
Emitted when the maximum terrain screen error has changed.
void setShowCameraViewCenter(bool enabled)
Sets whether to show camera's view center as a sphere (for debugging)
int mapTileResolution() const
Returns resolution (in pixels) of the texture of a terrain tile.
void set3DAxisSettings(const Qgs3DAxisSettings &axisSettings, bool force=false)
Sets the current configuration of 3d axis.
void setCameraMovementSpeed(double movementSpeed)
Sets the camera movement speed.
void terrainElevationOffsetChanged(float newElevation)
Emitted when the terrain elevation offset is changed.
void setTerrainRenderingEnabled(bool terrainRenderingEnabled)
Sets whether the 2D terrain surface will be rendered in.
Qgs3DMapSettings()
Constructor for Qgs3DMapSettings.
void setBackgroundColor(const QColor &color)
Sets background color of the 3D map view.
bool terrainRenderingEnabled() const
Returns whether the 2D terrain surface will be rendered.
void fpsCounterEnabledChanged(bool fpsCounterEnabled)
Emitted when the FPS counter is enabled or disabled.
void axisSettingsChanged()
Emitted when 3d axis rendering settings are changed.
void viewFrustumVisualizationEnabledChanged()
Emitted when the camera's view frustum visualization on the main 2D map canvas is enabled or disabled...
void setProjectionType(const Qt3DRender::QCameraLens::ProjectionType projectionType)
Sets the camera lens' projection type.
void setCameraNavigationMode(QgsCameraController::NavigationMode navigationMode)
Sets the navigation mode for the camera.
void configureTerrainFromProject(QgsProjectElevationProperties *properties, const QgsRectangle &fullExtent)
Configures the map's terrain settings directly from a project's elevation properties.
void layersChanged()
Emitted when the list of map layers for 3d rendering has changed.
void showTerrainTilesInfoChanged()
Emitted when the flag whether terrain's tile info is shown has changed.
void eyeDomeLightingStrengthChanged()
Emitted when the eye dome lighting strength has changed.
QgsSkyboxSettings skyboxSettings() const
Returns the current configuration of the skybox.
void setMaxTerrainScreenError(float error)
Sets maximum allowed screen error of terrain tiles in pixels.
void cameraMovementSpeedChanged()
Emitted when the camera movement speed was changed.
QgsCoordinateReferenceSystem crs() const
Returns coordinate reference system used in the 3D scene.
void setRendererUsage(Qgis::RendererUsage rendererUsage)
Sets the renderer usage.
float maxTerrainScreenError() const
Returns maximum allowed screen error of terrain tiles in pixels.
void setShowTerrainBoundingBoxes(bool enabled)
Sets whether to display bounding boxes of terrain tiles (for debugging)
void fieldOfViewChanged()
Emitted when the camera lens field of view changes.
Qgis::RendererUsage rendererUsage() const
Returns the renderer usage.
void setIsFpsCounterEnabled(bool fpsCounterEnabled)
Sets whether FPS counter label is enabled.
QList< QgsMapLayer * > layers() const
Returns the list of 3D map layers to be rendered in the scene.
void setTerrainMapTheme(const QString &theme)
Sets name of the map theme.
QgsCameraController::NavigationMode cameraNavigationMode() const
Returns the navigation mode used by the camera.
void terrainGeneratorChanged()
Emitted when the terrain generator has changed.
void setTerrainGenerator(QgsTerrainGenerator *gen)
Sets terrain generator.
void debugShadowMapSettingsChanged()
Emitted when shadow map debugging has changed.
void showCameraViewCenterChanged()
Emitted when the flag whether camera's view center is shown has changed.
void maxTerrainGroundErrorChanged()
Emitted when the maximum terrain ground error has changed.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
static QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords, const QgsVector3D &origin)
Converts 3D world coordinates to map coordinates (applies offset and turns (x,y,z) into (x,...
Definition: qgs3dutils.cpp:548
static QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords, const QgsVector3D &origin)
Converts map coordinates to 3D world coordinates (applies offset and turns (x,y,z) into (x,...
Definition: qgs3dutils.cpp:540
Base class for all renderers that may to participate in 3D view.
virtual void readXml(const QDomElement &elem, const QgsReadWriteContext &context)=0
Reads renderer's properties from given XML element.
virtual void resolveReferences(const QgsProject &project)
Resolves references to other objects - second phase of loading - after readXml()
virtual QString type() const =0
Returns the unique type ID string for the provider.
double offset() const
Returns the vertical offset value, used for adjusting the heights from the terrain provider.
double scale() const
Returns the vertical scale factor, which can be used to exaggerate vertical heights.
NavigationMode
The navigation mode used by the camera.
@ WalkNavigation
Uses WASD keys or arrows to navigate in walking (first person) manner.
@ TerrainBasedNavigation
The default navigation based on the terrain.
This class represents a coordinate reference system (CRS).
bool readXml(const QDomNode &node)
Restores state from the given DOM node.
bool writeXml(QDomNode &node, QDomDocument &doc) const
Stores state to the given Dom node in the given document.
Contains information about the context in which a coordinate transform is executed.
void setCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets CRS of the terrain.
void setLayer(QgsRasterLayer *layer)
Sets raster layer with elevation model to be used for terrain generation.
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets CRS of the terrain.
void setExtent(const QgsRectangle &extent) override
sets the extent of the terrain in terrain's CRS
static QgsLightSource * createFromXml(const QDomElement &element, const QgsReadWriteContext &context)
Creates a new light source from an XML element.
Base class for all map layer types.
Definition: qgsmaplayer.h:73
3D renderer that renders all mesh triangles of a mesh layer.
A terrain provider that uses the Z values of a mesh layer to build a terrain surface.
QgsMeshLayer * layer() const
Returns the mesh layer to be used as the terrain source.
void setCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets CRS of the terrain.
void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const override
Writes settings to a DOM element.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context) override
Reads settings from a DOM element.
3D renderer that renders all points from a point cloud layer
Temporarily blocks QgsProject "dirtying" for the lifetime of the object.
Definition: qgsproject.h:2311
Contains elevation properties for a QgsProject.
QgsAbstractTerrainProvider * terrainProvider()
Returns the project's terrain provider.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition: qgsproject.h:104
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:480
Q_INVOKABLE QgsMapLayer * mapLayer(const QString &layerId) const
Retrieve a pointer to a registered layer by layer ID.
void setDirty(bool b=true)
Flag the project as dirty (modified).
Definition: qgsproject.cpp:576
A terrain provider where the terrain source is a raster DEM layer.
QgsRasterLayer * layer() const
Returns the raster layer with elevation model to be used as the terrain source.
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
class containing the configuration of shadows rendering 3
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
Contains the configuration of a skybox entity.
void readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads settings from a DOM element.
void writeXml(QDomElement &element, const QgsReadWriteContext &context) const
Writes settings to a DOM element.
static QColor decodeColor(const QString &str)
static QString encodeColor(const QColor &color)
Base class for objects with an associated (optional) temporal range.
const QgsDateTimeRange & temporalRange() const
Returns the datetime range for the object.
void setTemporalRange(const QgsDateTimeRange &range)
Sets the temporal range for the object.
void terrainChanged()
Emitted when the terrain changed (for example, raster DEM or mesh have data changed)
void extentChanged()
Emitted when the terrain extent has changed.
static QString typeToString(Type type)
Converts terrain generator type enumeration into a string.
double y() const
Returns Y coordinate.
Definition: qgsvector3d.h:51
double z() const
Returns Z coordinate.
Definition: qgsvector3d.h:53
double x() const
Returns X coordinate.
Definition: qgsvector3d.h:49
3D renderer that renders all features of a vector layer with the same 3D symbol.
_LayerRef< QgsMapLayer > QgsMapLayerRef
const QgsCoordinateReferenceSystem & crs
void setLayer(TYPE *l)
Sets the reference to point to a specified layer.
QString layerId
Original layer ID.