* create map file for class / header files for PyQGIS API docs
* create map files
* install file
* add line numbers
* also add methods
* wait to sort
* more methods
* fix CMakeLists install
* fix sorting
* fix spell check
* remove map files for Qt6
* Revert "remove map files for Qt6"
This reverts commit 972f483410f556d1735a2070943b8ad9e2522c5e.
* do not test class_map files + auto sipify_all on branches
* fix warning
The 3D scene's CRS is not necessarily the same as the project's
CRS. For example, it can be "EPSG:3857" if the project's CRS is
geographic.
The stored extent in the settings is always the 3D scene's extent.
See:
b0d1a4f8b1
Adds a new material choice for a physically based metal/roughness
material. Options are available for setting the material base color,
metalness and roughness.
Internally this uses a clone of Qt's QMetalRoughMaterial class. We
use a copy of the Qt class instead of relying on Qt's implementation
as longer-term improvements (such as data defined base color) will
require a re-implementation anyway. By using our own material we
will avoid having two different code paths for the data-defined/
non-data defined scenarios.
stored in a single place, and that we always use the default
value when its not overwise set
This has two benefits:
1. The user doesn't see confusing "0" values for radius/length etc,
which are silently treated as some other fixed value when rendering
2. The default values are correctly accounted for when calculating
the layer's AABB, otherwise we end up with a flat AABB by
default
The `height` property is in fact a vertical offset applied to the
line. Also, the `offset` phrase is already used by the terrain for
similar purposes.
height() are setHeight() are kept for API compatibility reasons.
3D geometry renderer identification in QgsChunkedEntity was made according to the object name and can be prone to error. Now we used a property (prop name is defined in a const) with values from enum.
This adds a QgsRubberband in the 2D map canvas similar to the one used
to display the Frustum.
The option can be enabled in the General section of the 3D
configuration widget.
This is never used. The set or update renderer logic is handled in
Qgs3DMapScene by listening to the `onLayersChanged` and
`onLayerRenderer3DChanged` signals (see the previous commit).
* cleanup 3d measure tool class from pickers
* update qgs3dmapscene and identify tool
* remove pickers from chunked entity and terrain entity
* add QgsRay3d::intersects( QgsBox3d );
* demterrain and tesselated polygon geometry intersection checks
* Add vertex markers to 3d rubber bands
Add moveLastPoint() support for 3d rubber bands
* Forward keyEvents to 3d map tools
* proof of concept, needs refactoring
* move intersection logic to ChunkedEntities
* move ray casting logic to Qgs3DUtils
* cleanup map tools
* rename intersectEntity to rayIntersection, further cleanup
* cleanup
* move RayCastContext param
fix last rubberband marker
use singleResult for pointclouds
cleanup
* replace autos
* fix FID fetching logic
fix rule based rendering hits
fix selected feature hits
* fix clearing identify results, startDrag tolerance
* use doubles when dealing with map coordinates
return world coords in point cloud RayHits
* dosctrings and method rename
* use raycastingtools::ray3d
* move RayHit and Context to raycastingutils
* sip skip new methods
* fix build
* remove unused
* added docstring
* fix forward declarations
* fix qt6 build
* Use anti-aliasing for better looking billboards
* Slightly improve styling of 3D rubber band
* Make it possible to have 3D rubber band always on top
Also adds some docs to the frame graph implementation
* Do not leave the final rubber band segment when measuring is done
* address review comments
* spelling typo
* make cppcheck happy
* address benoit and loic review comments
* remove previous bool QgsTerrainEntity::rayIntersection() implementation
* add consts, update test mask
---------
Co-authored-by: Martin Dobias <wonder.sk@gmail.com>
Qgs3DMapScene.openScenes() will now return a map of
open Qgs3DMapScene objects (by name) visible in the app. Various
basic properties of the scene are exposed, including
the camera controller, allowing access to navigate 3d
scenes via python
* qgspoint3dsymbol: Rename mMaterial attribute to mMaterialSettings
mMaterial is not a material but an attribute to handle material
settings. Renaming it makes it easier to understand its usage.
* qgspoint3dsymbol: Rename materialSettings getter and setter
See previous commit.
* qgsline3dsymbol: Rename mMaterial attribute to mMaterialSettings
mMaterial is not a material but an attribute to handle material
settings. Renaming it makes it easier to understand its usage.
* qgsline3dsymbol: Rename materialSettings getter and setter
See previous commit.
* qgspolygon3dsymbol: Rename mMaterial attribute to mMaterialSettings
mMaterial is not a material but an attribute to handle material
settings. Renaming it makes it easier to understand its usage.
* qgspolygon3dsymbol: Rename materialSettings getter and setter
See previous commit.
* qgsmesh3dsymbol: Rename mMaterial attribute to mMaterialSettings
mMaterial is not a material but an attribute to handle material
settings. Renaming it makes it easier to understand its usage.
* qgsmesh3dsymbol: Rename materialSettings getter and setter
See previous commit.
* qgsgoochmaterialsettings: fix indentation
* Initial implementation
* - Add disabling of blur pass
- Change default parameter for shading factor
- fix some tests
* - Implement bilateral filtering
- Optimize textures
- Fix layout test
* rename SSAO to ambient occlusion
fix ssao settings widget margin
* Remove unused variable
* fix naming and add tooltips
* - Refactor quad entities
- Address Stefanos's suggestions
* Rework SSAO implementation
Previously we based the code on CloudCompare's implementation,
however that did not work too well for us for a couple of reasons:
- the code does not deal well with perspective projection, causing incorrect shading (CC uses orthographic projection)
- there was no range check, so we would be getting false ambient occlusion on larger depth discontinuities (silhouttes)
- banding artifacts as the sampling kernel was not getting rotated
- parameters (shading radius, distance attenuation) that are difficult to understand
The new implementation is based on John Chapman's tutorial and LearnOpenGL page (derived from the original tutorial):
https://john-chapman-graphics.blogspot.com/2013/01/ssao-tutorial.htmlhttps://learnopengl.com/Advanced-Lighting/SSAO
The general approach of the SSAO is the following:
- for each pixel, we pick a couple of random points nearby (64 samples currently)
and check with the depth buffer whether they are visible from the camera or not.
The nearby points that are occluded contribute to darkening of the pixel,
this is saved to a texture
- in the next rendering pass, we blur the texture using 4x4 box. This is because
in the first step we use 4x4 random noise pattern and it leaves a noticeable noise
pattern on the screen. This pass gets rid of that noise
- in the post-processing step, the blurred texture is blended with the rendered scene
There are few differences to J.C.'s tutorial and LearnOpenGL page:
- the approches above use normal maps (a texture with a normal vector for each pixel),
but we don't because we also want to support point clouds that do not have normals
(at least not by default)
- we use full sphere for sampling instead of hemisphere (which is possible when you
have normals), so maybe we are getting a bit lower quality / performance
- LearnOpenGL also uses a texture with positions of all pixels - we only use depth map
to get the original positions (like JC's original code does)
* Clean up ssao parameters and GUI, add intensity parameter
* Add missing Q_OBJECT macro
* Add more missing Q_OBJECT macros
* Add occlusion threshold parameter to control the darkening
With the default threshold of 50%, pixels only start to get darker
when more than half of the neighborhood samples are occluded. That
means flat surfaces should not get any darker. (What we had previously
is an equivalent of having threshold set at 0%)
The downside is that with increased threshold, more subtle occlusions get lost.
* Review from Stefanos
* More review and better defaults
* Clear button fix
Co-authored-by: NEDJIMAbelgacem <gb_nedjima@esi.dz>
Qt3DRender::QTexture2D does not handle opacity. Therefore, it is not
possible to use the default Qt3DExtras::QDiffuseSpecularMaterial
implementation. This problem is solved by using
Qt3DRender::QMaterial and copying the
Qt3DExtras::QDiffuseSpecularMaterial shaders from Qt3D source
code. Then, the texture color needs to be changed to set the correct
opacity. This is achieved in the fragement shader:
```
vec4 diffuseTextureColor = vec4(texture(diffuseTexture, texCoord).rgb,
opacity);
```
instead of the default:
```
vec4 diffuseTextureColor = vec4(texture(diffuseTexture, texCoord));
```
As far as the FrameGraph is concerned, this is already handled in
Qgs3DMapScene::finalizeNewEntity which checks for all material which
have an effect with an opacity parameter.
This stores the debug overlay visibility flag (mIsDebugOverlayEnabled)
even if it cannot be used (it needs at least Qt version 5.15). Its
default value is set to false to prevent any issue if the debug
overlay cannot be enabled.
This parameter is transient: it is not saved in the project
parameters.
The next commit will allow to this change this setting with
Qgs3DMapConfigWidget.
